Initial commit

24 files changed, 10760 insertions, 0 deletions

diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..9dc6287
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1 @@
+specgram.hpp
\ No newline at end of file
diff --git a/src/args.hxx b/src/args.hxx
new file mode 100644
index 0000000..77851b5
--- /dev/null
+++ b/src/args.hxx
@@ -0,0 +1,4311 @@
+/* A simple header-only C++ argument parser library.
+ *
+ * https://github.com/Taywee/args
+ *
+ * Copyright (c) 2016-2020 Taylor C. Richberger <taywee@gmx.com> and Pavel
+ * Belikov
+ * 
+ * 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.
+ */
+
+/** \file args.hxx
+ * \brief this single-header lets you use all of the args functionality
+ *
+ * The important stuff is done inside the args namespace
+ */
+
+#ifndef ARGS_HXX
+#define ARGS_HXX
+
+#define ARGS_VERSION "6.2.3"
+#define ARGS_VERSION_MAJOR 6
+#define ARGS_VERSION_MINOR 2
+#define ARGS_VERSION_PATCH 3
+
+#include <algorithm>
+#include <iterator>
+#include <exception>
+#include <functional>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <type_traits>
+#include <cstddef>
+#include <iostream>
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#define noexcept
+#endif
+
+#ifdef ARGS_TESTNAMESPACE
+namespace argstest
+{
+#else
+
+/** \namespace args
+ * \brief contains all the functionality of the args library
+ */
+namespace args
+{
+#endif
+    /** Getter to grab the value from the argument type.
+     *
+     * If the Get() function of the type returns a reference, so does this, and
+     * the value will be modifiable.
+     */
+    template <typename Option>
+    auto get(Option &option_) -> decltype(option_.Get())
+    {
+        return option_.Get();
+    }
+
+    /** (INTERNAL) Count UTF-8 glyphs
+     *
+     * This is not reliable, and will fail for combinatory glyphs, but it's
+     * good enough here for now.
+     *
+     * \param string The string to count glyphs from
+     * \return The UTF-8 glyphs in the string
+     */
+    inline std::string::size_type Glyphs(const std::string &string_)
+    {
+        std::string::size_type length = 0;
+        for (const char c: string_)
+        {
+            if ((c & 0xc0) != 0x80)
+            {
+                ++length;
+            }
+        }
+        return length;
+    }
+
+    /** (INTERNAL) Wrap a vector of words into a vector of lines
+     *
+     * Empty words are skipped. Word "\n" forces wrapping.
+     *
+     * \param begin The begin iterator
+     * \param end The end iterator
+     * \param width The width of the body
+     * \param firstlinewidth the width of the first line, defaults to the width of the body
+     * \param firstlineindent the indent of the first line, defaults to 0
+     * \return the vector of lines
+     */
+    template <typename It>
+    inline std::vector<std::string> Wrap(It begin,
+                                         It end,
+                                         const std::string::size_type width,
+                                         std::string::size_type firstlinewidth = 0,
+                                         std::string::size_type firstlineindent = 0)
+    {
+        std::vector<std::string> output;
+        std::string line(firstlineindent, ' ');
+        bool empty = true;
+
+        if (firstlinewidth == 0)
+        {
+            firstlinewidth = width;
+        }
+
+        auto currentwidth = firstlinewidth;
+
+        for (auto it = begin; it != end; ++it)
+        {
+            if (it->empty())
+            {
+                continue;
+            }
+
+            if (*it == "\n")
+            {
+                if (!empty)
+                {
+                    output.push_back(line);
+                    line.clear();
+                    empty = true;
+                    currentwidth = width;
+                }
+
+                continue;
+            }
+
+            auto itemsize = Glyphs(*it);
+            if ((line.length() + 1 + itemsize) > currentwidth)
+            {
+                if (!empty)
+                {
+                    output.push_back(line);
+                    line.clear();
+                    empty = true;
+                    currentwidth = width;
+                }
+            }
+
+            if (itemsize > 0)
+            {
+                if (!empty)
+                {
+                    line += ' ';
+                }
+
+                line += *it;
+                empty = false;
+            }
+        }
+
+        if (!empty)
+        {
+            output.push_back(line);
+        }
+
+        return output;
+    }
+
+    namespace detail
+    {
+        template <typename T>
+        std::string Join(const T& array, const std::string &delimiter)
+        {
+            std::string res;
+            for (auto &element : array)
+            {
+                if (!res.empty())
+                {
+                    res += delimiter;
+                }
+
+                res += element;
+            }
+
+            return res;
+        }
+    }
+
+    /** (INTERNAL) Wrap a string into a vector of lines
+     *
+     * This is quick and hacky, but works well enough.  You can specify a
+     * different width for the first line
+     *
+     * \param width The width of the body
+     * \param firstlinewid the width of the first line, defaults to the width of the body
+     * \return the vector of lines
+     */
+    inline std::vector<std::string> Wrap(const std::string &in, const std::string::size_type width, std::string::size_type firstlinewidth = 0)
+    {
+        // Preserve existing line breaks
+        const auto newlineloc = in.find('\n');
+        if (newlineloc != in.npos)
+        {
+            auto first = Wrap(std::string(in, 0, newlineloc), width);
+            auto second = Wrap(std::string(in, newlineloc + 1), width);
+            first.insert(
+                std::end(first),
+                std::make_move_iterator(std::begin(second)),
+                std::make_move_iterator(std::end(second)));
+            return first;
+        }
+
+        std::istringstream stream(in);
+        std::string::size_type indent = 0;
+
+        for (char c : in)
+        {
+            if (!isspace(c))
+            {
+                break;
+            }
+            ++indent;
+        }
+
+        return Wrap(std::istream_iterator<std::string>(stream), std::istream_iterator<std::string>(),
+                    width, firstlinewidth, indent);
+    }
+
+#ifdef ARGS_NOEXCEPT
+    /// Error class, for when ARGS_NOEXCEPT is defined
+    enum class Error
+    {
+        None,
+        Usage,
+        Parse,
+        Validation,
+        Required,
+        Map,
+        Extra,
+        Help,
+        Subparser,
+        Completion,
+    };
+#else
+    /** Base error class
+     */
+    class Error : public std::runtime_error
+    {
+        public:
+            Error(const std::string &problem) : std::runtime_error(problem) {}
+            virtual ~Error() {}
+    };
+
+    /** Errors that occur during usage
+     */
+    class UsageError : public Error
+    {
+        public:
+            UsageError(const std::string &problem) : Error(problem) {}
+            virtual ~UsageError() {}
+    };
+
+    /** Errors that occur during regular parsing
+     */
+    class ParseError : public Error
+    {
+        public:
+            ParseError(const std::string &problem) : Error(problem) {}
+            virtual ~ParseError() {}
+    };
+
+    /** Errors that are detected from group validation after parsing finishes
+     */
+    class ValidationError : public Error
+    {
+        public:
+            ValidationError(const std::string &problem) : Error(problem) {}
+            virtual ~ValidationError() {}
+    };
+
+    /** Errors that when a required flag is omitted
+     */
+    class RequiredError : public ValidationError
+    {
+        public:
+            RequiredError(const std::string &problem) : ValidationError(problem) {}
+            virtual ~RequiredError() {}
+    };
+
+    /** Errors in map lookups
+     */
+    class MapError : public ParseError
+    {
+        public:
+            MapError(const std::string &problem) : ParseError(problem) {}
+            virtual ~MapError() {}
+    };
+
+    /** Error that occurs when a singular flag is specified multiple times
+     */
+    class ExtraError : public ParseError
+    {
+        public:
+            ExtraError(const std::string &problem) : ParseError(problem) {}
+            virtual ~ExtraError() {}
+    };
+
+    /** An exception that indicates that the user has requested help
+     */
+    class Help : public Error
+    {
+        public:
+            Help(const std::string &flag) : Error(flag) {}
+            virtual ~Help() {}
+    };
+
+    /** (INTERNAL) An exception that emulates coroutine-like control flow for subparsers.
+     */
+    class SubparserError : public Error
+    {
+        public:
+            SubparserError() : Error("") {}
+            virtual ~SubparserError() {}
+    };
+
+    /** An exception that contains autocompletion reply
+     */
+    class Completion : public Error
+    {
+        public:
+            Completion(const std::string &flag) : Error(flag) {}
+            virtual ~Completion() {}
+    };
+#endif
+
+    /** A simple unified option type for unified initializer lists for the Matcher class.
+     */
+    struct EitherFlag
+    {
+        const bool isShort;
+        const char shortFlag;
+        const std::string longFlag;
+        EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
+        EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
+        EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
+
+        /** Get just the long flags from an initializer list of EitherFlags
+         */
+        static std::unordered_set<std::string> GetLong(std::initializer_list<EitherFlag> flags)
+        {
+            std::unordered_set<std::string>  longFlags;
+            for (const EitherFlag &flag: flags)
+            {
+                if (!flag.isShort)
+                {
+                    longFlags.insert(flag.longFlag);
+                }
+            }
+            return longFlags;
+        }
+
+        /** Get just the short flags from an initializer list of EitherFlags
+         */
+        static std::unordered_set<char> GetShort(std::initializer_list<EitherFlag> flags)
+        {
+            std::unordered_set<char>  shortFlags;
+            for (const EitherFlag &flag: flags)
+            {
+                if (flag.isShort)
+                {
+                    shortFlags.insert(flag.shortFlag);
+                }
+            }
+            return shortFlags;
+        }
+
+        std::string str() const
+        {
+            return isShort ? std::string(1, shortFlag) : longFlag;
+        }
+
+        std::string str(const std::string &shortPrefix, const std::string &longPrefix) const
+        {
+            return isShort ? shortPrefix + std::string(1, shortFlag) : longPrefix + longFlag;
+        }
+    };
+
+
+
+    /** A class of "matchers", specifying short and flags that can possibly be
+     * matched.
+     *
+     * This is supposed to be constructed and then passed in, not used directly
+     * from user code.
+     */
+    class Matcher
+    {
+        private:
+            const std::unordered_set<char> shortFlags;
+            const std::unordered_set<std::string> longFlags;
+
+        public:
+            /** Specify short and long flags separately as iterators
+             *
+             * ex: `args::Matcher(shortFlags.begin(), shortFlags.end(), longFlags.begin(), longFlags.end())`
+             */
+            template <typename ShortIt, typename LongIt>
+            Matcher(ShortIt shortFlagsStart, ShortIt shortFlagsEnd, LongIt longFlagsStart, LongIt longFlagsEnd) :
+                shortFlags(shortFlagsStart, shortFlagsEnd),
+                longFlags(longFlagsStart, longFlagsEnd)
+            {
+                if (shortFlags.empty() && longFlags.empty())
+                {
+#ifndef ARGS_NOEXCEPT
+                    throw UsageError("empty Matcher");
+#endif
+                }
+            }
+
+#ifdef ARGS_NOEXCEPT
+            /// Only for ARGS_NOEXCEPT
+            Error GetError() const noexcept
+            {
+                return shortFlags.empty() && longFlags.empty() ? Error::Usage : Error::None;
+            }
+#endif
+
+            /** Specify short and long flags separately as iterables
+             *
+             * ex: `args::Matcher(shortFlags, longFlags)`
+             */
+            template <typename Short, typename Long>
+            Matcher(Short &&shortIn, Long &&longIn) :
+                Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
+            {}
+
+            /** Specify a mixed single initializer-list of both short and long flags
+             *
+             * This is the fancy one.  It takes a single initializer list of
+             * any number of any mixed kinds of flags.  Chars are
+             * automatically interpreted as short flags, and strings are
+             * automatically interpreted as long flags:
+             *
+             *     args::Matcher{'a'}
+             *     args::Matcher{"foo"}
+             *     args::Matcher{'h', "help"}
+             *     args::Matcher{"foo", 'f', 'F', "FoO"}
+             */
+            Matcher(std::initializer_list<EitherFlag> in) :
+                Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
+
+            Matcher(Matcher &&other) : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
+            {}
+
+            ~Matcher() {}
+
+            /** (INTERNAL) Check if there is a match of a short flag
+             */
+            bool Match(const char flag) const
+            {
+                return shortFlags.find(flag) != shortFlags.end();
+            }
+
+            /** (INTERNAL) Check if there is a match of a long flag
+             */
+            bool Match(const std::string &flag) const
+            {
+                return longFlags.find(flag) != longFlags.end();
+            }
+
+            /** (INTERNAL) Check if there is a match of a flag
+             */
+            bool Match(const EitherFlag &flag) const
+            {
+                return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
+            }
+
+            /** (INTERNAL) Get all flag strings as a vector, with the prefixes embedded
+             */
+            std::vector<EitherFlag> GetFlagStrings() const
+            {
+                std::vector<EitherFlag> flagStrings;
+                flagStrings.reserve(shortFlags.size() + longFlags.size());
+                for (const char flag: shortFlags)
+                {
+                    flagStrings.emplace_back(flag);
+                }
+                for (const std::string &flag: longFlags)
+                {
+                    flagStrings.emplace_back(flag);
+                }
+                return flagStrings;
+            }
+
+            /** (INTERNAL) Get long flag if it exists or any short flag
+             */
+            EitherFlag GetLongOrAny() const
+            {
+                if (!longFlags.empty())
+                {
+                    return *longFlags.begin();
+                }
+
+                if (!shortFlags.empty())
+                {
+                    return *shortFlags.begin();
+                }
+
+                // should be unreachable
+                return ' ';
+            }
+
+            /** (INTERNAL) Get short flag if it exists or any long flag
+             */
+            EitherFlag GetShortOrAny() const
+            {
+                if (!shortFlags.empty())
+                {
+                    return *shortFlags.begin();
+                }
+
+                if (!longFlags.empty())
+                {
+                    return *longFlags.begin();
+                }
+
+                // should be unreachable
+                return ' ';
+            }
+    };
+
+    /** Attributes for flags.
+     */
+    enum class Options
+    {
+        /** Default options.
+         */
+        None = 0x0,
+
+        /** Flag can't be passed multiple times.
+         */
+        Single = 0x01,
+
+        /** Flag can't be omitted.
+         */
+        Required = 0x02,
+
+        /** Flag is excluded from usage line.
+         */
+        HiddenFromUsage = 0x04,
+
+        /** Flag is excluded from options help.
+         */
+        HiddenFromDescription = 0x08,
+
+        /** Flag is global and can be used in any subcommand.
+         */
+        Global = 0x10,
+
+        /** Flag stops a parser.
+         */
+        KickOut = 0x20,
+
+        /** Flag is excluded from auto completion.
+         */
+        HiddenFromCompletion = 0x40,
+
+        /** Flag is excluded from options help and usage line
+         */
+        Hidden = HiddenFromUsage | HiddenFromDescription | HiddenFromCompletion,
+    };
+
+    inline Options operator | (Options lhs, Options rhs)
+    {
+        return static_cast<Options>(static_cast<int>(lhs) | static_cast<int>(rhs));
+    }
+
+    inline Options operator & (Options lhs, Options rhs)
+    {
+        return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
+    }
+
+    class FlagBase;
+    class PositionalBase;
+    class Command;
+    class ArgumentParser;
+
+    /** A simple structure of parameters for easy user-modifyable help menus
+     */
+    struct HelpParams
+    {
+        /** The width of the help menu
+         */
+        unsigned int width = 80;
+        /** The indent of the program line
+         */
+        unsigned int progindent = 2;
+        /** The indent of the program trailing lines for long parameters
+         */
+        unsigned int progtailindent = 4;
+        /** The indent of the description and epilogs
+         */
+        unsigned int descriptionindent = 4;
+        /** The indent of the flags
+         */
+        unsigned int flagindent = 6;
+        /** The indent of the flag descriptions
+         */
+        unsigned int helpindent = 40;
+        /** The additional indent each group adds
+         */
+        unsigned int eachgroupindent = 2;
+
+        /** The minimum gutter between each flag and its help
+         */
+        unsigned int gutter = 1;
+
+        /** Show the terminator when both options and positional parameters are present
+         */
+        bool showTerminator = true;
+
+        /** Show the {OPTIONS} on the prog line when this is true
+         */
+        bool showProglineOptions = true;
+
+        /** Show the positionals on the prog line when this is true
+         */
+        bool showProglinePositionals = true;
+
+        /** The prefix for short flags
+         */
+        std::string shortPrefix;
+
+        /** The prefix for long flags
+         */
+        std::string longPrefix;
+
+        /** The separator for short flags
+         */
+        std::string shortSeparator;
+
+        /** The separator for long flags
+         */
+        std::string longSeparator;
+
+        /** The program name for help generation
+         */
+        std::string programName;
+
+        /** Show command's flags
+         */
+        bool showCommandChildren = false;
+
+        /** Show command's descriptions and epilog
+         */
+        bool showCommandFullHelp = false;
+
+        /** The postfix for progline when showProglineOptions is true and command has any flags
+         */
+        std::string proglineOptions = "{OPTIONS}";
+
+        /** The prefix for progline when command has any subcommands
+         */
+        std::string proglineCommand = "COMMAND";
+
+        /** The prefix for progline value
+         */
+        std::string proglineValueOpen = " <";
+
+        /** The postfix for progline value
+         */
+        std::string proglineValueClose = ">";
+
+        /** The prefix for progline required argument
+         */
+        std::string proglineRequiredOpen = "";
+
+        /** The postfix for progline required argument
+         */
+        std::string proglineRequiredClose = "";
+
+        /** The prefix for progline non-required argument
+         */
+        std::string proglineNonrequiredOpen = "[";
+
+        /** The postfix for progline non-required argument
+         */
+        std::string proglineNonrequiredClose = "]";
+
+        /** Show flags in program line
+         */
+        bool proglineShowFlags = false;
+
+        /** Use short flags in program lines when possible
+         */
+        bool proglinePreferShortFlags = false;
+
+        /** Program line prefix
+         */
+        std::string usageString;
+
+        /** String shown in help before flags descriptions
+         */
+        std::string optionsString = "OPTIONS:";
+
+        /** Display value name after all the long and short flags
+         */
+        bool useValueNameOnce = false;
+
+        /** Show value name
+         */
+        bool showValueName = true;
+
+        /** Add newline before flag description
+         */
+        bool addNewlineBeforeDescription = false;
+
+        /** The prefix for option value
+         */
+        std::string valueOpen = "[";
+
+        /** The postfix for option value
+         */
+        std::string valueClose = "]";
+
+        /** Add choices to argument description
+         */
+        bool addChoices = false;
+
+        /** The prefix for choices
+         */
+        std::string choiceString = "\nOne of: ";
+
+        /** Add default values to argument description
+         */
+        bool addDefault = false;
+
+        /** The prefix for default values
+         */
+        std::string defaultString = "\nDefault: ";
+    };
+
+    /** A number of arguments which can be consumed by an option.
+     *
+     * Represents a closed interval [min, max].
+     */
+    struct Nargs
+    {
+        const size_t min;
+        const size_t max;
+
+        Nargs(size_t min_, size_t max_) : min{min_}, max{max_}
+        {
+#ifndef ARGS_NOEXCEPT
+            if (max < min)
+            {
+                throw UsageError("Nargs: max > min");
+            }
+#endif
+        }
+
+        Nargs(size_t num_) : min{num_}, max{num_}
+        {
+        }
+
+        friend bool operator == (const Nargs &lhs, const Nargs &rhs)
+        {
+            return lhs.min == rhs.min && lhs.max == rhs.max;
+        }
+
+        friend bool operator != (const Nargs &lhs, const Nargs &rhs)
+        {
+            return !(lhs == rhs);
+        }
+    };
+
+    /** Base class for all match types
+     */
+    class Base
+    {
+        private:
+            Options options = {};
+
+        protected:
+            bool matched = false;
+            const std::string help;
+#ifdef ARGS_NOEXCEPT
+            /// Only for ARGS_NOEXCEPT
+            mutable Error error = Error::None;
+            mutable std::string errorMsg;
+#endif
+
+        public:
+            Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
+            virtual ~Base() {}
+
+            Options GetOptions() const noexcept
+            {
+                return options;
+            }
+
+            bool IsRequired() const noexcept
+            {
+                return (GetOptions() & Options::Required) != Options::None;
+            }
+
+            virtual bool Matched() const noexcept
+            {
+                return matched;
+            }
+
+            virtual void Validate(const std::string &, const std::string &) const
+            {
+            }
+
+            operator bool() const noexcept
+            {
+                return Matched();
+            }
+
+            virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &, const unsigned indentLevel) const
+            {
+                std::tuple<std::string, std::string, unsigned> description;
+                std::get<1>(description) = help;
+                std::get<2>(description) = indentLevel;
+                return { std::move(description) };
+            }
+
+            virtual std::vector<Command*> GetCommands()
+            {
+                return {};
+            }
+
+            virtual bool IsGroup() const
+            {
+                return false;
+            }
+
+            virtual FlagBase *Match(const EitherFlag &)
+            {
+                return nullptr;
+            }
+
+            virtual PositionalBase *GetNextPositional()
+            {
+                return nullptr;
+            }
+
+            virtual std::vector<FlagBase*> GetAllFlags()
+            {
+                return {};
+            }
+
+            virtual bool HasFlag() const
+            {
+                return false;
+            }
+
+            virtual bool HasPositional() const
+            {
+                return false;
+            }
+
+            virtual bool HasCommand() const
+            {
+                return false;
+            }
+
+            virtual std::vector<std::string> GetProgramLine(const HelpParams &) const
+            {
+                return {};
+            }
+
+            /// Sets a kick-out value for building subparsers
+            void KickOut(bool kickout_) noexcept
+            {
+                if (kickout_)
+                {
+                    options = options | Options::KickOut;
+                }
+                else
+                {
+                    options = static_cast<Options>(static_cast<int>(options) & ~static_cast<int>(Options::KickOut));
+                }
+            }
+
+            /// Gets the kick-out value for building subparsers
+            bool KickOut() const noexcept
+            {
+                return (options & Options::KickOut) != Options::None;
+            }
+
+            virtual void Reset() noexcept
+            {
+                matched = false;
+#ifdef ARGS_NOEXCEPT
+                error = Error::None;
+                errorMsg.clear();
+#endif
+            }
+
+#ifdef ARGS_NOEXCEPT
+            /// Only for ARGS_NOEXCEPT
+            virtual Error GetError() const
+            {
+                return error;
+            }
+
+            /// Only for ARGS_NOEXCEPT
+            std::string GetErrorMsg() const
+            {
+                return errorMsg;
+            }
+#endif
+    };
+
+    /** Base class for all match types that have a name
+     */
+    class NamedBase : public Base
+    {
+        protected:
+            const std::string name;
+            bool kickout = false;
+            std::string defaultString;
+            bool defaultStringManual = false;
+            std::vector<std::string> choicesStrings;
+            bool choicesStringManual = false;
+
+            virtual std::string GetDefaultString(const HelpParams&) const { return {}; }
+
+            virtual std::vector<std::string> GetChoicesStrings(const HelpParams&) const { return {}; }
+
+            virtual std::string GetNameString(const HelpParams&) const { return Name(); }
+
+            void AddDescriptionPostfix(std::string &dest, const bool isManual, const std::string &manual, bool isGenerated, const std::string &generated, const std::string &str) const
+            {
+                if (isManual && !manual.empty())
+                {
+                    dest += str;
+                    dest += manual;
+                }
+                else if (!isManual && isGenerated && !generated.empty())
+                {
+                    dest += str;
+                    dest += generated;
+                }
+            }
+
+        public:
+            NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
+            virtual ~NamedBase() {}
+
+            /** Sets default value string that will be added to argument description.
+             *  Use empty string to disable it for this argument.
+             */
+            void HelpDefault(const std::string &str)
+            {
+                defaultStringManual = true;
+                defaultString = str;
+            }
+
+            /** Gets default value string that will be added to argument description.
+             */
+            std::string HelpDefault(const HelpParams &params) const
+            {
+                return defaultStringManual ? defaultString : GetDefaultString(params);
+            }
+
+            /** Sets choices strings that will be added to argument description.
+             *  Use empty vector to disable it for this argument.
+             */
+            void HelpChoices(const std::vector<std::string> &array)
+            {
+                choicesStringManual = true;
+                choicesStrings = array;
+            }
+
+            /** Gets choices strings that will be added to argument description.
+             */
+            std::vector<std::string> HelpChoices(const HelpParams &params) const
+            {
+                return choicesStringManual ? choicesStrings : GetChoicesStrings(params);
+            }
+
+            virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &params, const unsigned indentLevel) const override
+            {
+                std::tuple<std::string, std::string, unsigned> description;
+                std::get<0>(description) = GetNameString(params);
+                std::get<1>(description) = help;
+                std::get<2>(description) = indentLevel;
+
+                AddDescriptionPostfix(std::get<1>(description), choicesStringManual, detail::Join(choicesStrings, ", "), params.addChoices, detail::Join(GetChoicesStrings(params), ", "), params.choiceString);
+                AddDescriptionPostfix(std::get<1>(description), defaultStringManual, defaultString, params.addDefault, GetDefaultString(params), params.defaultString);
+
+                return { std::move(description) };
+            }
+
+            virtual std::string Name() const
+            {
+                return name;
+            }
+    };
+
+    namespace detail
+    {
+        template<typename T>
+        using vector = std::vector<T, std::allocator<T>>;
+        
+        template<typename K, typename T>
+        using unordered_map = std::unordered_map<K, T, std::hash<K>, 
+            std::equal_to<K>, std::allocator<std::pair<const K, T> > >;
+
+        template<typename S, typename T>
+        class is_streamable
+        {
+            template<typename SS, typename TT>
+            static auto test(int)
+            -> decltype( std::declval<SS&>() << std::declval<TT>(), std::true_type() );
+
+            template<typename, typename>
+            static auto test(...) -> std::false_type;
+
+        public:
+            using type = decltype(test<S,T>(0));
+        };
+
+        template <typename T>
+        using IsConvertableToString = typename is_streamable<std::ostringstream, T>::type;
+
+        template <typename T>
+        typename std::enable_if<IsConvertableToString<T>::value, std::string>::type
+        ToString(const T &value)
+        {
+            std::ostringstream s;
+            s << value;
+            return s.str();
+        }
+
+        template <typename T>
+        typename std::enable_if<!IsConvertableToString<T>::value, std::string>::type
+        ToString(const T &)
+        {
+            return {};
+        }
+
+        template <typename T>
+        std::vector<std::string> MapKeysToStrings(const T &map)
+        {
+            std::vector<std::string> res;
+            using K = typename std::decay<decltype(std::begin(map)->first)>::type;
+            if (IsConvertableToString<K>::value)
+            {
+                for (const auto &p : map)
+                {
+                    res.push_back(detail::ToString(p.first));
+                }
+
+                std::sort(res.begin(), res.end());
+            }
+            return res;
+        }
+    }
+
+    /** Base class for all flag options
+     */
+    class FlagBase : public NamedBase
+    {
+        protected:
+            const Matcher matcher;
+
+            virtual std::string GetNameString(const HelpParams &params) const override
+            {
+                const std::string postfix = !params.showValueName || NumberOfArguments() == 0 ? std::string() : Name();
+                std::string flags;
+                const auto flagStrings = matcher.GetFlagStrings();
+                const bool useValueNameOnce = flagStrings.size() == 1 ? false : params.useValueNameOnce;
+                for (auto it = flagStrings.begin(); it != flagStrings.end(); ++it)
+                {
+                    auto &flag = *it;
+                    if (it != flagStrings.begin())
+                    {
+                        flags += ", ";
+                    }
+
+                    flags += flag.isShort ? params.shortPrefix : params.longPrefix;
+                    flags += flag.str();
+
+                    if (!postfix.empty() && (!useValueNameOnce || it + 1 == flagStrings.end()))
+                    {
+                        flags += flag.isShort ? params.shortSeparator : params.longSeparator;
+                        flags += params.valueOpen + postfix + params.valueClose;
+                    }
+                }
+
+                return flags;
+            }
+
+        public:
+            FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : NamedBase(name_, help_, extraError_ ? Options::Single : Options()), matcher(std::move(matcher_)) {}
+
+            FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : NamedBase(name_, help_, options_), matcher(std::move(matcher_)) {}
+
+            virtual ~FlagBase() {}
+
+            virtual FlagBase *Match(const EitherFlag &flag) override
+            {
+                if (matcher.Match(flag))
+                {
+                    if ((GetOptions() & Options::Single) != Options::None && matched)
+                    {
+                        std::ostringstream problem;
+                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
+#ifdef ARGS_NOEXCEPT
+                        error = Error::Extra;
+                        errorMsg = problem.str();
+#else
+                        throw ExtraError(problem.str());
+#endif
+                    }
+                    matched = true;
+                    return this;
+                }
+                return nullptr;
+            }
+
+            virtual std::vector<FlagBase*> GetAllFlags() override
+            {
+                return { this };
+            }
+
+            const Matcher &GetMatcher() const
+            {
+                return matcher;
+            }
+
+            virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) const override
+            {
+                if (!Matched() && IsRequired())
+                {
+                        std::ostringstream problem;
+                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
+#ifdef ARGS_NOEXCEPT
+                        error = Error::Required;
+                        errorMsg = problem.str();
+#else
+                        throw RequiredError(problem.str());
+#endif
+                }
+            }
+
+            virtual std::vector<std::string> GetProgramLine(const HelpParams &params) const override
+            {
+                if (!params.proglineShowFlags)
+                {
+                    return {};
+                }
+
+                const std::string postfix = NumberOfArguments() == 0 ? std::string() : Name();
+                const EitherFlag flag = params.proglinePreferShortFlags ? matcher.GetShortOrAny() : matcher.GetLongOrAny();
+                std::string res = flag.str(params.shortPrefix, params.longPrefix);
+                if (!postfix.empty())
+                {
+                    res += params.proglineValueOpen + postfix + params.proglineValueClose;
+                }
+
+                return { IsRequired() ? params.proglineRequiredOpen + res + params.proglineRequiredClose
+                                      : params.proglineNonrequiredOpen + res + params.proglineNonrequiredClose };
+            }
+
+            virtual bool HasFlag() const override
+            {
+                return true;
+            }
+
+#ifdef ARGS_NOEXCEPT
+            /// Only for ARGS_NOEXCEPT
+            virtual Error GetError() const override
+            {
+                const auto nargs = NumberOfArguments();
+                if (nargs.min > nargs.max)
+                {
+                    return Error::Usage;
+                }
+
+                const auto matcherError = matcher.GetError();
+                if (matcherError != Error::None)
+                {
+                    return matcherError;
+                }
+
+                return error;
+            }
+#endif
+
+            /** Defines how many values can be consumed by this option.
+             *
+             * \return closed interval [min, max]
+             */
+            virtual Nargs NumberOfArguments() const noexcept = 0;
+
+            /** Parse values of this option.
+             *
+             * \param value Vector of values. It's size must be in NumberOfArguments() interval.
+             */
+            virtual void ParseValue(const std::vector<std::string> &value) = 0;
+    };
+
+    /** Base class for value-accepting flag options
+     */
+    class ValueFlagBase : public FlagBase
+    {
+        public:
+            ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : FlagBase(name_, help_, std::move(matcher_), extraError_) {}
+            ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : FlagBase(name_, help_, std::move(matcher_), options_) {}
+            virtual ~ValueFlagBase() {}
+
+            virtual Nargs NumberOfArguments() const noexcept override
+            {
+                return 1;
+            }
+    };
+
+    class CompletionFlag : public ValueFlagBase
+    {
+        public:
+            std::vector<std::string> reply;
+            size_t cword = 0;
+            std::string syntax;
+
+            template <typename GroupClass>
+            CompletionFlag(GroupClass &group_, Matcher &&matcher_): ValueFlagBase("completion", "completion flag", std::move(matcher_), Options::Hidden)
+            {
+                group_.AddCompletion(*this);
+            }
+
+            virtual ~CompletionFlag() {}
+
+            virtual Nargs NumberOfArguments() const noexcept override
+            {
+                return 2;
+            }
+
+            virtual void ParseValue(const std::vector<std::string> &value_) override
+            {
+                syntax = value_.at(0);
+                std::istringstream(value_.at(1)) >> cword;
+            }
+
+            /** Get the completion reply
+             */
+            std::string Get() noexcept
+            {
+                return detail::Join(reply, "\n");
+            }
+
+            virtual void Reset() noexcept override
+            {
+                ValueFlagBase::Reset();
+                cword = 0;
+                syntax.clear();
+                reply.clear();
+            }
+    };
+
+
+    /** Base class for positional options
+     */
+    class PositionalBase : public NamedBase
+    {
+        protected:
+            bool ready;
+
+        public:
+            PositionalBase(const std::string &name_, const std::string &help_, Options options_ = {}) : NamedBase(name_, help_, options_), ready(true) {}
+            virtual ~PositionalBase() {}
+
+            bool Ready()
+            {
+                return ready;
+            }
+
+            virtual void ParseValue(const std::string &value_) = 0;
+
+            virtual void Reset() noexcept override
+            {
+                matched = false;
+                ready = true;
+#ifdef ARGS_NOEXCEPT
+                error = Error::None;
+                errorMsg.clear();
+#endif
+            }
+
+            virtual PositionalBase *GetNextPositional() override
+            {
+                return Ready() ? this : nullptr;
+            }
+
+            virtual bool HasPositional() const override
+            {
+                return true;
+            }
+
+            virtual std::vector<std::string> GetProgramLine(const HelpParams &params) const override
+            {
+                return { IsRequired() ? params.proglineRequiredOpen + Name() + params.proglineRequiredClose
+                                      : params.proglineNonrequiredOpen + Name() + params.proglineNonrequiredClose };
+            }
+
+            virtual void Validate(const std::string &, const std::string &) const override
+            {
+                if (IsRequired() && !Matched())
+                {
+                    std::ostringstream problem;
+                    problem << "Option '" << Name() << "' is required";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Required;
+                    errorMsg = problem.str();
+#else
+                    throw RequiredError(problem.str());
+#endif
+                }
+            }
+    };
+
+    /** Class for all kinds of validating groups, including ArgumentParser
+     */
+    class Group : public Base
+    {
+        private:
+            std::vector<Base*> children;
+            std::function<bool(const Group &)> validator;
+
+        public:
+            /** Default validators
+             */
+            struct Validators
+            {
+                static bool Xor(const Group &group)
+                {
+                    return group.MatchedChildren() == 1;
+                }
+
+                static bool AtLeastOne(const Group &group)
+                {
+                    return group.MatchedChildren() >= 1;
+                }
+
+                static bool AtMostOne(const Group &group)
+                {
+                    return group.MatchedChildren() <= 1;
+                }
+
+                static bool All(const Group &group)
+                {
+                    return group.Children().size() == group.MatchedChildren();
+                }
+
+                static bool AllOrNone(const Group &group)
+                {
+                    return (All(group) || None(group));
+                }
+
+                static bool AllChildGroups(const Group &group)
+                {
+                    return std::none_of(std::begin(group.Children()), std::end(group.Children()), [](const Base* child) -> bool {
+                            return child->IsGroup() && !child->Matched();
+                            });
+                }
+
+                static bool DontCare(const Group &)
+                {
+                    return true;
+                }
+
+                static bool CareTooMuch(const Group &)
+                {
+                    return false;
+                }
+
+                static bool None(const Group &group)
+                {
+                    return group.MatchedChildren() == 0;
+                }
+            };
+            /// If help is empty, this group will not be printed in help output
+            Group(const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_) {}
+            /// If help is empty, this group will not be printed in help output
+            Group(Group &group_, const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_)
+            {
+                group_.Add(*this);
+            }
+            virtual ~Group() {}
+
+            /** Append a child to this Group.
+             */
+            void Add(Base &child)
+            {
+                children.emplace_back(&child);
+            }
+
+            /** Get all this group's children
+             */
+            const std::vector<Base *> &Children() const
+            {
+                return children;
+            }
+
+            /** Return the first FlagBase that matches flag, or nullptr
+             *
+             * \param flag The flag with prefixes stripped
+             * \return the first matching FlagBase pointer, or nullptr if there is no match
+             */
+            virtual FlagBase *Match(const EitherFlag &flag) override
+            {
+                for (Base *child: Children())
+                {
+                    if (FlagBase *match = child->Match(flag))
+                    {
+                        return match;
+                    }
+                }
+                return nullptr;
+            }
+
+            virtual std::vector<FlagBase*> GetAllFlags() override
+            {
+                std::vector<FlagBase*> res;
+                for (Base *child: Children())
+                {
+                    auto childRes = child->GetAllFlags();
+                    res.insert(res.end(), childRes.begin(), childRes.end());
+                }
+                return res;
+            }
+
+            virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) const override
+            {
+                for (Base *child: Children())
+                {
+                    child->Validate(shortPrefix, longPrefix);
+                }
+            }
+
+            /** Get the next ready positional, or nullptr if there is none
+             *
+             * \return the first ready PositionalBase pointer, or nullptr if there is no match
+             */
+            virtual PositionalBase *GetNextPositional() override
+            {
+                for (Base *child: Children())
+                {
+                    if (auto next = child->GetNextPositional())
+                    {
+                        return next;
+                    }
+                }
+                return nullptr;
+            }
+
+            /** Get whether this has any FlagBase children
+             *
+             * \return Whether or not there are any FlagBase children
+             */
+            virtual bool HasFlag() const override
+            {
+                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasFlag(); });
+            }
+
+            /** Get whether this has any PositionalBase children
+             *
+             * \return Whether or not there are any PositionalBase children
+             */
+            virtual bool HasPositional() const override
+            {
+                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasPositional(); });
+            }
+
+            /** Get whether this has any Command children
+             *
+             * \return Whether or not there are any Command children
+             */
+            virtual bool HasCommand() const override
+            {
+                return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
+            }
+
+            /** Count the number of matched children this group has
+             */
+            std::vector<Base *>::size_type MatchedChildren() const
+            {
+                // Cast to avoid warnings from -Wsign-conversion
+                return static_cast<std::vector<Base *>::size_type>(
+                        std::count_if(std::begin(Children()), std::end(Children()), [](const Base *child){return child->Matched();}));
+            }
+
+            /** Whether or not this group matches validation
+             */
+            virtual bool Matched() const noexcept override
+            {
+                return validator(*this);
+            }
+
+            /** Get validation
+             */
+            bool Get() const
+            {
+                return Matched();
+            }
+
+            /** Get all the child descriptions for help generation
+             */
+            virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &params, const unsigned int indent) const override
+            {
+                std::vector<std::tuple<std::string, std::string, unsigned int>> descriptions;
+
+                // Push that group description on the back if not empty
+                unsigned addindent = 0;
+                if (!help.empty())
+                {
+                    descriptions.emplace_back(help, "", indent);
+                    addindent = 1;
+                }
+
+                for (Base *child: Children())
+                {
+                    if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None)
+                    {
+                        continue;
+                    }
+
+                    auto groupDescriptions = child->GetDescription(params, indent + addindent);
+                    descriptions.insert(
+                        std::end(descriptions),
+                        std::make_move_iterator(std::begin(groupDescriptions)),
+                        std::make_move_iterator(std::end(groupDescriptions)));
+                }
+                return descriptions;
+            }
+
+            /** Get the names of positional parameters
+             */
+            virtual std::vector<std::string> GetProgramLine(const HelpParams &params) const override
+            {
+                std::vector <std::string> names;
+                for (Base *child: Children())
+                {
+                    if ((child->GetOptions() & Options::HiddenFromUsage) != Options::None)
+                    {
+                        continue;
+                    }
+
+                    auto groupNames = child->GetProgramLine(params);
+                    names.insert(
+                        std::end(names),
+                        std::make_move_iterator(std::begin(groupNames)),
+                        std::make_move_iterator(std::end(groupNames)));
+                }
+                return names;
+            }
+
+            virtual std::vector<Command*> GetCommands() override
+            {
+                std::vector<Command*> res;
+                for (const auto &child : Children())
+                {
+                    auto subparsers = child->GetCommands();
+                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
+                }
+                return res;
+            }
+
+            virtual bool IsGroup() const override
+            {
+                return true;
+            }
+
+            virtual void Reset() noexcept override
+            {
+                Base::Reset();
+
+                for (auto &child: Children())
+                {
+                    child->Reset();
+                }
+#ifdef ARGS_NOEXCEPT
+                error = Error::None;
+                errorMsg.clear();
+#endif
+            }
+
+#ifdef ARGS_NOEXCEPT
+            /// Only for ARGS_NOEXCEPT
+            virtual Error GetError() const override
+            {
+                if (error != Error::None)
+                {
+                    return error;
+                }
+
+                auto it = std::find_if(Children().begin(), Children().end(), [](const Base *child){return child->GetError() != Error::None;});
+                if (it == Children().end())
+                {
+                    return Error::None;
+                } else
+                {
+                    return (*it)->GetError();
+                }
+            }
+#endif
+
+    };
+
+    /** Class for using global options in ArgumentParser.
+     */
+    class GlobalOptions : public Group
+    {
+        public:
+            GlobalOptions(Group &base, Base &options_) : Group(base, {}, Group::Validators::DontCare, Options::Global)
+            {
+                Add(options_);
+            }
+    };
+
+    /** Utility class for building subparsers with coroutines/callbacks.
+     *
+     * Brief example:
+     * \code
+     * Command command(argumentParser, "command", "my command", [](args::Subparser &s)
+     * {
+     *      // your command flags/positionals
+     *      s.Parse(); //required
+     *      //your command code
+     * });
+     * \endcode
+     *
+     * For ARGS_NOEXCEPT mode don't forget to check `s.GetError()` after `s.Parse()`
+     * and return if it isn't equals to args::Error::None.
+     *
+     * \sa Command
+     */
+    class Subparser : public Group
+    {
+        private:
+            std::vector<std::string> args;
+            std::vector<std::string> kicked;
+            ArgumentParser *parser = nullptr;
+            const HelpParams &helpParams;
+            const Command &command;
+            bool isParsed = false;
+
+        public:
+            Subparser(std::vector<std::string> args_, ArgumentParser &parser_, const Command &command_, const HelpParams &helpParams_)
+                : Group({}, Validators::AllChildGroups), args(std::move(args_)), parser(&parser_), helpParams(helpParams_), command(command_)
+            {
+            }
+
+            Subparser(const Command &command_, const HelpParams &helpParams_) : Group({}, Validators::AllChildGroups), helpParams(helpParams_), command(command_)
+            {
+            }
+
+            Subparser(const Subparser&) = delete;
+            Subparser(Subparser&&) = delete;
+            Subparser &operator = (const Subparser&) = delete;
+            Subparser &operator = (Subparser&&) = delete;
+
+            const Command &GetCommand()
+            {
+                return command;
+            }
+
+            /** (INTERNAL) Determines whether Parse was called or not.
+             */
+            bool IsParsed() const
+            {
+                return isParsed;
+            }
+
+            /** Continue parsing arguments for new command.
+             */
+            void Parse();
+
+            /** Returns a vector of kicked out arguments.
+             *
+             * \sa Base::KickOut
+             */
+            const std::vector<std::string> &KickedOut() const noexcept
+            {
+                return kicked;
+            }
+    };
+
+    /** Main class for building subparsers.
+     *
+     * /sa Subparser
+     */
+    class Command : public Group
+    {
+        private:
+            friend class Subparser;
+
+            std::string name;
+            std::string help;
+            std::string description;
+            std::string epilog;
+            std::string proglinePostfix;
+
+            std::function<void(Subparser&)> parserCoroutine;
+            bool commandIsRequired = true;
+            Command *selectedCommand = nullptr;
+
+            mutable std::vector<std::tuple<std::string, std::string, unsigned>> subparserDescription;
+            mutable std::vector<std::string> subparserProgramLine;
+            mutable bool subparserHasFlag = false;
+            mutable bool subparserHasPositional = false;
+            mutable bool subparserHasCommand = false;
+#ifdef ARGS_NOEXCEPT
+            mutable Error subparserError = Error::None;
+#endif
+            mutable Subparser *subparser = nullptr;
+
+        protected:
+
+            class RaiiSubparser
+            {
+                public:
+                    RaiiSubparser(ArgumentParser &parser_, std::vector<std::string> args_);
+                    RaiiSubparser(const Command &command_, const HelpParams &params_);
+
+                    ~RaiiSubparser()
+                    {
+                        command.subparser = oldSubparser;
+                    }
+
+                    Subparser &Parser()
+                    {
+                        return parser;
+                    }
+
+                private:
+                    const Command &command;
+                    Subparser parser;
+                    Subparser *oldSubparser;
+            };
+
+            Command() = default;
+
+            std::function<void(Subparser&)> &GetCoroutine()
+            {
+                return selectedCommand != nullptr ? selectedCommand->GetCoroutine() : parserCoroutine;
+            }
+
+            Command &SelectedCommand()
+            {
+                Command *res = this;
+                while (res->selectedCommand != nullptr)
+                {
+                    res = res->selectedCommand;
+                }
+
+                return *res;
+            }
+
+            const Command &SelectedCommand() const
+            {
+                const Command *res = this;
+                while (res->selectedCommand != nullptr)
+                {
+                    res = res->selectedCommand;
+                }
+
+                return *res;
+            }
+
+            void UpdateSubparserHelp(const HelpParams &params) const
+            {
+                if (parserCoroutine)
+                {
+                    RaiiSubparser coro(*this, params);
+#ifndef ARGS_NOEXCEPT
+                    try
+                    {
+                        parserCoroutine(coro.Parser());
+                    }
+                    catch (args::SubparserError&)
+                    {
+                    }
+#else
+                    parserCoroutine(coro.Parser());
+#endif
+                }
+            }
+
+        public:
+            Command(Group &base_, std::string name_, std::string help_, std::function<void(Subparser&)> coroutine_ = {})
+                : name(std::move(name_)), help(std::move(help_)), parserCoroutine(std::move(coroutine_))
+            {
+                base_.Add(*this);
+            }
+
+            /** The description that appears on the prog line after options
+             */
+            const std::string &ProglinePostfix() const
+            { return proglinePostfix; }
+
+            /** The description that appears on the prog line after options
+             */
+            void ProglinePostfix(const std::string &proglinePostfix_)
+            { this->proglinePostfix = proglinePostfix_; }
+
+            /** The description that appears above options
+             */
+            const std::string &Description() const
+            { return description; }
+            /** The description that appears above options
+             */
+
+            void Description(const std::string &description_)
+            { this->description = description_; }
+
+            /** The description that appears below options
+             */
+            const std::string &Epilog() const
+            { return epilog; }
+
+            /** The description that appears below options
+             */
+            void Epilog(const std::string &epilog_)
+            { this->epilog = epilog_; }
+
+            /** The name of command
+             */
+            const std::string &Name() const
+            { return name; }
+
+            /** The description of command
+             */
+            const std::string &Help() const
+            { return help; }
+
+            /** If value is true, parser will fail if no command was parsed.
+             *
+             * Default: true.
+             */
+            void RequireCommand(bool value)
+            { commandIsRequired = value; }
+
+            virtual bool IsGroup() const override
+            { return false; }
+
+            virtual bool Matched() const noexcept override
+            { return Base::Matched(); }
+
+            operator bool() const noexcept
+            { return Matched(); }
+
+            void Match() noexcept
+            { matched = true; }
+
+            void SelectCommand(Command *c) noexcept
+            {
+                selectedCommand = c;
+
+                if (c != nullptr)
+                {
+                    c->Match();
+                }
+            }
+
+            virtual FlagBase *Match(const EitherFlag &flag) override
+            {
+                if (selectedCommand != nullptr)
+                {
+                    if (auto *res = selectedCommand->Match(flag))
+                    {
+                        return res;
+                    }
+
+                    for (auto *child: Children())
+                    {
+                        if ((child->GetOptions() & Options::Global) != Options::None)
+                        {
+                            if (auto *res = child->Match(flag))
+                            {
+                                return res;
+                            }
+                        }
+                    }
+
+                    return nullptr;
+                }
+
+                if (subparser != nullptr)
+                {
+                    return subparser->Match(flag);
+                }
+
+                return Matched() ? Group::Match(flag) : nullptr;
+            }
+
+            virtual std::vector<FlagBase*> GetAllFlags() override
+            {
+                std::vector<FlagBase*> res;
+
+                if (!Matched())
+                {
+                    return res;
+                }
+
+                for (auto *child: Children())
+                {
+                    if (selectedCommand == nullptr || (child->GetOptions() & Options::Global) != Options::None)
+                    {
+                        auto childFlags = child->GetAllFlags();
+                        res.insert(res.end(), childFlags.begin(), childFlags.end());
+                    }
+                }
+
+                if (selectedCommand != nullptr)
+                {
+                    auto childFlags = selectedCommand->GetAllFlags();
+                    res.insert(res.end(), childFlags.begin(), childFlags.end());
+                }
+
+                if (subparser != nullptr)
+                {
+                    auto childFlags = subparser->GetAllFlags();
+                    res.insert(res.end(), childFlags.begin(), childFlags.end());
+                }
+
+                return res;
+            }
+
+            virtual PositionalBase *GetNextPositional() override
+            {
+                if (selectedCommand != nullptr)
+                {
+                    if (auto *res = selectedCommand->GetNextPositional())
+                    {
+                        return res;
+                    }
+
+                    for (auto *child: Children())
+                    {
+                        if ((child->GetOptions() & Options::Global) != Options::None)
+                        {
+                            if (auto *res = child->GetNextPositional())
+                            {
+                                return res;
+                            }
+                        }
+                    }
+
+                    return nullptr;
+                }
+
+                if (subparser != nullptr)
+                {
+                    return subparser->GetNextPositional();
+                }
+
+                return Matched() ? Group::GetNextPositional() : nullptr;
+            }
+
+            virtual bool HasFlag() const override
+            {
+                return subparserHasFlag || Group::HasFlag();
+            }
+
+            virtual bool HasPositional() const override
+            {
+                return subparserHasPositional || Group::HasPositional();
+            }
+
+            virtual bool HasCommand() const override
+            {
+                return true;
+            }
+
+            std::vector<std::string> GetCommandProgramLine(const HelpParams &params) const
+            {
+                UpdateSubparserHelp(params);
+
+                auto res = Group::GetProgramLine(params);
+                res.insert(res.end(), subparserProgramLine.begin(), subparserProgramLine.end());
+
+                if (!params.proglineCommand.empty() && (Group::HasCommand() || subparserHasCommand))
+                {
+                    res.insert(res.begin(), commandIsRequired ? params.proglineCommand : "[" + params.proglineCommand + "]");
+                }
+
+                if (!Name().empty())
+                {
+                    res.insert(res.begin(), Name());
+                }
+
+                if ((subparserHasFlag || Group::HasFlag()) && params.showProglineOptions && !params.proglineShowFlags)
+                {
+                    res.push_back(params.proglineOptions);
+                }
+
+                if (!ProglinePostfix().empty())
+                {
+                    std::string line;
+                    for (char c : ProglinePostfix())
+                    {
+                        if (isspace(c))
+                        {
+                            if (!line.empty())
+                            {
+                                res.push_back(line);
+                                line.clear();
+                            }
+
+                            if (c == '\n')
+                            {
+                                res.push_back("\n");
+                            }
+                        }
+                        else
+                        {
+                            line += c;
+                        }
+                    }
+
+                    if (!line.empty())
+                    {
+                        res.push_back(line);
+                    }
+                }
+
+                return res;
+            }
+
+            virtual std::vector<std::string> GetProgramLine(const HelpParams &params) const override
+            {
+                if (!Matched())
+                {
+                    return {};
+                }
+
+                return GetCommandProgramLine(params);
+            }
+
+            virtual std::vector<Command*> GetCommands() override
+            {
+                if (selectedCommand != nullptr)
+                {
+                    return selectedCommand->GetCommands();
+                }
+
+                if (Matched())
+                {
+                    return Group::GetCommands();
+                }
+
+                return { this };
+            }
+
+            virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &params, const unsigned int indent) const override
+            {
+                std::vector<std::tuple<std::string, std::string, unsigned>> descriptions;
+                unsigned addindent = 0;
+
+                UpdateSubparserHelp(params);
+
+                if (!Matched())
+                {
+                    if (params.showCommandFullHelp)
+                    {
+                        std::ostringstream s;
+                        bool empty = true;
+                        for (const auto &progline: GetCommandProgramLine(params))
+                        {
+                            if (!empty)
+                            {
+                                s << ' ';
+                            }
+                            else
+                            {
+                                empty = false;
+                            }
+
+                            s << progline;
+                        }
+
+                        descriptions.emplace_back(s.str(), "", indent);
+                    }
+                    else
+                    {
+                        descriptions.emplace_back(Name(), help, indent);
+                    }
+
+                    if (!params.showCommandChildren && !params.showCommandFullHelp)
+                    {
+                        return descriptions;
+                    }
+
+                    addindent = 1;
+                }
+
+                if (params.showCommandFullHelp && !Matched())
+                {
+                    descriptions.emplace_back("", "", indent + addindent);
+                    descriptions.emplace_back(Description().empty() ? Help() : Description(), "", indent + addindent);
+                    descriptions.emplace_back("", "", indent + addindent);
+                }
+
+                for (Base *child: Children())
+                {
+                    if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None)
+                    {
+                        continue;
+                    }
+
+                    auto groupDescriptions = child->GetDescription(params, indent + addindent);
+                    descriptions.insert(
+                                        std::end(descriptions),
+                                        std::make_move_iterator(std::begin(groupDescriptions)),
+                                        std::make_move_iterator(std::end(groupDescriptions)));
+                }
+
+                for (auto childDescription: subparserDescription)
+                {
+                    std::get<2>(childDescription) += indent + addindent;
+                    descriptions.push_back(std::move(childDescription));
+                }
+
+                if (params.showCommandFullHelp && !Matched())
+                {
+                    descriptions.emplace_back("", "", indent + addindent);
+                    if (!Epilog().empty())
+                    {
+                        descriptions.emplace_back(Epilog(), "", indent + addindent);
+                        descriptions.emplace_back("", "", indent + addindent);
+                    }
+                }
+
+                return descriptions;
+            }
+
+            virtual void Validate(const std::string &shortprefix, const std::string &longprefix) const override
+            {
+                if (!Matched())
+                {
+                    return;
+                }
+
+                auto onValidationError = [&]
+                {
+                    std::ostringstream problem;
+                    problem << "Group validation failed somewhere!";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Validation;
+                    errorMsg = problem.str();
+#else
+                    throw ValidationError(problem.str());
+#endif
+                };
+
+                for (Base *child: Children())
+                {
+                    if (child->IsGroup() && !child->Matched())
+                    {
+                        onValidationError();
+                    }
+
+                    child->Validate(shortprefix, longprefix);
+                }
+
+                if (subparser != nullptr)
+                {
+                    subparser->Validate(shortprefix, longprefix);
+                    if (!subparser->Matched())
+                    {
+                        onValidationError();
+                    }
+                }
+
+                if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
+                {
+                    std::ostringstream problem;
+                    problem << "Command is required";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Validation;
+                    errorMsg = problem.str();
+#else
+                    throw ValidationError(problem.str());
+#endif
+                }
+            }
+
+            virtual void Reset() noexcept override
+            {
+                Group::Reset();
+                selectedCommand = nullptr;
+                subparserProgramLine.clear();
+                subparserDescription.clear();
+                subparserHasFlag = false;
+                subparserHasPositional = false;
+                subparserHasCommand = false;
+#ifdef ARGS_NOEXCEPT
+                subparserError = Error::None;
+#endif
+            }
+
+#ifdef ARGS_NOEXCEPT
+            /// Only for ARGS_NOEXCEPT
+            virtual Error GetError() const override
+            {
+                if (!Matched())
+                {
+                    return Error::None;
+                }
+
+                if (error != Error::None)
+                {
+                    return error;
+                }
+
+                if (subparserError != Error::None)
+                {
+                    return subparserError;
+                }
+
+                return Group::GetError();
+            }
+#endif
+    };
+
+    /** The main user facing command line argument parser class
+     */
+    class ArgumentParser : public Command
+    {
+        friend class Subparser;
+
+        private:
+            std::string longprefix;
+            std::string shortprefix;
+
+            std::string longseparator;
+
+            std::string terminator;
+
+            bool allowJoinedShortValue = true;
+            bool allowJoinedLongValue = true;
+            bool allowSeparateShortValue = true;
+            bool allowSeparateLongValue = true;
+
+            CompletionFlag *completion = nullptr;
+            bool readCompletion = false;
+
+        protected:
+            enum class OptionType
+            {
+                LongFlag,
+                ShortFlag,
+                Positional
+            };
+
+            OptionType ParseOption(const std::string &s, bool allowEmpty = false)
+            {
+                if (s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()))
+                {
+                    return OptionType::LongFlag;
+                }
+
+                if (s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()))
+                {
+                    return OptionType::ShortFlag;
+                }
+
+                return OptionType::Positional;
+            }
+
+            template <typename It>
+            bool Complete(FlagBase &flag, It it, It end)
+            {
+                auto nextIt = it;
+                if (!readCompletion || (++nextIt != end))
+                {
+                    return false;
+                }
+
+                const auto &chunk = *it;
+                for (auto &choice : flag.HelpChoices(helpParams))
+                {
+                    AddCompletionReply(chunk, choice);
+                }
+
+#ifndef ARGS_NOEXCEPT
+                throw Completion(completion->Get());
+#else
+                return true;
+#endif
+            }
+
+            /** (INTERNAL) Parse flag's values
+             *
+             * \param arg The string to display in error message as a flag name
+             * \param[in, out] it The iterator to first value. It will point to the last value
+             * \param end The end iterator
+             * \param joinedArg Joined value (e.g. bar in --foo=bar)
+             * \param canDiscardJoined If true joined value can be parsed as flag not as a value (as in -abcd)
+             * \param[out] values The vector to store parsed arg's values
+             */
+            template <typename It>
+            std::string ParseArgsValues(FlagBase &flag, const std::string &arg, It &it, It end,
+                                        const bool allowSeparate, const bool allowJoined,
+                                        const bool hasJoined, const std::string &joinedArg,
+                                        const bool canDiscardJoined, std::vector<std::string> &values)
+            {
+                values.clear();
+
+                Nargs nargs = flag.NumberOfArguments();
+
+                if (hasJoined && !allowJoined && nargs.min != 0)
+                {
+                    return "Flag '" + arg + "' was passed a joined argument, but these are disallowed";
+                }
+
+                if (hasJoined)
+                {
+                    if (!canDiscardJoined || nargs.max != 0)
+                    {
+                        values.push_back(joinedArg);
+                    }
+                } else if (!allowSeparate)
+                {
+                    if (nargs.min != 0)
+                    {
+                        return "Flag '" + arg + "' was passed a separate argument, but these are disallowed";
+                    }
+                } else
+                {
+                    auto valueIt = it;
+                    ++valueIt;
+
+                    while (valueIt != end &&
+                           values.size() < nargs.max &&
+                           (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional))
+                    {
+                        if (Complete(flag, valueIt, end))
+                        {
+                            it = end;
+                            return "";
+                        }
+
+                        values.push_back(*valueIt);
+                        ++it;
+                        ++valueIt;
+                    }
+                }
+
+                if (values.size() > nargs.max)
+                {
+                    return "Passed an argument into a non-argument flag: " + arg;
+                } else if (values.size() < nargs.min)
+                {
+                    if (nargs.min == 1 && nargs.max == 1)
+                    {
+                        return "Flag '" + arg + "' requires an argument but received none";
+                    } else if (nargs.min == 1)
+                    {
+                        return "Flag '" + arg + "' requires at least one argument but received none";
+                    } else if (nargs.min != nargs.max)
+                    {
+                        return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
+                               " arguments but received " + std::to_string(values.size());
+                    } else
+                    {
+                        return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
+                               " arguments but received " + std::to_string(values.size());
+                    }
+                }
+
+                return {};
+            }
+
+            template <typename It>
+            bool ParseLong(It &it, It end)
+            {
+                const auto &chunk = *it;
+                const auto argchunk = chunk.substr(longprefix.size());
+                // Try to separate it, in case of a separator:
+                const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
+                // If the separator is in the argument, separate it.
+                const auto arg = (separator != argchunk.npos ?
+                    std::string(argchunk, 0, separator)
+                    : argchunk);
+                const auto joined = (separator != argchunk.npos ?
+                    argchunk.substr(separator + longseparator.size())
+                    : std::string());
+
+                if (auto flag = Match(arg))
+                {
+                    std::vector<std::string> values;
+                    const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
+                                                                     separator != argchunk.npos, joined, false, values);
+                    if (!errorMessage.empty())
+                    {
+#ifndef ARGS_NOEXCEPT
+                        throw ParseError(errorMessage);
+#else
+                        error = Error::Parse;
+                        errorMsg = errorMessage;
+                        return false;
+#endif
+                    }
+
+                    if (!readCompletion)
+                    {
+                        flag->ParseValue(values);
+                    }
+
+                    if (flag->KickOut())
+                    {
+                        ++it;
+                        return false;
+                    }
+                } else
+                {
+                    const std::string errorMessage("Flag could not be matched: " + arg);
+#ifndef ARGS_NOEXCEPT
+                    throw ParseError(errorMessage);
+#else
+                    error = Error::Parse;
+                    errorMsg = errorMessage;
+                    return false;
+#endif
+                }
+
+                return true;
+            }
+
+            template <typename It>
+            bool ParseShort(It &it, It end)
+            {
+                const auto &chunk = *it;
+                const auto argchunk = chunk.substr(shortprefix.size());
+                for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
+                {
+                    const auto arg = *argit;
+
+                    if (auto flag = Match(arg))
+                    {
+                        const std::string value(argit + 1, std::end(argchunk));
+                        std::vector<std::string> values;
+                        const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
+                                                                         allowSeparateShortValue, allowJoinedShortValue,
+                                                                         !value.empty(), value, !value.empty(), values);
+
+                        if (!errorMessage.empty())
+                        {
+#ifndef ARGS_NOEXCEPT
+                            throw ParseError(errorMessage);
+#else
+                            error = Error::Parse;
+                            errorMsg = errorMessage;
+                            return false;
+#endif
+                        }
+
+                        if (!readCompletion)
+                        {
+                            flag->ParseValue(values);
+                        }
+
+                        if (flag->KickOut())
+                        {
+                            ++it;
+                            return false;
+                        }
+
+                        if (!values.empty())
+                        {
+                            break;
+                        }
+                    } else
+                    {
+                        const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
+#ifndef ARGS_NOEXCEPT
+                        throw ParseError(errorMessage);
+#else
+                        error = Error::Parse;
+                        errorMsg = errorMessage;
+                        return false;
+#endif
+                    }
+                }
+
+                return true;
+            }
+
+            bool AddCompletionReply(const std::string &cur, const std::string &choice)
+            {
+                if (cur.empty() || choice.find(cur) == 0)
+                {
+                    if (completion->syntax == "bash" && ParseOption(choice) == OptionType::LongFlag && choice.find(longseparator) != std::string::npos)
+                    {
+                        completion->reply.push_back(choice.substr(choice.find(longseparator) + 1));
+                    } else
+                    {
+                        completion->reply.push_back(choice);
+                    }
+                    return true;
+                }
+
+                return false;
+            }
+
+            template <typename It>
+            bool Complete(It it, It end)
+            {
+                auto nextIt = it;
+                if (!readCompletion || (++nextIt != end))
+                {
+                    return false;
+                }
+
+                const auto &chunk = *it;
+                auto pos = GetNextPositional();
+                std::vector<Command *> commands = GetCommands();
+                const auto optionType = ParseOption(chunk, true);
+
+                if (!commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
+                {
+                    for (auto &cmd : commands)
+                    {
+                        if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
+                        {
+                            AddCompletionReply(chunk, cmd->Name());
+                        }
+                    }
+                } else
+                {
+                    bool hasPositionalCompletion = true;
+
+                    if (!commands.empty())
+                    {
+                        for (auto &cmd : commands)
+                        {
+                            if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
+                            {
+                                AddCompletionReply(chunk, cmd->Name());
+                            }
+                        }
+                    } else if (pos)
+                    {
+                        if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
+                        {
+                            auto choices = pos->HelpChoices(helpParams);
+                            hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
+                            for (auto &choice : choices)
+                            {
+                                AddCompletionReply(chunk, choice);
+                            }
+                        }
+                    }
+
+                    if (hasPositionalCompletion)
+                    {
+                        auto flags = GetAllFlags();
+                        for (auto flag : flags)
+                        {
+                            if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
+                            {
+                                continue;
+                            }
+
+                            auto &matcher = flag->GetMatcher();
+                            if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
+                            {
+                                for (auto &flagName : matcher.GetFlagStrings())
+                                {
+                                    if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
+                                    {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (optionType == OptionType::LongFlag && allowJoinedLongValue)
+                        {
+                            const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
+                            if (separator != chunk.npos)
+                            {
+                                std::string arg(chunk, 0, separator);
+                                if (auto flag = this->Match(arg.substr(longprefix.size())))
+                                {
+                                    for (auto &choice : flag->HelpChoices(helpParams))
+                                    {
+                                        AddCompletionReply(chunk, arg + longseparator + choice);
+                                    }
+                                }
+                            }
+                        } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
+                        {
+                            if (chunk.size() > shortprefix.size() + 1)
+                            {
+                                auto arg = chunk.at(shortprefix.size());
+                                //TODO: support -abcVALUE where a and b take no value
+                                if (auto flag = this->Match(arg))
+                                {
+                                    for (auto &choice : flag->HelpChoices(helpParams))
+                                    {
+                                        AddCompletionReply(chunk, shortprefix + arg + choice);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+#ifndef ARGS_NOEXCEPT
+                throw Completion(completion->Get());
+#else
+                return true;
+#endif
+            }
+
+            template <typename It>
+            It Parse(It begin, It end)
+            {
+                bool terminated = false;
+                std::vector<Command *> commands = GetCommands();
+
+                // Check all arg chunks
+                for (auto it = begin; it != end; ++it)
+                {
+                    if (Complete(it, end))
+                    {
+                        return end;
+                    }
+
+                    const auto &chunk = *it;
+
+                    if (!terminated && chunk == terminator)
+                    {
+                        terminated = true;
+                    } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
+                    {
+                        if (!ParseLong(it, end))
+                        {
+                            return it;
+                        }
+                    } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
+                    {
+                        if (!ParseShort(it, end))
+                        {
+                            return it;
+                        }
+                    } else if (!terminated && !commands.empty())
+                    {
+                        auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
+                        if (itCommand == commands.end())
+                        {
+                            const std::string errorMessage("Unknown command: " + chunk);
+#ifndef ARGS_NOEXCEPT
+                            throw ParseError(errorMessage);
+#else
+                            error = Error::Parse;
+                            errorMsg = errorMessage;
+                            return it;
+#endif
+                        }
+
+                        SelectCommand(*itCommand);
+
+                        if (const auto &coroutine = GetCoroutine())
+                        {
+                            ++it;
+                            RaiiSubparser coro(*this, std::vector<std::string>(it, end));
+                            coroutine(coro.Parser());
+#ifdef ARGS_NOEXCEPT
+                            error = GetError();
+                            if (error != Error::None)
+                            {
+                                return end;
+                            }
+
+                            if (!coro.Parser().IsParsed())
+                            {
+                                error = Error::Usage;
+                                return end;
+                            }
+#else
+                            if (!coro.Parser().IsParsed())
+                            {
+                                throw UsageError("Subparser::Parse was not called");
+                            }
+#endif
+
+                            break;
+                        }
+
+                        commands = GetCommands();
+                    } else
+                    {
+                        auto pos = GetNextPositional();
+                        if (pos)
+                        {
+                            pos->ParseValue(chunk);
+
+                            if (pos->KickOut())
+                            {
+                                return ++it;
+                            }
+                        } else
+                        {
+                            const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
+#ifndef ARGS_NOEXCEPT
+                            throw ParseError(errorMessage);
+#else
+                            error = Error::Parse;
+                            errorMsg = errorMessage;
+                            return it;
+#endif
+                        }
+                    }
+
+                    if (!readCompletion && completion != nullptr && completion->Matched())
+                    {
+#ifdef ARGS_NOEXCEPT
+                        error = Error::Completion;
+#endif
+                        readCompletion = true;
+                        ++it;
+                        const auto argsLeft = static_cast<size_t>(std::distance(it, end));
+                        if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
+                        {
+#ifndef ARGS_NOEXCEPT
+                            throw Completion("");
+#endif
+                        }
+
+                        std::vector<std::string> curArgs(++it, end);
+                        curArgs.resize(completion->cword);
+
+                        if (completion->syntax == "bash")
+                        {
+                            // bash tokenizes --flag=value as --flag=value
+                            for (size_t idx = 0; idx < curArgs.size(); )
+                            {
+                                if (idx > 0 && curArgs[idx] == "=")
+                                {
+                                    curArgs[idx - 1] += "=";
+                                    // Avoid warnings from -Wsign-conversion
+                                    const auto signedIdx = static_cast<std::ptrdiff_t>(idx);
+                                    if (idx + 1 < curArgs.size())
+                                    {
+                                        curArgs[idx - 1] += curArgs[idx + 1];
+                                        curArgs.erase(curArgs.begin() + signedIdx, curArgs.begin() + signedIdx + 2);
+                                    } else
+                                    {
+                                        curArgs.erase(curArgs.begin() + signedIdx);
+                                    }
+                                } else
+                                {
+                                    ++idx;
+                                }
+                            }
+
+                        }
+#ifndef ARGS_NOEXCEPT
+                        try
+                        {
+                            Parse(curArgs.begin(), curArgs.end());
+                            throw Completion("");
+                        }
+                        catch (Completion &)
+                        {
+                            throw;
+                        }
+                        catch (args::Error&)
+                        {
+                            throw Completion("");
+                        }
+#else
+                        return Parse(curArgs.begin(), curArgs.end());
+#endif
+                    }
+                }
+
+                Validate(shortprefix, longprefix);
+                return end;
+            }
+
+        public:
+            HelpParams helpParams;
+
+            ArgumentParser(const std::string &description_, const std::string &epilog_ = std::string())
+            {
+                Description(description_);
+                Epilog(epilog_);
+                LongPrefix("--");
+                ShortPrefix("-");
+                LongSeparator("=");
+                Terminator("--");
+                SetArgumentSeparations(true, true, true, true);
+                matched = true;
+            }
+
+            void AddCompletion(CompletionFlag &completionFlag)
+            {
+                completion = &completionFlag;
+                Add(completionFlag);
+            }
+
+            /** The program name for help generation
+             */
+            const std::string &Prog() const
+            { return helpParams.programName; }
+            /** The program name for help generation
+             */
+            void Prog(const std::string &prog_)
+            { this->helpParams.programName = prog_; }
+
+            /** The prefix for long flags
+             */
+            const std::string &LongPrefix() const
+            { return longprefix; }
+            /** The prefix for long flags
+             */
+            void LongPrefix(const std::string &longprefix_)
+            {
+                this->longprefix = longprefix_;
+                this->helpParams.longPrefix = longprefix_;
+            }
+
+            /** The prefix for short flags
+             */
+            const std::string &ShortPrefix() const
+            { return shortprefix; }
+            /** The prefix for short flags
+             */
+            void ShortPrefix(const std::string &shortprefix_)
+            {
+                this->shortprefix = shortprefix_;
+                this->helpParams.shortPrefix = shortprefix_;
+            }
+
+            /** The separator for long flags
+             */
+            const std::string &LongSeparator() const
+            { return longseparator; }
+            /** The separator for long flags
+             */
+            void LongSeparator(const std::string &longseparator_)
+            {
+                if (longseparator_.empty())
+                {
+                    const std::string errorMessage("longseparator can not be set to empty");
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Usage;
+                    errorMsg = errorMessage;
+#else
+                    throw UsageError(errorMessage);
+#endif
+                } else
+                {
+                    this->longseparator = longseparator_;
+                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator_ : " ";
+                }
+            }
+
+            /** The terminator that forcibly separates flags from positionals
+             */
+            const std::string &Terminator() const
+            { return terminator; }
+            /** The terminator that forcibly separates flags from positionals
+             */
+            void Terminator(const std::string &terminator_)
+            { this->terminator = terminator_; }
+
+            /** Get the current argument separation parameters.
+             *
+             * See SetArgumentSeparations for details on what each one means.
+             */
+            void GetArgumentSeparations(
+                bool &allowJoinedShortValue_,
+                bool &allowJoinedLongValue_,
+                bool &allowSeparateShortValue_,
+                bool &allowSeparateLongValue_) const
+            {
+                allowJoinedShortValue_ = this->allowJoinedShortValue;
+                allowJoinedLongValue_ = this->allowJoinedLongValue;
+                allowSeparateShortValue_ = this->allowSeparateShortValue;
+                allowSeparateLongValue_ = this->allowSeparateLongValue;
+            }
+
+            /** Change allowed option separation.
+             *
+             * \param allowJoinedShortValue_ Allow a short flag that accepts an argument to be passed its argument immediately next to it (ie. in the same argv field)
+             * \param allowJoinedLongValue_ Allow a long flag that accepts an argument to be passed its argument separated by the longseparator (ie. in the same argv field)
+             * \param allowSeparateShortValue_ Allow a short flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field)
+             * \param allowSeparateLongValue_ Allow a long flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field)
+             */
+            void SetArgumentSeparations(
+                const bool allowJoinedShortValue_,
+                const bool allowJoinedLongValue_,
+                const bool allowSeparateShortValue_,
+                const bool allowSeparateLongValue_)
+            {
+                this->allowJoinedShortValue = allowJoinedShortValue_;
+                this->allowJoinedLongValue = allowJoinedLongValue_;
+                this->allowSeparateShortValue = allowSeparateShortValue_;
+                this->allowSeparateLongValue = allowSeparateLongValue_;
+
+                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
+                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
+            }
+
+            /** Pass the help menu into an ostream
+             */
+            void Help(std::ostream &help_) const
+            {
+                auto &command = SelectedCommand();
+                const auto &commandDescription = command.Description().empty() ? command.Help() : command.Description();
+                const auto description_text = Wrap(commandDescription, helpParams.width - helpParams.descriptionindent);
+                const auto epilog_text = Wrap(command.Epilog(), helpParams.width - helpParams.descriptionindent);
+
+                const bool hasoptions = command.HasFlag();
+                const bool hasarguments = command.HasPositional();
+
+                std::vector<std::string> prognameline;
+                prognameline.push_back(helpParams.usageString);
+                prognameline.push_back(Prog());
+                auto commandProgLine = command.GetProgramLine(helpParams);
+                prognameline.insert(prognameline.end(), commandProgLine.begin(), commandProgLine.end());
+
+                const auto proglines = Wrap(prognameline.begin(), prognameline.end(),
+                                            helpParams.width - (helpParams.progindent + helpParams.progtailindent),
+                                            helpParams.width - helpParams.progindent);
+                auto progit = std::begin(proglines);
+                if (progit != std::end(proglines))
+                {
+                    help_ << std::string(helpParams.progindent, ' ') << *progit << '\n';
+                    ++progit;
+                }
+                for (; progit != std::end(proglines); ++progit)
+                {
+                    help_ << std::string(helpParams.progtailindent, ' ') << *progit << '\n';
+                }
+
+                help_ << '\n';
+
+                if (!description_text.empty())
+                {
+                    for (const auto &line: description_text)
+                    {
+                        help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n";
+                    }
+                    help_ << "\n";
+                }
+
+                bool lastDescriptionIsNewline = false;
+
+                if (!helpParams.optionsString.empty())
+                {
+                    help_ << std::string(helpParams.progindent, ' ') << helpParams.optionsString << "\n\n";
+                }
+
+                for (const auto &desc: command.GetDescription(helpParams, 0))
+                {
+                    lastDescriptionIsNewline = std::get<0>(desc).empty() && std::get<1>(desc).empty();
+                    const auto groupindent = std::get<2>(desc) * helpParams.eachgroupindent;
+                    const auto flags = Wrap(std::get<0>(desc), helpParams.width - (helpParams.flagindent + helpParams.helpindent + helpParams.gutter));
+                    const auto info = Wrap(std::get<1>(desc), helpParams.width - (helpParams.helpindent + groupindent));
+
+                    std::string::size_type flagssize = 0;
+                    for (auto flagsit = std::begin(flags); flagsit != std::end(flags); ++flagsit)
+                    {
+                        if (flagsit != std::begin(flags))
+                        {
+                            help_ << '\n';
+                        }
+                        help_ << std::string(groupindent + helpParams.flagindent, ' ') << *flagsit;
+                        flagssize = Glyphs(*flagsit);
+                    }
+
+                    auto infoit = std::begin(info);
+                    // groupindent is on both sides of this inequality, and therefore can be removed
+                    if ((helpParams.flagindent + flagssize + helpParams.gutter) > helpParams.helpindent || infoit == std::end(info) || helpParams.addNewlineBeforeDescription)
+                    {
+                        help_ << '\n';
+                    } else
+                    {
+                        // groupindent is on both sides of the minus sign, and therefore doesn't actually need to be in here
+                        help_ << std::string(helpParams.helpindent - (helpParams.flagindent + flagssize), ' ') << *infoit << '\n';
+                        ++infoit;
+                    }
+                    for (; infoit != std::end(info); ++infoit)
+                    {
+                        help_ << std::string(groupindent + helpParams.helpindent, ' ') << *infoit << '\n';
+                    }
+                }
+                if (hasoptions && hasarguments && helpParams.showTerminator)
+                {
+                    lastDescriptionIsNewline = false;
+                    for (const auto &item: Wrap(std::string("\"") + terminator + "\" can be used to terminate flag options and force all following arguments to be treated as positional options", helpParams.width - helpParams.flagindent))
+                    {
+                        help_ << std::string(helpParams.flagindent, ' ') << item << '\n';
+                    }
+                }
+
+                if (!lastDescriptionIsNewline)
+                {
+                    help_ << "\n";
+                }
+
+                for (const auto &line: epilog_text)
+                {
+                    help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n";
+                }
+            }
+
+            /** Generate a help menu as a string.
+             *
+             * \return the help text as a single string
+             */
+            std::string Help() const
+            {
+                std::ostringstream help_;
+                Help(help_);
+                return help_.str();
+            }
+
+            virtual void Reset() noexcept override
+            {
+                Command::Reset();
+                matched = true;
+                readCompletion = false;
+            }
+
+            /** Parse all arguments.
+             *
+             * \param begin an iterator to the beginning of the argument list
+             * \param end an iterator to the past-the-end element of the argument list
+             * \return the iterator after the last parsed value.  Only useful for kick-out
+             */
+            template <typename It>
+            It ParseArgs(It begin, It end)
+            {
+                // Reset all Matched statuses and errors
+                Reset();
+#ifdef ARGS_NOEXCEPT
+                error = GetError();
+                if (error != Error::None)
+                {
+                    return end;
+                }
+#endif
+                return Parse(begin, end);
+            }
+
+            /** Parse all arguments.
+             *
+             * \param args an iterable of the arguments
+             * \return the iterator after the last parsed value.  Only useful for kick-out
+             */
+            template <typename T>
+            auto ParseArgs(const T &args) -> decltype(std::begin(args))
+            {
+                return ParseArgs(std::begin(args), std::end(args));
+            }
+
+            /** Convenience function to parse the CLI from argc and argv
+             *
+             * Just assigns the program name and vectorizes arguments for passing into ParseArgs()
+             *
+             * \return whether or not all arguments were parsed.  This works for detecting kick-out, but is generally useless as it can't do anything with it.
+             */
+            bool ParseCLI(const int argc, const char * const * argv)
+            {
+                if (Prog().empty())
+                {
+                    Prog(argv[0]);
+                }
+                const std::vector<std::string> args(argv + 1, argv + argc);
+                return ParseArgs(args) == std::end(args);
+            }
+            
+            template <typename T>
+            bool ParseCLI(const T &args)
+            {
+                return ParseArgs(args) == std::end(args);
+            }
+    };
+
+    inline Command::RaiiSubparser::RaiiSubparser(ArgumentParser &parser_, std::vector<std::string> args_)
+        : command(parser_.SelectedCommand()), parser(std::move(args_), parser_, command, parser_.helpParams), oldSubparser(command.subparser)
+    {
+        command.subparser = &parser;
+    }
+
+    inline Command::RaiiSubparser::RaiiSubparser(const Command &command_, const HelpParams &params_): command(command_), parser(command, params_), oldSubparser(command.subparser)
+    {
+        command.subparser = &parser;
+    }
+
+    inline void Subparser::Parse()
+    {
+        isParsed = true;
+        Reset();
+        command.subparserDescription = GetDescription(helpParams, 0);
+        command.subparserHasFlag = HasFlag();
+        command.subparserHasPositional = HasPositional();
+        command.subparserHasCommand = HasCommand();
+        command.subparserProgramLine = GetProgramLine(helpParams);
+        if (parser == nullptr)
+        {
+#ifndef ARGS_NOEXCEPT
+            throw args::SubparserError();
+#else
+            error = Error::Subparser;
+            return;
+#endif
+        }
+
+        auto it = parser->Parse(args.begin(), args.end());
+        command.Validate(parser->ShortPrefix(), parser->LongPrefix());
+        kicked.assign(it, args.end());
+
+#ifdef ARGS_NOEXCEPT
+        command.subparserError = GetError();
+#endif
+    }
+
+    inline std::ostream &operator<<(std::ostream &os, const ArgumentParser &parser)
+    {
+        parser.Help(os);
+        return os;
+    }
+
+    /** Boolean argument matcher
+     */
+    class Flag : public FlagBase
+    {
+        public:
+            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
+            {
+                group_.Add(*this);
+            }
+
+            Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false): Flag(group_, name_, help_, std::move(matcher_), extraError_ ? Options::Single : Options::None)
+            {
+            }
+
+            virtual ~Flag() {}
+
+            /** Get whether this was matched
+             */
+            bool Get() const
+            {
+                return Matched();
+            }
+
+            virtual Nargs NumberOfArguments() const noexcept override
+            {
+                return 0;
+            }
+
+            virtual void ParseValue(const std::vector<std::string>&) override
+            {
+            }
+    };
+
+    /** Help flag class
+     *
+     * Works like a regular flag, but throws an instance of Help when it is matched
+     */
+    class HelpFlag : public Flag
+    {
+        public:
+            HelpFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_ = {}): Flag(group_, name_, help_, std::move(matcher_), options_) {}
+
+            virtual ~HelpFlag() {}
+
+            virtual void ParseValue(const std::vector<std::string> &)
+            {
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Help;
+                    errorMsg = Name();
+#else
+                    throw Help(Name());
+#endif
+            }
+
+            /** Get whether this was matched
+             */
+            bool Get() const noexcept
+            {
+                return Matched();
+            }
+    };
+
+    /** A flag class that simply counts the number of times it's matched
+     */
+    class CounterFlag : public Flag
+    {
+        private:
+            const int startcount;
+            int count;
+
+        public:
+            CounterFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const int startcount_ = 0, Options options_ = {}):
+                Flag(group_, name_, help_, std::move(matcher_), options_), startcount(startcount_), count(startcount_) {}
+
+            virtual ~CounterFlag() {}
+
+            virtual FlagBase *Match(const EitherFlag &arg) override
+            {
+                auto me = FlagBase::Match(arg);
+                if (me)
+                {
+                    ++count;
+                }
+                return me;
+            }
+
+            /** Get the count
+             */
+            int &Get() noexcept
+            {
+                return count;
+            }
+
+            virtual void Reset() noexcept override
+            {
+                FlagBase::Reset();
+                count = startcount;
+            }
+    };
+
+    /** A flag class that calls a function when it's matched
+     */
+    class ActionFlag : public FlagBase
+    {
+        private:
+            std::function<void(const std::vector<std::string> &)> action;
+            Nargs nargs;
+
+        public:
+            ActionFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Nargs nargs_, std::function<void(const std::vector<std::string> &)> action_, Options options_ = {}):
+                FlagBase(name_, help_, std::move(matcher_), options_), action(std::move(action_)), nargs(nargs_)
+            {
+                group_.Add(*this);
+            }
+
+            ActionFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, std::function<void(const std::string &)> action_, Options options_ = {}):
+                FlagBase(name_, help_, std::move(matcher_), options_), nargs(1)
+            {
+                group_.Add(*this);
+                action = [action_](const std::vector<std::string> &a) { return action_(a.at(0)); };
+            }
+
+            ActionFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, std::function<void()> action_, Options options_ = {}):
+                FlagBase(name_, help_, std::move(matcher_), options_), nargs(0)
+            {
+                group_.Add(*this);
+                action = [action_](const std::vector<std::string> &) { return action_(); };
+            }
+
+            virtual Nargs NumberOfArguments() const noexcept override
+            { return nargs; }
+
+            virtual void ParseValue(const std::vector<std::string> &value) override
+            { action(value); }
+    };
+
+    /** A default Reader class for argument classes
+     *
+     * If destination type is assignable to std::string it uses an assignment to std::string.
+     * Otherwise ValueReader simply uses a std::istringstream to read into the destination type, and
+     * raises a ParseError if there are any characters left.
+     */
+    struct ValueReader
+    {
+        template <typename T>
+        typename std::enable_if<!std::is_assignable<T, std::string>::value, bool>::type
+        operator ()(const std::string &name, const std::string &value, T &destination)
+        {
+            std::istringstream ss(value);
+            bool failed = !(ss >> destination);
+
+            if (!failed)
+            {
+                ss >> std::ws;
+            }
+
+            if (ss.rdbuf()->in_avail() > 0 || failed)
+            {
+#ifdef ARGS_NOEXCEPT
+                (void)name;
+                return false;
+#else
+                std::ostringstream problem;
+                problem << "Argument '" << name << "' received invalid value type '" << value << "'";
+                throw ParseError(problem.str());
+#endif
+            }
+            return true;
+        }
+
+        template <typename T>
+        typename std::enable_if<std::is_assignable<T, std::string>::value, bool>::type
+        operator()(const std::string &, const std::string &value, T &destination)
+        {
+            destination = value;
+            return true;
+        }
+    };
+
+    /** An argument-accepting flag class
+     * 
+     * \tparam T the type to extract the argument as
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     */
+    template <
+        typename T,
+        typename Reader = ValueReader>
+    class ValueFlag : public ValueFlagBase
+    {
+        protected:
+            T value;
+            T defaultValue;
+
+            virtual std::string GetDefaultString(const HelpParams&) const override
+            {
+                return detail::ToString(defaultValue);
+            }
+
+        private:
+            Reader reader;
+
+        public:
+
+            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_)
+            {
+                group_.Add(*this);
+            }
+
+            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None)
+            {
+            }
+
+            ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): ValueFlag(group_, name_, help_, std::move(matcher_), T(), options_)
+            {
+            }
+
+            virtual ~ValueFlag() {}
+
+            virtual void ParseValue(const std::vector<std::string> &values_) override
+            {
+                const std::string &value_ = values_.at(0);
+
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, this->value))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, this->value);
+#endif
+            }
+
+            virtual void Reset() noexcept override
+            {
+                ValueFlagBase::Reset();
+                value = defaultValue;
+            }
+
+            /** Get the value
+             */
+            T &Get() noexcept
+            {
+                return value;
+            }
+
+            /** Get the default value
+             */
+            const T &GetDefault() noexcept
+            {
+                return defaultValue;
+            }
+    };
+
+    /** An optional argument-accepting flag class
+     *
+     * \tparam T the type to extract the argument as
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     */
+    template <
+        typename T,
+        typename Reader = ValueReader>
+    class ImplicitValueFlag : public ValueFlag<T, Reader>
+    {
+        protected:
+            T implicitValue;
+
+        public:
+
+            ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &implicitValue_, const T &defaultValue_ = T(), Options options_ = {})
+                : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(implicitValue_)
+            {
+            }
+
+            ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), Options options_ = {})
+                : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(defaultValue_)
+            {
+            }
+
+            ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_)
+                : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), {}, options_), implicitValue()
+            {
+            }
+
+            virtual ~ImplicitValueFlag() {}
+
+            virtual Nargs NumberOfArguments() const noexcept override
+            {
+                return {0, 1};
+            }
+
+            virtual void ParseValue(const std::vector<std::string> &value_) override
+            {
+                if (value_.empty())
+                {
+                    this->value = implicitValue;
+                } else
+                {
+                    ValueFlag<T, Reader>::ParseValue(value_);
+                }
+            }
+    };
+
+    /** A variadic arguments accepting flag class
+     *
+     * \tparam T the type to extract the argument as
+     * \tparam List the list type that houses the values
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     */
+    template <
+        typename T,
+        template <typename...> class List = detail::vector,
+        typename Reader = ValueReader>
+    class NargsValueFlag : public FlagBase
+    {
+        protected:
+
+            List<T> values;
+            const List<T> defaultValues;
+            Nargs nargs;
+            Reader reader;
+
+        public:
+
+            typedef List<T> Container;
+            typedef T value_type;
+            typedef typename Container::allocator_type allocator_type;
+            typedef typename Container::pointer pointer;
+            typedef typename Container::const_pointer const_pointer;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef typename Container::size_type size_type;
+            typedef typename Container::difference_type difference_type;
+            typedef typename Container::iterator iterator;
+            typedef typename Container::const_iterator const_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+            NargsValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Nargs nargs_, const List<T> &defaultValues_ = {}, Options options_ = {})
+                : FlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_),nargs(nargs_)
+            {
+                group_.Add(*this);
+            }
+
+            virtual ~NargsValueFlag() {}
+
+            virtual Nargs NumberOfArguments() const noexcept override
+            {
+                return nargs;
+            }
+
+            virtual void ParseValue(const std::vector<std::string> &values_) override
+            {
+                values.clear();
+
+                for (const std::string &value : values_)
+                {
+                    T v;
+#ifdef ARGS_NOEXCEPT
+                    if (!reader(name, value, v))
+                    {
+                        error = Error::Parse;
+                    }
+#else
+                    reader(name, value, v);
+#endif
+                    values.insert(std::end(values), v);
+                }
+            }
+
+            List<T> &Get() noexcept
+            {
+                return values;
+            }
+
+            iterator begin() noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator begin() const noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator cbegin() const noexcept
+            {
+                return values.cbegin();
+            }
+
+            iterator end() noexcept
+            {
+                return values.end();
+            }
+
+            const_iterator end() const noexcept 
+            {
+                return values.end();
+            }
+
+            const_iterator cend() const noexcept
+            {
+                return values.cend();
+            }
+
+            virtual void Reset() noexcept override
+            {
+                FlagBase::Reset();
+                values = defaultValues;
+            }
+
+            virtual FlagBase *Match(const EitherFlag &arg) override
+            {
+                const bool wasMatched = Matched();
+                auto me = FlagBase::Match(arg);
+                if (me && !wasMatched)
+                {
+                    values.clear();
+                }
+                return me;
+            }
+    };
+
+    /** An argument-accepting flag class that pushes the found values into a list
+     * 
+     * \tparam T the type to extract the argument as
+     * \tparam List the list type that houses the values
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     */
+    template <
+        typename T,
+        template <typename...> class List = detail::vector,
+        typename Reader = ValueReader>
+    class ValueFlagList : public ValueFlagBase
+    {
+        private:
+            using Container = List<T>;
+            Container values;
+            const Container defaultValues;
+            Reader reader;
+
+        public:
+
+            typedef T value_type;
+            typedef typename Container::allocator_type allocator_type;
+            typedef typename Container::pointer pointer;
+            typedef typename Container::const_pointer const_pointer;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef typename Container::size_type size_type;
+            typedef typename Container::difference_type difference_type;
+            typedef typename Container::iterator iterator;
+            typedef typename Container::const_iterator const_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+            ValueFlagList(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Container &defaultValues_ = Container(), Options options_ = {}):
+                ValueFlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_)
+            {
+                group_.Add(*this);
+            }
+
+            virtual ~ValueFlagList() {}
+
+            virtual void ParseValue(const std::vector<std::string> &values_) override
+            {
+                const std::string &value_ = values_.at(0);
+
+                T v;
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, v))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, v);
+#endif
+                values.insert(std::end(values), v);
+            }
+
+            /** Get the values
+             */
+            Container &Get() noexcept
+            {
+                return values;
+            }
+
+            virtual std::string Name() const override
+            {
+                return name + std::string("...");
+            }
+
+            virtual void Reset() noexcept override
+            {
+                ValueFlagBase::Reset();
+                values = defaultValues;
+            }
+
+            virtual FlagBase *Match(const EitherFlag &arg) override
+            {
+                const bool wasMatched = Matched();
+                auto me = FlagBase::Match(arg);
+                if (me && !wasMatched)
+                {
+                    values.clear();
+                }
+                return me;
+            }
+
+            iterator begin() noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator begin() const noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator cbegin() const noexcept
+            {
+                return values.cbegin();
+            }
+
+            iterator end() noexcept
+            {
+                return values.end();
+            }
+
+            const_iterator end() const noexcept 
+            {
+                return values.end();
+            }
+
+            const_iterator cend() const noexcept
+            {
+                return values.cend();
+            }
+    };
+
+    /** A mapping value flag class
+     * 
+     * \tparam K the type to extract the argument as
+     * \tparam T the type to store the result as
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     * \tparam Map The Map type.  Should operate like std::map or std::unordered_map
+     */
+    template <
+        typename K,
+        typename T,
+        typename Reader = ValueReader,
+        template <typename...> class Map = detail::unordered_map>
+    class MapFlag : public ValueFlagBase
+    {
+        private:
+            const Map<K, T> map;
+            T value;
+            const T defaultValue;
+            Reader reader;
+
+        protected:
+            virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+            {
+                return detail::MapKeysToStrings(map);
+            }
+
+        public:
+
+            MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), map(map_), value(defaultValue_), defaultValue(defaultValue_)
+            {
+                group_.Add(*this);
+            }
+
+            MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const T &defaultValue_ = T(), const bool extraError_ = false): MapFlag(group_, name_, help_, std::move(matcher_), map_, defaultValue_, extraError_ ? Options::Single : Options::None)
+            {
+            }
+
+            MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, Options options_): MapFlag(group_, name_, help_, std::move(matcher_), map_, T(), options_)
+            {
+            }
+
+            virtual ~MapFlag() {}
+
+            virtual void ParseValue(const std::vector<std::string> &values_) override
+            {
+                const std::string &value_ = values_.at(0);
+
+                K key;
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, key))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, key);
+#endif
+                auto it = map.find(key);
+                if (it == std::end(map))
+                {
+                    std::ostringstream problem;
+                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Map;
+                    errorMsg = problem.str();
+#else
+                    throw MapError(problem.str());
+#endif
+                } else
+                {
+                    this->value = it->second;
+                }
+            }
+
+            /** Get the value
+             */
+            T &Get() noexcept
+            {
+                return value;
+            }
+
+            virtual void Reset() noexcept override
+            {
+                ValueFlagBase::Reset();
+                value = defaultValue;
+            }
+    };
+
+    /** A mapping value flag list class
+     * 
+     * \tparam K the type to extract the argument as
+     * \tparam T the type to store the result as
+     * \tparam List the list type that houses the values
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     * \tparam Map The Map type.  Should operate like std::map or std::unordered_map
+     */
+    template <
+        typename K,
+        typename T,
+        template <typename...> class List = detail::vector,
+        typename Reader = ValueReader,
+        template <typename...> class Map = detail::unordered_map>
+    class MapFlagList : public ValueFlagBase
+    {
+        private:
+            using Container = List<T>;
+            const Map<K, T> map;
+            Container values;
+            const Container defaultValues;
+            Reader reader;
+
+        protected:
+            virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+            {
+                return detail::MapKeysToStrings(map);
+            }
+
+        public:
+            typedef T value_type;
+            typedef typename Container::allocator_type allocator_type;
+            typedef typename Container::pointer pointer;
+            typedef typename Container::const_pointer const_pointer;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef typename Container::size_type size_type;
+            typedef typename Container::difference_type difference_type;
+            typedef typename Container::iterator iterator;
+            typedef typename Container::const_iterator const_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+            MapFlagList(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const Container &defaultValues_ = Container()): ValueFlagBase(name_, help_, std::move(matcher_)), map(map_), values(defaultValues_), defaultValues(defaultValues_)
+            {
+                group_.Add(*this);
+            }
+
+            virtual ~MapFlagList() {}
+
+            virtual void ParseValue(const std::vector<std::string> &values_) override
+            {
+                const std::string &value = values_.at(0);
+
+                K key;
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value, key))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value, key);
+#endif
+                auto it = map.find(key);
+                if (it == std::end(map))
+                {
+                    std::ostringstream problem;
+                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Map;
+                    errorMsg = problem.str();
+#else
+                    throw MapError(problem.str());
+#endif
+                } else
+                {
+                    this->values.emplace_back(it->second);
+                }
+            }
+
+            /** Get the value
+             */
+            Container &Get() noexcept
+            {
+                return values;
+            }
+
+            virtual std::string Name() const override
+            {
+                return name + std::string("...");
+            }
+
+            virtual void Reset() noexcept override
+            {
+                ValueFlagBase::Reset();
+                values = defaultValues;
+            }
+
+            virtual FlagBase *Match(const EitherFlag &arg) override
+            {
+                const bool wasMatched = Matched();
+                auto me = FlagBase::Match(arg);
+                if (me && !wasMatched)
+                {
+                    values.clear();
+                }
+                return me;
+            }
+
+            iterator begin() noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator begin() const noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator cbegin() const noexcept
+            {
+                return values.cbegin();
+            }
+
+            iterator end() noexcept
+            {
+                return values.end();
+            }
+
+            const_iterator end() const noexcept 
+            {
+                return values.end();
+            }
+
+            const_iterator cend() const noexcept
+            {
+                return values.cend();
+            }
+    };
+
+    /** A positional argument class
+     *
+     * \tparam T the type to extract the argument as
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     */
+    template <
+        typename T,
+        typename Reader = ValueReader>
+    class Positional : public PositionalBase
+    {
+        private:
+            T value;
+            const T defaultValue;
+            Reader reader;
+        public:
+            Positional(Group &group_, const std::string &name_, const std::string &help_, const T &defaultValue_ = T(), Options options_ = {}): PositionalBase(name_, help_, options_), value(defaultValue_), defaultValue(defaultValue_)
+            {
+                group_.Add(*this);
+            }
+
+            Positional(Group &group_, const std::string &name_, const std::string &help_, Options options_): Positional(group_, name_, help_, T(), options_)
+            {
+            }
+
+            virtual ~Positional() {}
+
+            virtual void ParseValue(const std::string &value_) override
+            {
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, this->value))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, this->value);
+#endif
+                ready = false;
+                matched = true;
+            }
+
+            /** Get the value
+             */
+            T &Get() noexcept
+            {
+                return value;
+            }
+
+            virtual void Reset() noexcept override
+            {
+                PositionalBase::Reset();
+                value = defaultValue;
+            }
+    };
+
+    /** A positional argument class that pushes the found values into a list
+     * 
+     * \tparam T the type to extract the argument as
+     * \tparam List the list type that houses the values
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     */
+    template <
+        typename T,
+        template <typename...> class List = detail::vector,
+        typename Reader = ValueReader>
+    class PositionalList : public PositionalBase
+    {
+        private:
+            using Container = List<T>;
+            Container values;
+            const Container defaultValues;
+            Reader reader;
+
+        public:
+            typedef T value_type;
+            typedef typename Container::allocator_type allocator_type;
+            typedef typename Container::pointer pointer;
+            typedef typename Container::const_pointer const_pointer;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef typename Container::size_type size_type;
+            typedef typename Container::difference_type difference_type;
+            typedef typename Container::iterator iterator;
+            typedef typename Container::const_iterator const_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+            PositionalList(Group &group_, const std::string &name_, const std::string &help_, const Container &defaultValues_ = Container(), Options options_ = {}): PositionalBase(name_, help_, options_), values(defaultValues_), defaultValues(defaultValues_)
+            {
+                group_.Add(*this);
+            }
+
+            PositionalList(Group &group_, const std::string &name_, const std::string &help_, Options options_): PositionalList(group_, name_, help_, {}, options_)
+            {
+            }
+
+            virtual ~PositionalList() {}
+
+            virtual void ParseValue(const std::string &value_) override
+            {
+                T v;
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, v))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, v);
+#endif
+                values.insert(std::end(values), v);
+                matched = true;
+            }
+
+            virtual std::string Name() const override
+            {
+                return name + std::string("...");
+            }
+
+            /** Get the values
+             */
+            Container &Get() noexcept
+            {
+                return values;
+            }
+
+            virtual void Reset() noexcept override
+            {
+                PositionalBase::Reset();
+                values = defaultValues;
+            }
+
+            virtual PositionalBase *GetNextPositional() override
+            {
+                const bool wasMatched = Matched();
+                auto me = PositionalBase::GetNextPositional();
+                if (me && !wasMatched)
+                {
+                    values.clear();
+                }
+                return me;
+            }
+
+            iterator begin() noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator begin() const noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator cbegin() const noexcept
+            {
+                return values.cbegin();
+            }
+
+            iterator end() noexcept
+            {
+                return values.end();
+            }
+
+            const_iterator end() const noexcept 
+            {
+                return values.end();
+            }
+
+            const_iterator cend() const noexcept
+            {
+                return values.cend();
+            }
+    };
+
+    /** A positional argument mapping class
+     * 
+     * \tparam K the type to extract the argument as
+     * \tparam T the type to store the result as
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     * \tparam Map The Map type.  Should operate like std::map or std::unordered_map
+     */
+    template <
+        typename K,
+        typename T,
+        typename Reader = ValueReader,
+        template <typename...> class Map = detail::unordered_map>
+    class MapPositional : public PositionalBase
+    {
+        private:
+            const Map<K, T> map;
+            T value;
+            const T defaultValue;
+            Reader reader;
+
+        protected:
+            virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+            {
+                return detail::MapKeysToStrings(map);
+            }
+
+        public:
+
+            MapPositional(Group &group_, const std::string &name_, const std::string &help_, const Map<K, T> &map_, const T &defaultValue_ = T(), Options options_ = {}):
+                PositionalBase(name_, help_, options_), map(map_), value(defaultValue_), defaultValue(defaultValue_)
+            {
+                group_.Add(*this);
+            }
+
+            virtual ~MapPositional() {}
+
+            virtual void ParseValue(const std::string &value_) override
+            {
+                K key;
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, key))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, key);
+#endif
+                auto it = map.find(key);
+                if (it == std::end(map))
+                {
+                    std::ostringstream problem;
+                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Map;
+                    errorMsg = problem.str();
+#else
+                    throw MapError(problem.str());
+#endif
+                } else
+                {
+                    this->value = it->second;
+                    ready = false;
+                    matched = true;
+                }
+            }
+
+            /** Get the value
+             */
+            T &Get() noexcept
+            {
+                return value;
+            }
+
+            virtual void Reset() noexcept override
+            {
+                PositionalBase::Reset();
+                value = defaultValue;
+            }
+    };
+
+    /** A positional argument mapping list class
+     * 
+     * \tparam K the type to extract the argument as
+     * \tparam T the type to store the result as
+     * \tparam List the list type that houses the values
+     * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+     * \tparam Map The Map type.  Should operate like std::map or std::unordered_map
+     */
+    template <
+        typename K,
+        typename T,
+        template <typename...> class List = detail::vector,
+        typename Reader = ValueReader,
+        template <typename...> class Map = detail::unordered_map>
+    class MapPositionalList : public PositionalBase
+    {
+        private:
+            using Container = List<T>;
+
+            const Map<K, T> map;
+            Container values;
+            const Container defaultValues;
+            Reader reader;
+
+        protected:
+            virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+            {
+                return detail::MapKeysToStrings(map);
+            }
+
+        public:
+            typedef T value_type;
+            typedef typename Container::allocator_type allocator_type;
+            typedef typename Container::pointer pointer;
+            typedef typename Container::const_pointer const_pointer;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef typename Container::size_type size_type;
+            typedef typename Container::difference_type difference_type;
+            typedef typename Container::iterator iterator;
+            typedef typename Container::const_iterator const_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+            MapPositionalList(Group &group_, const std::string &name_, const std::string &help_, const Map<K, T> &map_, const Container &defaultValues_ = Container(), Options options_ = {}):
+                PositionalBase(name_, help_, options_), map(map_), values(defaultValues_), defaultValues(defaultValues_)
+            {
+                group_.Add(*this);
+            }
+
+            virtual ~MapPositionalList() {}
+
+            virtual void ParseValue(const std::string &value_) override
+            {
+                K key;
+#ifdef ARGS_NOEXCEPT
+                if (!reader(name, value_, key))
+                {
+                    error = Error::Parse;
+                }
+#else
+                reader(name, value_, key);
+#endif
+                auto it = map.find(key);
+                if (it == std::end(map))
+                {
+                    std::ostringstream problem;
+                    problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+                    error = Error::Map;
+                    errorMsg = problem.str();
+#else
+                    throw MapError(problem.str());
+#endif
+                } else
+                {
+                    this->values.emplace_back(it->second);
+                    matched = true;
+                }
+            }
+
+            /** Get the value
+             */
+            Container &Get() noexcept
+            {
+                return values;
+            }
+
+            virtual std::string Name() const override
+            {
+                return name + std::string("...");
+            }
+
+            virtual void Reset() noexcept override
+            {
+                PositionalBase::Reset();
+                values = defaultValues;
+            }
+
+            virtual PositionalBase *GetNextPositional() override
+            {
+                const bool wasMatched = Matched();
+                auto me = PositionalBase::GetNextPositional();
+                if (me && !wasMatched)
+                {
+                    values.clear();
+                }
+                return me;
+            }
+
+            iterator begin() noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator begin() const noexcept
+            {
+                return values.begin();
+            }
+
+            const_iterator cbegin() const noexcept
+            {
+                return values.cbegin();
+            }
+
+            iterator end() noexcept
+            {
+                return values.end();
+            }
+
+            const_iterator end() const noexcept 
+            {
+                return values.end();
+            }
+
+            const_iterator cend() const noexcept
+            {
+                return values.cend();
+            }
+    };
+}
+
+#endif
diff --git a/src/color-map.cpp b/src/color-map.cpp
new file mode 100644
index 0000000..d3d4e49
--- /dev/null
+++ b/src/color-map.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "color-map.hpp"
+
+#include <cmath>
+#include <cassert>
+
+std::unique_ptr<ColorMap>
+ColorMap::FromType(ColorMapType type,
+                   const sf::Color& bg_color,
+                   const sf::Color& custom_color)
+{
+    /* colormaps are not allowed to be translucent */
+    sf::Color opaque_bg_color(bg_color.r, bg_color.g, bg_color.b, 255);
+    sf::Color opaque_custom_color(custom_color.r, custom_color.g, custom_color.b, 255);
+
+    switch (type) {
+        case ColorMapType::kJet:
+            return std::make_unique<JetColorMap>();
+
+        case ColorMapType::kGray:
+            return std::make_unique<TwoColorMap>(sf::Color::Black, sf::Color::White);
+
+        case ColorMapType::kPurple:
+            return std::make_unique<ThreeColorMap>(sf::Color::Black, sf::Color(204, 51, 255, 255), sf::Color::White);
+
+        case ColorMapType::kBlue:
+            return std::make_unique<ThreeColorMap>(sf::Color::Black, sf::Color(51, 51, 255, 255), sf::Color::White);
+
+        case ColorMapType::kGreen:
+            return std::make_unique<ThreeColorMap>(sf::Color::Black, sf::Color(0, 150, 0, 255), sf::Color::White);
+
+        case ColorMapType::kOrange:
+            return std::make_unique<ThreeColorMap>(sf::Color::Black, sf::Color(255, 102, 0, 255), sf::Color::White);
+
+        case ColorMapType::kRed:
+            return std::make_unique<ThreeColorMap>(sf::Color::Black, sf::Color(230, 0, 0, 255), sf::Color::White);
+
+        case ColorMapType::kCustom:
+            return std::make_unique<TwoColorMap>(opaque_bg_color, opaque_custom_color);
+
+        default:
+            throw std::runtime_error("unknown color map");
+    }
+}
+
+std::vector<uint8_t>
+ColorMap::Gradient(std::size_t width) const
+{
+    RealWindow values;
+    values.resize(width);
+    for (std::size_t i = 0; i < width; i++) {
+        values[i] = (double) i / (double) (width-1);
+    }
+    return this->Map(values);
+}
+
+InterpolationColorMap::InterpolationColorMap(const std::vector<sf::Color>& colors,
+                                             const std::vector<double>& vals) : colors_(colors), values_(vals)
+{
+    /* respect boundaries */
+    if (vals.size() != colors.size()) {
+        throw std::runtime_error("number of boundaries and number of colors differ");
+    }
+    if (vals.size() < 2) {
+        throw std::runtime_error("at least two colors needed in a colormap");
+    }
+    if (vals[0] != 0.0f) {
+        throw std::runtime_error("first colormap boundary must be 0.0");
+    }
+    if (vals[vals.size()-1] != 1.0f) {
+        throw std::runtime_error("last colormap boundary must be 1.0");
+    }
+    for (std::size_t i = 0; i < vals.size()-1; i++) {
+        if (vals[i] >= vals[i+1]) {
+            throw std::runtime_error("boundaries must be ascending");
+        }
+    }
+}
+
+std::vector<uint8_t>
+InterpolationColorMap::GetColor(double value) const
+{
+    if ((value < 0.0f) || (value > 1.0f)) {
+        throw std::runtime_error("input value outside of colormap domain");
+    }
+
+    std::size_t k = 0;
+    while (value > this->values_[k+1]) {
+        k++;
+        assert(k < (this->values_.size()-1));
+    }
+
+    double fu = (value - this->values_[k]) / (this->values_[k+1] - this->values_[k]);
+    double fl = 1.0f - fu;
+
+    return {
+        static_cast<uint8_t>(std::round(fl * this->colors_[k].r + fu * this->colors_[k+1].r)),
+        static_cast<uint8_t>(std::round(fl * this->colors_[k].g + fu * this->colors_[k+1].g)),
+        static_cast<uint8_t>(std::round(fl * this->colors_[k].b + fu * this->colors_[k+1].b)),
+        static_cast<uint8_t>(std::round(fl * this->colors_[k].a + fu * this->colors_[k+1].a)),
+    };
+}
+
+std::vector<uint8_t>
+InterpolationColorMap::Map(const RealWindow& input) const
+{
+    std::vector<uint8_t> output;
+    output.resize(input.size() * 4);
+
+    for (std::size_t i = 0; i < input.size(); i++) {
+        auto color = this->GetColor(input[i]);
+        assert(color.size() == 4);
+        output[i * 4 + 0] = color[0];
+        output[i * 4 + 1] = color[1];
+        output[i * 4 + 2] = color[2];
+        output[i * 4 + 3] = color[3];
+    }
+
+    return output;
+}
+
+TwoColorMap::TwoColorMap(const sf::Color& c1, const sf::Color& c2)
+    : InterpolationColorMap({ c1, c2 }, { 0.0f, 1.0f })
+{
+}
+
+ThreeColorMap::ThreeColorMap(const sf::Color& c1, const sf::Color& c2, const sf::Color& c3)
+    : InterpolationColorMap({ c1, c2, c3 }, { 0.0f, 0.5f, 1.0f })
+{
+}
+
+JetColorMap::JetColorMap() : InterpolationColorMap(
+            { /* MATLAB jet colormap */
+                sf::Color(0, 0, 143, 255),
+                sf::Color(0, 0, 255, 255),
+                sf::Color(0, 255, 255, 255),
+                sf::Color(255, 255, 0, 255),
+                sf::Color(255, 127, 0, 255),
+                sf::Color(255, 0, 0, 255),
+                sf::Color(127, 0, 0, 255),
+            },
+            { 0.0f, 1.0f / 9.0f, 23.0f / 63.0f, 13.0f / 21.0f, 47.0f / 63.0f, 55.0 / 63.0, 1.0f }
+        )
+{
+}
\ No newline at end of file
diff --git a/src/color-map.hpp b/src/color-map.hpp
new file mode 100644
index 0000000..2878652
--- /dev/null
+++ b/src/color-map.hpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef _COLOR_MAP_HPP_
+#define _COLOR_MAP_HPP_
+
+#include "input-parser.hpp"
+
+#include <vector>
+#include <memory>
+#include <cstdint>
+#include <SFML/Graphics.hpp>
+
+enum class ColorMapType {
+    /* MATLAB jet map */
+    kJet,
+
+    /* bicolor maps */
+    kGray,
+    kPurple,
+    kBlue,
+    kGreen,
+    kOrange,
+    kRed,
+
+    /* custom; bg->color */
+    kCustom
+};
+
+class ColorMap {
+protected:
+    ColorMap() = default;
+
+public:
+    ColorMap(const ColorMap&) = default;
+
+    static std::unique_ptr<ColorMap> FromType(ColorMapType type,
+                                              const sf::Color& bg_color,
+                                              const sf::Color& custom_color);
+
+    virtual std::vector<uint8_t> Map(const RealWindow& input) const = 0;
+    std::vector<uint8_t> Gradient(std::size_t width) const;
+};
+
+class InterpolationColorMap : public ColorMap {
+private:
+    const std::vector<sf::Color> colors_;
+    const std::vector<double> values_;
+
+    std::vector<uint8_t> GetColor(double value) const;
+
+protected:
+    InterpolationColorMap(const std::vector<sf::Color>& colors, const std::vector<double>& vals);
+
+public:
+    InterpolationColorMap() = delete;
+
+    std::vector<uint8_t> Map(const std::vector<double>& input) const override;
+};
+
+class TwoColorMap : public InterpolationColorMap {
+public:
+    TwoColorMap(const sf::Color& c1, const sf::Color& c2);
+};
+
+class ThreeColorMap : public InterpolationColorMap {
+public:
+    ThreeColorMap(const sf::Color& c1, const sf::Color& c2, const sf::Color& c3);
+};
+
+class JetColorMap : public InterpolationColorMap {
+public:
+    JetColorMap();
+};
+
+#endif
\ No newline at end of file
diff --git a/src/configuration.cpp b/src/configuration.cpp
new file mode 100644
index 0000000..fd28f8e
--- /dev/null
+++ b/src/configuration.cpp
@@ -0,0 +1,491 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "configuration.hpp"
+#include "args.hxx"
+#include "input-parser.hpp"
+#include "specgram.hpp"
+#include "fft.hpp"
+
+#include <tuple>
+#include <regex>
+
+Configuration::Configuration()
+{
+    this->input_filename_ = {};
+    this->output_filename_ = {};
+
+    this->block_size_ = 256;
+    this->rate_ = 44100;
+    this->datatype_ = DataType::kSignedInt16;
+    this->prescale_factor_ = 1.0f;
+
+    this->fft_width_ = 1024;
+    this->fft_stride_ = 1024;
+    this->alias_negative_ = true;
+    this->window_function_ = WindowFunctionType::kHann;
+    this->average_count_ = 1;
+
+    this->no_resampling_ = false;
+    this->width_ = 512;
+    this->min_freq_ = 0;
+    this->max_freq_ = this->rate_ / 2;
+    this->scale_ = ValueMapType::kdBFS;
+    this->scale_lower_bound_ = -120.0f;
+    this->color_map_ = ColorMapType::kJet;
+    this->background_color_ = sf::Color(0, 0, 0);
+    this->foreground_color_ = sf::Color(255, 255, 255);
+    this->has_axes_ = false;
+    this->has_legend_ = false;
+    this->is_horizontal_ = false;
+    this->print_input_ = false;
+    this->print_fft_ = false;
+    this->print_output_ = false;
+
+    this->live_ = false;
+    this->count_ = 512;
+    this->title_ = "Spectrogram";
+
+
+    this->has_live_window_ = false;
+    this->margin_size_ = 30;
+    this->live_margin_size_ = 16; /* this is so the two axes share the same label... more or less */
+    this->minimum_margin_size_ = 15;
+    this->legend_height_ = 20;
+    this->live_fft_height_ = 100;
+    this->axis_font_size_ = 12;
+}
+
+sf::Color
+Configuration::GetLiveGuidelinesColor() const
+{
+    sf::Color c = this->GetForegroundColor();
+    c.a = 50;
+    return c;
+}
+
+Configuration
+Configuration::GetForLive() const
+{
+    Configuration c(*this);
+
+    /* overridden configuration for live output */
+    c.has_axes_ = true;
+    c.has_legend_ = true;
+    c.has_live_window_ = true;
+
+    /* do not allow transparent background, will generate artifacts on live view */
+    c.background_color_.a = 255;
+
+    return c;
+}
+
+sf::Color
+Configuration::StringToColor(const std::string& str)
+{
+    if (std::regex_match(str, std::regex("[0-9a-fA-F]{6}"))) {
+        unsigned int color = std::strtoul(str.c_str(), 0, 16);
+        return sf::Color(
+                ((color >> 16) & 0xff),
+                ((color >> 8) & 0xff),
+                (color & 0xff),
+                255);
+    } else if (std::regex_match(str, std::regex("[0-9a-fA-F]{8}"))) {
+        unsigned int color = std::strtoul(str.c_str(), 0, 16);
+        return sf::Color(
+                ((color >> 24) & 0xff),
+                ((color >> 16) & 0xff),
+                ((color >> 8) & 0xff),
+                (color & 0xff));
+    } else {
+        throw std::runtime_error("invalid hex color format");
+    }
+}
+
+std::tuple<Configuration, int, bool>
+Configuration::FromArgs(int argc, char **argv)
+{
+    Configuration conf;
+
+    /* build parser */
+    args::ArgumentParser parser("Generate spectrogram from stdin.", "For more info see https://github.com/rimio/specgram");
+
+    args::Positional<std::string> outfile(parser, "outfile", "Output PNG file");
+
+    args::HelpFlag help(parser, "help", "Display this help menu", {'h', "help"});
+    args::Flag version(parser, "version", "Display version", {'v', "version"});
+
+    args::Group input_opts(parser, "Input options:", args::Group::Validators::DontCare);
+    args::ValueFlag<std::string>
+        infile(input_opts, "string", "Input file name", {'i', "input"});
+    args::ValueFlag<float>
+        rate(input_opts, "float", "Sampling rate of input in Hz (default: 44100)", {'r', "rate"});
+    args::ValueFlag<std::string>
+        datatype(input_opts, "string", "Data type of input (default: s16)", {'d', "datatype"});
+    args::ValueFlag<float>
+        prescale(input_opts, "float", "Prescaling factor (default: 1.0)", {'p', "prescale"});
+    args::ValueFlag<int>
+        block_size(input_opts, "integer", "Block size when reading input, in data types (default: 256)", {'b', "block_size"});
+
+    args::Group fft_opts(parser, "FFT options:", args::Group::Validators::DontCare);
+    args::ValueFlag<int>
+        fft_width(fft_opts, "integer", "FFT window width (default: 1024)", {'f', "fft_width"});
+    args::ValueFlag<int>
+        fft_stride(fft_opts, "integer", "FFT window stride (default: 1024)", {'g', "fft_stride"});
+    args::ValueFlag<std::string>
+        win_func(fft_opts, "string", "ComplexWindow function (default: hann)", {'n', "window_function"});
+    args::ValueFlag<bool>
+        alias(fft_opts, "boolean", "Alias negative and positive frequencies (default: 0 (no) for complex data types, 1 (yes) otherwise)",
+              {'m', "alias"});
+    args::ValueFlag<int>
+        average(fft_opts, "integer", "Number of windows to average (default: 1)", {'A', "average"});
+
+    args::Group display_opts(parser, "Display options:", args::Group::Validators::DontCare);
+    args::Flag
+        no_resampling(display_opts, "no_resampling", "No resampling; width will be computed from FFT parameters and fmin/fmax",
+                      {'q', "no_resampling"});
+    args::ValueFlag<int>
+        width(display_opts, "integer", "Display width (default: 512)", {'w', "width"});
+    args::ValueFlag<float>
+        fmin(display_opts, "float", "Minimum frequency in Hz (default: -0.5 * rate for complex data types, 0 otherwise)", {'x', "fmin"});
+    args::ValueFlag<float>
+        fmax(display_opts, "float", "Maximum frequency in Hz (default: 0.5 * rate)", {'y', "fmax"});
+    args::ValueFlag<std::string>
+        scale(display_opts, "string", "Display scale (default: dBFS)", {'s', "scale"});
+    args::ValueFlag<std::string>
+        colormap(display_opts, "string", "Colormap (default: jet)", {'c', "colormap"});
+    args::ValueFlag<std::string>
+        bgcolor(display_opts, "string", "Background color (default: 000000)", {"bg-color"});
+    args::ValueFlag<std::string>
+        fgcolor(display_opts, "string", "Foreground color (default: ffffff)", {"fg-color"});
+    args::Flag
+        axes(display_opts, "axes", "Display axes (inferred for -e, --legend)", {'a', "axes"});
+    args::Flag
+        legend(display_opts, "legend", "Display legend", {'e', "legend"});
+    args::Flag
+        horizontal(display_opts, "horizontal", "Display horizontally", {'z', "horizontal"});
+    args::Flag
+        print_input(display_opts, "print_input", "Print input window", {"print_input"});
+    args::Flag
+        print_fft(display_opts, "print_fft", "Print FFT output", {"print_fft"});
+    args::Flag
+        print_output(display_opts, "print_output", "Print resampled/cropped and normalized output", {"print_output"});
+
+    args::Group live_opts(parser, "Live options:", args::Group::Validators::DontCare);
+    args::Flag
+        live(live_opts, "live", "Display live spectrogram", {'l', "live"});
+    args::ValueFlag<int>
+        count(live_opts, "integer", "Number of FFT windows in displayed history (default: 512)", {'k', "count"});
+    args::ValueFlag<std::string>
+        title(live_opts, "string", "ComplexWindow title", {'t', "title"});
+
+    /* parse arguments */
+    try {
+        parser.ParseCLI(argc, argv);
+    } catch (const args::Help&) {
+        std::cout << parser;
+        return std::make_tuple(conf, 0, true);
+    } catch (const args::ParseError& e) {
+        std::cerr << e.what() << std::endl;
+        std::cerr << parser;
+        return std::make_tuple(conf, 1, true);
+    } catch (args::ValidationError& e) {
+        std::cerr << e.what() << std::endl;
+        std::cerr << parser;
+        return std::make_tuple(conf, 1, true);
+    }
+
+    /* version mode */
+    if (version) {
+        std::cout << "specgram version " << SPECGRAM_VERSION << std::endl;
+        return std::make_tuple(conf, 0, true);
+    }
+
+    /* check and store command line arguments */
+    if (outfile) {
+        conf.output_filename_ = args::get(outfile);
+    } else if (!live) {
+        std::cerr << "Either specify file or '--live', otherwise nothing to do." << std::endl;
+        return std::make_tuple(conf, 1, true);
+    }
+
+    if (infile) {
+        conf.input_filename_ = args::get(infile);
+    }
+    if (block_size) {
+        if (args::get(block_size) <= 0) {
+            std::cerr << "'block_size' must be positive." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else {
+            conf.block_size_ = args::get(block_size);
+        }
+    }
+    if (rate) {
+        if (args::get(rate) <= 0) {
+            std::cerr << "'rate' must be positive." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else {
+            conf.rate_ = args::get(rate);
+        }
+    }
+    if (datatype) {
+        auto dtype = args::get(datatype);
+        if ((dtype.size() > 0) && (dtype[0] == 'c')) {
+            conf.alias_negative_ = false;
+            conf.has_complex_input_ = true;
+            dtype = dtype.substr(1, dtype.size() - 1);
+        } else {
+            conf.alias_negative_ = true;
+            conf.has_complex_input_ = false;
+        }
+
+        if (dtype == "s8") {
+            conf.datatype_ = DataType::kSignedInt8;
+        } else if (dtype == "s16") {
+            conf.datatype_ = DataType::kSignedInt16;
+        } else if (dtype == "s32") {
+            conf.datatype_ = DataType::kSignedInt32;
+        } else if (dtype == "s64") {
+            conf.datatype_ = DataType::kSignedInt64;
+        } else if (dtype == "u8") {
+            conf.datatype_ = DataType::kUnsignedInt8;
+        } else if (dtype == "u16") {
+            conf.datatype_ = DataType::kUnsignedInt16;
+        } else if (dtype == "u32") {
+            conf.datatype_ = DataType::kUnsignedInt32;
+        } else if (dtype == "u64") {
+            conf.datatype_ = DataType::kUnsignedInt64;
+        } else if (dtype == "f32") {
+            conf.datatype_ = DataType::kFloat32;
+        } else if (dtype == "f64") {
+            conf.datatype_ = DataType::kFloat64;
+        } else {
+            std::cerr << "Unknown data type '" << dtype << "'" << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+    }
+    if (prescale) {
+        conf.prescale_factor_ = args::get(prescale);
+    }
+
+    if (fft_width) {
+        if (args::get(fft_width) <= 0) {
+            std::cerr << "'fft_width' must be positive." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else {
+            conf.fft_width_ = args::get(fft_width);
+        }
+    }
+    if (conf.fft_width_ % 2 == 0) {
+        double boundary = conf.rate_ * (conf.fft_width_ - 2.0f) / (2.0f * conf.fft_width_);
+        conf.min_freq_ = conf.alias_negative_ ? 0.0f : -boundary;
+        conf.max_freq_ = conf.rate_ / 2.0f;
+    } else {
+        double boundary = conf.rate_ * (conf.fft_width_ - 1.0f) / (2.0f * conf.fft_width_);
+        conf.min_freq_ = conf.alias_negative_ ? 0.0f : -boundary;
+        conf.max_freq_ = boundary;
+    }
+    if (fft_stride) {
+        if (args::get(fft_stride) <= 0) {
+            std::cerr << "'fft_width' must be positive." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else {
+            conf.fft_stride_ = args::get(fft_stride);
+        }
+    }
+    if (win_func) {
+        auto& wf_str = args::get(win_func);
+        if (wf_str == "none") {
+            conf.window_function_ = WindowFunctionType::kNone;
+        } else if (wf_str == "hann") {
+            conf.window_function_ = WindowFunctionType::kHann;
+        } else if (wf_str == "hamming") {
+            conf.window_function_ = WindowFunctionType::kHamming;
+        } else if (wf_str == "blackman") {
+            conf.window_function_ = WindowFunctionType::kBlackman;
+        } else if (wf_str == "nuttall") {
+            conf.window_function_ = WindowFunctionType::kBlackman;
+        } else {
+            std::cerr << "Unknown window function '" << wf_str << "'" << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+    }
+    if (alias) {
+        conf.alias_negative_ = args::get(alias);
+    }
+    if (average) {
+        conf.average_count_ = args::get(average);
+        if (conf.average_count_ == 0) {
+            conf.average_count_ = 1;
+        }
+    }
+
+    if (no_resampling) {
+        conf.no_resampling_ = true;
+    }
+    if (width) {
+        if (args::get(width) <= 0) {
+            std::cerr << "'width' must be positive." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else if (conf.no_resampling_) {
+            std::cerr << "'width' cannot be specified when not resampling (-q, --no_resampling)." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else {
+            conf.width_ = args::get(width);
+        }
+    }
+    if (fmin) {
+        conf.min_freq_ = args::get(fmin);
+    }
+    if (fmax) {
+        conf.max_freq_ = args::get(fmax);
+    }
+    if (scale) {
+        auto& scale_str = args::get(scale);
+        if (scale_str.starts_with("dbfs") || scale_str.starts_with("dBFS")) {
+            conf.scale_ = ValueMapType::kdBFS;
+            auto value_str = scale_str.substr(4, scale_str.size() - 4);
+            if (value_str.size() > 0) {
+                try {
+                    conf.scale_lower_bound_ = std::stod(value_str);
+                } catch (const std::exception& e) {
+                    std::cerr << "Invalid lower bound for dBFS scale '" << value_str << "'" << std::endl;
+                    return std::make_tuple(conf, 1, true);
+                }
+                if (conf.scale_lower_bound_ >= 0.0f) {
+                    std::cerr << "Lower bound for dBFS scale must be negative, "
+                              << conf.scale_lower_bound_ << " was received" << std::endl;
+                    return std::make_tuple(conf, 1, true);
+                }
+            }
+        } else {
+            std::cerr << "Unknown scale '" << scale_str << "'" << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+    }
+    if (colormap) {
+        auto& cmap_str = args::get(colormap);
+        if (cmap_str == "gray") {
+            conf.color_map_ = ColorMapType::kGray;
+        } else if (cmap_str == "jet") {
+            conf.color_map_ = ColorMapType::kJet;
+        } else if (cmap_str == "purple") {
+            conf.color_map_ = ColorMapType::kPurple;
+        } else if (cmap_str == "blue") {
+            conf.color_map_ = ColorMapType::kBlue;
+        } else if (cmap_str == "green") {
+            conf.color_map_ = ColorMapType::kGreen;
+        } else if (cmap_str == "orange") {
+            conf.color_map_ = ColorMapType::kOrange;
+        } else if (cmap_str == "red") {
+            conf.color_map_ = ColorMapType::kRed;
+        } else {
+            try {
+                auto color = Configuration::StringToColor(cmap_str);
+                conf.color_map_custom_color_ = color;
+                conf.color_map_ = ColorMapType::kCustom;
+            } catch (const std::exception& e) {
+                std::cerr << "Unknown colormap '" << cmap_str << "'" << std::endl;
+                return std::make_tuple(conf, 1, true);
+            }
+        }
+    }
+    if (bgcolor) {
+        auto& str = args::get(bgcolor);
+        try {
+            auto color = Configuration::StringToColor(str);
+            conf.background_color_ = color;
+        } catch (const std::exception& e) {
+            std::cerr << "Invalid background color '" << str << "'" << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+    }
+    if (fgcolor) {
+        auto& str = args::get(fgcolor);
+        try {
+            auto color = Configuration::StringToColor(str);
+            conf.foreground_color_ = color;
+        } catch (const std::exception& e) {
+            std::cerr << "Invalid foreground color '" << str << "'" << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+    }
+    if (axes) {
+        conf.has_axes_ = true;
+    }
+    if (legend) {
+        conf.has_legend_ = true;
+    }
+    if (horizontal) {
+        conf.is_horizontal_ = true;
+    }
+    if (print_input) {
+        conf.print_input_ = true;
+    }
+    if (print_fft) {
+        conf.print_fft_ = true;
+    }
+    if (print_output) {
+        conf.print_output_ = true;
+    }
+
+    if (live) {
+        conf.live_ = true;
+        if (infile) {
+            std::cerr << "live view not allowed on file input (-i, --input)" << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+    }
+    if (count) {
+        if (args::get(count) <= 0) {
+            std::cerr << "'count' must be positive." << std::endl;
+            return std::make_tuple(conf, 1, true);
+        } else {
+            conf.count_ = args::get(count);
+        }
+    }
+    if (title) {
+        conf.title_ = args::get(title);
+    }
+
+    /* compute width for --no_resampling case */
+    if (conf.no_resampling_) {
+        int mini = static_cast<int>(std::round(FFT::GetFrequencyIndex(conf.rate_, conf.fft_width_, conf.min_freq_)));
+        int maxi = static_cast<int>(std::round(FFT::GetFrequencyIndex(conf.rate_, conf.fft_width_, conf.max_freq_)));
+
+        if (mini < 0) {
+            std::cerr
+                    << "'fmin' is outside of FFT window, which is not allowed when not resampling (-q, --no_resampling)."
+                    << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+        if (maxi >= static_cast<int>(conf.fft_width_)) {
+            std::cerr
+                    << "'fmax' is outside of FFT window, which is not allowed when not resampling (-q, --no_resampling)."
+                    << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+
+        conf.width_ = maxi - mini;
+        if (conf.width_ == 0) {
+            std::cerr
+                    << "'fmin' and 'fmax' are either equal or very close, which is not allowed when not resampling (-q, --no_resampling)."
+                    << std::endl;
+            return std::make_tuple(conf, 1, true);
+        }
+        /* (maxi-mini) < 0 should be caught lower */
+    }
+
+    /* fmin/fmax checks */
+    if (conf.min_freq_ >= conf.max_freq_) {
+        std::cerr << "'fmin' must be less than 'fmax'." << std::endl;
+        return std::make_tuple(conf, 1, true);
+    }
+
+    /* normal usage mode, don't exit */
+    return std::make_tuple(conf, 0, false);
+}
diff --git a/src/configuration.hpp b/src/configuration.hpp
new file mode 100644
index 0000000..126a10d
--- /dev/null
+++ b/src/configuration.hpp
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef _CONFIGURATION_HPP_
+#define _CONFIGURATION_HPP_
+
+#include "color-map.hpp"
+#include "value-map.hpp"
+#include "window-function.hpp"
+
+#include <SFML/Graphics/Color.hpp>
+#include <string>
+#include <optional>
+#include <tuple>
+
+class Configuration {
+private:
+    std::optional<std::string> input_filename_;
+    std::optional<std::string> output_filename_;
+
+    std::size_t block_size_;
+    double rate_;
+    DataType datatype_;
+    bool has_complex_input_;
+    double prescale_factor_;
+
+    std::size_t fft_width_;
+    std::size_t fft_stride_;
+    WindowFunctionType window_function_;
+    std::size_t average_count_;
+    bool alias_negative_;
+
+    bool no_resampling_;
+    std::size_t width_;
+    double min_freq_;
+    double max_freq_;
+    ValueMapType scale_;
+    double scale_lower_bound_;
+    ColorMapType color_map_;
+    sf::Color color_map_custom_color_;
+    sf::Color background_color_;
+    sf::Color foreground_color_;
+    bool has_axes_;
+    bool has_legend_;
+    bool is_horizontal_;
+    bool print_input_;
+    bool print_fft_;
+    bool print_output_;
+
+    bool live_;
+    std::size_t count_;
+    std::string title_;
+
+    bool has_live_window_;
+
+    std::size_t margin_size_;
+    std::size_t live_margin_size_;
+    std::size_t minimum_margin_size_;
+    std::size_t legend_height_;
+    std::size_t live_fft_height_;
+    std::size_t axis_font_size_;
+
+    Configuration();
+
+    static sf::Color StringToColor(const std::string& str);
+
+public:
+    /* parse command line arguments and return a configuration object */
+    static std::tuple<Configuration, int, bool> FromArgs(int argc, char **argv);
+
+    /* generic getters */
+    Configuration GetForLive() const;
+    const auto & GetInputFilename() const { return input_filename_; }
+    const auto & GetOutputFilename() const { return output_filename_; }
+
+    /* input getters */
+    auto GetBlockSize() const { return block_size_; }
+    auto GetRate() const { return rate_; }
+    auto GetDataType() const { return datatype_; }
+    auto HasComplexInput() const { return has_complex_input_; }
+    auto GetPrescaleFactor() const { return prescale_factor_; }
+
+    /* FFT getters */
+    auto GetFFTWidth() const { return fft_width_; }
+    auto GetFFTStride() const { return fft_stride_; }
+    auto GetWindowFunction() const { return window_function_; }
+    auto IsAliasingNegativeFrequencies() const { return alias_negative_; }
+    auto GetAverageCount() const { return average_count_; }
+
+    /* display getters */
+    auto CanResample() const { return !no_resampling_; }
+    auto GetWidth() const { return width_; }
+    auto GetMinFreq() const { return min_freq_; }
+    auto GetMaxFreq() const { return max_freq_; }
+    auto GetScale() const { return scale_; }
+    auto GetScaleLowerBound() const { return scale_lower_bound_; }
+    auto GetColorMap() const { return color_map_; }
+    auto GetColorMapCustomColor() const { return color_map_custom_color_; }
+    auto GetBackgroundColor() const { return background_color_; }
+    auto GetForegroundColor() const { return foreground_color_; }
+    auto HasAxes() const { return has_axes_ || has_legend_; }
+    auto HasLegend() const { return has_legend_; }
+    auto IsHorizontal() const { return is_horizontal_; }
+    auto MustPrintInput() const { return print_input_; }
+    auto MustPrintFFT() const { return print_fft_; }
+    auto MustPrintOutput() const { return print_output_; }
+
+    /* live options */
+    auto IsLive() const { return live_; }
+    auto GetCount() const { return count_; }
+    auto GetTitle() const { return title_; }
+
+    /* internal options */
+    auto HasLiveWindow() const { return has_live_window_; }
+
+    auto GetMarginSize() const { return margin_size_; }
+    auto GetLiveMarginSize() const { return live_margin_size_; }
+    auto GetMinimumMarginSize() const { return minimum_margin_size_; }
+    auto GetLegendHeight() const { return legend_height_; }
+    auto GetLiveFFTHeight() const { return live_fft_height_; }
+
+    auto GetAxisFontSize() const { return axis_font_size_; }
+
+    sf::Color GetLiveGuidelinesColor() const;
+};
+
+#endif
\ No newline at end of file
diff --git a/src/fft.cpp b/src/fft.cpp
new file mode 100644
index 0000000..fea0a08
--- /dev/null
+++ b/src/fft.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "fft.hpp"
+
+#include <cassert>
+#include <cstring>
+#include <cmath>
+#include <complex>
+
+static double
+sinc(double x)
+{
+    /* this function is straight up lifted from boost, as I have absolutely no inclination of linking to it */
+    static const double taylor_0_bound = std::numeric_limits<double>::epsilon();
+    static const double taylor_2_bound = sqrt(taylor_0_bound);
+    static const double taylor_n_bound = sqrt(taylor_2_bound);
+
+    if (std::abs(x) >= taylor_n_bound) {
+        return std::sin(x) / x;
+    } else {
+        double result = 1.0f;
+
+        if (abs(x) >= taylor_0_bound) {
+            double x2 = x * x;
+            result -= x2 / 6.0f;
+
+            if (abs(x) >= taylor_2_bound) {
+                result += (x2 * x2) / 120.0f;
+            }
+        }
+
+        return result;
+    }
+}
+
+FFT::FFT(std::size_t win_width, std::unique_ptr<WindowFunction>& win_func)
+    : window_width_(win_width), window_function_(std::move(win_func))
+{
+    /* allocate buffers */
+    this->in_ = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * win_width);
+    assert(this->in_ != nullptr);
+    this->out_ = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * win_width);
+    assert(this->out_ != nullptr);
+
+    /* compute plan */
+    this->plan_ = fftw_plan_dft_1d(win_width, this->in_, this->out_, FFTW_FORWARD, FFTW_ESTIMATE);
+}
+
+FFT::~FFT()
+{
+    fftw_destroy_plan(this->plan_);
+
+    fftw_free(this->in_);
+    this->in_ = nullptr;
+    fftw_free(this->out_);
+    this->out_ = nullptr;
+}
+
+ComplexWindow
+FFT::Compute(const ComplexWindow& input)
+{
+    /* assume the same memory representation */
+    assert(sizeof(fftw_complex) == sizeof(Complex));
+
+    /* assume we received exactly one window */
+    if (input.size() != this->window_width_) {
+        throw std::runtime_error("input window size must match FFTW plan size");
+    }
+
+    /* make a copy of the input and apply window function */
+    auto input_ref = &input;
+    ComplexWindow processed_input;
+    if (this->window_function_ != nullptr) {
+        processed_input = this->window_function_->Apply(input);
+        input_ref = &processed_input;
+    }
+
+    /* copy to input buffer */
+    assert(this->in_ != nullptr);
+    std::memcpy((void *)this->in_, (void *)input_ref->data(), this->window_width_ * sizeof(fftw_complex));
+
+    /* execute plan */
+    fftw_execute(this->plan_);
+
+    /* build output vector from output buffer */
+    /* fftw maps frequencies to k/T for k=0..window_width; we want negative frequencies at the beginning of
+     * the output (i.e. first half) so we switch the upper and lower halves, i.e.: */
+    /*    even width: out_: [0 1 2 3 4 5 6 7] -> output: [5 6 7 0 1 2 3 4] */
+    /*     odd width: out_: [0 1 2 3 4 5 6]   -> output: [4 5 6 0 1 2 3] */
+    ComplexWindow output;
+    output.resize(this->window_width_);
+
+    assert(this->out_ != nullptr);
+    auto uhl = (this->window_width_ - 1) / 2; /* upper half length */
+    auto lhl = this->window_width_ - uhl; /* lower half length */
+    std::memcpy((void *) output.data(),
+                (void *) (this->out_ + lhl),
+                uhl * sizeof(fftw_complex));
+    std::memcpy((void *) (output.data() + uhl),
+                (void *) this->out_,
+                lhl * sizeof(fftw_complex));
+
+    return output;
+}
+
+RealWindow
+FFT::GetMagnitude(const ComplexWindow& input, bool alias)
+{
+    auto n = input.size();
+
+    RealWindow output;
+    output.resize(n);
+    for (std::size_t i = 0; i < n; i++) {
+        output[i] = std::abs<double>(input[i]);
+    }
+
+    /* alias negative/positive frequencies (e.g. if input is not true complex) */
+    if (alias) {
+        std::size_t offset = 2 - n % 2;
+        for (std::size_t i = 0; i < (n - 1) / 2; i++) {
+            output[i] += output[n - i - offset];
+            output[n - i - offset] = output[i];
+        }
+    }
+
+    return output;
+}
+
+std::tuple<double, double>
+FFT::GetFrequencyLimits(double rate, std::size_t width)
+{
+    if (rate <= 0) {
+        throw std::runtime_error("rate must be positive in order to compute frequency limits");
+    }
+    if (width == 0) {
+        throw std::runtime_error("FFT width must be positive in order to compute frequency limits");
+    }
+
+    if (width % 2 == 0) {
+        std::size_t half = width / 2;
+        return std::make_tuple(-(double)(half-1) / (double)width * (double)rate,
+                               +(double)half / (double)width * (double)rate);
+    } else {
+        std::size_t half = width / 2;
+        return std::make_tuple(-(double)half / (double)width * (double)rate,
+                               +(double)half / (double)width * (double)rate);
+    }
+}
+
+double
+FFT::GetFrequencyIndex(double rate, std::size_t width, double f)
+{
+    auto [in_fmin, in_fmax] = FFT::GetFrequencyLimits(rate, width);
+    assert(in_fmin < in_fmax);
+    return (f - in_fmin) / (in_fmax - in_fmin) * (width - 1);
+}
+
+RealWindow
+FFT::Resample(const RealWindow& input, double rate, std::size_t width, double fmin, double fmax)
+{
+    if (rate <= 0.0f) {
+        throw std::runtime_error("rate must be positive for resampling");
+    }
+    if (fmin >= fmax) {
+        throw std::runtime_error("resampling frequency bounds either not distinct or not in order");
+    }
+    if (width == 0) {
+        throw std::runtime_error("resampling requires positive width");
+    }
+
+    /* find corresponding indices for fmin/fmax */
+    /* [0..input.size()-1] -> [in_fmin, in_fmax] */
+    /*   [i_fmin..i_fmax]  ->    [fmin, fmax]    */
+    double i_fmin = FFT::GetFrequencyIndex(rate, input.size(), fmin);
+    double i_fmax = FFT::GetFrequencyIndex(rate, input.size(), fmax);
+
+    /* prepare output */
+    RealWindow output;
+    output.resize(width);
+
+    /* [0..width] -> [i_fmin..i_fmax] */
+    /* Lanczos resampling */
+    static constexpr std::size_t lanc_a = 3;
+    for (std::size_t j = 0; j < width; j++) {
+        double x = (double)j / (double)(width - 1) * (i_fmax - i_fmin) + i_fmin;
+        double sum = 0.0f;
+        double lsum = 0.0f;
+
+        /* convolve */
+        for (int i = static_cast<int>(std::floor(x)) - static_cast<int>(lanc_a) + 1; i <= std::floor(x) + lanc_a; i ++) {
+            if (i >= 0 && i < static_cast<int>(input.size())) {
+                double lanc_xi = ::sinc(x - i) * ::sinc((x - i) / lanc_a);
+                sum += input[i] * lanc_xi;
+                lsum += lanc_xi;
+            }
+        }
+
+        output[j] = std::clamp<double>(sum / lsum, 0.0f, 1.0f);
+    }
+
+    return output;
+}
+
+RealWindow
+FFT::Crop(const RealWindow& input, double rate, double fmin, double fmax)
+{
+    if (rate <= 0.0f) {
+        throw std::runtime_error("rate must be positive for cropping");
+    }
+    if (fmin >= fmax) {
+        throw std::runtime_error("cropping frequency bounds either not distinct or not in order");
+    }
+
+    /* find corresponding indices for fmin/fmax */
+    /* [0..input.size()-1] -> [in_fmin, in_fmax] */
+    /*   [i_fmin..i_fmax]  ->    [fmin, fmax]    */
+    double di_fmin = std::round(FFT::GetFrequencyIndex(rate, input.size(), fmin));
+    double di_fmax = std::round(FFT::GetFrequencyIndex(rate, input.size(), fmax));
+    assert(di_fmin >= 0);
+    assert(di_fmax < input.size());
+    assert(di_fmin < di_fmax);
+
+    /* we're cropping, so no interpolation allowed */
+    auto i_fmin = static_cast<std::size_t>(di_fmin);
+    auto i_fmax = static_cast<std::size_t>(di_fmax);
+    assert(i_fmax - i_fmin > 0);
+
+    /* return corresponding subvector */
+    return RealWindow(input.begin() + i_fmin, input.begin() + i_fmax);
+}
\ No newline at end of file
diff --git a/src/fft.hpp b/src/fft.hpp
new file mode 100644
index 0000000..9eac372
--- /dev/null
+++ b/src/fft.hpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef _FFT_HPP_
+#define _FFT_HPP_
+
+#include "window-function.hpp"
+
+#include <fftw3.h>
+
+class FFT {
+private:
+    /* FFT window width */
+    const std::size_t window_width_;
+
+    /* fftw buffers */
+    fftw_complex *in_;
+    fftw_complex *out_;
+
+    /* fftw plan */
+    fftw_plan plan_;
+
+    /* window function */
+    std::unique_ptr<WindowFunction> window_function_;
+
+public:
+    FFT() = delete;
+    FFT(const FFT &c) = delete;
+    FFT(FFT &&) = delete;
+    FFT & operator=(const FFT&) = delete;
+
+    FFT(std::size_t win_width, std::unique_ptr<WindowFunction>& win_func);
+    virtual ~FFT();
+
+    ComplexWindow Compute(const ComplexWindow& input);
+
+    static RealWindow GetMagnitude(const ComplexWindow& input, bool alias);
+    static std::tuple<double, double> GetFrequencyLimits(double rate, std::size_t width);
+    static double GetFrequencyIndex(double rate, std::size_t width, double f);
+    static RealWindow Resample(const RealWindow& input, double rate, std::size_t width, double fmin, double fmax);
+    static RealWindow Crop(const RealWindow& input, double rate, double fmin, double fmax);
+};
+
+#endif
\ No newline at end of file
diff --git a/src/input-parser.cpp b/src/input-parser.cpp
new file mode 100644
index 0000000..d55661b
--- /dev/null
+++ b/src/input-parser.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "input-parser.hpp"
+
+#include <cassert>
+
+InputParser::InputParser(double prescale, bool is_complex) : prescale_factor_(prescale), is_complex_(is_complex)
+{
+}
+
+std::size_t
+InputParser::GetBufferedValueCount() const
+{
+    return values_.size();
+}
+
+std::vector<Complex>
+InputParser::PeekValues(std::size_t count) const
+{
+    count = std::min<std::size_t>(count, this->values_.size());
+    if (count == 0) {
+        return std::vector<Complex>();
+    }
+    return std::vector<Complex> (this->values_.begin(), this->values_.begin() + count);
+}
+
+void
+InputParser::RemoveValues(std::size_t count)
+{
+    count = std::min<std::size_t>(count, this->values_.size());
+    if (count > 0) {
+        this->values_.erase(this->values_.begin(), this->values_.begin() + count);
+    }
+}
+
+std::unique_ptr<InputParser>
+InputParser::FromDataType(DataType dtype, double prescale, bool is_complex)
+{
+    if (dtype == DataType::kSignedInt8) {
+        return std::make_unique<IntegerInputParser<char>>(prescale, is_complex);
+    } else if (dtype == DataType::kSignedInt16) {
+        return std::make_unique<IntegerInputParser<short>>(prescale, is_complex);
+    } else if (dtype == DataType::kSignedInt32) {
+        return std::make_unique<IntegerInputParser<int>>(prescale, is_complex);
+    } else if (dtype == DataType::kSignedInt64) {
+        return std::make_unique<IntegerInputParser<long long>>(prescale, is_complex);
+    } else if (dtype == DataType::kUnsignedInt8) {
+        return std::make_unique<IntegerInputParser<unsigned char>>(prescale, is_complex);
+    } else if (dtype == DataType::kUnsignedInt16) {
+        return std::make_unique<IntegerInputParser<unsigned short>>(prescale, is_complex);
+    } else if (dtype == DataType::kUnsignedInt32) {
+        return std::make_unique<IntegerInputParser<unsigned int>>(prescale, is_complex);
+    } else if (dtype == DataType::kUnsignedInt64) {
+        return std::make_unique<IntegerInputParser<unsigned long long>>(prescale, is_complex);
+    } else if (dtype == DataType::kFloat32) {
+        return std::make_unique<FloatInputParser<float>>(prescale, is_complex);
+    } else if (dtype == DataType::kFloat64) {
+        return std::make_unique<FloatInputParser<double>>(prescale, is_complex);
+    } else {
+        throw std::runtime_error("unknown datatype");
+    }
+}
+
+template <class T>
+IntegerInputParser<T>::IntegerInputParser(double prescale, bool is_complex) : InputParser(prescale, is_complex)
+{
+}
+
+template <class T>
+std::size_t
+IntegerInputParser<T>::GetDataTypeSize() const
+{
+    return sizeof(T) * (this->is_complex_ ? 2 : 1);
+}
+
+template <class T>
+std::size_t
+IntegerInputParser<T>::ParseBlock(const std::vector<char> &block)
+{
+    /* this function assumes well structured blocks */
+    std::size_t item_size = (this->is_complex_ ? 2 : 1) * sizeof(T);
+    if (block.size() % item_size != 0) {
+        throw std::runtime_error("block size must be a multiple of sizeof(datatype)");
+    }
+
+    std::size_t count = block.size() / item_size;
+    const T *start = reinterpret_cast<const T *>(block.data());
+
+    /* parse one value at a time into complex target */
+    for (std::size_t i = 0; i < count; i ++) {
+        Complex value;
+        if (this->is_complex_) {
+            value = Complex(start[i * 2], start[i * 2 + 1]);
+        } else {
+            value = Complex(start[i], 0.0f);
+        }
+
+        /* normalize to domain limit */
+        value /= (double)std::numeric_limits<T>::max();
+        value *= this->prescale_factor_;
+        this->values_.emplace_back(value);
+    }
+
+    return count;
+}
+
+template <class T>
+FloatInputParser<T>::FloatInputParser(double prescale, bool is_complex) : InputParser(prescale, is_complex)
+{
+}
+
+template <class T>
+std::size_t
+FloatInputParser<T>::GetDataTypeSize() const
+{
+    return sizeof(T) * (this->is_complex_ ? 2 : 1);
+}
+
+template <class T>
+std::size_t
+FloatInputParser<T>::ParseBlock(const std::vector<char> &block)
+{
+    /* this function assumes well structured blocks */
+    std::size_t item_size = (this->is_complex_ ? 2 : 1) * sizeof(T);
+    if (block.size() % item_size != 0) {
+        throw std::runtime_error("block size must be a multiple of sizeof(datatype)");
+    }
+
+    std::size_t count = block.size() / item_size;
+    const T *start = reinterpret_cast<const T *>(block.data());
+
+    /* parse one value at a time into complex target */
+    for (std::size_t i = 0; i < count; i ++) {
+        Complex value;
+        /* remove NaNs */
+        if (this->is_complex_) {
+            value = Complex(std::isnan(start[i * 2]) ? 0.0f : start[i * 2],
+                            std::isnan(start[i * 2 + 1]) ? 0.0f : start[i * 2 + 1]);
+        } else {
+            value = Complex(std::isnan(start[i]) ? 0.0f : start[i], 0.0f);
+        }
+
+        /* prescale */
+        value *= this->prescale_factor_;
+        this->values_.emplace_back(value);
+    }
+
+    return count;
+}
\ No newline at end of file
diff --git a/src/input-parser.hpp b/src/input-parser.hpp
new file mode 100644
index 0000000..8df72ab
--- /dev/null
+++ b/src/input-parser.hpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#ifndef _INPUT_PARSER_HPP_
+#define _INPUT_PARSER_HPP_
+
+#include <vector>
+#include <complex>
+#include <memory>
+
+/* Input data type */
+enum class DataType {
+    /* signed integer */
+    kSignedInt8,
+    kSignedInt16,
+    kSignedInt32,
+    kSignedInt64,
+
+    /* unsigned integer */
+    kUnsignedInt8,
+    kUnsignedInt16,
+    kUnsignedInt32,
+    kUnsignedInt64,
+
+    /* floating point */
+    kFloat32,
+    kFloat64
+};
+
+/* Complex type that we normalize everything to */
+typedef std::complex<double> Complex;
+
+/* Window of real numbers */
+typedef std::vector<double> RealWindow;
+
+/* Window of complex numbers */
+typedef std::vector<Complex> ComplexWindow;
+
+/*
+ * Input parser base class
+ */
+class InputParser {
+protected:
+    double prescale_factor_;
+    bool is_complex_;
+    std::vector<Complex> values_;
+
+    InputParser() = delete;
+    explicit InputParser(double prescale, bool is_complex);
+
+public:
+    InputParser(const InputParser &c) = delete;
+    InputParser(InputParser &&) = delete;
+    InputParser & operator=(const InputParser&) = delete;
+    virtual ~InputParser() = default;
+
+    static std::unique_ptr<InputParser> FromDataType(DataType dtype, double prescale, bool is_complex);
+
+    std::size_t GetBufferedValueCount() const;
+
+    std::vector<Complex> PeekValues(std::size_t count) const;
+    void RemoveValues(std::size_t count);
+
+    virtual std::size_t ParseBlock(const std::vector<char> &block) = 0;
+    virtual std::size_t GetDataTypeSize() const = 0;
+    virtual bool IsSigned() const = 0;
+    virtual bool IsFloatingPoint() const = 0;
+    virtual bool IsComplex() const { return is_complex_; };
+};
+
+/*
+ * Integer input parser
+ */
+template <class T>
+class IntegerInputParser : public InputParser {
+public:
+    IntegerInputParser() = delete;
+    explicit IntegerInputParser(double prescale, bool is_complex);
+
+    std::size_t ParseBlock(const std::vector<char> &block) override;
+
+    std::size_t GetDataTypeSize() const override;
+    bool IsSigned() const override { return std::numeric_limits<T>::is_signed; };
+    bool IsFloatingPoint() const override { return false; };
+};
+
+/*
+ * Floating point input parser
+ */
+template <class T>
+class FloatInputParser : public InputParser {
+public:
+    FloatInputParser() = delete;
+    explicit FloatInputParser(double prescale, bool is_complex);
+
+    std::size_t ParseBlock(const std::vector<char> &block) override;
+
+    std::size_t GetDataTypeSize() const override;
+    bool IsSigned() const override { return true; };
+    bool IsFloatingPoint() const override { return true; };
+};
+
+#endif
\ No newline at end of file
diff --git a/src/input-reader.cpp b/src/input-reader.cpp
new file mode 100644
index 0000000..3f05251
--- /dev/null
+++ b/src/input-reader.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "input-reader.hpp"
+
+#include <csignal>
+#include <cassert>
+
+InputReader::InputReader(std::istream * stream, std::size_t block_size_bytes)
+    : stream_(stream), block_size_bytes_(block_size_bytes)
+{
+}
+
+SyncInputReader::SyncInputReader(std::istream * stream, std::size_t block_size_bytes)
+    : InputReader(stream, block_size_bytes)
+{
+}
+
+bool
+SyncInputReader::ReachedEOF() const
+{
+    assert(this->stream_ != nullptr);
+    return this->stream_->eof();
+}
+
+std::optional<std::vector<char>>
+SyncInputReader::GetBlock()
+{
+    auto buffer = this->GetBuffer();
+    if (buffer.size() == this->block_size_bytes_) {
+        return buffer;
+    } else {
+        /* we assume the only time we're reading less than a block is at EOF */
+        assert(this->stream_->eof());
+        return {};
+    }
+}
+
+std::vector<char>
+SyncInputReader::GetBuffer()
+{
+    std::vector<char> local_buffer;
+    local_buffer.resize(this->block_size_bytes_);
+
+    assert(this->stream_ != nullptr);
+    this->stream_->read(local_buffer.data(), this->block_size_bytes_);
+    return std::vector<char>(local_buffer.data(), local_buffer.data() + this->stream_->gcount());
+}
+
+AsyncInputReader::AsyncInputReader(std::istream * stream, std::size_t block_size_bytes)
+    : InputReader(stream, block_size_bytes)
+{
+    if (block_size_bytes == 0) {
+        throw std::runtime_error("block size in bytes must be positive");
+    }
+    this->buffer_ = new char[block_size_bytes];
+    assert(this->buffer_ != nullptr);
+    this->bytes_in_buffer_ = 0;
+
+    /* start reader thread */
+    this->running_ = true;
+    this->reader_thread_ = std::thread(&AsyncInputReader::Read, this);
+}
+
+AsyncInputReader::~AsyncInputReader()
+{
+    /* end reader thread */
+    this->mutex_.lock();
+    this->running_ = false;
+    this->mutex_.unlock();
+
+    /* send SIGINT so we interrupt any blocking reads */
+    pthread_kill(this->reader_thread_.native_handle(), SIGINT);
+    this->reader_thread_.join();
+
+    /* dealloc buffer */
+    if (this->buffer_ != nullptr) {
+        delete[] this->buffer_;
+        this->buffer_ = nullptr;
+    }
+}
+
+void
+AsyncInputReader::Read()
+{
+    char *local_buffer = new char[this->block_size_bytes_];
+    assert(local_buffer != nullptr);
+
+    while (true) {
+        /* find out how much we need to populate in the buffer */
+        this->mutex_.lock();
+        long long int to_read = this->block_size_bytes_ - this->bytes_in_buffer_;
+        if (!this->running_) {
+            this->mutex_.unlock();
+            break;
+        }
+        this->mutex_.unlock();
+        assert(to_read >= 0);
+
+        /* yield execution if nothing to read */
+        if (to_read == 0) {
+            std::this_thread::yield();
+            continue;
+        }
+
+        /* blocking read */
+        assert(this->stream_ != nullptr);
+        this->stream_->read(local_buffer, to_read);
+        if (this->stream_->fail()) {
+            break;
+        } else {
+            assert(this->stream_->gcount() == to_read);
+        }
+
+        /* write to buffer */
+        this->mutex_.lock();
+        if (!this->running_) {
+            this->mutex_.unlock();
+            break;
+        }
+        assert(to_read + this->bytes_in_buffer_ <= this->block_size_bytes_);
+        auto k = to_read;
+        assert(this->buffer_ != nullptr);
+        for (volatile char *a = local_buffer, *b = this->buffer_ + this->bytes_in_buffer_; k > 0; *b++ = *a++, k--) /* nop */;
+        this->bytes_in_buffer_ = this->bytes_in_buffer_ + to_read;
+        this->mutex_.unlock();
+    }
+}
+
+bool
+AsyncInputReader::ReachedEOF() const
+{
+    /* we will never reach end of file in async mode */
+    /* only way out is SIGINT from user */
+    return false;
+}
+
+std::optional<std::vector<char>>
+AsyncInputReader::GetBlock()
+{
+    const std::lock_guard<std::mutex> lock(this->mutex_);
+    if (this->bytes_in_buffer_ < this->block_size_bytes_) {
+        return {};
+    } else {
+        auto bcount = this->bytes_in_buffer_;
+        this->bytes_in_buffer_ = 0;
+        assert(this->buffer_);
+        return std::vector<char>(this->buffer_, this->buffer_ + bcount);
+    }
+}
+
+std::vector<char>
+AsyncInputReader::GetBuffer()
+{
+    const std::lock_guard<std::mutex> lock(this->mutex_);
+    assert(this->buffer_);
+    std::vector<char> wrapper(this->buffer_, this->buffer_ + this->bytes_in_buffer_);
+    this->bytes_in_buffer_ = 0;
+    return wrapper;
+}
\ No newline at end of file
diff --git a/src/input-reader.hpp b/src/input-reader.hpp
new file mode 100644
index 0000000..71025c8
--- /dev/null
+++ b/src/input-reader.hpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#ifndef _INPUT_READER_HPP_
+#define _INPUT_READER_HPP_
+
+#include <istream>
+#include <mutex>
+#include <optional>
+#include <thread>
+#include <vector>
+
+/*
+ * Input reader base class
+ */
+class InputReader {
+protected:
+    std::istream * const stream_;
+    const std::size_t block_size_bytes_;
+
+public:
+    InputReader() = delete;
+    InputReader(const InputReader&) = delete;
+    InputReader(InputReader&&) = delete;
+    InputReader & operator=(const InputReader&) = delete;
+
+    InputReader(std::istream * stream, std::size_t block_size_bytes);
+    virtual ~InputReader() = default;
+
+    virtual bool ReachedEOF() const = 0;
+    virtual std::optional<std::vector<char>> GetBlock() = 0;
+    virtual std::vector<char> GetBuffer() = 0;
+};
+
+/*
+ * Synchronous input reader
+ */
+class SyncInputReader : public InputReader {
+public:
+    SyncInputReader(std::istream * stream, std::size_t block_size_bytes);
+
+    bool ReachedEOF() const override;
+    std::optional<std::vector<char>> GetBlock() override;
+    std::vector<char> GetBuffer() override;
+};
+
+/*
+ * Asynchronous input reader
+ */
+class AsyncInputReader : public InputReader {
+private:
+    /* buffer where we read up until one block */
+    volatile char *buffer_;
+    volatile std::size_t bytes_in_buffer_;
+
+    /* mutex for accessing buffer */
+    std::mutex mutex_;
+
+    /* thread for reading from input stream */
+    std::thread reader_thread_;
+    volatile bool running_;
+
+    void Read();
+
+public:
+    AsyncInputReader(std::istream * stream, std::size_t block_size_bytes);
+    ~AsyncInputReader() override;
+
+    bool ReachedEOF() const override;
+    std::optional<std::vector<char>> GetBlock() override;
+    std::vector<char> GetBuffer() override;
+};
+
+#endif
diff --git a/src/live.cpp b/src/live.cpp
new file mode 100644
index 0000000..037b97c
--- /dev/null
+++ b/src/live.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "live.hpp"
+
+#include <cassert>
+#include <cstring>
+
+LiveOutput::LiveOutput(const Configuration& conf, const ColorMap& cmap, const ValueMap& vmap)
+    : configuration_(conf), renderer_(conf.GetForLive(), cmap, vmap, conf.GetCount())
+{
+    auto width = conf.IsHorizontal() ? renderer_.GetHeight() : renderer_.GetWidth();
+    auto height = conf.IsHorizontal() ? renderer_.GetWidth() : renderer_.GetHeight();
+
+    /* create non-resizable window */
+    this->window_.create(sf::VideoMode(width, height),
+                         conf.GetTitle(),
+                         sf::Style::Close);
+    this->window_.setFramerateLimit(0);
+
+    /* FFT area raw memory used to update the area texture */
+    this->fft_area_.resize(conf.GetWidth() * conf.GetCount() * 4); /* RGBA pixel array */
+}
+
+void
+LiveOutput::AddWindow(const std::vector<uint8_t>& window, const RealWindow& win_values)
+{
+    std::size_t wlen_bytes = this->configuration_.GetWidth() * 4;
+    if (window.size() != wlen_bytes) {
+        throw std::runtime_error("input window size differs from live window size");
+    }
+
+    /* scroll down one window */
+    assert(this->fft_area_.size() >= wlen_bytes);
+    std::memmove(reinterpret_cast<void *>(this->fft_area_.data() + wlen_bytes),
+                 reinterpret_cast<const void *>(this->fft_area_.data()),
+                 fft_area_.size() - wlen_bytes);
+    /* copy new window */
+    std::memcpy(reinterpret_cast<void *>(this->fft_area_.data()),
+                reinterpret_cast<const void *>(window.data()),
+                wlen_bytes);
+
+    /* update renderer */
+    this->renderer_.RenderFFTArea(this->fft_area_);
+    this->renderer_.RenderLiveFFT(win_values, window);
+
+    /* draw window */
+    this->Render();
+}
+
+bool
+LiveOutput::HandleEvents()
+{
+    sf::Event event;
+    while (this->window_.pollEvent(event)) {
+        if (event.type == sf::Event::Closed)
+            this->window_.close();
+    }
+    return this->window_.isOpen();
+}
+
+void
+LiveOutput::Render()
+{
+    sf::Texture canvas_texture = this->renderer_.GetCanvas();
+    sf::Sprite canvas_sprite(canvas_texture);
+    if (this->configuration_.IsHorizontal()) {
+        canvas_sprite.setRotation(-90.0f);
+        canvas_sprite.setPosition(0.0f, canvas_texture.getSize().x);
+    }
+
+    this->window_.draw(canvas_sprite);
+    this->window_.display();
+}
\ No newline at end of file
diff --git a/src/live.hpp b/src/live.hpp
new file mode 100644
index 0000000..b49db8c
--- /dev/null
+++ b/src/live.hpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#ifndef _LIVE_HPP_
+#define _LIVE_HPP_
+
+#include "configuration.hpp"
+#include "renderer.hpp"
+#include "color-map.hpp"
+#include <SFML/Graphics.hpp>
+
+class LiveOutput {
+private:
+    /* configuration */
+    const Configuration configuration_;
+    Renderer renderer_;
+
+    /* live window */
+    sf::RenderWindow window_;
+
+    /* raw FFT history */
+    std::vector<uint8_t> fft_area_;
+
+public:
+    LiveOutput() = delete;
+    LiveOutput(const LiveOutput &c) = delete;
+    LiveOutput(LiveOutput &&) = delete;
+    LiveOutput & operator=(const LiveOutput&) = delete;
+
+    LiveOutput(const Configuration& conf, const ColorMap& cmap, const ValueMap& vmap);
+
+    void AddWindow(const std::vector<uint8_t>& window, const RealWindow& win_values);
+    bool HandleEvents();
+    void Render();
+};
+
+#endif
\ No newline at end of file
diff --git a/src/renderer.cpp b/src/renderer.cpp
new file mode 100644
index 0000000..4b7e602
--- /dev/null
+++ b/src/renderer.cpp
@@ -0,0 +1,502 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "renderer.hpp"
+#include "share-tech-mono.hpp"
+#include "fft.hpp"
+
+#include <iomanip>
+#include <sstream>
+#include <cassert>
+#include <cstring>
+
+static std::string
+ValueToShortString(double value, int prec, const std::string& unit)
+{
+    static const std::vector<std::string> PREFIXES = { "p", "n", "u", "m", "", "k", "M", "G", "T" };
+    std::size_t pidx = 4;
+
+    while ((prec >= 3) && (pidx > 0)) {
+        prec -= 3;
+        pidx--;
+        value *= 1000.0f;
+    }
+    while ((prec <= -3) && (pidx < PREFIXES.size() - 1)) {
+        prec += 3;
+        pidx++;
+        value /= 1000.0f;
+    }
+
+    prec++;
+
+    std::stringstream ss;
+    ss << std::fixed << std::setprecision(prec > 0 ? prec : 0) << value << PREFIXES[pidx] << unit;
+    return ss.str();
+}
+
+Renderer::Renderer(const Configuration& conf, const ColorMap& cmap, const ValueMap& vmap, std::size_t fft_count)
+    : configuration_(conf), fft_count_(fft_count)
+{
+    if (fft_count == 0) {
+        throw std::runtime_error("positive number of FFT windows required by rendere");
+    }
+
+    /* load font */
+    if (!this->font_.loadFromMemory(ShareTechMono_Regular_ttf, ShareTechMono_Regular_ttf_len)) {
+        throw std::runtime_error("unable to load font");
+    }
+
+    /* compute tickmarks */
+    this->frequency_ticks_ =
+        Renderer::GetNiceTicks(this->configuration_.GetMinFreq(), this->configuration_.GetMaxFreq(),
+                               "Hz", this->configuration_.GetWidth(), 75);
+    auto time_ticks =
+        Renderer::GetNiceTicks(0.0f, (double)fft_count * this->configuration_.GetAverageCount() * this->configuration_.GetFFTStride() / this->configuration_.GetRate(),
+                               "s", fft_count, 50);
+
+    std::list<AxisTick> legend_ticks;
+    if (vmap.GetName() == "dBFS") {
+        unsigned int lticks = 1 + this->configuration_.GetWidth() / 60;
+        lticks = std::clamp<unsigned int>(lticks, 2, 13); /* at maximum 10dBFS spacing */
+        legend_ticks = Renderer::GetLinearTicks(vmap.GetLowerBound(), vmap.GetUpperBound(), vmap.GetUnit(), lticks);
+        this->live_ticks_ = Renderer::GetLinearTicks(vmap.GetLowerBound(), vmap.GetUpperBound(), "", 5); /* no unit, keep it short */
+    } else {
+        legend_ticks = Renderer::GetNiceTicks(vmap.GetLowerBound(), vmap.GetUpperBound(),
+                                            vmap.GetUnit(), this->configuration_.GetWidth(), 60);
+        this->live_ticks_ = Renderer::GetNiceTicks(vmap.GetLowerBound(), vmap.GetUpperBound(),
+                                                   "", this->configuration_.GetLiveFFTHeight(), 30); /* no unit, keep it short */
+    }
+
+    typeof(this->frequency_ticks_) freq_no_text_ticks;
+    for (auto& t : this->frequency_ticks_) {
+        freq_no_text_ticks.emplace_back(std::make_tuple(std::get<0>(t), ""));
+    }
+
+    /* get maximum text widths */
+    double max_freq_ticks_width = 0.0f;
+    double max_freq_ticks_height = 0.0f;
+
+    double max_time_ticks_width = 0.0f;
+    double max_time_ticks_height = 0.0f;
+
+    double max_legend_ticks_width = 0.0f;
+    double max_legend_ticks_height = 0.0f;
+
+    double max_live_ticks_width = 0.0f;
+    double max_live_ticks_height = 0.0f;
+
+    if (this->configuration_.HasAxes()) {
+        for (auto &t : this->frequency_ticks_) {
+            sf::Text text;
+            text.setCharacterSize(this->configuration_.GetAxisFontSize());
+            text.setFont(this->font_);
+            text.setString(std::get<1>(t));
+            if (text.getLocalBounds().width > max_freq_ticks_width) {
+                max_freq_ticks_width = text.getLocalBounds().width;
+            }
+            if (text.getLocalBounds().height > max_freq_ticks_height) {
+                max_freq_ticks_height = text.getLocalBounds().height;
+            }
+        }
+
+        for (auto &t : time_ticks) {
+            sf::Text text;
+            text.setCharacterSize(this->configuration_.GetAxisFontSize());
+            text.setFont(this->font_);
+            text.setString(std::get<1>(t));
+            if (text.getLocalBounds().width > max_time_ticks_width) {
+                max_time_ticks_width = text.getLocalBounds().width;
+            }
+            if (text.getLocalBounds().height > max_time_ticks_height) {
+                max_time_ticks_height = text.getLocalBounds().height;
+            }
+        }
+
+        for (auto &t : legend_ticks) {
+            sf::Text text;
+            text.setCharacterSize(this->configuration_.GetAxisFontSize());
+            text.setFont(this->font_);
+            text.setString(std::get<1>(t));
+            if (text.getLocalBounds().width > max_legend_ticks_width) {
+                max_legend_ticks_width = text.getLocalBounds().width;
+            }
+            if (text.getLocalBounds().height > max_legend_ticks_height) {
+                max_legend_ticks_height = text.getLocalBounds().height;
+            }
+        }
+
+        for (auto &t : this->live_ticks_) {
+            sf::Text text;
+            text.setCharacterSize(this->configuration_.GetAxisFontSize());
+            text.setFont(this->font_);
+            text.setString(std::get<1>(t));
+            if (text.getLocalBounds().width > max_live_ticks_width) {
+                max_live_ticks_width = text.getLocalBounds().width;
+            }
+            if (text.getLocalBounds().height > max_live_ticks_height) {
+                max_live_ticks_height = text.getLocalBounds().height;
+            }
+        }
+    }
+
+    double freq_axis_spacing = (this->configuration_.IsHorizontal() ? max_freq_ticks_width : max_freq_ticks_height);
+    double time_axis_spacing = (this->configuration_.IsHorizontal() ? max_time_ticks_height : max_time_ticks_width);
+    double legend_axis_spacing = (this->configuration_.IsHorizontal() ? max_legend_ticks_width : max_legend_ticks_height);
+    double live_axis_spacing = (this->configuration_.IsHorizontal() ? max_live_ticks_height : max_live_ticks_width);
+
+    double horizontal_extra_spacing = std::max({ time_axis_spacing, live_axis_spacing });
+    horizontal_extra_spacing =
+        std::max<double>({ 0.0f, horizontal_extra_spacing - this->configuration_.GetMarginSize() + this->configuration_.GetMinimumMarginSize() });
+
+    /* compute various sizes */
+    this->width_ = conf.GetWidth();
+    this->width_ += conf.HasAxes() ? 2 * conf.GetMarginSize() + static_cast<int>(horizontal_extra_spacing) : 0;
+    this->height_ = 0;
+
+    /* compute transforms */
+    if (this->configuration_.HasLegend()) {
+        if (this->configuration_.HasAxes()) {
+            this->legend_transform_.translate(conf.GetMarginSize() + horizontal_extra_spacing,
+                                              conf.GetMarginSize() + legend_axis_spacing);
+            this->height_ += conf.GetMarginSize() + legend_axis_spacing;
+        }
+        this->height_ += conf.GetLegendHeight();
+    }
+
+    this->fft_live_transform_.translate(0.0f, this->height_);
+    if (conf.HasLiveWindow()) {
+        if (this->configuration_.HasAxes()) {
+            this->fft_live_transform_.translate(conf.GetMarginSize() + horizontal_extra_spacing,
+                                                conf.GetMarginSize());
+            this->height_ += conf.GetLiveMarginSize();
+        }
+        this->height_ += conf.GetLiveFFTHeight();
+    }
+
+    this->fft_area_transform_.translate(0.0f, this->height_);
+    if (conf.HasAxes()) {
+        this->fft_area_transform_.translate(conf.GetMarginSize() + horizontal_extra_spacing,
+                                            conf.GetMarginSize() + freq_axis_spacing);
+        this->height_ += conf.GetMarginSize() * 2 + freq_axis_spacing;
+    }
+    this->height_ += this->fft_count_;
+
+    /* allocate canvas render texture */
+    this->canvas_.create(this->width_, this->height_);
+    this->canvas_.clear(this->configuration_.GetBackgroundColor());
+
+    /* allocate FFT area texture */
+    this->fft_area_texture_.create(conf.GetWidth(), fft_count);
+
+    /*
+     * render UI
+     */
+
+    /* render FFT area axes */
+    if (this->configuration_.HasAxes()) {
+        /* FFT area box */
+        sf::RectangleShape fft_area_box(sf::Vector2f(this->configuration_.GetWidth(), this->fft_count_));
+        fft_area_box.setFillColor(this->configuration_.GetBackgroundColor());
+        fft_area_box.setOutlineColor(this->configuration_.GetForegroundColor());
+        fft_area_box.setOutlineThickness(1);
+        this->canvas_.draw(fft_area_box, this->fft_area_transform_);
+
+        /* frequency axis */
+        this->RenderAxis(this->canvas_, this->fft_area_transform_,
+                         true, this->configuration_.IsHorizontal() ? Orientation::k90CW : Orientation::kNormal,
+                         this->configuration_.GetWidth(), this->frequency_ticks_);
+
+        /* time axis */
+        this->RenderAxis(this->canvas_, this->fft_area_transform_ * sf::Transform().rotate(90.0f),
+                         false, this->configuration_.IsHorizontal() ? Orientation::kNormal : Orientation::k90CCW,
+                         fft_count, time_ticks);
+    }
+
+    if (this->configuration_.HasLegend()) {
+        /* legend box */
+        sf::RectangleShape legend_box(sf::Vector2f(this->configuration_.GetWidth(),
+                                                   this->configuration_.GetLegendHeight()));
+        legend_box.setFillColor(this->configuration_.GetBackgroundColor());
+        legend_box.setOutlineColor(this->configuration_.GetForegroundColor());
+        legend_box.setOutlineThickness(1);
+        this->canvas_.draw(legend_box, this->legend_transform_);
+
+        /* legend gradient */
+        auto memory = cmap.Gradient(this->configuration_.GetWidth());
+        sf::Texture tex;
+        tex.create(this->configuration_.GetWidth(), 1);
+        tex.update(reinterpret_cast<const uint8_t *>(memory.data()));
+        this->canvas_.draw(sf::Sprite(tex), this->legend_transform_ * sf::Transform().scale(1.0f, this->configuration_.GetLegendHeight()));
+
+        if (this->configuration_.HasAxes()) {
+            this->RenderAxis(this->canvas_, this->legend_transform_,
+                             true, this->configuration_.IsHorizontal() ? Orientation::k90CW : Orientation::kNormal,
+                             this->configuration_.GetWidth(), legend_ticks);
+        }
+    }
+
+    if (this->configuration_.HasLiveWindow() && this->configuration_.HasAxes()) {
+        /* value axis */
+        this->RenderAxis(this->canvas_,
+                         this->fft_live_transform_ * sf::Transform().translate(0.0f, this->configuration_.GetLiveFFTHeight()).rotate(-90.0f),
+                         true, this->configuration_.IsHorizontal() ? Orientation::k180 : Orientation::k90CW,
+                         this->configuration_.GetLiveFFTHeight(), this->live_ticks_);
+
+        /* frequency axis */
+        this->RenderAxis(this->canvas_, this->fft_live_transform_ * sf::Transform().translate(0.0f, this->configuration_.GetLiveFFTHeight()),
+                         false, this->configuration_.IsHorizontal() ? Orientation::k90CW : Orientation::kNormal,
+                         this->configuration_.GetWidth(), freq_no_text_ticks);
+    }
+}
+
+std::list<AxisTick>
+Renderer::GetLinearTicks(double v_min, double v_max, const std::string& v_unit, unsigned int num_ticks)
+{
+    if (num_ticks <= 1) {
+        throw std::runtime_error("GetLinearTicks() requires at least two ticks");
+    }
+    if (v_min >= v_max) {
+        throw std::runtime_error("minimum and maximum values are not in order");
+    }
+
+    int prec = 0;
+    double dist = (v_max - v_min) / ((double) num_ticks - 1);
+    while (dist >= 10.0f) {
+        prec--;
+        dist /= 10.0f;
+    }
+    while (dist < 1.0f) {
+        prec++;
+        dist *= 10.0f;
+    }
+
+    std::list<AxisTick> ticks;
+    for (unsigned int i = 0; i < num_ticks; i ++) {
+        double k = (double) i / (double)(num_ticks - 1);
+        double v = v_min + k * (v_max - v_min);
+        ticks.emplace_back(std::make_tuple(k, ::ValueToShortString(v, prec, v_unit)));
+    }
+
+    return ticks;
+}
+
+std::list<AxisTick>
+Renderer::GetNiceTicks(double v_min, double v_max, const std::string& v_unit, unsigned int length_px,
+                       unsigned int est_tick_length_px)
+{
+    if (v_min >= v_max) {
+        throw std::runtime_error("minimum and maximum values are not in order");
+    }
+    if (length_px == 0) {
+        throw std::runtime_error("length in pixels must be positive");
+    }
+    if (est_tick_length_px == 0) {
+        throw std::runtime_error("estimate tick length in pixels must be positive");
+    }
+
+    std::list<AxisTick> ticks;
+
+    /* find a factor that brings some span close to est_tick_length to a nice value */
+    double v_diff = v_max - v_min;
+    double px_per_v = length_px / v_diff;
+
+    double mdist = 1e12, mfact;
+
+    constexpr double NICE_FACTORS[] = { 0.15f, 0.2f, 0.25f, 0.3f, 0.5f };
+    for (double f = 1e-15; f < 1e+15; f *= 10.0f) {
+        for (double nf : NICE_FACTORS) {
+            double factor = f * nf;
+            double dist = std::abs(est_tick_length_px - px_per_v * factor);
+            if (dist < mdist) {
+                mdist = dist;
+                mfact = factor;
+            }
+        }
+    }
+
+    /* compute precision */
+    int prec = 0;
+    double dist = mfact;
+    while (dist > 10.0f) {
+        prec--;
+        dist /= 10.0f;
+    }
+    while (dist < 1.0f) {
+        prec++;
+        dist *= 10.0f;
+    }
+
+    /* find the first nice value */
+    double fval = v_min / mfact;
+    constexpr double ROUND_EPSILON = 1e-6;
+    if (std::abs(fval - std::floor(fval)) > ROUND_EPSILON) {
+        fval = std::floor(fval) + 1.0f;
+    }
+    fval *= mfact;
+    assert(v_min <= fval);
+    assert(fval <= v_max);
+
+    /* add ticks */
+    for (double value = fval; value < v_max; value += mfact) {
+        double k = (value - v_min) / (v_max - v_min);
+        ticks.emplace_back(std::make_tuple(k, ::ValueToShortString(value, prec, v_unit)));
+    }
+
+    return ticks;
+}
+
+void
+Renderer::RenderAxis(sf::RenderTexture& texture,
+                     const sf::Transform& t, bool lhs, Orientation orientation, double length,
+                     const std::list<AxisTick>& ticks)
+{
+    if (length <= 0.0f) {
+        throw std::runtime_error("positive axis length required for rendering");
+    }
+
+    for (auto& tick : ticks) {
+        /* draw tick line */
+        double x = (length - 1) * std::get<0>(tick);
+        sf::RectangleShape tick_shape(sf::Vector2f(1.0, (lhs ? -5.0f : 5.0f)));
+        tick_shape.setFillColor(this->configuration_.GetForegroundColor());
+        texture.draw(tick_shape, t * sf::Transform().translate(x, 0.0f));
+
+        /* draw text */
+        sf::Text text;
+        text.setFillColor(this->configuration_.GetForegroundColor());
+        text.setCharacterSize(this->configuration_.GetAxisFontSize());
+        text.setFont(this->font_);
+        text.setString(std::get<1>(tick));
+
+        sf::Vector2f pos;
+        switch (orientation) {
+            case Orientation::k90CCW:
+                pos = sf::Vector2f(sf::Vector2f(length * std::get<0>(tick) - text.getLocalBounds().height,
+                                                (lhs ? -10.0f : text.getLocalBounds().width + 10.0f)));
+                text.setRotation(-90.0f);
+                break;
+
+            case Orientation::k90CW:
+                pos = sf::Vector2f(sf::Vector2f(length * std::get<0>(tick) + text.getLocalBounds().height,
+                                                (lhs ? -text.getLocalBounds().width - 10.0f : 10.0f)));
+                text.setRotation(90.0f);
+                break;
+
+            case Orientation::kNormal:
+                pos = sf::Vector2f(sf::Vector2f(length * std::get<0>(tick) - text.getLocalBounds().width / 2,
+                                                (lhs ? -2.0f * text.getLocalBounds().height - 3.0f : 3.0f)));
+                break;
+
+            case Orientation::k180:
+                pos = sf::Vector2f(sf::Vector2f(length * std::get<0>(tick) + text.getLocalBounds().width / 2,
+                                                (lhs ? -3.0f : 2.0f * text.getLocalBounds().height + 3.0f)));
+                text.setRotation(180.0f);
+                break;
+
+            default:
+                throw std::runtime_error("unknown orientation");
+        }
+
+        text.setPosition(std::round(pos.x), std::round(pos.y)); /* avoid interpolation on text, looks yuck */
+        texture.draw(text, t);
+    }
+}
+
+void
+Renderer::RenderFFTArea(const std::vector<uint8_t>& memory)
+{
+    if (memory.size() != configuration_.GetWidth() * this->fft_count_ * 4) {
+        throw std::runtime_error("bad memory size");
+    }
+
+    /* update FFT area texture */
+    this->fft_area_texture_.update(reinterpret_cast<const uint8_t *>(memory.data()));
+
+    /* render FFT area on canvas */
+    this->canvas_.draw(sf::Sprite(this->fft_area_texture_), this->fft_area_transform_);
+}
+
+void
+Renderer::RenderFFTArea(const std::list<std::vector<uint8_t>>& history)
+{
+    if (history.size() != this->fft_count_) {
+        throw std::runtime_error("bad history size");
+    }
+
+    std::vector<uint8_t> memory;
+    memory.resize(this->fft_count_ * this->configuration_.GetWidth() * 4);
+
+    std::size_t i = 0;
+    for (auto& win : history) {
+        std::memcpy(reinterpret_cast<void *>(memory.data() + i * this->configuration_.GetWidth() * 4),
+                    reinterpret_cast<const void *>(win.data()),
+                    this->configuration_.GetWidth() * 4);
+        i++;
+    }
+
+    return this->RenderFFTArea(memory);
+}
+
+void
+Renderer::RenderLiveFFT(const RealWindow& window, const std::vector<uint8_t>& colors)
+{
+    if (window.size() != this->configuration_.GetWidth()) {
+        throw std::runtime_error("incorrect window size to be rendered");
+    }
+
+    if (!this->configuration_.HasLiveWindow()) {
+        /* noop */
+        return;
+    }
+
+    /* FFT live box (so we overwrite old one */
+    sf::RectangleShape fft_live_box(sf::Vector2f(this->configuration_.GetWidth(),
+                                                 this->configuration_.GetLiveFFTHeight() + 1.0f));
+    fft_live_box.setFillColor(this->configuration_.GetBackgroundColor());
+    fft_live_box.setOutlineColor(this->configuration_.GetForegroundColor());
+    fft_live_box.setOutlineThickness(1);
+    this->canvas_.draw(fft_live_box, this->fft_live_transform_);
+
+    /* horizontal live guidelines */
+    for (std::size_t i = 1; i < this->live_ticks_.size() - 1; i ++) {
+        sf::RectangleShape hline(sf::Vector2f(this->configuration_.GetWidth(), 1.0f));
+        hline.setFillColor(this->configuration_.GetLiveGuidelinesColor());
+
+        sf::Transform tran;
+        tran.translate(0.0f, std::get<0>(*std::next(this->live_ticks_.begin(), i)) * (this->configuration_.GetLiveFFTHeight() - 1.0f));
+        this->canvas_.draw(hline, this->fft_live_transform_ * tran);
+    }
+
+    /* vertical live guidelines */
+    for (std::size_t i = 1; i < this->frequency_ticks_.size(); i ++) {
+        sf::RectangleShape vline(sf::Vector2f(1.0f, this->configuration_.GetLiveFFTHeight()));
+        vline.setFillColor(this->configuration_.GetLiveGuidelinesColor());
+
+        sf::Transform tran;
+        tran.translate(std::get<0>(*std::next(this->frequency_ticks_.begin(), i)) * (this->configuration_.GetWidth() - 1.0f), 0.0f);
+        this->canvas_.draw(vline, this->fft_live_transform_ * tran);
+    }
+
+    /* plot */
+    std::vector<sf::Vertex> vertices;
+    vertices.resize(window.size());
+    for (std::size_t i = 0; i < window.size(); i++) {
+        double x = i;
+        double y = (1.0f - window[i]) * this->configuration_.GetLiveFFTHeight();
+        vertices[i] = sf::Vertex(sf::Vector2f(x, y),
+                                 sf::Color(colors[i * 4 + 0], colors[i * 4 + 1], colors[i * 4 + 2]));
+    }
+    this->canvas_.draw(reinterpret_cast<sf::Vertex *>(vertices.data()), vertices.size(),
+                       sf::LineStrip, this->fft_live_transform_);
+
+}
+
+sf::Texture
+Renderer::GetCanvas()
+{
+    this->canvas_.display();
+    return this->canvas_.getTexture();
+}
\ No newline at end of file
diff --git a/src/renderer.hpp b/src/renderer.hpp
new file mode 100644
index 0000000..4272203
--- /dev/null
+++ b/src/renderer.hpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#ifndef _RENDERER_HPP_
+#define _RENDERER_HPP_
+
+#include "configuration.hpp"
+#include <SFML/Graphics.hpp>
+#include <vector>
+#include <list>
+
+/* Axis tick */
+typedef std::tuple<double, std::string> AxisTick;
+
+/* Orientation */
+enum class Orientation {
+    k90CCW,
+    kNormal,
+    k90CW,
+    k180
+};
+
+/*
+ * Spectrogram rendering class
+ */
+class Renderer {
+private:
+    const Configuration configuration_;
+    const std::size_t fft_count_;
+
+    sf::Font font_;
+
+    sf::RenderTexture canvas_;
+    sf::Texture fft_area_texture_;
+
+    std::size_t width_;
+    std::size_t height_;
+
+    sf::Transform legend_transform_;
+    sf::Transform fft_live_transform_;
+    sf::Transform fft_area_transform_;
+
+    std::list<AxisTick> frequency_ticks_;
+    std::list<AxisTick> live_ticks_;
+
+    static std::list<AxisTick> GetLinearTicks(double v_min, double v_max, const std::string& v_unit,
+                                              unsigned int num_ticks);
+    static std::list<AxisTick> GetNiceTicks(double v_min, double v_max, const std::string& v_unit,
+                                            unsigned int length_px, unsigned int est_tick_length_px);
+
+    void RenderAxis(sf::RenderTexture& texture,
+                    const sf::Transform& t, bool lhs, Orientation orientation, double length,
+                    const std::list<AxisTick>& ticks);
+
+public:
+    Renderer() = delete;
+    Renderer(const Configuration& conf, const ColorMap& cmap, const ValueMap& vmap, std::size_t fft_count);
+
+    /* render commands */
+    void RenderFFTArea(const std::vector<uint8_t>& memory);
+    void RenderFFTArea(const std::list<std::vector<uint8_t>>& history);
+    void RenderLiveFFT(const RealWindow& window, const std::vector<uint8_t>& colors);
+
+    /* canvas builder */
+    sf::Texture GetCanvas();
+
+    /* size getters */
+    auto GetWidth() const { return width_; }
+    auto GetHeight() const { return height_; }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/share-tech-mono.cpp b/src/share-tech-mono.cpp
new file mode 100644
index 0000000..2431d6c
--- /dev/null
+++ b/src/share-tech-mono.cpp
@@ -0,0 +1,3566 @@
+unsigned char ShareTechMono_Regular_ttf[] = {
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x47, 0x50, 0x4f, 0x53, 0x52, 0x48, 0x73, 0xb3, 0x00, 0x00, 0xa4, 0x68,
+  0x00, 0x00, 0x00, 0x82, 0x47, 0x53, 0x55, 0x42, 0x90, 0x45, 0xa1, 0xad,
+  0x00, 0x00, 0xa4, 0xec, 0x00, 0x00, 0x02, 0x16, 0x4f, 0x53, 0x2f, 0x32,
+  0x6e, 0xbe, 0x81, 0x7d, 0x00, 0x00, 0x8d, 0x34, 0x00, 0x00, 0x00, 0x60,
+  0x63, 0x6d, 0x61, 0x70, 0x0b, 0x51, 0x3b, 0xa3, 0x00, 0x00, 0x8d, 0x94,
+  0x00, 0x00, 0x03, 0x82, 0x63, 0x76, 0x74, 0x20, 0x01, 0x82, 0x12, 0xac,
+  0x00, 0x00, 0x9d, 0x14, 0x00, 0x00, 0x00, 0x42, 0x66, 0x70, 0x67, 0x6d,
+  0x71, 0xf9, 0x28, 0x6f, 0x00, 0x00, 0x91, 0x18, 0x00, 0x00, 0x0b, 0x6f,
+  0x67, 0x61, 0x73, 0x70, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xa4, 0x60,
+  0x00, 0x00, 0x00, 0x08, 0x67, 0x6c, 0x79, 0x66, 0xc2, 0x93, 0xe6, 0x76,
+  0x00, 0x00, 0x01, 0x0c, 0x00, 0x00, 0x85, 0xf4, 0x68, 0x65, 0x61, 0x64,
+  0x04, 0xd8, 0xcb, 0x3e, 0x00, 0x00, 0x89, 0x3c, 0x00, 0x00, 0x00, 0x36,
+  0x68, 0x68, 0x65, 0x61, 0x07, 0x4c, 0x03, 0xeb, 0x00, 0x00, 0x8d, 0x10,
+  0x00, 0x00, 0x00, 0x24, 0x68, 0x6d, 0x74, 0x78, 0xa8, 0xda, 0x53, 0xa7,
+  0x00, 0x00, 0x89, 0x74, 0x00, 0x00, 0x03, 0x9c, 0x6c, 0x6f, 0x63, 0x61,
+  0x0d, 0x75, 0xeb, 0x69, 0x00, 0x00, 0x87, 0x20, 0x00, 0x00, 0x02, 0x1a,
+  0x6d, 0x61, 0x78, 0x70, 0x02, 0x2b, 0x0c, 0x54, 0x00, 0x00, 0x87, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0xc5, 0x87, 0x87,
+  0x00, 0x00, 0x9d, 0x58, 0x00, 0x00, 0x04, 0x10, 0x70, 0x6f, 0x73, 0x74,
+  0x1e, 0x25, 0xe8, 0x57, 0x00, 0x00, 0xa1, 0x68, 0x00, 0x00, 0x02, 0xf5,
+  0x70, 0x72, 0x65, 0x70, 0x9a, 0x3c, 0xb8, 0x2a, 0x00, 0x00, 0x9c, 0x88,
+  0x00, 0x00, 0x00, 0x8b, 0x00, 0x02, 0x00, 0x54, 0x00, 0x00, 0x01, 0xc8,
+  0x02, 0xbc, 0x00, 0x03, 0x00, 0x07, 0x00, 0x08, 0xb5, 0x05, 0x04, 0x02,
+  0x00, 0x02, 0x2d, 0x2b, 0x21, 0x21, 0x11, 0x21, 0x05, 0x11, 0x33, 0x11,
+  0x01, 0xc8, 0xfe, 0x8c, 0x01, 0x74, 0xfe, 0xd7, 0xde, 0x02, 0xbc, 0x48,
+  0xfd, 0xd4, 0x02, 0x2c, 0x00, 0x02, 0x00, 0x2d, 0x00, 0x00, 0x01, 0xef,
+  0x02, 0xbc, 0x00, 0x07, 0x00, 0x0a, 0x00, 0x31, 0x40, 0x2e, 0x09, 0x01,
+  0x04, 0x01, 0x01, 0x47, 0x06, 0x01, 0x04, 0x05, 0x01, 0x03, 0x00, 0x04,
+  0x03, 0x5f, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x02, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x49, 0x08, 0x08, 0x00, 0x00, 0x08, 0x0a, 0x08, 0x0a, 0x00, 0x07,
+  0x00, 0x07, 0x11, 0x11, 0x11, 0x07, 0x05, 0x17, 0x2b, 0x37, 0x07, 0x23,
+  0x13, 0x33, 0x13, 0x23, 0x27, 0x27, 0x03, 0x03, 0xad, 0x27, 0x59, 0xa9,
+  0x73, 0xa6, 0x59, 0x26, 0x10, 0x52, 0x51, 0xb1, 0xb1, 0x02, 0xbc, 0xfd,
+  0x44, 0xb1, 0x4b, 0x01, 0x7e, 0xfe, 0x82, 0x00, 0x00, 0x03, 0x00, 0x2d,
+  0x00, 0x00, 0x01, 0xef, 0x03, 0x49, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x0e,
+  0x00, 0x46, 0x40, 0x43, 0x0d, 0x01, 0x06, 0x03, 0x01, 0x47, 0x07, 0x01,
+  0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x09, 0x01, 0x06,
+  0x08, 0x01, 0x05, 0x02, 0x06, 0x05, 0x5f, 0x00, 0x03, 0x03, 0x0f, 0x48,
+  0x04, 0x01, 0x02, 0x02, 0x10, 0x02, 0x49, 0x0c, 0x0c, 0x04, 0x04, 0x00,
+  0x00, 0x0c, 0x0e, 0x0c, 0x0e, 0x04, 0x0b, 0x04, 0x0b, 0x0a, 0x09, 0x08,
+  0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05, 0x15, 0x2b,
+  0x01, 0x07, 0x23, 0x37, 0x03, 0x07, 0x23, 0x13, 0x33, 0x13, 0x23, 0x27,
+  0x27, 0x03, 0x03, 0x01, 0x8c, 0x84, 0x53, 0x68, 0x70, 0x27, 0x59, 0xa9,
+  0x73, 0xa6, 0x59, 0x26, 0x10, 0x52, 0x59, 0x03, 0x49, 0x73, 0x73, 0xfd,
+  0x68, 0xb1, 0x02, 0xbc, 0xfd, 0x44, 0xb1, 0x4b, 0x01, 0x7e, 0xfe, 0x82,
+  0x00, 0x03, 0x00, 0x2d, 0x00, 0x00, 0x01, 0xef, 0x03, 0x4d, 0x00, 0x06,
+  0x00, 0x0e, 0x00, 0x11, 0x00, 0x43, 0x40, 0x40, 0x06, 0x01, 0x00, 0x01,
+  0x10, 0x01, 0x07, 0x04, 0x02, 0x47, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02,
+  0x01, 0x00, 0x04, 0x00, 0x6f, 0x09, 0x01, 0x07, 0x08, 0x01, 0x06, 0x03,
+  0x07, 0x06, 0x5f, 0x00, 0x04, 0x04, 0x0f, 0x48, 0x05, 0x01, 0x03, 0x03,
+  0x10, 0x03, 0x49, 0x0f, 0x0f, 0x07, 0x07, 0x0f, 0x11, 0x0f, 0x11, 0x07,
+  0x0e, 0x07, 0x0e, 0x11, 0x11, 0x13, 0x11, 0x11, 0x10, 0x0a, 0x05, 0x1a,
+  0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x03, 0x07, 0x23, 0x13,
+  0x33, 0x13, 0x23, 0x27, 0x27, 0x03, 0x03, 0xd1, 0x60, 0x6e, 0x5c, 0x6f,
+  0x61, 0x3c, 0x60, 0x27, 0x59, 0xa9, 0x73, 0xa6, 0x59, 0x26, 0x10, 0x52,
+  0x51, 0x02, 0xda, 0x73, 0x73, 0x40, 0xfd, 0x97, 0xb1, 0x02, 0xbc, 0xfd,
+  0x44, 0xb1, 0x4b, 0x01, 0x7e, 0xfe, 0x82, 0x00, 0x00, 0x04, 0x00, 0x2d,
+  0x00, 0x00, 0x01, 0xef, 0x03, 0x2f, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0f,
+  0x00, 0x12, 0x00, 0x4f, 0x40, 0x4c, 0x11, 0x01, 0x08, 0x05, 0x01, 0x47,
+  0x0a, 0x03, 0x09, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01, 0x00, 0x5e,
+  0x0c, 0x01, 0x08, 0x0b, 0x01, 0x07, 0x04, 0x08, 0x07, 0x5f, 0x00, 0x05,
+  0x05, 0x0f, 0x48, 0x06, 0x01, 0x04, 0x04, 0x10, 0x04, 0x49, 0x10, 0x10,
+  0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x10, 0x12, 0x10, 0x12, 0x08, 0x0f,
+  0x08, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x04, 0x07, 0x04, 0x07,
+  0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0d, 0x05, 0x15, 0x2b, 0x13,
+  0x15, 0x23, 0x35, 0x21, 0x17, 0x23, 0x35, 0x03, 0x07, 0x23, 0x13, 0x33,
+  0x13, 0x23, 0x27, 0x27, 0x03, 0x03, 0xd9, 0x55, 0x01, 0x12, 0x0b, 0x55,
+  0x9f, 0x27, 0x59, 0xa9, 0x73, 0xa6, 0x59, 0x26, 0x10, 0x52, 0x51, 0x03,
+  0x2f, 0x50, 0x50, 0x50, 0x50, 0xfd, 0x82, 0xb1, 0x02, 0xbc, 0xfd, 0x44,
+  0xb1, 0x4b, 0x01, 0x7e, 0xfe, 0x82, 0x00, 0x03, 0x00, 0x2d, 0x00, 0x00,
+  0x01, 0xef, 0x03, 0x49, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x0e, 0x00, 0x46,
+  0x40, 0x43, 0x0d, 0x01, 0x06, 0x03, 0x01, 0x47, 0x07, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x09, 0x01, 0x06, 0x08, 0x01,
+  0x05, 0x02, 0x06, 0x05, 0x5f, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x04, 0x01,
+  0x02, 0x02, 0x10, 0x02, 0x49, 0x0c, 0x0c, 0x04, 0x04, 0x00, 0x00, 0x0c,
+  0x0e, 0x0c, 0x0e, 0x04, 0x0b, 0x04, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06,
+  0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05, 0x15, 0x2b, 0x13, 0x17,
+  0x23, 0x27, 0x13, 0x07, 0x23, 0x13, 0x33, 0x13, 0x23, 0x27, 0x27, 0x03,
+  0x03, 0xfd, 0x68, 0x53, 0x84, 0x1f, 0x27, 0x59, 0xa9, 0x73, 0xa6, 0x59,
+  0x26, 0x10, 0x52, 0x51, 0x03, 0x49, 0x73, 0x73, 0xfd, 0x68, 0xb1, 0x02,
+  0xbc, 0xfd, 0x44, 0xb1, 0x4b, 0x01, 0x7e, 0xfe, 0x82, 0x00, 0x00, 0x03,
+  0x00, 0x2d, 0x00, 0x00, 0x01, 0xef, 0x03, 0x57, 0x00, 0x13, 0x00, 0x21,
+  0x00, 0x24, 0x00, 0x37, 0x40, 0x34, 0x23, 0x08, 0x01, 0x03, 0x06, 0x05,
+  0x01, 0x47, 0x00, 0x03, 0x00, 0x04, 0x05, 0x03, 0x04, 0x60, 0x07, 0x01,
+  0x06, 0x00, 0x01, 0x00, 0x06, 0x01, 0x5f, 0x00, 0x05, 0x05, 0x0f, 0x48,
+  0x02, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49, 0x22, 0x22, 0x22, 0x24, 0x22,
+  0x24, 0x35, 0x34, 0x36, 0x11, 0x11, 0x12, 0x08, 0x05, 0x1a, 0x2b, 0x00,
+  0x07, 0x13, 0x23, 0x27, 0x23, 0x07, 0x23, 0x13, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x23, 0x23, 0x22, 0x06,
+  0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x35, 0x35, 0x13, 0x03, 0x03,
+  0x01, 0x69, 0x1a, 0xa0, 0x59, 0x26, 0xc3, 0x27, 0x59, 0xa3, 0x1d, 0x31,
+  0x28, 0x06, 0x28, 0x31, 0x39, 0x20, 0x06, 0x12, 0x10, 0x10, 0x12, 0x06,
+  0x20, 0x2e, 0x52, 0x51, 0x02, 0xb8, 0x15, 0xfd, 0x5d, 0xb1, 0xb1, 0x02,
+  0xa2, 0x17, 0x2c, 0x1d, 0x2a, 0x2b, 0x2b, 0x2a, 0x1d, 0x44, 0x15, 0x11,
+  0x1f, 0x11, 0x15, 0x26, 0x1f, 0xfd, 0xf9, 0x01, 0x7e, 0xfe, 0x82, 0x00,
+  0x00, 0x03, 0x00, 0x2d, 0x00, 0x00, 0x01, 0xef, 0x03, 0x48, 0x00, 0x1a,
+  0x00, 0x22, 0x00, 0x25, 0x00, 0x4f, 0x40, 0x4c, 0x1a, 0x0c, 0x02, 0x01,
+  0x00, 0x19, 0x0d, 0x02, 0x02, 0x03, 0x24, 0x01, 0x08, 0x05, 0x03, 0x47,
+  0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x03, 0x60, 0x00, 0x01, 0x00, 0x02,
+  0x05, 0x01, 0x02, 0x60, 0x0a, 0x01, 0x08, 0x09, 0x01, 0x07, 0x04, 0x08,
+  0x07, 0x5f, 0x00, 0x05, 0x05, 0x0f, 0x48, 0x06, 0x01, 0x04, 0x04, 0x10,
+  0x04, 0x49, 0x23, 0x23, 0x1b, 0x1b, 0x23, 0x25, 0x23, 0x25, 0x1b, 0x22,
+  0x1b, 0x22, 0x11, 0x11, 0x15, 0x33, 0x26, 0x24, 0x21, 0x0b, 0x05, 0x1b,
+  0x2b, 0x12, 0x36, 0x33, 0x33, 0x32, 0x16, 0x17, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22, 0x27, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x07, 0x35, 0x13, 0x07, 0x23, 0x13, 0x33, 0x13, 0x23, 0x27,
+  0x27, 0x03, 0x03, 0x90, 0x38, 0x0c, 0x0f, 0x08, 0x20, 0x11, 0x2a, 0x0c,
+  0x0a, 0x08, 0x32, 0x09, 0x08, 0x31, 0x0b, 0x0f, 0x05, 0x28, 0x34, 0x0d,
+  0x0a, 0x09, 0x3a, 0x0a, 0x26, 0x27, 0x59, 0xa9, 0x73, 0xa6, 0x59, 0x26,
+  0x10, 0x52, 0x51, 0x03, 0x2c, 0x1c, 0x0c, 0x08, 0x14, 0x1e, 0x06, 0x48,
+  0x05, 0x1c, 0x11, 0x17, 0x1e, 0x06, 0x48, 0xfd, 0x8a, 0xb1, 0x02, 0xbc,
+  0xfd, 0x44, 0xb1, 0x4b, 0x01, 0x7e, 0xfe, 0x82, 0x00, 0x02, 0x00, 0x0f,
+  0x00, 0x00, 0x02, 0x06, 0x02, 0xbc, 0x00, 0x0f, 0x00, 0x12, 0x00, 0x41,
+  0x40, 0x3e, 0x10, 0x01, 0x02, 0x01, 0x46, 0x00, 0x03, 0x00, 0x04, 0x08,
+  0x03, 0x04, 0x5e, 0x00, 0x08, 0x09, 0x01, 0x07, 0x05, 0x08, 0x07, 0x5e,
+  0x00, 0x02, 0x02, 0x01, 0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x05,
+  0x05, 0x00, 0x56, 0x06, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49, 0x00, 0x00,
+  0x12, 0x11, 0x00, 0x0f, 0x00, 0x0f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x0a, 0x05, 0x1b, 0x2b, 0x37, 0x07, 0x23, 0x13, 0x21, 0x15, 0x23,
+  0x17, 0x33, 0x15, 0x23, 0x17, 0x33, 0x15, 0x23, 0x27, 0x03, 0x03, 0x33,
+  0x8d, 0x2a, 0x54, 0xb0, 0x01, 0x33, 0xad, 0x17, 0x91, 0x89, 0x19, 0x89,
+  0xd3, 0x0f, 0x2d, 0x58, 0x7c, 0xb1, 0xb1, 0x02, 0xbc, 0x49, 0xe5, 0x49,
+  0xfc, 0x49, 0xb1, 0x01, 0xc2, 0xfe, 0x89, 0x00, 0x00, 0x03, 0x00, 0x55,
+  0x00, 0x00, 0x01, 0xc7, 0x02, 0xbc, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x22,
+  0x00, 0x2f, 0x40, 0x2c, 0x0b, 0x01, 0x04, 0x03, 0x01, 0x47, 0x00, 0x03,
+  0x00, 0x04, 0x05, 0x03, 0x04, 0x60, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00,
+  0x01, 0x01, 0x0f, 0x48, 0x00, 0x05, 0x05, 0x00, 0x58, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x49, 0x21, 0x25, 0x21, 0x2a, 0x21, 0x21, 0x06, 0x05, 0x1a,
+  0x2b, 0x24, 0x06, 0x23, 0x23, 0x11, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14,
+  0x07, 0x16, 0x15, 0x15, 0x02, 0x26, 0x23, 0x23, 0x15, 0x33, 0x32, 0x36,
+  0x35, 0x35, 0x12, 0x26, 0x23, 0x23, 0x15, 0x33, 0x32, 0x36, 0x35, 0x35,
+  0x01, 0xc7, 0x4f, 0x5b, 0xc8, 0xbc, 0x59, 0x53, 0x37, 0x41, 0x61, 0x23,
+  0x26, 0x71, 0x71, 0x1f, 0x2a, 0x0a, 0x28, 0x21, 0x7b, 0x7a, 0x26, 0x24,
+  0x48, 0x48, 0x02, 0xbc, 0x48, 0x54, 0x39, 0x4d, 0x27, 0x24, 0x57, 0x5a,
+  0x01, 0xb1, 0x22, 0xdd, 0x28, 0x21, 0x4c, 0xfe, 0xf9, 0x27, 0xfe, 0x23,
+  0x26, 0x6d, 0x00, 0x01, 0x00, 0x6d, 0x00, 0x00, 0x01, 0xaf, 0x02, 0xbc,
+  0x00, 0x13, 0x00, 0x25, 0x40, 0x22, 0x00, 0x01, 0x01, 0x00, 0x58, 0x00,
+  0x00, 0x00, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x03, 0x58, 0x04, 0x01, 0x03,
+  0x03, 0x10, 0x03, 0x49, 0x00, 0x00, 0x00, 0x13, 0x00, 0x12, 0x25, 0x21,
+  0x25, 0x05, 0x05, 0x17, 0x2b, 0x32, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33,
+  0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x15,
+  0x23, 0xca, 0x5d, 0x5d, 0x57, 0x8e, 0x98, 0x25, 0x2e, 0x2e, 0x25, 0x98,
+  0x8e, 0x55, 0x55, 0x01, 0x68, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0xfe, 0x72,
+  0x1f, 0x2c, 0x4c, 0x00, 0x00, 0x01, 0x00, 0x6d, 0xff, 0x38, 0x01, 0xaf,
+  0x02, 0xbc, 0x00, 0x24, 0x00, 0xb6, 0xb5, 0x07, 0x01, 0x05, 0x04, 0x01,
+  0x47, 0x4b, 0xb0, 0x0b, 0x50, 0x58, 0x40, 0x2a, 0x00, 0x06, 0x05, 0x01,
+  0x00, 0x06, 0x65, 0x00, 0x01, 0x00, 0x05, 0x01, 0x63, 0x08, 0x01, 0x00,
+  0x00, 0x07, 0x00, 0x07, 0x5d, 0x00, 0x03, 0x03, 0x02, 0x58, 0x00, 0x02,
+  0x02, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05, 0x05, 0x10,
+  0x05, 0x49, 0x1b, 0x4b, 0xb0, 0x11, 0x50, 0x58, 0x40, 0x2b, 0x00, 0x06,
+  0x05, 0x01, 0x05, 0x06, 0x01, 0x6d, 0x00, 0x01, 0x00, 0x05, 0x01, 0x63,
+  0x08, 0x01, 0x00, 0x00, 0x07, 0x00, 0x07, 0x5d, 0x00, 0x03, 0x03, 0x02,
+  0x58, 0x00, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00,
+  0x05, 0x05, 0x10, 0x05, 0x49, 0x1b, 0x40, 0x2c, 0x00, 0x06, 0x05, 0x01,
+  0x05, 0x06, 0x01, 0x6d, 0x00, 0x01, 0x00, 0x05, 0x01, 0x00, 0x6b, 0x08,
+  0x01, 0x00, 0x00, 0x07, 0x00, 0x07, 0x5d, 0x00, 0x03, 0x03, 0x02, 0x58,
+  0x00, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05,
+  0x05, 0x10, 0x05, 0x49, 0x59, 0x59, 0x40, 0x17, 0x01, 0x00, 0x23, 0x21,
+  0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x17, 0x12, 0x10, 0x0f, 0x0d, 0x06, 0x04,
+  0x00, 0x24, 0x01, 0x24, 0x09, 0x05, 0x14, 0x2b, 0x05, 0x32, 0x35, 0x34,
+  0x26, 0x23, 0x23, 0x35, 0x26, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33,
+  0x15, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23,
+  0x15, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x23, 0x35, 0x01, 0x2f, 0x21,
+  0x11, 0x12, 0x31, 0x46, 0x49, 0x5d, 0x57, 0x8e, 0x98, 0x25, 0x2e, 0x2e,
+  0x25, 0x98, 0x6d, 0x2e, 0x29, 0x33, 0x25, 0x55, 0x88, 0x1f, 0x11, 0x0c,
+  0x4e, 0x08, 0x55, 0x4b, 0x01, 0x68, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0xfe,
+  0x72, 0x1f, 0x2c, 0x4c, 0x15, 0x23, 0x31, 0x3a, 0x25, 0x40, 0x00, 0x02,
+  0x00, 0x52, 0x00, 0x00, 0x01, 0xca, 0x02, 0xbc, 0x00, 0x09, 0x00, 0x13,
+  0x00, 0x1f, 0x40, 0x1c, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01, 0x01,
+  0x0f, 0x48, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x49, 0x21, 0x25, 0x21, 0x21, 0x04, 0x05, 0x18, 0x2b, 0x24, 0x06, 0x23,
+  0x23, 0x11, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26, 0x23, 0x23, 0x11,
+  0x33, 0x32, 0x36, 0x35, 0x11, 0x01, 0xca, 0x4f, 0x5b, 0xce, 0xc2, 0x5a,
+  0x5c, 0x57, 0x28, 0x21, 0x81, 0x80, 0x26, 0x24, 0x48, 0x48, 0x02, 0xbc,
+  0x49, 0x53, 0xfe, 0x7e, 0x01, 0xac, 0x27, 0xfd, 0xda, 0x23, 0x26, 0x01,
+  0x95, 0x00, 0x00, 0x02, 0x00, 0x22, 0x00, 0x00, 0x01, 0xd3, 0x02, 0xbc,
+  0x00, 0x0d, 0x00, 0x1b, 0x00, 0x2d, 0x40, 0x2a, 0x05, 0x01, 0x02, 0x06,
+  0x01, 0x01, 0x07, 0x02, 0x01, 0x5e, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00,
+  0x03, 0x03, 0x0f, 0x48, 0x00, 0x07, 0x07, 0x00, 0x58, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x49, 0x21, 0x11, 0x11, 0x25, 0x21, 0x11, 0x11, 0x21, 0x08,
+  0x05, 0x1c, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x11, 0x23, 0x35, 0x33, 0x11,
+  0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26, 0x23, 0x23, 0x15, 0x33, 0x15,
+  0x23, 0x15, 0x33, 0x32, 0x36, 0x35, 0x11, 0x01, 0xd3, 0x4f, 0x5b, 0xce,
+  0x39, 0x39, 0xc2, 0x5a, 0x5c, 0x57, 0x28, 0x21, 0x81, 0x74, 0x74, 0x80,
+  0x26, 0x24, 0x48, 0x48, 0x01, 0x45, 0x4b, 0x01, 0x2c, 0x49, 0x53, 0xfe,
+  0x7e, 0x01, 0xac, 0x27, 0xe1, 0x4b, 0xfa, 0x23, 0x26, 0x01, 0x95, 0x00,
+  0x00, 0x01, 0x00, 0x67, 0x00, 0x00, 0x01, 0xb5, 0x02, 0xbc, 0x00, 0x0b,
+  0x00, 0x2f, 0x40, 0x2c, 0x00, 0x01, 0x00, 0x02, 0x03, 0x01, 0x02, 0x5e,
+  0x00, 0x00, 0x00, 0x05, 0x56, 0x06, 0x01, 0x05, 0x05, 0x0f, 0x48, 0x00,
+  0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x00, 0x00,
+  0x00, 0x0b, 0x00, 0x0b, 0x11, 0x11, 0x11, 0x11, 0x11, 0x07, 0x05, 0x19,
+  0x2b, 0x01, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x21,
+  0x11, 0x01, 0xb5, 0xf7, 0xde, 0xde, 0xf7, 0xfe, 0xb2, 0x02, 0xbc, 0x49,
+  0xe5, 0x49, 0xfc, 0x49, 0x02, 0xbc, 0x00, 0x02, 0x00, 0x67, 0x00, 0x00,
+  0x01, 0xb5, 0x03, 0x49, 0x00, 0x03, 0x00, 0x0f, 0x00, 0x7b, 0x4b, 0xb0,
+  0x09, 0x50, 0x58, 0x40, 0x2a, 0x08, 0x01, 0x01, 0x00, 0x07, 0x01, 0x63,
+  0x00, 0x00, 0x07, 0x00, 0x6f, 0x00, 0x03, 0x00, 0x04, 0x05, 0x03, 0x04,
+  0x5e, 0x00, 0x02, 0x02, 0x07, 0x56, 0x09, 0x01, 0x07, 0x07, 0x0f, 0x48,
+  0x00, 0x05, 0x05, 0x06, 0x56, 0x00, 0x06, 0x06, 0x10, 0x06, 0x49, 0x1b,
+  0x40, 0x29, 0x08, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x07, 0x00,
+  0x6f, 0x00, 0x03, 0x00, 0x04, 0x05, 0x03, 0x04, 0x5e, 0x00, 0x02, 0x02,
+  0x07, 0x56, 0x09, 0x01, 0x07, 0x07, 0x0f, 0x48, 0x00, 0x05, 0x05, 0x06,
+  0x56, 0x00, 0x06, 0x06, 0x10, 0x06, 0x49, 0x59, 0x40, 0x1a, 0x04, 0x04,
+  0x00, 0x00, 0x04, 0x0f, 0x04, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09,
+  0x08, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05, 0x15,
+  0x2b, 0x01, 0x07, 0x23, 0x37, 0x17, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23,
+  0x15, 0x33, 0x15, 0x21, 0x11, 0x01, 0x8d, 0x84, 0x53, 0x68, 0x97, 0xf7,
+  0xde, 0xde, 0xf7, 0xfe, 0xb2, 0x03, 0x49, 0x73, 0x73, 0x8d, 0x49, 0xe5,
+  0x49, 0xfc, 0x49, 0x02, 0xbc, 0x00, 0x00, 0x02, 0x00, 0x67, 0x00, 0x00,
+  0x01, 0xb5, 0x03, 0x4d, 0x00, 0x06, 0x00, 0x12, 0x00, 0x79, 0xb5, 0x06,
+  0x01, 0x00, 0x01, 0x01, 0x47, 0x4b, 0xb0, 0x09, 0x50, 0x58, 0x40, 0x2a,
+  0x00, 0x01, 0x00, 0x08, 0x01, 0x63, 0x02, 0x01, 0x00, 0x08, 0x00, 0x6f,
+  0x00, 0x04, 0x00, 0x05, 0x06, 0x04, 0x05, 0x5e, 0x00, 0x03, 0x03, 0x08,
+  0x56, 0x09, 0x01, 0x08, 0x08, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x07, 0x56,
+  0x00, 0x07, 0x07, 0x10, 0x07, 0x49, 0x1b, 0x40, 0x29, 0x00, 0x01, 0x00,
+  0x01, 0x6f, 0x02, 0x01, 0x00, 0x08, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x05,
+  0x06, 0x04, 0x05, 0x5e, 0x00, 0x03, 0x03, 0x08, 0x56, 0x09, 0x01, 0x08,
+  0x08, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x07, 0x56, 0x00, 0x07, 0x07, 0x10,
+  0x07, 0x49, 0x59, 0x40, 0x11, 0x07, 0x07, 0x07, 0x12, 0x07, 0x12, 0x11,
+  0x11, 0x11, 0x11, 0x13, 0x11, 0x11, 0x10, 0x0a, 0x05, 0x1c, 0x2b, 0x13,
+  0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x17, 0x15, 0x23, 0x15, 0x33, 0x15,
+  0x23, 0x15, 0x33, 0x15, 0x21, 0x11, 0xd2, 0x60, 0x6e, 0x5c, 0x6f, 0x61,
+  0x3c, 0xa7, 0xf7, 0xde, 0xde, 0xf7, 0xfe, 0xb2, 0x02, 0xda, 0x73, 0x73,
+  0x40, 0x5e, 0x49, 0xe5, 0x49, 0xfc, 0x49, 0x02, 0xbc, 0x00, 0x00, 0x03,
+  0x00, 0x67, 0x00, 0x00, 0x01, 0xb5, 0x03, 0x2f, 0x00, 0x03, 0x00, 0x07,
+  0x00, 0x13, 0x00, 0x4f, 0x40, 0x4c, 0x0b, 0x03, 0x0a, 0x03, 0x01, 0x02,
+  0x01, 0x00, 0x09, 0x01, 0x00, 0x5e, 0x00, 0x05, 0x00, 0x06, 0x07, 0x05,
+  0x06, 0x5e, 0x00, 0x04, 0x04, 0x09, 0x56, 0x0c, 0x01, 0x09, 0x09, 0x0f,
+  0x48, 0x00, 0x07, 0x07, 0x08, 0x56, 0x00, 0x08, 0x08, 0x10, 0x08, 0x49,
+  0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x08, 0x13, 0x08, 0x13, 0x12, 0x11,
+  0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x04, 0x07, 0x04, 0x07,
+  0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0d, 0x05, 0x15, 0x2b, 0x13,
+  0x15, 0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x17, 0x15, 0x23, 0x15, 0x33,
+  0x15, 0x23, 0x15, 0x33, 0x15, 0x21, 0x11, 0xd4, 0x55, 0x01, 0x1d, 0x55,
+  0x6e, 0xf7, 0xde, 0xde, 0xf7, 0xfe, 0xb2, 0x03, 0x2f, 0x50, 0x50, 0x50,
+  0x50, 0x73, 0x49, 0xe5, 0x49, 0xfc, 0x49, 0x02, 0xbc, 0x00, 0x00, 0x02,
+  0x00, 0x67, 0x00, 0x00, 0x01, 0xb5, 0x03, 0x49, 0x00, 0x03, 0x00, 0x0f,
+  0x00, 0x7b, 0x4b, 0xb0, 0x09, 0x50, 0x58, 0x40, 0x2a, 0x08, 0x01, 0x01,
+  0x00, 0x07, 0x01, 0x63, 0x00, 0x00, 0x07, 0x00, 0x6f, 0x00, 0x03, 0x00,
+  0x04, 0x05, 0x03, 0x04, 0x5e, 0x00, 0x02, 0x02, 0x07, 0x56, 0x09, 0x01,
+  0x07, 0x07, 0x0f, 0x48, 0x00, 0x05, 0x05, 0x06, 0x56, 0x00, 0x06, 0x06,
+  0x10, 0x06, 0x49, 0x1b, 0x40, 0x29, 0x08, 0x01, 0x01, 0x00, 0x01, 0x6f,
+  0x00, 0x00, 0x07, 0x00, 0x6f, 0x00, 0x03, 0x00, 0x04, 0x05, 0x03, 0x04,
+  0x5e, 0x00, 0x02, 0x02, 0x07, 0x56, 0x09, 0x01, 0x07, 0x07, 0x0f, 0x48,
+  0x00, 0x05, 0x05, 0x06, 0x56, 0x00, 0x06, 0x06, 0x10, 0x06, 0x49, 0x59,
+  0x40, 0x1a, 0x04, 0x04, 0x00, 0x00, 0x04, 0x0f, 0x04, 0x0f, 0x0e, 0x0d,
+  0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03,
+  0x11, 0x0a, 0x05, 0x15, 0x2b, 0x13, 0x17, 0x23, 0x27, 0x05, 0x15, 0x23,
+  0x15, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x21, 0x11, 0xf8, 0x68, 0x53,
+  0x84, 0x01, 0x2c, 0xf7, 0xde, 0xde, 0xf7, 0xfe, 0xb2, 0x03, 0x49, 0x73,
+  0x73, 0x8d, 0x49, 0xe5, 0x49, 0xfc, 0x49, 0x02, 0xbc, 0x00, 0x00, 0x01,
+  0x00, 0x6a, 0x00, 0x00, 0x01, 0xb8, 0x02, 0xbc, 0x00, 0x09, 0x00, 0x29,
+  0x40, 0x26, 0x05, 0x01, 0x04, 0x00, 0x00, 0x01, 0x04, 0x00, 0x5e, 0x00,
+  0x03, 0x03, 0x02, 0x56, 0x00, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x01, 0x01,
+  0x10, 0x01, 0x49, 0x00, 0x00, 0x00, 0x09, 0x00, 0x09, 0x11, 0x11, 0x11,
+  0x11, 0x06, 0x05, 0x18, 0x2b, 0x01, 0x15, 0x23, 0x11, 0x23, 0x11, 0x21,
+  0x15, 0x23, 0x15, 0x01, 0x9f, 0xde, 0x57, 0x01, 0x4e, 0xf7, 0x01, 0x84,
+  0x49, 0xfe, 0xc5, 0x02, 0xbc, 0x49, 0xef, 0x00, 0x00, 0x01, 0x00, 0x5e,
+  0x00, 0x00, 0x01, 0xbd, 0x02, 0xbc, 0x00, 0x17, 0x00, 0x2f, 0x40, 0x2c,
+  0x00, 0x04, 0x00, 0x03, 0x02, 0x04, 0x03, 0x5e, 0x00, 0x01, 0x01, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x05, 0x58, 0x06,
+  0x01, 0x05, 0x05, 0x10, 0x05, 0x49, 0x00, 0x00, 0x00, 0x17, 0x00, 0x16,
+  0x11, 0x11, 0x25, 0x21, 0x25, 0x07, 0x05, 0x19, 0x2b, 0x32, 0x26, 0x35,
+  0x11, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14,
+  0x16, 0x33, 0x33, 0x35, 0x23, 0x35, 0x33, 0x11, 0x23, 0xbb, 0x5d, 0x5d,
+  0x57, 0x8d, 0x97, 0x25, 0x2e, 0x2e, 0x25, 0x62, 0x57, 0xaa, 0xab, 0x55,
+  0x55, 0x01, 0x68, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c,
+  0xd9, 0x4b, 0xfe, 0x90, 0x00, 0x01, 0x00, 0x50, 0x00, 0x00, 0x01, 0xcc,
+  0x02, 0xbc, 0x00, 0x0b, 0x00, 0x27, 0x40, 0x24, 0x00, 0x02, 0x06, 0x01,
+  0x05, 0x00, 0x02, 0x05, 0x5e, 0x03, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x04,
+  0x01, 0x00, 0x00, 0x10, 0x00, 0x49, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x0b,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x07, 0x05, 0x19, 0x2b, 0x13, 0x11, 0x23,
+  0x11, 0x33, 0x11, 0x33, 0x11, 0x33, 0x11, 0x23, 0x11, 0xa7, 0x57, 0x57,
+  0xce, 0x57, 0x57, 0x01, 0x42, 0xfe, 0xbe, 0x02, 0xbc, 0xfe, 0xd0, 0x01,
+  0x30, 0xfd, 0x44, 0x01, 0x42, 0x00, 0x00, 0x01, 0x00, 0x88, 0x00, 0x00,
+  0x01, 0x93, 0x02, 0xbc, 0x00, 0x0b, 0x00, 0x29, 0x40, 0x26, 0x02, 0x01,
+  0x00, 0x00, 0x01, 0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x06, 0x05, 0x02,
+  0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x00, 0x00,
+  0x00, 0x0b, 0x00, 0x0b, 0x11, 0x11, 0x11, 0x11, 0x11, 0x07, 0x05, 0x19,
+  0x2b, 0x37, 0x11, 0x23, 0x35, 0x21, 0x15, 0x23, 0x11, 0x33, 0x15, 0x21,
+  0x35, 0xe2, 0x5a, 0x01, 0x0b, 0x5a, 0x5a, 0xfe, 0xf5, 0x49, 0x02, 0x2a,
+  0x49, 0x49, 0xfd, 0xd6, 0x49, 0x49, 0x00, 0x02, 0x00, 0x88, 0x00, 0x00,
+  0x01, 0x93, 0x03, 0x49, 0x00, 0x03, 0x00, 0x0f, 0x00, 0x6f, 0x4b, 0xb0,
+  0x09, 0x50, 0x58, 0x40, 0x24, 0x08, 0x01, 0x01, 0x00, 0x03, 0x01, 0x63,
+  0x00, 0x00, 0x03, 0x00, 0x6f, 0x04, 0x01, 0x02, 0x02, 0x03, 0x56, 0x00,
+  0x03, 0x03, 0x0f, 0x48, 0x09, 0x07, 0x02, 0x05, 0x05, 0x06, 0x56, 0x00,
+  0x06, 0x06, 0x10, 0x06, 0x49, 0x1b, 0x40, 0x23, 0x08, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x04, 0x01, 0x02, 0x02, 0x03,
+  0x56, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x09, 0x07, 0x02, 0x05, 0x05, 0x06,
+  0x56, 0x00, 0x06, 0x06, 0x10, 0x06, 0x49, 0x59, 0x40, 0x1a, 0x04, 0x04,
+  0x00, 0x00, 0x04, 0x0f, 0x04, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09,
+  0x08, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05, 0x15,
+  0x2b, 0x01, 0x07, 0x23, 0x37, 0x03, 0x11, 0x23, 0x35, 0x21, 0x15, 0x23,
+  0x11, 0x33, 0x15, 0x21, 0x35, 0x01, 0x88, 0x84, 0x53, 0x68, 0x37, 0x5a,
+  0x01, 0x0b, 0x5a, 0x5a, 0xfe, 0xf5, 0x03, 0x49, 0x73, 0x73, 0xfd, 0x00,
+  0x02, 0x2a, 0x49, 0x49, 0xfd, 0xd6, 0x49, 0x49, 0x00, 0x02, 0x00, 0x72,
+  0x00, 0x00, 0x01, 0xab, 0x03, 0x4d, 0x00, 0x06, 0x00, 0x12, 0x00, 0x6d,
+  0xb5, 0x06, 0x01, 0x00, 0x01, 0x01, 0x47, 0x4b, 0xb0, 0x09, 0x50, 0x58,
+  0x40, 0x24, 0x00, 0x01, 0x00, 0x04, 0x01, 0x63, 0x02, 0x01, 0x00, 0x04,
+  0x00, 0x6f, 0x05, 0x01, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x0f,
+  0x48, 0x09, 0x08, 0x02, 0x06, 0x06, 0x07, 0x56, 0x00, 0x07, 0x07, 0x10,
+  0x07, 0x49, 0x1b, 0x40, 0x23, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02, 0x01,
+  0x00, 0x04, 0x00, 0x6f, 0x05, 0x01, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04,
+  0x04, 0x0f, 0x48, 0x09, 0x08, 0x02, 0x06, 0x06, 0x07, 0x56, 0x00, 0x07,
+  0x07, 0x10, 0x07, 0x49, 0x59, 0x40, 0x11, 0x07, 0x07, 0x07, 0x12, 0x07,
+  0x12, 0x11, 0x11, 0x11, 0x11, 0x13, 0x11, 0x11, 0x10, 0x0a, 0x05, 0x1c,
+  0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x03, 0x11, 0x23, 0x35,
+  0x21, 0x15, 0x23, 0x11, 0x33, 0x15, 0x21, 0x35, 0xd2, 0x60, 0x6e, 0x5c,
+  0x6f, 0x61, 0x3c, 0x2b, 0x5a, 0x01, 0x0b, 0x5a, 0x5a, 0xfe, 0xf5, 0x02,
+  0xda, 0x73, 0x73, 0x40, 0xfd, 0x2f, 0x02, 0x2a, 0x49, 0x49, 0xfd, 0xd6,
+  0x49, 0x49, 0x00, 0x03, 0x00, 0x80, 0x00, 0x00, 0x01, 0x9d, 0x03, 0x2f,
+  0x00, 0x03, 0x00, 0x07, 0x00, 0x13, 0x00, 0x49, 0x40, 0x46, 0x0b, 0x03,
+  0x0a, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01, 0x00, 0x5e, 0x06, 0x01,
+  0x04, 0x04, 0x05, 0x56, 0x00, 0x05, 0x05, 0x0f, 0x48, 0x0c, 0x09, 0x02,
+  0x07, 0x07, 0x08, 0x56, 0x00, 0x08, 0x08, 0x10, 0x08, 0x49, 0x08, 0x08,
+  0x04, 0x04, 0x00, 0x00, 0x08, 0x13, 0x08, 0x13, 0x12, 0x11, 0x10, 0x0f,
+  0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05,
+  0x00, 0x03, 0x00, 0x03, 0x11, 0x0d, 0x05, 0x15, 0x2b, 0x13, 0x15, 0x23,
+  0x35, 0x21, 0x15, 0x23, 0x35, 0x03, 0x11, 0x23, 0x35, 0x21, 0x15, 0x23,
+  0x11, 0x33, 0x15, 0x21, 0x35, 0xd5, 0x55, 0x01, 0x1d, 0x55, 0x66, 0x5a,
+  0x01, 0x0b, 0x5a, 0x5a, 0xfe, 0xf5, 0x03, 0x2f, 0x50, 0x50, 0x50, 0x50,
+  0xfd, 0x1a, 0x02, 0x2a, 0x49, 0x49, 0xfd, 0xd6, 0x49, 0x49, 0x00, 0x02,
+  0x00, 0x88, 0x00, 0x00, 0x01, 0x96, 0x03, 0x49, 0x00, 0x03, 0x00, 0x0f,
+  0x00, 0x6f, 0x4b, 0xb0, 0x09, 0x50, 0x58, 0x40, 0x24, 0x08, 0x01, 0x01,
+  0x00, 0x03, 0x01, 0x63, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x04, 0x01, 0x02,
+  0x02, 0x03, 0x56, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x09, 0x07, 0x02, 0x05,
+  0x05, 0x06, 0x56, 0x00, 0x06, 0x06, 0x10, 0x06, 0x49, 0x1b, 0x40, 0x23,
+  0x08, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x04,
+  0x01, 0x02, 0x02, 0x03, 0x56, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x09, 0x07,
+  0x02, 0x05, 0x05, 0x06, 0x56, 0x00, 0x06, 0x06, 0x10, 0x06, 0x49, 0x59,
+  0x40, 0x1a, 0x04, 0x04, 0x00, 0x00, 0x04, 0x0f, 0x04, 0x0f, 0x0e, 0x0d,
+  0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03,
+  0x11, 0x0a, 0x05, 0x15, 0x2b, 0x13, 0x17, 0x23, 0x27, 0x13, 0x11, 0x23,
+  0x35, 0x21, 0x15, 0x23, 0x11, 0x33, 0x15, 0x21, 0x35, 0xf7, 0x68, 0x53,
+  0x84, 0x5d, 0x5a, 0x01, 0x0b, 0x5a, 0x5a, 0xfe, 0xf5, 0x03, 0x49, 0x73,
+  0x73, 0xfd, 0x00, 0x02, 0x2a, 0x49, 0x49, 0xfd, 0xd6, 0x49, 0x49, 0x00,
+  0x00, 0x01, 0x00, 0x7d, 0x00, 0x00, 0x01, 0x9a, 0x02, 0xbc, 0x00, 0x0d,
+  0x00, 0x1f, 0x40, 0x1c, 0x00, 0x02, 0x02, 0x03, 0x56, 0x00, 0x03, 0x03,
+  0x0f, 0x48, 0x00, 0x01, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x49, 0x11, 0x13, 0x21, 0x21, 0x04, 0x05, 0x18, 0x2b, 0x24, 0x06, 0x23,
+  0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x11, 0x23, 0x35, 0x33, 0x11, 0x01,
+  0x9a, 0x5d, 0x57, 0x69, 0x73, 0x25, 0x2e, 0xa1, 0xf8, 0x55, 0x55, 0x4c,
+  0x2c, 0x1f, 0x01, 0xda, 0x4b, 0xfd, 0xee, 0x00, 0x00, 0x01, 0x00, 0x51,
+  0x00, 0x00, 0x01, 0xd1, 0x02, 0xbc, 0x00, 0x0b, 0x00, 0x20, 0x40, 0x1d,
+  0x0b, 0x08, 0x05, 0x00, 0x04, 0x00, 0x01, 0x01, 0x47, 0x02, 0x01, 0x01,
+  0x01, 0x0f, 0x48, 0x03, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49, 0x12, 0x12,
+  0x11, 0x11, 0x04, 0x05, 0x18, 0x2b, 0x13, 0x11, 0x23, 0x11, 0x33, 0x11,
+  0x13, 0x33, 0x03, 0x13, 0x23, 0x03, 0xa8, 0x57, 0x57, 0xbe, 0x5f, 0xc1,
+  0xcd, 0x64, 0x9f, 0x01, 0x02, 0xfe, 0xfe, 0x02, 0xbc, 0xfe, 0xd2, 0x01,
+  0x2e, 0xfe, 0xcb, 0xfe, 0x79, 0x01, 0x3b, 0x00, 0x00, 0x01, 0x00, 0x73,
+  0x00, 0x00, 0x01, 0xa9, 0x02, 0xbc, 0x00, 0x05, 0x00, 0x1f, 0x40, 0x1c,
+  0x03, 0x01, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x00, 0x00, 0x01, 0x57, 0x00,
+  0x01, 0x01, 0x10, 0x01, 0x49, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x11,
+  0x11, 0x04, 0x05, 0x16, 0x2b, 0x13, 0x11, 0x33, 0x15, 0x21, 0x11, 0xca,
+  0xdf, 0xfe, 0xca, 0x02, 0xbc, 0xfd, 0x90, 0x4c, 0x02, 0xbc, 0x00, 0x01,
+  0x00, 0x4b, 0x00, 0x00, 0x01, 0xdb, 0x02, 0xbc, 0x00, 0x0d, 0x00, 0x26,
+  0x40, 0x23, 0x0d, 0x08, 0x07, 0x06, 0x05, 0x02, 0x01, 0x00, 0x08, 0x01,
+  0x00, 0x01, 0x47, 0x00, 0x00, 0x00, 0x0f, 0x48, 0x00, 0x01, 0x01, 0x02,
+  0x57, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x11, 0x15, 0x13, 0x03, 0x05,
+  0x17, 0x2b, 0x13, 0x35, 0x37, 0x11, 0x33, 0x15, 0x37, 0x15, 0x07, 0x11,
+  0x33, 0x15, 0x21, 0x11, 0x4b, 0x5a, 0x57, 0x71, 0x71, 0xdf, 0xfe, 0xca,
+  0x01, 0x2c, 0x50, 0x2b, 0x01, 0x15, 0xeb, 0x37, 0x50, 0x37, 0xfe, 0xcb,
+  0x4c, 0x01, 0x57, 0x00, 0x00, 0x01, 0x00, 0x35, 0x00, 0x00, 0x01, 0xe8,
+  0x02, 0xbc, 0x00, 0x0c, 0x00, 0x28, 0x40, 0x25, 0x0c, 0x07, 0x02, 0x03,
+  0x00, 0x02, 0x01, 0x47, 0x00, 0x00, 0x02, 0x01, 0x02, 0x00, 0x01, 0x6d,
+  0x03, 0x01, 0x02, 0x02, 0x0f, 0x48, 0x04, 0x01, 0x01, 0x01, 0x10, 0x01,
+  0x49, 0x11, 0x12, 0x11, 0x12, 0x10, 0x05, 0x05, 0x19, 0x2b, 0x25, 0x23,
+  0x03, 0x11, 0x23, 0x11, 0x33, 0x13, 0x13, 0x33, 0x11, 0x23, 0x11, 0x01,
+  0x36, 0x53, 0x62, 0x4c, 0x8b, 0x50, 0x51, 0x87, 0x4e, 0xeb, 0x01, 0x89,
+  0xfd, 0x8c, 0x02, 0xbc, 0xfe, 0x9a, 0x01, 0x66, 0xfd, 0x44, 0x02, 0x74,
+  0x00, 0x01, 0x00, 0x4f, 0x00, 0x00, 0x01, 0xcc, 0x02, 0xbc, 0x00, 0x09,
+  0x00, 0x1e, 0x40, 0x1b, 0x09, 0x04, 0x02, 0x00, 0x01, 0x01, 0x47, 0x02,
+  0x01, 0x01, 0x01, 0x0f, 0x48, 0x03, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49,
+  0x11, 0x12, 0x11, 0x10, 0x04, 0x05, 0x18, 0x2b, 0x33, 0x23, 0x11, 0x33,
+  0x13, 0x11, 0x33, 0x11, 0x23, 0x03, 0xa0, 0x51, 0x8e, 0x9e, 0x51, 0x8f,
+  0x9d, 0x02, 0xbc, 0xfd, 0x8e, 0x02, 0x72, 0xfd, 0x44, 0x02, 0x72, 0x00,
+  0x00, 0x02, 0x00, 0x4f, 0x00, 0x00, 0x01, 0xcc, 0x03, 0x48, 0x00, 0x1a,
+  0x00, 0x24, 0x00, 0x3c, 0x40, 0x39, 0x1a, 0x0c, 0x02, 0x01, 0x00, 0x19,
+  0x0d, 0x02, 0x02, 0x03, 0x24, 0x1f, 0x02, 0x04, 0x05, 0x03, 0x47, 0x00,
+  0x00, 0x00, 0x03, 0x02, 0x00, 0x03, 0x60, 0x00, 0x01, 0x00, 0x02, 0x05,
+  0x01, 0x02, 0x60, 0x06, 0x01, 0x05, 0x05, 0x0f, 0x48, 0x07, 0x01, 0x04,
+  0x04, 0x10, 0x04, 0x49, 0x11, 0x12, 0x11, 0x14, 0x33, 0x26, 0x24, 0x21,
+  0x08, 0x05, 0x1c, 0x2b, 0x12, 0x36, 0x33, 0x33, 0x32, 0x16, 0x17, 0x16,
+  0x33, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22, 0x27,
+  0x26, 0x23, 0x23, 0x22, 0x06, 0x07, 0x35, 0x13, 0x23, 0x11, 0x33, 0x13,
+  0x11, 0x33, 0x11, 0x23, 0x03, 0x8e, 0x38, 0x0c, 0x0f, 0x08, 0x20, 0x11,
+  0x2a, 0x0c, 0x0a, 0x08, 0x32, 0x09, 0x08, 0x31, 0x0b, 0x0f, 0x05, 0x28,
+  0x34, 0x0d, 0x0a, 0x09, 0x3a, 0x0a, 0x1b, 0x51, 0x8e, 0x9e, 0x51, 0x8f,
+  0x9d, 0x03, 0x2c, 0x1c, 0x0c, 0x08, 0x14, 0x1e, 0x06, 0x48, 0x05, 0x1c,
+  0x11, 0x17, 0x1e, 0x06, 0x48, 0xfc, 0xd9, 0x02, 0xbc, 0xfd, 0x8e, 0x02,
+  0x72, 0xfd, 0x44, 0x02, 0x72, 0x00, 0x00, 0x02, 0x00, 0x46, 0x00, 0x00,
+  0x01, 0xd6, 0x02, 0xbc, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x1f, 0x40, 0x1c,
+  0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x03,
+  0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x35, 0x35, 0x35,
+  0x31, 0x04, 0x05, 0x18, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35,
+  0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26, 0x23,
+  0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35,
+  0x11, 0x01, 0xd6, 0x5d, 0x57, 0x28, 0x57, 0x5d, 0x5d, 0x57, 0x28, 0x57,
+  0x5d, 0x57, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x2e, 0x25, 0x3c, 0x25, 0x2e,
+  0x55, 0x55, 0x55, 0x55, 0x01, 0x68, 0x55, 0x55, 0x55, 0x55, 0xfe, 0x98,
+  0x01, 0x9a, 0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c, 0x2c, 0x1f, 0x01,
+  0x8e, 0x00, 0x00, 0x03, 0x00, 0x46, 0x00, 0x00, 0x01, 0xd6, 0x03, 0x49,
+  0x00, 0x03, 0x00, 0x13, 0x00, 0x23, 0x00, 0x61, 0x4b, 0xb0, 0x09, 0x50,
+  0x58, 0x40, 0x21, 0x06, 0x01, 0x01, 0x00, 0x03, 0x01, 0x63, 0x00, 0x00,
+  0x03, 0x00, 0x6f, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x0f,
+  0x48, 0x00, 0x05, 0x05, 0x02, 0x58, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49,
+  0x1b, 0x40, 0x20, 0x06, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x03,
+  0x00, 0x6f, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x0f, 0x48,
+  0x00, 0x05, 0x05, 0x02, 0x58, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x59,
+  0x40, 0x12, 0x00, 0x00, 0x20, 0x1d, 0x18, 0x15, 0x10, 0x0d, 0x08, 0x05,
+  0x00, 0x03, 0x00, 0x03, 0x11, 0x07, 0x05, 0x15, 0x2b, 0x01, 0x07, 0x23,
+  0x37, 0x12, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33,
+  0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15,
+  0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0x01, 0x8f, 0x84,
+  0x53, 0x68, 0xb6, 0x5d, 0x57, 0x28, 0x57, 0x5d, 0x5d, 0x57, 0x28, 0x57,
+  0x5d, 0x57, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x2e, 0x25, 0x3c, 0x25, 0x2e,
+  0x03, 0x49, 0x73, 0x73, 0xfd, 0x0c, 0x55, 0x55, 0x55, 0x01, 0x68, 0x55,
+  0x55, 0x55, 0x55, 0xfe, 0x98, 0x01, 0x9a, 0x2c, 0x2c, 0x1f, 0xfe, 0x72,
+  0x1f, 0x2c, 0x2c, 0x1f, 0x01, 0x8e, 0x00, 0x03, 0x00, 0x46, 0x00, 0x00,
+  0x01, 0xd6, 0x03, 0x4d, 0x00, 0x06, 0x00, 0x16, 0x00, 0x26, 0x00, 0x60,
+  0xb5, 0x06, 0x01, 0x00, 0x01, 0x01, 0x47, 0x4b, 0xb0, 0x09, 0x50, 0x58,
+  0x40, 0x21, 0x00, 0x01, 0x00, 0x04, 0x01, 0x63, 0x02, 0x01, 0x00, 0x04,
+  0x00, 0x6f, 0x00, 0x05, 0x05, 0x04, 0x58, 0x00, 0x04, 0x04, 0x0f, 0x48,
+  0x00, 0x06, 0x06, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x1b,
+  0x40, 0x20, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02, 0x01, 0x00, 0x04, 0x00,
+  0x6f, 0x00, 0x05, 0x05, 0x04, 0x58, 0x00, 0x04, 0x04, 0x0f, 0x48, 0x00,
+  0x06, 0x06, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x59, 0x40,
+  0x0a, 0x35, 0x35, 0x35, 0x33, 0x11, 0x11, 0x10, 0x07, 0x05, 0x1b, 0x2b,
+  0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x12, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02,
+  0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x11, 0xd1, 0x60, 0x6e, 0x5c, 0x6f, 0x61, 0x3c, 0xc9, 0x5d,
+  0x57, 0x28, 0x57, 0x5d, 0x5d, 0x57, 0x28, 0x57, 0x5d, 0x57, 0x2e, 0x25,
+  0x3c, 0x25, 0x2e, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x02, 0xda, 0x73, 0x73,
+  0x40, 0xfd, 0x3b, 0x55, 0x55, 0x55, 0x01, 0x68, 0x55, 0x55, 0x55, 0x55,
+  0xfe, 0x98, 0x01, 0x9a, 0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c, 0x2c,
+  0x1f, 0x01, 0x8e, 0x00, 0x00, 0x04, 0x00, 0x46, 0x00, 0x00, 0x01, 0xd6,
+  0x03, 0x2f, 0x00, 0x03, 0x00, 0x07, 0x00, 0x17, 0x00, 0x27, 0x00, 0x3e,
+  0x40, 0x3b, 0x09, 0x03, 0x08, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01,
+  0x00, 0x5e, 0x00, 0x06, 0x06, 0x05, 0x58, 0x00, 0x05, 0x05, 0x0f, 0x48,
+  0x00, 0x07, 0x07, 0x04, 0x58, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x04,
+  0x04, 0x00, 0x00, 0x24, 0x21, 0x1c, 0x19, 0x14, 0x11, 0x0c, 0x09, 0x04,
+  0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05,
+  0x15, 0x2b, 0x13, 0x15, 0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x12, 0x06,
+  0x23, 0x23, 0x22, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16,
+  0x15, 0x11, 0x02, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16,
+  0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0xd8, 0x55, 0x01, 0x1d, 0x55, 0x8b,
+  0x5d, 0x57, 0x28, 0x57, 0x5d, 0x5d, 0x57, 0x28, 0x57, 0x5d, 0x57, 0x2e,
+  0x25, 0x3c, 0x25, 0x2e, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x03, 0x2f, 0x50,
+  0x50, 0x50, 0x50, 0xfd, 0x26, 0x55, 0x55, 0x55, 0x01, 0x68, 0x55, 0x55,
+  0x55, 0x55, 0xfe, 0x98, 0x01, 0x9a, 0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f,
+  0x2c, 0x2c, 0x1f, 0x01, 0x8e, 0x00, 0x00, 0x03, 0x00, 0x46, 0x00, 0x00,
+  0x01, 0xd6, 0x03, 0x49, 0x00, 0x03, 0x00, 0x13, 0x00, 0x23, 0x00, 0x61,
+  0x4b, 0xb0, 0x09, 0x50, 0x58, 0x40, 0x21, 0x06, 0x01, 0x01, 0x00, 0x03,
+  0x01, 0x63, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x00, 0x04, 0x04, 0x03, 0x58,
+  0x00, 0x03, 0x03, 0x0f, 0x48, 0x00, 0x05, 0x05, 0x02, 0x58, 0x00, 0x02,
+  0x02, 0x10, 0x02, 0x49, 0x1b, 0x40, 0x20, 0x06, 0x01, 0x01, 0x00, 0x01,
+  0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00,
+  0x03, 0x03, 0x0f, 0x48, 0x00, 0x05, 0x05, 0x02, 0x58, 0x00, 0x02, 0x02,
+  0x10, 0x02, 0x49, 0x59, 0x40, 0x12, 0x00, 0x00, 0x20, 0x1d, 0x18, 0x15,
+  0x10, 0x0d, 0x08, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x07, 0x05, 0x15,
+  0x2b, 0x13, 0x17, 0x23, 0x27, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35,
+  0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26, 0x23,
+  0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35,
+  0x11, 0xf7, 0x68, 0x53, 0x84, 0x01, 0x4e, 0x5d, 0x57, 0x28, 0x57, 0x5d,
+  0x5d, 0x57, 0x28, 0x57, 0x5d, 0x57, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x2e,
+  0x25, 0x3c, 0x25, 0x2e, 0x03, 0x49, 0x73, 0x73, 0xfd, 0x0c, 0x55, 0x55,
+  0x55, 0x01, 0x68, 0x55, 0x55, 0x55, 0x55, 0xfe, 0x98, 0x01, 0x9a, 0x2c,
+  0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c, 0x2c, 0x1f, 0x01, 0x8e, 0x00, 0x03,
+  0x00, 0x46, 0xff, 0xa5, 0x01, 0xd6, 0x03, 0x17, 0x00, 0x17, 0x00, 0x1f,
+  0x00, 0x27, 0x00, 0x35, 0x40, 0x32, 0x14, 0x01, 0x04, 0x02, 0x08, 0x01,
+  0x00, 0x05, 0x02, 0x47, 0x00, 0x03, 0x02, 0x03, 0x6f, 0x00, 0x01, 0x00,
+  0x01, 0x70, 0x00, 0x04, 0x04, 0x02, 0x58, 0x00, 0x02, 0x02, 0x0f, 0x48,
+  0x00, 0x05, 0x05, 0x00, 0x59, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x26,
+  0x27, 0x12, 0x36, 0x12, 0x31, 0x06, 0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23,
+  0x23, 0x22, 0x27, 0x07, 0x23, 0x37, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33,
+  0x33, 0x32, 0x17, 0x37, 0x33, 0x07, 0x16, 0x15, 0x11, 0x04, 0x17, 0x13,
+  0x23, 0x22, 0x06, 0x15, 0x11, 0x12, 0x27, 0x03, 0x33, 0x32, 0x36, 0x35,
+  0x11, 0x01, 0xd6, 0x5d, 0x57, 0x28, 0x1b, 0x0c, 0x1a, 0x4c, 0x20, 0x47,
+  0x5d, 0x57, 0x28, 0x0d, 0x18, 0x1a, 0x4c, 0x20, 0x49, 0xfe, 0xc7, 0x09,
+  0x8c, 0x42, 0x25, 0x2e, 0xe2, 0x0b, 0x8d, 0x45, 0x25, 0x2e, 0x55, 0x55,
+  0x02, 0x5d, 0x73, 0x2a, 0x68, 0x01, 0x68, 0x55, 0x55, 0x02, 0x5d, 0x73,
+  0x28, 0x6a, 0xfe, 0x98, 0x27, 0x0f, 0x01, 0xfc, 0x2c, 0x1f, 0xfe, 0x72,
+  0x01, 0xa2, 0x11, 0xfe, 0x02, 0x2c, 0x1f, 0x01, 0x8e, 0x00, 0x00, 0x03,
+  0x00, 0x46, 0x00, 0x00, 0x01, 0xd6, 0x03, 0x48, 0x00, 0x1a, 0x00, 0x2a,
+  0x00, 0x3a, 0x00, 0x3f, 0x40, 0x3c, 0x1a, 0x0c, 0x02, 0x01, 0x00, 0x19,
+  0x0d, 0x02, 0x02, 0x03, 0x02, 0x47, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00,
+  0x03, 0x60, 0x00, 0x01, 0x00, 0x02, 0x05, 0x01, 0x02, 0x60, 0x00, 0x06,
+  0x06, 0x05, 0x58, 0x00, 0x05, 0x05, 0x0f, 0x48, 0x00, 0x07, 0x07, 0x04,
+  0x58, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x35, 0x35, 0x35, 0x35, 0x33,
+  0x26, 0x24, 0x21, 0x08, 0x05, 0x1c, 0x2b, 0x12, 0x36, 0x33, 0x33, 0x32,
+  0x16, 0x17, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06, 0x23,
+  0x23, 0x22, 0x27, 0x26, 0x23, 0x23, 0x22, 0x06, 0x07, 0x35, 0x00, 0x06,
+  0x23, 0x23, 0x22, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16,
+  0x15, 0x11, 0x02, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16,
+  0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0x8d, 0x38, 0x0c, 0x0f, 0x08, 0x20,
+  0x11, 0x2a, 0x0c, 0x0a, 0x07, 0x33, 0x09, 0x08, 0x31, 0x0b, 0x0f, 0x05,
+  0x28, 0x34, 0x0d, 0x0a, 0x09, 0x3a, 0x0a, 0x01, 0x52, 0x5d, 0x57, 0x28,
+  0x57, 0x5d, 0x5d, 0x57, 0x28, 0x57, 0x5d, 0x57, 0x2e, 0x25, 0x3c, 0x25,
+  0x2e, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x03, 0x2c, 0x1c, 0x0c, 0x08, 0x14,
+  0x1e, 0x06, 0x48, 0x05, 0x1c, 0x11, 0x17, 0x1e, 0x06, 0x48, 0xfd, 0x2e,
+  0x55, 0x55, 0x55, 0x01, 0x68, 0x55, 0x55, 0x55, 0x55, 0xfe, 0x98, 0x01,
+  0x9a, 0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c, 0x2c, 0x1f, 0x01, 0x8e,
+  0x00, 0x02, 0x00, 0x1a, 0x00, 0x00, 0x02, 0x0b, 0x02, 0xbc, 0x00, 0x15,
+  0x00, 0x25, 0x00, 0x35, 0x40, 0x32, 0x00, 0x02, 0x00, 0x03, 0x04, 0x02,
+  0x03, 0x5e, 0x06, 0x01, 0x01, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f,
+  0x48, 0x07, 0x01, 0x04, 0x04, 0x05, 0x58, 0x08, 0x01, 0x05, 0x05, 0x10,
+  0x05, 0x49, 0x00, 0x00, 0x22, 0x1f, 0x1a, 0x17, 0x00, 0x15, 0x00, 0x14,
+  0x13, 0x11, 0x13, 0x11, 0x25, 0x09, 0x05, 0x19, 0x2b, 0x32, 0x26, 0x35,
+  0x11, 0x34, 0x36, 0x33, 0x21, 0x15, 0x23, 0x16, 0x15, 0x15, 0x33, 0x15,
+  0x23, 0x15, 0x14, 0x07, 0x33, 0x15, 0x21, 0x12, 0x26, 0x23, 0x23, 0x22,
+  0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0x77,
+  0x5d, 0x5d, 0x57, 0x01, 0x3d, 0xb0, 0x18, 0x89, 0x89, 0x18, 0xb0, 0xfe,
+  0xc3, 0x4e, 0x2e, 0x25, 0x05, 0x25, 0x2e, 0x2e, 0x25, 0x05, 0x25, 0x2e,
+  0x55, 0x55, 0x01, 0x68, 0x55, 0x55, 0x49, 0x2d, 0x34, 0x84, 0x49, 0x9b,
+  0x36, 0x2b, 0x49, 0x02, 0x44, 0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c,
+  0x2c, 0x1f, 0x01, 0x8e, 0x00, 0x02, 0x00, 0x5a, 0x00, 0x00, 0x01, 0xc3,
+  0x02, 0xbc, 0x00, 0x0b, 0x00, 0x15, 0x00, 0x23, 0x40, 0x20, 0x00, 0x04,
+  0x00, 0x00, 0x01, 0x04, 0x00, 0x60, 0x00, 0x03, 0x03, 0x02, 0x58, 0x00,
+  0x02, 0x02, 0x0f, 0x48, 0x00, 0x01, 0x01, 0x10, 0x01, 0x49, 0x21, 0x25,
+  0x21, 0x11, 0x21, 0x05, 0x05, 0x19, 0x2b, 0x00, 0x06, 0x23, 0x23, 0x11,
+  0x23, 0x11, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23, 0x11,
+  0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0xc3, 0x56, 0x54, 0x68, 0x57, 0xbd,
+  0x55, 0x57, 0x57, 0x23, 0x26, 0x72, 0x72, 0x26, 0x23, 0x01, 0x5d, 0x4d,
+  0xfe, 0xf0, 0x02, 0xbc, 0x4b, 0x51, 0x72, 0xa1, 0x22, 0xfe, 0xea, 0x23,
+  0x26, 0x85, 0x00, 0x02, 0x00, 0x5e, 0x00, 0x00, 0x01, 0xc7, 0x02, 0xbc,
+  0x00, 0x0d, 0x00, 0x17, 0x00, 0x27, 0x40, 0x24, 0x00, 0x03, 0x00, 0x04,
+  0x05, 0x03, 0x04, 0x60, 0x00, 0x05, 0x00, 0x00, 0x01, 0x05, 0x00, 0x60,
+  0x00, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x01, 0x01, 0x10, 0x01, 0x49, 0x21,
+  0x25, 0x21, 0x11, 0x11, 0x21, 0x06, 0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23,
+  0x23, 0x15, 0x23, 0x11, 0x33, 0x15, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26,
+  0x26, 0x23, 0x23, 0x11, 0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0xc7, 0x56,
+  0x54, 0x68, 0x57, 0x57, 0x66, 0x55, 0x57, 0x57, 0x23, 0x26, 0x72, 0x72,
+  0x26, 0x23, 0xdb, 0x4d, 0x8e, 0x02, 0xbc, 0x82, 0x4b, 0x51, 0x72, 0xa1,
+  0x22, 0xfe, 0xea, 0x23, 0x26, 0x85, 0x00, 0x02, 0x00, 0x46, 0xff, 0xc5,
+  0x02, 0x08, 0x02, 0xbc, 0x00, 0x13, 0x00, 0x23, 0x00, 0x2b, 0x40, 0x28,
+  0x13, 0x10, 0x02, 0x00, 0x03, 0x01, 0x47, 0x12, 0x11, 0x02, 0x00, 0x44,
+  0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x03,
+  0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x35, 0x3a, 0x35,
+  0x30, 0x04, 0x05, 0x18, 0x2b, 0x20, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x14, 0x07, 0x17, 0x07,
+  0x27, 0x02, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33,
+  0x33, 0x32, 0x36, 0x35, 0x11, 0x01, 0x5b, 0x39, 0x28, 0x57, 0x5d, 0x5d,
+  0x57, 0x28, 0x57, 0x5d, 0x17, 0x49, 0x39, 0x4d, 0x03, 0x2e, 0x25, 0x3c,
+  0x25, 0x2e, 0x2e, 0x25, 0x3c, 0x25, 0x2e, 0x55, 0x55, 0x01, 0x68, 0x55,
+  0x55, 0x55, 0x55, 0xfe, 0x98, 0x3b, 0x28, 0x49, 0x39, 0x4d, 0x02, 0x32,
+  0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1f, 0x2c, 0x2c, 0x1f, 0x01, 0x8e, 0x00,
+  0x00, 0x02, 0x00, 0x46, 0x00, 0x00, 0x01, 0xdf, 0x02, 0xbc, 0x00, 0x0d,
+  0x00, 0x17, 0x00, 0x33, 0x40, 0x30, 0x0a, 0x01, 0x03, 0x05, 0x01, 0x47,
+  0x00, 0x05, 0x06, 0x01, 0x03, 0x00, 0x05, 0x03, 0x5e, 0x00, 0x04, 0x04,
+  0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x02, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x49, 0x00, 0x00, 0x14, 0x12, 0x11, 0x0f, 0x00, 0x0d, 0x00, 0x0d,
+  0x16, 0x21, 0x11, 0x07, 0x05, 0x17, 0x2b, 0x13, 0x11, 0x23, 0x11, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x14, 0x07, 0x13, 0x23, 0x03, 0x12, 0x26, 0x23,
+  0x23, 0x11, 0x33, 0x32, 0x36, 0x35, 0x35, 0x9d, 0x57, 0xbc, 0x55, 0x57,
+  0x5a, 0x8b, 0x5f, 0x81, 0x58, 0x23, 0x26, 0x71, 0x71, 0x26, 0x23, 0x01,
+  0x22, 0xfe, 0xde, 0x02, 0xbc, 0x4b, 0x51, 0x60, 0x71, 0x1c, 0xfe, 0xcd,
+  0x01, 0x22, 0x01, 0x2d, 0x22, 0xfe, 0xfc, 0x23, 0x26, 0x73, 0x00, 0x01,
+  0x00, 0x64, 0x00, 0x00, 0x01, 0xb7, 0x02, 0xbc, 0x00, 0x23, 0x00, 0x29,
+  0x40, 0x26, 0x00, 0x05, 0x00, 0x02, 0x01, 0x05, 0x02, 0x60, 0x00, 0x04,
+  0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x00, 0x01, 0x01, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x35, 0x21, 0x25, 0x35, 0x21,
+  0x21, 0x06, 0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33,
+  0x33, 0x32, 0x16, 0x15, 0x15, 0x01, 0xb7, 0x5d, 0x57, 0x8e, 0x98, 0x25,
+  0x2e, 0x1f, 0x1f, 0x1e, 0x4a, 0x56, 0x5d, 0x57, 0x8f, 0x99, 0x25, 0x2e,
+  0x28, 0x20, 0x1e, 0x47, 0x4f, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0x68, 0x1e,
+  0x25, 0x57, 0x53, 0x26, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0x4c, 0x1f, 0x29,
+  0x52, 0x53, 0x42, 0x00, 0x00, 0x02, 0x00, 0x64, 0x00, 0x00, 0x01, 0xb7,
+  0x03, 0x4d, 0x00, 0x06, 0x00, 0x2a, 0x00, 0x72, 0xb5, 0x06, 0x01, 0x01,
+  0x00, 0x01, 0x47, 0x4b, 0xb0, 0x09, 0x50, 0x58, 0x40, 0x29, 0x02, 0x01,
+  0x00, 0x01, 0x06, 0x00, 0x63, 0x00, 0x01, 0x06, 0x01, 0x6f, 0x00, 0x08,
+  0x00, 0x05, 0x04, 0x08, 0x05, 0x60, 0x00, 0x07, 0x07, 0x06, 0x58, 0x00,
+  0x06, 0x06, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03,
+  0x10, 0x03, 0x49, 0x1b, 0x40, 0x28, 0x02, 0x01, 0x00, 0x01, 0x00, 0x6f,
+  0x00, 0x01, 0x06, 0x01, 0x6f, 0x00, 0x08, 0x00, 0x05, 0x04, 0x08, 0x05,
+  0x60, 0x00, 0x07, 0x07, 0x06, 0x58, 0x00, 0x06, 0x06, 0x0f, 0x48, 0x00,
+  0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x59, 0x40,
+  0x0c, 0x35, 0x21, 0x25, 0x35, 0x21, 0x23, 0x11, 0x11, 0x10, 0x09, 0x05,
+  0x1d, 0x2b, 0x01, 0x33, 0x07, 0x23, 0x27, 0x33, 0x17, 0x12, 0x06, 0x23,
+  0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15,
+  0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x01, 0x57, 0x60,
+  0x70, 0x58, 0x71, 0x61, 0x3c, 0x9c, 0x5d, 0x57, 0x8e, 0x98, 0x25, 0x2e,
+  0x1f, 0x1f, 0x1e, 0x4a, 0x56, 0x5d, 0x57, 0x8f, 0x99, 0x25, 0x2e, 0x28,
+  0x20, 0x1e, 0x47, 0x4f, 0x03, 0x4d, 0x73, 0x73, 0x43, 0xfd, 0x4b, 0x55,
+  0x4c, 0x2c, 0x1f, 0x68, 0x1e, 0x25, 0x57, 0x53, 0x26, 0x55, 0x55, 0x4c,
+  0x2c, 0x1f, 0x4c, 0x1f, 0x29, 0x52, 0x53, 0x42, 0x00, 0x01, 0x00, 0x43,
+  0x00, 0x00, 0x01, 0xd8, 0x02, 0xbc, 0x00, 0x07, 0x00, 0x21, 0x40, 0x1e,
+  0x02, 0x01, 0x00, 0x00, 0x01, 0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x04,
+  0x01, 0x03, 0x03, 0x10, 0x03, 0x49, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07,
+  0x11, 0x11, 0x11, 0x05, 0x05, 0x17, 0x2b, 0x33, 0x11, 0x23, 0x35, 0x21,
+  0x15, 0x23, 0x11, 0xe2, 0x9f, 0x01, 0x95, 0x9f, 0x02, 0x70, 0x4c, 0x4c,
+  0xfd, 0x90, 0x00, 0x01, 0x00, 0x4d, 0x00, 0x00, 0x01, 0xce, 0x02, 0xbc,
+  0x00, 0x13, 0x00, 0x1b, 0x40, 0x18, 0x03, 0x01, 0x01, 0x01, 0x0f, 0x48,
+  0x00, 0x02, 0x02, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x13,
+  0x33, 0x13, 0x31, 0x04, 0x05, 0x18, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35,
+  0x11, 0x33, 0x11, 0x01, 0xce, 0x5d, 0x57, 0x19, 0x57, 0x5d, 0x57, 0x2e,
+  0x25, 0x2d, 0x25, 0x2e, 0x57, 0x55, 0x55, 0x55, 0x55, 0x02, 0x12, 0xfd,
+  0xdb, 0x1f, 0x2c, 0x2c, 0x1f, 0x02, 0x25, 0xfd, 0xee, 0x00, 0x00, 0x02,
+  0x00, 0x4d, 0x00, 0x00, 0x01, 0xce, 0x03, 0x49, 0x00, 0x03, 0x00, 0x17,
+  0x00, 0x31, 0x40, 0x2e, 0x06, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00,
+  0x03, 0x00, 0x6f, 0x05, 0x01, 0x03, 0x03, 0x0f, 0x48, 0x00, 0x04, 0x04,
+  0x02, 0x58, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x00, 0x00, 0x16, 0x15,
+  0x12, 0x0f, 0x0c, 0x0b, 0x08, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x07,
+  0x05, 0x15, 0x2b, 0x01, 0x07, 0x23, 0x37, 0x12, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35,
+  0x11, 0x33, 0x11, 0x01, 0xaa, 0x84, 0x53, 0x68, 0x93, 0x5d, 0x57, 0x19,
+  0x57, 0x5d, 0x57, 0x2e, 0x25, 0x2d, 0x25, 0x2e, 0x57, 0x03, 0x49, 0x73,
+  0x73, 0xfd, 0x0c, 0x55, 0x55, 0x55, 0x02, 0x12, 0xfd, 0xdb, 0x1f, 0x2c,
+  0x2c, 0x1f, 0x02, 0x25, 0xfd, 0xee, 0x00, 0x02, 0x00, 0x4d, 0x00, 0x00,
+  0x01, 0xce, 0x03, 0x4d, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x2f, 0x40, 0x2c,
+  0x06, 0x01, 0x00, 0x01, 0x01, 0x47, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02,
+  0x01, 0x00, 0x04, 0x00, 0x6f, 0x06, 0x01, 0x04, 0x04, 0x0f, 0x48, 0x00,
+  0x05, 0x05, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x13, 0x33,
+  0x13, 0x33, 0x11, 0x11, 0x10, 0x07, 0x05, 0x1b, 0x2b, 0x13, 0x23, 0x37,
+  0x33, 0x17, 0x23, 0x27, 0x12, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11,
+  0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0x33, 0x11,
+  0xd6, 0x60, 0x6e, 0x5c, 0x6f, 0x61, 0x3c, 0xbc, 0x5d, 0x57, 0x19, 0x57,
+  0x5d, 0x57, 0x2e, 0x25, 0x2d, 0x25, 0x2e, 0x57, 0x02, 0xda, 0x73, 0x73,
+  0x40, 0xfd, 0x3b, 0x55, 0x55, 0x55, 0x02, 0x12, 0xfd, 0xdb, 0x1f, 0x2c,
+  0x2c, 0x1f, 0x02, 0x25, 0xfd, 0xee, 0x00, 0x03, 0x00, 0x4d, 0x00, 0x00,
+  0x01, 0xce, 0x03, 0x2f, 0x00, 0x03, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x3a,
+  0x40, 0x37, 0x09, 0x03, 0x08, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01,
+  0x00, 0x5e, 0x07, 0x01, 0x05, 0x05, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x04,
+  0x58, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x04, 0x04, 0x00, 0x00, 0x1a,
+  0x19, 0x16, 0x13, 0x10, 0x0f, 0x0c, 0x09, 0x04, 0x07, 0x04, 0x07, 0x06,
+  0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05, 0x15, 0x2b, 0x13, 0x15,
+  0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x12, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11,
+  0x33, 0x11, 0xd6, 0x55, 0x01, 0x1d, 0x55, 0x85, 0x5d, 0x57, 0x19, 0x57,
+  0x5d, 0x57, 0x2e, 0x25, 0x2d, 0x25, 0x2e, 0x57, 0x03, 0x2f, 0x50, 0x50,
+  0x50, 0x50, 0xfd, 0x26, 0x55, 0x55, 0x55, 0x02, 0x12, 0xfd, 0xdb, 0x1f,
+  0x2c, 0x2c, 0x1f, 0x02, 0x25, 0xfd, 0xee, 0x00, 0x00, 0x02, 0x00, 0x4d,
+  0x00, 0x00, 0x01, 0xce, 0x03, 0x49, 0x00, 0x03, 0x00, 0x17, 0x00, 0x31,
+  0x40, 0x2e, 0x06, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x03, 0x00,
+  0x6f, 0x05, 0x01, 0x03, 0x03, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x02, 0x58,
+  0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x00, 0x00, 0x16, 0x15, 0x12, 0x0f,
+  0x0c, 0x0b, 0x08, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x07, 0x05, 0x15,
+  0x2b, 0x13, 0x17, 0x23, 0x27, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35,
+  0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0x33,
+  0x11, 0xe3, 0x68, 0x53, 0x84, 0x01, 0x5a, 0x5d, 0x57, 0x19, 0x57, 0x5d,
+  0x57, 0x2e, 0x25, 0x2d, 0x25, 0x2e, 0x57, 0x03, 0x49, 0x73, 0x73, 0xfd,
+  0x0c, 0x55, 0x55, 0x55, 0x02, 0x12, 0xfd, 0xdb, 0x1f, 0x2c, 0x2c, 0x1f,
+  0x02, 0x25, 0xfd, 0xee, 0x00, 0x01, 0x00, 0x38, 0x00, 0x00, 0x01, 0xdf,
+  0x02, 0xbc, 0x00, 0x06, 0x00, 0x1b, 0x40, 0x18, 0x02, 0x01, 0x02, 0x00,
+  0x01, 0x47, 0x01, 0x01, 0x00, 0x00, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x10,
+  0x02, 0x49, 0x11, 0x12, 0x10, 0x03, 0x05, 0x17, 0x2b, 0x13, 0x33, 0x13,
+  0x13, 0x33, 0x03, 0x23, 0x38, 0x58, 0x78, 0x81, 0x56, 0x9d, 0x77, 0x02,
+  0xbc, 0xfd, 0x9c, 0x02, 0x64, 0xfd, 0x44, 0x00, 0x00, 0x01, 0x00, 0x33,
+  0x00, 0x00, 0x01, 0xe5, 0x02, 0xbc, 0x00, 0x0c, 0x00, 0x28, 0x40, 0x25,
+  0x08, 0x05, 0x00, 0x03, 0x00, 0x02, 0x01, 0x47, 0x00, 0x02, 0x01, 0x00,
+  0x01, 0x02, 0x00, 0x6d, 0x03, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x04, 0x01,
+  0x00, 0x00, 0x10, 0x00, 0x49, 0x11, 0x12, 0x12, 0x11, 0x11, 0x05, 0x05,
+  0x19, 0x2b, 0x01, 0x03, 0x23, 0x03, 0x33, 0x13, 0x13, 0x33, 0x13, 0x13,
+  0x33, 0x03, 0x23, 0x01, 0x0c, 0x3f, 0x78, 0x22, 0x4a, 0x1e, 0x53, 0x3e,
+  0x55, 0x1f, 0x45, 0x22, 0x7e, 0x01, 0x1c, 0xfe, 0xe4, 0x02, 0xbc, 0xfd,
+  0x8f, 0x01, 0x4a, 0xfe, 0xb6, 0x02, 0x71, 0xfd, 0x44, 0x00, 0x00, 0x01,
+  0x00, 0x33, 0x00, 0x00, 0x01, 0xe9, 0x02, 0xbc, 0x00, 0x0b, 0x00, 0x20,
+  0x40, 0x1d, 0x0b, 0x08, 0x05, 0x02, 0x04, 0x00, 0x01, 0x01, 0x47, 0x02,
+  0x01, 0x01, 0x01, 0x0f, 0x48, 0x03, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49,
+  0x12, 0x12, 0x12, 0x10, 0x04, 0x05, 0x18, 0x2b, 0x33, 0x23, 0x13, 0x03,
+  0x33, 0x17, 0x37, 0x33, 0x03, 0x13, 0x23, 0x03, 0x91, 0x5e, 0xae, 0x9e,
+  0x5f, 0x6e, 0x72, 0x5d, 0xa2, 0xac, 0x62, 0x78, 0x01, 0x6a, 0x01, 0x52,
+  0xed, 0xed, 0xfe, 0xaf, 0xfe, 0x95, 0x01, 0x07, 0x00, 0x01, 0x00, 0x2c,
+  0x00, 0x00, 0x01, 0xef, 0x02, 0xbc, 0x00, 0x08, 0x00, 0x23, 0x40, 0x20,
+  0x07, 0x04, 0x01, 0x03, 0x02, 0x00, 0x01, 0x47, 0x01, 0x01, 0x00, 0x00,
+  0x0f, 0x48, 0x03, 0x01, 0x02, 0x02, 0x10, 0x02, 0x49, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x08, 0x12, 0x12, 0x04, 0x05, 0x16, 0x2b, 0x33, 0x11, 0x03,
+  0x33, 0x13, 0x13, 0x33, 0x03, 0x11, 0xdf, 0xb3, 0x60, 0x84, 0x84, 0x5b,
+  0xb6, 0x01, 0x45, 0x01, 0x77, 0xfe, 0xdd, 0x01, 0x23, 0xfe, 0x89, 0xfe,
+  0xbb, 0x00, 0x00, 0x02, 0x00, 0x2c, 0x00, 0x00, 0x01, 0xef, 0x03, 0x49,
+  0x00, 0x03, 0x00, 0x0c, 0x00, 0x37, 0x40, 0x34, 0x0b, 0x08, 0x05, 0x03,
+  0x04, 0x02, 0x01, 0x47, 0x05, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00,
+  0x02, 0x00, 0x6f, 0x03, 0x01, 0x02, 0x02, 0x0f, 0x48, 0x06, 0x01, 0x04,
+  0x04, 0x10, 0x04, 0x49, 0x04, 0x04, 0x00, 0x00, 0x04, 0x0c, 0x04, 0x0c,
+  0x0a, 0x09, 0x07, 0x06, 0x00, 0x03, 0x00, 0x03, 0x11, 0x07, 0x05, 0x15,
+  0x2b, 0x01, 0x07, 0x23, 0x37, 0x03, 0x11, 0x03, 0x33, 0x13, 0x13, 0x33,
+  0x03, 0x11, 0x01, 0x91, 0x84, 0x53, 0x68, 0x43, 0xb3, 0x60, 0x84, 0x84,
+  0x5b, 0xb6, 0x03, 0x49, 0x73, 0x73, 0xfc, 0xb7, 0x01, 0x45, 0x01, 0x77,
+  0xfe, 0xdd, 0x01, 0x23, 0xfe, 0x89, 0xfe, 0xbb, 0x00, 0x03, 0x00, 0x2c,
+  0x00, 0x00, 0x01, 0xef, 0x03, 0x2f, 0x00, 0x03, 0x00, 0x07, 0x00, 0x10,
+  0x00, 0x40, 0x40, 0x3d, 0x0f, 0x0c, 0x09, 0x03, 0x06, 0x04, 0x01, 0x47,
+  0x08, 0x03, 0x07, 0x03, 0x01, 0x02, 0x01, 0x00, 0x04, 0x01, 0x00, 0x5e,
+  0x05, 0x01, 0x04, 0x04, 0x0f, 0x48, 0x09, 0x01, 0x06, 0x06, 0x10, 0x06,
+  0x49, 0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x08, 0x10, 0x08, 0x10, 0x0e,
+  0x0d, 0x0b, 0x0a, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00,
+  0x03, 0x11, 0x0a, 0x05, 0x15, 0x2b, 0x13, 0x15, 0x23, 0x35, 0x21, 0x15,
+  0x23, 0x35, 0x03, 0x11, 0x03, 0x33, 0x13, 0x13, 0x33, 0x03, 0x11, 0xd5,
+  0x55, 0x01, 0x1d, 0x55, 0x69, 0xb3, 0x60, 0x84, 0x84, 0x5b, 0xb6, 0x03,
+  0x2f, 0x50, 0x50, 0x50, 0x50, 0xfc, 0xd1, 0x01, 0x45, 0x01, 0x77, 0xfe,
+  0xdd, 0x01, 0x23, 0xfe, 0x89, 0xfe, 0xbb, 0x00, 0x00, 0x01, 0x00, 0x57,
+  0x00, 0x00, 0x01, 0xc3, 0x02, 0xbc, 0x00, 0x09, 0x00, 0x26, 0x40, 0x23,
+  0x07, 0x02, 0x02, 0x03, 0x01, 0x01, 0x47, 0x00, 0x01, 0x01, 0x02, 0x56,
+  0x00, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x03, 0x03, 0x00, 0x56, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x49, 0x12, 0x11, 0x12, 0x10, 0x04, 0x05, 0x18, 0x2b,
+  0x21, 0x21, 0x35, 0x01, 0x23, 0x35, 0x21, 0x15, 0x01, 0x21, 0x01, 0xb9,
+  0xfe, 0x9e, 0x01, 0x12, 0xfb, 0x01, 0x55, 0xfe, 0xef, 0x01, 0x07, 0x58,
+  0x02, 0x1a, 0x4a, 0x58, 0xfd, 0xe6, 0x00, 0x02, 0x00, 0x57, 0x00, 0x00,
+  0x01, 0xc3, 0x03, 0x4d, 0x00, 0x06, 0x00, 0x10, 0x00, 0x66, 0x40, 0x0b,
+  0x06, 0x01, 0x01, 0x00, 0x0e, 0x09, 0x02, 0x06, 0x04, 0x02, 0x47, 0x4b,
+  0xb0, 0x09, 0x50, 0x58, 0x40, 0x21, 0x02, 0x01, 0x00, 0x01, 0x05, 0x00,
+  0x63, 0x00, 0x01, 0x05, 0x01, 0x6f, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00,
+  0x05, 0x05, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x03, 0x56, 0x00, 0x03, 0x03,
+  0x10, 0x03, 0x49, 0x1b, 0x40, 0x20, 0x02, 0x01, 0x00, 0x01, 0x00, 0x6f,
+  0x00, 0x01, 0x05, 0x01, 0x6f, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05,
+  0x05, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x03, 0x56, 0x00, 0x03, 0x03, 0x10,
+  0x03, 0x49, 0x59, 0x40, 0x0a, 0x12, 0x11, 0x12, 0x12, 0x11, 0x11, 0x10,
+  0x07, 0x05, 0x1b, 0x2b, 0x01, 0x33, 0x07, 0x23, 0x27, 0x33, 0x17, 0x13,
+  0x21, 0x35, 0x01, 0x23, 0x35, 0x21, 0x15, 0x01, 0x21, 0x01, 0x5a, 0x60,
+  0x70, 0x58, 0x71, 0x61, 0x3c, 0x9b, 0xfe, 0x9e, 0x01, 0x12, 0xfb, 0x01,
+  0x55, 0xfe, 0xef, 0x01, 0x07, 0x03, 0x4d, 0x73, 0x73, 0x43, 0xfc, 0xf6,
+  0x58, 0x02, 0x1a, 0x4a, 0x58, 0xfd, 0xe6, 0x00, 0x00, 0x02, 0x00, 0x43,
+  0x00, 0x00, 0x01, 0xd8, 0x01, 0xf4, 0x00, 0x1c, 0x00, 0x29, 0x00, 0x78,
+  0xb5, 0x02, 0x01, 0x00, 0x04, 0x01, 0x47, 0x4b, 0xb0, 0x2d, 0x50, 0x58,
+  0x40, 0x21, 0x00, 0x01, 0x00, 0x06, 0x04, 0x01, 0x06, 0x60, 0x00, 0x02,
+  0x02, 0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x09, 0x07, 0x02, 0x04,
+  0x04, 0x00, 0x58, 0x08, 0x05, 0x02, 0x00, 0x00, 0x10, 0x00, 0x49, 0x1b,
+  0x40, 0x2c, 0x00, 0x01, 0x00, 0x06, 0x07, 0x01, 0x06, 0x60, 0x00, 0x02,
+  0x02, 0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x09, 0x01, 0x07, 0x07,
+  0x00, 0x58, 0x08, 0x05, 0x02, 0x00, 0x00, 0x10, 0x48, 0x00, 0x04, 0x04,
+  0x00, 0x58, 0x08, 0x05, 0x02, 0x00, 0x00, 0x10, 0x00, 0x49, 0x59, 0x40,
+  0x16, 0x1d, 0x1d, 0x00, 0x00, 0x1d, 0x29, 0x1d, 0x27, 0x22, 0x20, 0x00,
+  0x1c, 0x00, 0x1b, 0x15, 0x21, 0x23, 0x24, 0x33, 0x0a, 0x05, 0x19, 0x2b,
+  0x20, 0x26, 0x27, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x33,
+  0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x16, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x15, 0x23, 0x26, 0x36, 0x35, 0x35, 0x23, 0x22, 0x06,
+  0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x01, 0x94, 0x1f, 0x0b, 0x17, 0x26,
+  0x59, 0x4c, 0x45, 0x92, 0x7c, 0x26, 0x25, 0x9b, 0x91, 0x57, 0x53, 0x17,
+  0x1b, 0x37, 0x60, 0x10, 0x7d, 0x1a, 0x22, 0x18, 0x1a, 0x59, 0x10, 0x0e,
+  0x1e, 0x3d, 0x4a, 0x14, 0x9b, 0x32, 0x1f, 0x22, 0x4b, 0x4c, 0x54, 0xf0,
+  0x0f, 0x0f, 0x46, 0x4b, 0x1c, 0x16, 0x6e, 0x22, 0x1a, 0x32, 0x1a, 0x18,
+  0x00, 0x03, 0x00, 0x43, 0x00, 0x00, 0x01, 0xd8, 0x02, 0xcb, 0x00, 0x03,
+  0x00, 0x20, 0x00, 0x2d, 0x00, 0xd2, 0xb5, 0x06, 0x01, 0x02, 0x06, 0x01,
+  0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x2f, 0x00, 0x00, 0x01, 0x05,
+  0x01, 0x00, 0x05, 0x6d, 0x00, 0x03, 0x00, 0x08, 0x06, 0x03, 0x08, 0x61,
+  0x0a, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x05, 0x58, 0x00,
+  0x05, 0x05, 0x12, 0x48, 0x0c, 0x09, 0x02, 0x06, 0x06, 0x02, 0x58, 0x0b,
+  0x07, 0x02, 0x02, 0x02, 0x10, 0x02, 0x49, 0x1b, 0x4b, 0xb0, 0x2d, 0x50,
+  0x58, 0x40, 0x2c, 0x0a, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x05,
+  0x00, 0x6f, 0x00, 0x03, 0x00, 0x08, 0x06, 0x03, 0x08, 0x61, 0x00, 0x04,
+  0x04, 0x05, 0x58, 0x00, 0x05, 0x05, 0x12, 0x48, 0x0c, 0x09, 0x02, 0x06,
+  0x06, 0x02, 0x58, 0x0b, 0x07, 0x02, 0x02, 0x02, 0x10, 0x02, 0x49, 0x1b,
+  0x40, 0x37, 0x0a, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x05, 0x00,
+  0x6f, 0x00, 0x03, 0x00, 0x08, 0x09, 0x03, 0x08, 0x61, 0x00, 0x04, 0x04,
+  0x05, 0x58, 0x00, 0x05, 0x05, 0x12, 0x48, 0x0c, 0x01, 0x09, 0x09, 0x02,
+  0x58, 0x0b, 0x07, 0x02, 0x02, 0x02, 0x10, 0x48, 0x00, 0x06, 0x06, 0x02,
+  0x58, 0x0b, 0x07, 0x02, 0x02, 0x02, 0x10, 0x02, 0x49, 0x59, 0x59, 0x40,
+  0x22, 0x21, 0x21, 0x04, 0x04, 0x00, 0x00, 0x21, 0x2d, 0x21, 0x2b, 0x26,
+  0x24, 0x04, 0x20, 0x04, 0x1f, 0x1e, 0x1d, 0x18, 0x16, 0x15, 0x13, 0x10,
+  0x0e, 0x0a, 0x07, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0d, 0x05, 0x15, 0x2b,
+  0x01, 0x07, 0x23, 0x37, 0x12, 0x26, 0x27, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x35, 0x34, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x23, 0x26, 0x36, 0x35,
+  0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x01, 0x9a,
+  0x7a, 0x56, 0x68, 0x62, 0x1f, 0x0b, 0x17, 0x26, 0x59, 0x4c, 0x45, 0x92,
+  0x7c, 0x26, 0x25, 0x9b, 0x91, 0x57, 0x53, 0x17, 0x1b, 0x37, 0x60, 0x10,
+  0x7d, 0x1a, 0x22, 0x18, 0x1a, 0x59, 0x02, 0xcb, 0x87, 0x87, 0xfd, 0x35,
+  0x10, 0x0e, 0x1e, 0x3d, 0x4a, 0x14, 0x9b, 0x32, 0x1f, 0x22, 0x4b, 0x4c,
+  0x54, 0xf0, 0x0f, 0x0f, 0x46, 0x4b, 0x1c, 0x16, 0x6e, 0x22, 0x1a, 0x32,
+  0x1a, 0x18, 0x00, 0x03, 0x00, 0x43, 0x00, 0x00, 0x01, 0xd8, 0x02, 0xcb,
+  0x00, 0x06, 0x00, 0x23, 0x00, 0x30, 0x00, 0xce, 0x40, 0x0a, 0x06, 0x01,
+  0x00, 0x01, 0x09, 0x01, 0x03, 0x07, 0x02, 0x47, 0x4b, 0xb0, 0x21, 0x50,
+  0x58, 0x40, 0x2f, 0x02, 0x01, 0x00, 0x01, 0x06, 0x01, 0x00, 0x06, 0x6d,
+  0x00, 0x04, 0x00, 0x09, 0x07, 0x04, 0x09, 0x60, 0x00, 0x01, 0x01, 0x0f,
+  0x48, 0x00, 0x05, 0x05, 0x06, 0x58, 0x00, 0x06, 0x06, 0x12, 0x48, 0x0c,
+  0x0a, 0x02, 0x07, 0x07, 0x03, 0x58, 0x0b, 0x08, 0x02, 0x03, 0x03, 0x10,
+  0x03, 0x49, 0x1b, 0x4b, 0xb0, 0x2d, 0x50, 0x58, 0x40, 0x2c, 0x00, 0x01,
+  0x00, 0x01, 0x6f, 0x02, 0x01, 0x00, 0x06, 0x00, 0x6f, 0x00, 0x04, 0x00,
+  0x09, 0x07, 0x04, 0x09, 0x60, 0x00, 0x05, 0x05, 0x06, 0x58, 0x00, 0x06,
+  0x06, 0x12, 0x48, 0x0c, 0x0a, 0x02, 0x07, 0x07, 0x03, 0x58, 0x0b, 0x08,
+  0x02, 0x03, 0x03, 0x10, 0x03, 0x49, 0x1b, 0x40, 0x37, 0x00, 0x01, 0x00,
+  0x01, 0x6f, 0x02, 0x01, 0x00, 0x06, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x09,
+  0x0a, 0x04, 0x09, 0x60, 0x00, 0x05, 0x05, 0x06, 0x58, 0x00, 0x06, 0x06,
+  0x12, 0x48, 0x0c, 0x01, 0x0a, 0x0a, 0x03, 0x58, 0x0b, 0x08, 0x02, 0x03,
+  0x03, 0x10, 0x48, 0x00, 0x07, 0x07, 0x03, 0x58, 0x0b, 0x08, 0x02, 0x03,
+  0x03, 0x10, 0x03, 0x49, 0x59, 0x59, 0x40, 0x19, 0x24, 0x24, 0x07, 0x07,
+  0x24, 0x30, 0x24, 0x2e, 0x29, 0x27, 0x07, 0x23, 0x07, 0x22, 0x15, 0x21,
+  0x23, 0x24, 0x35, 0x11, 0x11, 0x10, 0x0d, 0x05, 0x1c, 0x2b, 0x13, 0x23,
+  0x37, 0x33, 0x17, 0x23, 0x27, 0x12, 0x26, 0x27, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x35, 0x34, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35,
+  0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x23, 0x26, 0x36,
+  0x35, 0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0xc2,
+  0x60, 0x70, 0x58, 0x71, 0x61, 0x3c, 0x96, 0x1f, 0x0b, 0x17, 0x26, 0x59,
+  0x4c, 0x45, 0x92, 0x7c, 0x26, 0x25, 0x9b, 0x91, 0x57, 0x53, 0x17, 0x1b,
+  0x37, 0x60, 0x10, 0x7d, 0x1a, 0x22, 0x18, 0x1a, 0x59, 0x02, 0x44, 0x87,
+  0x87, 0x4b, 0xfd, 0x71, 0x10, 0x0e, 0x1e, 0x3d, 0x4a, 0x14, 0x9b, 0x32,
+  0x1f, 0x22, 0x4b, 0x4c, 0x54, 0xf0, 0x0f, 0x0f, 0x46, 0x4b, 0x1c, 0x16,
+  0x6e, 0x22, 0x1a, 0x32, 0x1a, 0x18, 0x00, 0x04, 0x00, 0x43, 0x00, 0x00,
+  0x01, 0xd8, 0x02, 0xa3, 0x00, 0x03, 0x00, 0x07, 0x00, 0x24, 0x00, 0x31,
+  0x00, 0xa4, 0xb5, 0x0a, 0x01, 0x04, 0x08, 0x01, 0x47, 0x4b, 0xb0, 0x2d,
+  0x50, 0x58, 0x40, 0x2d, 0x0d, 0x03, 0x0c, 0x03, 0x01, 0x02, 0x01, 0x00,
+  0x07, 0x01, 0x00, 0x5e, 0x00, 0x05, 0x00, 0x0a, 0x08, 0x05, 0x0a, 0x60,
+  0x00, 0x06, 0x06, 0x07, 0x58, 0x00, 0x07, 0x07, 0x12, 0x48, 0x0f, 0x0b,
+  0x02, 0x08, 0x08, 0x04, 0x58, 0x0e, 0x09, 0x02, 0x04, 0x04, 0x10, 0x04,
+  0x49, 0x1b, 0x40, 0x38, 0x0d, 0x03, 0x0c, 0x03, 0x01, 0x02, 0x01, 0x00,
+  0x07, 0x01, 0x00, 0x5e, 0x00, 0x05, 0x00, 0x0a, 0x0b, 0x05, 0x0a, 0x60,
+  0x00, 0x06, 0x06, 0x07, 0x58, 0x00, 0x07, 0x07, 0x12, 0x48, 0x0f, 0x01,
+  0x0b, 0x0b, 0x04, 0x58, 0x0e, 0x09, 0x02, 0x04, 0x04, 0x10, 0x48, 0x00,
+  0x08, 0x08, 0x04, 0x58, 0x0e, 0x09, 0x02, 0x04, 0x04, 0x10, 0x04, 0x49,
+  0x59, 0x40, 0x2a, 0x25, 0x25, 0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x25,
+  0x31, 0x25, 0x2f, 0x2a, 0x28, 0x08, 0x24, 0x08, 0x23, 0x22, 0x21, 0x1c,
+  0x1a, 0x19, 0x17, 0x14, 0x12, 0x0e, 0x0b, 0x04, 0x07, 0x04, 0x07, 0x06,
+  0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x10, 0x05, 0x15, 0x2b, 0x13, 0x15,
+  0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x12, 0x26, 0x27, 0x06, 0x23, 0x23,
+  0x22, 0x26, 0x35, 0x35, 0x34, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23,
+  0x35, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x23, 0x26,
+  0x36, 0x35, 0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33,
+  0xbf, 0x55, 0x01, 0x1d, 0x55, 0x62, 0x1f, 0x0b, 0x17, 0x26, 0x59, 0x4c,
+  0x45, 0x92, 0x7c, 0x26, 0x25, 0x9b, 0x91, 0x57, 0x53, 0x17, 0x1b, 0x37,
+  0x60, 0x10, 0x7d, 0x1a, 0x22, 0x18, 0x1a, 0x59, 0x02, 0xa3, 0x50, 0x50,
+  0x50, 0x50, 0xfd, 0x5d, 0x10, 0x0e, 0x1e, 0x3d, 0x4a, 0x14, 0x9b, 0x32,
+  0x1f, 0x22, 0x4b, 0x4c, 0x54, 0xf0, 0x0f, 0x0f, 0x46, 0x4b, 0x1c, 0x16,
+  0x6e, 0x22, 0x1a, 0x32, 0x1a, 0x18, 0x00, 0x03, 0x00, 0x43, 0x00, 0x00,
+  0x01, 0xd8, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x20, 0x00, 0x2d, 0x00, 0xd2,
+  0xb5, 0x06, 0x01, 0x02, 0x06, 0x01, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58,
+  0x40, 0x2f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x00, 0x05, 0x6d, 0x00, 0x03,
+  0x00, 0x08, 0x06, 0x03, 0x08, 0x60, 0x0a, 0x01, 0x01, 0x01, 0x0f, 0x48,
+  0x00, 0x04, 0x04, 0x05, 0x58, 0x00, 0x05, 0x05, 0x12, 0x48, 0x0c, 0x09,
+  0x02, 0x06, 0x06, 0x02, 0x58, 0x0b, 0x07, 0x02, 0x02, 0x02, 0x10, 0x02,
+  0x49, 0x1b, 0x4b, 0xb0, 0x2d, 0x50, 0x58, 0x40, 0x2c, 0x0a, 0x01, 0x01,
+  0x00, 0x01, 0x6f, 0x00, 0x00, 0x05, 0x00, 0x6f, 0x00, 0x03, 0x00, 0x08,
+  0x06, 0x03, 0x08, 0x60, 0x00, 0x04, 0x04, 0x05, 0x58, 0x00, 0x05, 0x05,
+  0x12, 0x48, 0x0c, 0x09, 0x02, 0x06, 0x06, 0x02, 0x58, 0x0b, 0x07, 0x02,
+  0x02, 0x02, 0x10, 0x02, 0x49, 0x1b, 0x40, 0x37, 0x0a, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x05, 0x00, 0x6f, 0x00, 0x03, 0x00, 0x08, 0x09,
+  0x03, 0x08, 0x60, 0x00, 0x04, 0x04, 0x05, 0x58, 0x00, 0x05, 0x05, 0x12,
+  0x48, 0x0c, 0x01, 0x09, 0x09, 0x02, 0x58, 0x0b, 0x07, 0x02, 0x02, 0x02,
+  0x10, 0x48, 0x00, 0x06, 0x06, 0x02, 0x58, 0x0b, 0x07, 0x02, 0x02, 0x02,
+  0x10, 0x02, 0x49, 0x59, 0x59, 0x40, 0x22, 0x21, 0x21, 0x04, 0x04, 0x00,
+  0x00, 0x21, 0x2d, 0x21, 0x2b, 0x26, 0x24, 0x04, 0x20, 0x04, 0x1f, 0x1e,
+  0x1d, 0x18, 0x16, 0x15, 0x13, 0x10, 0x0e, 0x0a, 0x07, 0x00, 0x03, 0x00,
+  0x03, 0x11, 0x0d, 0x05, 0x15, 0x2b, 0x13, 0x17, 0x23, 0x27, 0x00, 0x26,
+  0x27, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x33, 0x33, 0x35,
+  0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x16,
+  0x33, 0x15, 0x23, 0x26, 0x36, 0x35, 0x35, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0xee, 0x68, 0x56, 0x7a, 0x01, 0x0e, 0x1f, 0x0b,
+  0x17, 0x26, 0x59, 0x4c, 0x45, 0x92, 0x7c, 0x26, 0x25, 0x9b, 0x91, 0x57,
+  0x53, 0x17, 0x1b, 0x37, 0x60, 0x10, 0x7d, 0x1a, 0x22, 0x18, 0x1a, 0x59,
+  0x02, 0xcb, 0x87, 0x87, 0xfd, 0x35, 0x10, 0x0e, 0x1e, 0x3d, 0x4a, 0x14,
+  0x9b, 0x32, 0x1f, 0x22, 0x4b, 0x4c, 0x54, 0xf0, 0x0f, 0x0f, 0x46, 0x4b,
+  0x1c, 0x16, 0x6e, 0x22, 0x1a, 0x32, 0x1a, 0x18, 0x00, 0x04, 0x00, 0x43,
+  0x00, 0x00, 0x01, 0xd8, 0x02, 0xeb, 0x00, 0x0f, 0x00, 0x1d, 0x00, 0x3a,
+  0x00, 0x47, 0x00, 0x9c, 0xb5, 0x20, 0x01, 0x04, 0x08, 0x01, 0x47, 0x4b,
+  0xb0, 0x2d, 0x50, 0x58, 0x40, 0x31, 0x00, 0x01, 0x00, 0x02, 0x03, 0x01,
+  0x02, 0x60, 0x00, 0x03, 0x00, 0x00, 0x07, 0x03, 0x00, 0x60, 0x00, 0x05,
+  0x00, 0x0a, 0x08, 0x05, 0x0a, 0x60, 0x00, 0x06, 0x06, 0x07, 0x58, 0x00,
+  0x07, 0x07, 0x12, 0x48, 0x0d, 0x0b, 0x02, 0x08, 0x08, 0x04, 0x58, 0x0c,
+  0x09, 0x02, 0x04, 0x04, 0x10, 0x04, 0x49, 0x1b, 0x40, 0x3c, 0x00, 0x01,
+  0x00, 0x02, 0x03, 0x01, 0x02, 0x60, 0x00, 0x03, 0x00, 0x00, 0x07, 0x03,
+  0x00, 0x60, 0x00, 0x05, 0x00, 0x0a, 0x0b, 0x05, 0x0a, 0x60, 0x00, 0x06,
+  0x06, 0x07, 0x58, 0x00, 0x07, 0x07, 0x12, 0x48, 0x0d, 0x01, 0x0b, 0x0b,
+  0x04, 0x58, 0x0c, 0x09, 0x02, 0x04, 0x04, 0x10, 0x48, 0x00, 0x08, 0x08,
+  0x04, 0x58, 0x0c, 0x09, 0x02, 0x04, 0x04, 0x10, 0x04, 0x49, 0x59, 0x40,
+  0x1a, 0x3b, 0x3b, 0x1e, 0x1e, 0x3b, 0x47, 0x3b, 0x45, 0x40, 0x3e, 0x1e,
+  0x3a, 0x1e, 0x39, 0x15, 0x21, 0x23, 0x24, 0x36, 0x35, 0x34, 0x35, 0x31,
+  0x0e, 0x05, 0x1d, 0x2b, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x23, 0x23, 0x22,
+  0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x35, 0x35, 0x12, 0x26,
+  0x27, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x33, 0x33, 0x35,
+  0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x16,
+  0x33, 0x15, 0x23, 0x26, 0x36, 0x35, 0x35, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0x01, 0x58, 0x32, 0x27, 0x06, 0x27, 0x32, 0x31,
+  0x28, 0x06, 0x28, 0x31, 0x39, 0x20, 0x06, 0x12, 0x10, 0x10, 0x12, 0x06,
+  0x20, 0x75, 0x1f, 0x0b, 0x17, 0x26, 0x59, 0x4c, 0x45, 0x92, 0x7c, 0x26,
+  0x25, 0x9b, 0x91, 0x57, 0x53, 0x17, 0x1b, 0x37, 0x60, 0x10, 0x7d, 0x1a,
+  0x22, 0x18, 0x1a, 0x59, 0x02, 0x50, 0x2c, 0x2c, 0x29, 0x1d, 0x2a, 0x2b,
+  0x2b, 0x2a, 0x1d, 0x44, 0x15, 0x11, 0x1f, 0x11, 0x15, 0x26, 0x1f, 0xfd,
+  0x69, 0x10, 0x0e, 0x1e, 0x3d, 0x4a, 0x14, 0x9b, 0x32, 0x1f, 0x22, 0x4b,
+  0x4c, 0x54, 0xf0, 0x0f, 0x0f, 0x46, 0x4b, 0x1c, 0x16, 0x6e, 0x22, 0x1a,
+  0x32, 0x1a, 0x18, 0x00, 0x00, 0x03, 0x00, 0x43, 0x00, 0x00, 0x01, 0xd8,
+  0x02, 0xbc, 0x00, 0x1a, 0x00, 0x37, 0x00, 0x44, 0x00, 0xab, 0x40, 0x10,
+  0x1a, 0x0c, 0x02, 0x01, 0x00, 0x19, 0x0d, 0x02, 0x02, 0x03, 0x1d, 0x01,
+  0x04, 0x08, 0x03, 0x47, 0x4b, 0xb0, 0x2d, 0x50, 0x58, 0x40, 0x33, 0x00,
+  0x01, 0x00, 0x02, 0x07, 0x01, 0x02, 0x60, 0x00, 0x05, 0x00, 0x0a, 0x08,
+  0x05, 0x0a, 0x60, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f,
+  0x48, 0x00, 0x06, 0x06, 0x07, 0x58, 0x00, 0x07, 0x07, 0x12, 0x48, 0x0d,
+  0x0b, 0x02, 0x08, 0x08, 0x04, 0x58, 0x0c, 0x09, 0x02, 0x04, 0x04, 0x10,
+  0x04, 0x49, 0x1b, 0x40, 0x3e, 0x00, 0x01, 0x00, 0x02, 0x07, 0x01, 0x02,
+  0x60, 0x00, 0x05, 0x00, 0x0a, 0x0b, 0x05, 0x0a, 0x60, 0x00, 0x03, 0x03,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x07, 0x58,
+  0x00, 0x07, 0x07, 0x12, 0x48, 0x0d, 0x01, 0x0b, 0x0b, 0x04, 0x58, 0x0c,
+  0x09, 0x02, 0x04, 0x04, 0x10, 0x48, 0x00, 0x08, 0x08, 0x04, 0x58, 0x0c,
+  0x09, 0x02, 0x04, 0x04, 0x10, 0x04, 0x49, 0x59, 0x40, 0x1a, 0x38, 0x38,
+  0x1b, 0x1b, 0x38, 0x44, 0x38, 0x42, 0x3d, 0x3b, 0x1b, 0x37, 0x1b, 0x36,
+  0x15, 0x21, 0x23, 0x24, 0x37, 0x33, 0x26, 0x24, 0x21, 0x0e, 0x05, 0x1d,
+  0x2b, 0x12, 0x36, 0x33, 0x33, 0x32, 0x16, 0x17, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22, 0x27, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x07, 0x35, 0x00, 0x26, 0x27, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x35, 0x34, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x23, 0x26, 0x36, 0x35,
+  0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x73, 0x38,
+  0x0c, 0x0f, 0x08, 0x20, 0x11, 0x2a, 0x0c, 0x0a, 0x08, 0x32, 0x09, 0x08,
+  0x31, 0x0b, 0x0f, 0x05, 0x28, 0x34, 0x0d, 0x0a, 0x09, 0x3a, 0x0a, 0x01,
+  0x2a, 0x1f, 0x0b, 0x17, 0x26, 0x59, 0x4c, 0x45, 0x92, 0x7c, 0x26, 0x25,
+  0x9b, 0x91, 0x57, 0x53, 0x17, 0x1b, 0x37, 0x60, 0x10, 0x7d, 0x1a, 0x22,
+  0x18, 0x1a, 0x59, 0x02, 0xa0, 0x1c, 0x0c, 0x08, 0x14, 0x1e, 0x06, 0x48,
+  0x05, 0x1c, 0x11, 0x17, 0x1e, 0x06, 0x48, 0xfd, 0x65, 0x10, 0x0e, 0x1e,
+  0x3d, 0x4a, 0x14, 0x9b, 0x32, 0x1f, 0x22, 0x4b, 0x4c, 0x54, 0xf0, 0x0f,
+  0x0f, 0x46, 0x4b, 0x1c, 0x16, 0x6e, 0x22, 0x1a, 0x32, 0x1a, 0x18, 0x00,
+  0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x02, 0x04, 0x01, 0xf4, 0x00, 0x27,
+  0x00, 0x31, 0x00, 0x3e, 0x00, 0x4e, 0x40, 0x4b, 0x18, 0x01, 0x02, 0x03,
+  0x02, 0x01, 0x00, 0x06, 0x02, 0x47, 0x09, 0x01, 0x01, 0x0d, 0x0b, 0x02,
+  0x05, 0x06, 0x01, 0x05, 0x60, 0x08, 0x01, 0x02, 0x02, 0x03, 0x58, 0x04,
+  0x01, 0x03, 0x03, 0x12, 0x48, 0x0a, 0x01, 0x06, 0x06, 0x00, 0x58, 0x0c,
+  0x07, 0x02, 0x00, 0x00, 0x10, 0x00, 0x49, 0x32, 0x32, 0x00, 0x00, 0x32,
+  0x3e, 0x32, 0x3d, 0x3a, 0x37, 0x31, 0x30, 0x2d, 0x2a, 0x00, 0x27, 0x00,
+  0x26, 0x22, 0x13, 0x34, 0x21, 0x23, 0x25, 0x34, 0x0e, 0x05, 0x1b, 0x2b,
+  0x20, 0x26, 0x27, 0x06, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x16,
+  0x17, 0x36, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x23, 0x15, 0x16,
+  0x33, 0x33, 0x15, 0x23, 0x13, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15,
+  0x15, 0x33, 0x04, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36,
+  0x35, 0x35, 0x23, 0x01, 0x5a, 0x3b, 0x0e, 0x0b, 0x32, 0x26, 0x0e, 0x43,
+  0x44, 0x44, 0x49, 0x42, 0x1f, 0x24, 0x69, 0x5f, 0x2d, 0x34, 0x17, 0x15,
+  0x29, 0x26, 0x07, 0x46, 0x40, 0xc9, 0x03, 0x43, 0x63, 0x59, 0x28, 0x1b,
+  0x19, 0x08, 0x23, 0x19, 0x78, 0xfe, 0xd6, 0x1d, 0x18, 0x1a, 0x1a, 0x1e,
+  0x12, 0x45, 0x16, 0x19, 0x14, 0x1b, 0x3f, 0x48, 0x0c, 0x4d, 0x4e, 0x3a,
+  0x20, 0x21, 0x4b, 0x12, 0x13, 0x14, 0x11, 0x4e, 0x4d, 0x74, 0x61, 0x3b,
+  0x49, 0x01, 0x6f, 0x1b, 0x21, 0x20, 0x21, 0x3c, 0x49, 0x23, 0x1b, 0x2c,
+  0x1a, 0x18, 0x1c, 0x16, 0x6a, 0x00, 0x00, 0x02, 0x00, 0x57, 0x00, 0x00,
+  0x01, 0xc5, 0x02, 0xbc, 0x00, 0x0d, 0x00, 0x1a, 0x00, 0x31, 0x40, 0x2e,
+  0x06, 0x01, 0x04, 0x02, 0x01, 0x47, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x05,
+  0x01, 0x04, 0x04, 0x02, 0x58, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x03,
+  0x03, 0x00, 0x59, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x0e, 0x0e, 0x0e,
+  0x1a, 0x0e, 0x18, 0x27, 0x32, 0x11, 0x21, 0x06, 0x05, 0x18, 0x2b, 0x24,
+  0x06, 0x23, 0x23, 0x11, 0x33, 0x15, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15,
+  0x15, 0x02, 0x06, 0x15, 0x11, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26,
+  0x23, 0x23, 0x01, 0xc5, 0x53, 0x57, 0xc4, 0x55, 0x1e, 0x2d, 0x24, 0x58,
+  0x52, 0xf9, 0x20, 0x79, 0x25, 0x26, 0x26, 0x25, 0x38, 0x4c, 0x4c, 0x02,
+  0xbc, 0xdc, 0x14, 0x4b, 0x55, 0xb4, 0x01, 0x09, 0x23, 0x14, 0xfe, 0xd9,
+  0x22, 0x1f, 0xdc, 0x1f, 0x22, 0x00, 0x00, 0x01, 0x00, 0x78, 0x00, 0x00,
+  0x01, 0xa3, 0x01, 0xf4, 0x00, 0x13, 0x00, 0x25, 0x40, 0x22, 0x00, 0x01,
+  0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x12, 0x48, 0x00, 0x02, 0x02, 0x03,
+  0x58, 0x04, 0x01, 0x03, 0x03, 0x10, 0x03, 0x49, 0x00, 0x00, 0x00, 0x13,
+  0x00, 0x12, 0x25, 0x21, 0x25, 0x05, 0x05, 0x17, 0x2b, 0x32, 0x26, 0x35,
+  0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14,
+  0x16, 0x33, 0x33, 0x15, 0x23, 0xca, 0x52, 0x53, 0x57, 0x81, 0x8b, 0x25,
+  0x26, 0x26, 0x25, 0x8b, 0x81, 0x4b, 0x55, 0xb4, 0x54, 0x4c, 0x4b, 0x22,
+  0x1f, 0xdc, 0x1f, 0x22, 0x4b, 0x00, 0x00, 0x01, 0x00, 0x78, 0xff, 0x38,
+  0x01, 0xa3, 0x01, 0xf4, 0x00, 0x24, 0x00, 0xb6, 0xb5, 0x07, 0x01, 0x05,
+  0x04, 0x01, 0x47, 0x4b, 0xb0, 0x0b, 0x50, 0x58, 0x40, 0x2a, 0x00, 0x06,
+  0x05, 0x01, 0x00, 0x06, 0x65, 0x00, 0x01, 0x00, 0x05, 0x01, 0x63, 0x08,
+  0x01, 0x00, 0x00, 0x07, 0x00, 0x07, 0x5d, 0x00, 0x03, 0x03, 0x02, 0x58,
+  0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05,
+  0x05, 0x10, 0x05, 0x49, 0x1b, 0x4b, 0xb0, 0x11, 0x50, 0x58, 0x40, 0x2b,
+  0x00, 0x06, 0x05, 0x01, 0x05, 0x06, 0x01, 0x6d, 0x00, 0x01, 0x00, 0x05,
+  0x01, 0x63, 0x08, 0x01, 0x00, 0x00, 0x07, 0x00, 0x07, 0x5d, 0x00, 0x03,
+  0x03, 0x02, 0x58, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x04, 0x04, 0x05,
+  0x56, 0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x1b, 0x40, 0x2c, 0x00, 0x06,
+  0x05, 0x01, 0x05, 0x06, 0x01, 0x6d, 0x00, 0x01, 0x00, 0x05, 0x01, 0x00,
+  0x6b, 0x08, 0x01, 0x00, 0x00, 0x07, 0x00, 0x07, 0x5d, 0x00, 0x03, 0x03,
+  0x02, 0x58, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x04, 0x04, 0x05, 0x56,
+  0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x59, 0x59, 0x40, 0x17, 0x01, 0x00,
+  0x23, 0x21, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x17, 0x12, 0x10, 0x0f, 0x0d,
+  0x06, 0x04, 0x00, 0x24, 0x01, 0x24, 0x09, 0x05, 0x14, 0x2b, 0x05, 0x32,
+  0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x26, 0x26, 0x35, 0x35, 0x34, 0x36,
+  0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33,
+  0x15, 0x23, 0x15, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x23, 0x35, 0x01,
+  0x25, 0x21, 0x11, 0x12, 0x31, 0x3e, 0x3c, 0x53, 0x57, 0x81, 0x8b, 0x25,
+  0x26, 0x26, 0x25, 0x8b, 0x6b, 0x2e, 0x29, 0x33, 0x25, 0x55, 0x88, 0x1f,
+  0x11, 0x0c, 0x4f, 0x09, 0x4b, 0x49, 0xb4, 0x54, 0x4c, 0x4b, 0x22, 0x1f,
+  0xdc, 0x1f, 0x22, 0x4b, 0x15, 0x23, 0x31, 0x3a, 0x25, 0x40, 0x00, 0x02,
+  0x00, 0x54, 0x00, 0x00, 0x01, 0xc7, 0x02, 0xbc, 0x00, 0x0f, 0x00, 0x1c,
+  0x00, 0x33, 0x40, 0x30, 0x0f, 0x01, 0x00, 0x05, 0x01, 0x47, 0x00, 0x02,
+  0x02, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x01, 0x58, 0x00, 0x01, 0x01, 0x12,
+  0x48, 0x06, 0x01, 0x05, 0x05, 0x00, 0x58, 0x03, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x49, 0x10, 0x10, 0x10, 0x1c, 0x10, 0x1a, 0x25, 0x11, 0x11, 0x25,
+  0x30, 0x07, 0x05, 0x19, 0x2b, 0x20, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x35, 0x33, 0x11, 0x23, 0x35, 0x26, 0x36, 0x35,
+  0x11, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x01, 0x56,
+  0x2f, 0x29, 0x58, 0x52, 0x53, 0x57, 0x74, 0x55, 0x50, 0x25, 0x20, 0x7e,
+  0x25, 0x26, 0x26, 0x25, 0x3d, 0x4b, 0x55, 0xb4, 0x54, 0x4c, 0xc8, 0xfd,
+  0x44, 0x17, 0x34, 0x23, 0x14, 0x01, 0x27, 0x22, 0x1f, 0xdc, 0x1f, 0x22,
+  0x00, 0x02, 0x00, 0x5e, 0x00, 0x00, 0x01, 0xbd, 0x02, 0xee, 0x00, 0x1b,
+  0x00, 0x28, 0x00, 0x7f, 0x40, 0x0a, 0x06, 0x01, 0x00, 0x01, 0x19, 0x01,
+  0x05, 0x00, 0x02, 0x47, 0x4b, 0xb0, 0x15, 0x50, 0x58, 0x40, 0x2a, 0x00,
+  0x02, 0x01, 0x02, 0x6f, 0x00, 0x05, 0x00, 0x04, 0x00, 0x05, 0x65, 0x00,
+  0x04, 0x08, 0x01, 0x07, 0x06, 0x04, 0x07, 0x61, 0x00, 0x00, 0x00, 0x01,
+  0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x03, 0x58, 0x00,
+  0x03, 0x03, 0x10, 0x03, 0x49, 0x1b, 0x40, 0x2b, 0x00, 0x02, 0x01, 0x02,
+  0x6f, 0x00, 0x05, 0x00, 0x04, 0x00, 0x05, 0x04, 0x6d, 0x00, 0x04, 0x08,
+  0x01, 0x07, 0x06, 0x04, 0x07, 0x61, 0x00, 0x00, 0x00, 0x01, 0x56, 0x00,
+  0x01, 0x01, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x03, 0x58, 0x00, 0x03, 0x03,
+  0x10, 0x03, 0x49, 0x59, 0x40, 0x10, 0x1c, 0x1c, 0x1c, 0x28, 0x1c, 0x27,
+  0x36, 0x15, 0x25, 0x36, 0x11, 0x11, 0x10, 0x09, 0x05, 0x1b, 0x2b, 0x13,
+  0x23, 0x35, 0x33, 0x37, 0x33, 0x07, 0x16, 0x15, 0x11, 0x14, 0x06, 0x23,
+  0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x35, 0x34, 0x26,
+  0x27, 0x07, 0x23, 0x16, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x23, 0xdf, 0x4c, 0x77, 0x1e, 0x52, 0x24, 0x67, 0x5a,
+  0x44, 0x23, 0x44, 0x5a, 0x52, 0x56, 0x62, 0x1f, 0x1a, 0x21, 0x52, 0x1c,
+  0x25, 0x2a, 0x24, 0x19, 0x24, 0x2a, 0x6c, 0x02, 0x72, 0x4a, 0x32, 0x3c,
+  0x20, 0x80, 0xfe, 0x98, 0x52, 0x58, 0x58, 0x52, 0x82, 0x54, 0x4c, 0x59,
+  0x19, 0x29, 0x07, 0x38, 0xb5, 0x23, 0x1f, 0xa8, 0x20, 0x2c, 0x2c, 0x20,
+  0xea, 0x00, 0x00, 0x02, 0x00, 0x5e, 0x00, 0x00, 0x01, 0xbd, 0x01, 0xf4,
+  0x00, 0x13, 0x00, 0x1d, 0x00, 0x31, 0x40, 0x2e, 0x00, 0x05, 0x00, 0x01,
+  0x02, 0x05, 0x01, 0x5e, 0x00, 0x04, 0x04, 0x00, 0x58, 0x00, 0x00, 0x00,
+  0x12, 0x48, 0x00, 0x02, 0x02, 0x03, 0x58, 0x06, 0x01, 0x03, 0x03, 0x10,
+  0x03, 0x49, 0x00, 0x00, 0x1d, 0x1c, 0x19, 0x16, 0x00, 0x13, 0x00, 0x12,
+  0x23, 0x13, 0x35, 0x07, 0x05, 0x17, 0x2b, 0x32, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x21, 0x15, 0x14, 0x16, 0x33,
+  0x33, 0x15, 0x23, 0x13, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x33, 0xb0, 0x52, 0x4a, 0x56, 0x2f, 0x47, 0x49, 0xfe, 0xf6, 0x26, 0x25,
+  0x9f, 0x95, 0x62, 0x22, 0x1a, 0x3a, 0x24, 0x1d, 0xb7, 0x4b, 0x55, 0xb4,
+  0x56, 0x4a, 0x4f, 0x4c, 0x82, 0x4b, 0x1f, 0x22, 0x4b, 0x01, 0x6d, 0x1a,
+  0x22, 0x21, 0x20, 0x46, 0x00, 0x03, 0x00, 0x5e, 0x00, 0x00, 0x01, 0xbd,
+  0x02, 0xcb, 0x00, 0x03, 0x00, 0x17, 0x00, 0x21, 0x00, 0x7d, 0x4b, 0xb0,
+  0x21, 0x50, 0x58, 0x40, 0x2c, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x02,
+  0x6d, 0x00, 0x07, 0x00, 0x03, 0x04, 0x07, 0x03, 0x5e, 0x08, 0x01, 0x01,
+  0x01, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x02, 0x58, 0x00, 0x02, 0x02, 0x12,
+  0x48, 0x00, 0x04, 0x04, 0x05, 0x58, 0x09, 0x01, 0x05, 0x05, 0x10, 0x05,
+  0x49, 0x1b, 0x40, 0x29, 0x08, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00,
+  0x02, 0x00, 0x6f, 0x00, 0x07, 0x00, 0x03, 0x04, 0x07, 0x03, 0x5e, 0x00,
+  0x06, 0x06, 0x02, 0x58, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x04, 0x04,
+  0x05, 0x58, 0x09, 0x01, 0x05, 0x05, 0x10, 0x05, 0x49, 0x59, 0x40, 0x1a,
+  0x04, 0x04, 0x00, 0x00, 0x21, 0x20, 0x1d, 0x1a, 0x04, 0x17, 0x04, 0x16,
+  0x15, 0x13, 0x10, 0x0f, 0x0c, 0x09, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a,
+  0x05, 0x15, 0x2b, 0x01, 0x07, 0x23, 0x37, 0x02, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x21, 0x15, 0x14, 0x16, 0x33,
+  0x33, 0x15, 0x23, 0x13, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x33, 0x01, 0xaa, 0x7a, 0x56, 0x68, 0x92, 0x52, 0x4a, 0x56, 0x2f, 0x47,
+  0x49, 0xfe, 0xf6, 0x26, 0x25, 0x9f, 0x95, 0x62, 0x22, 0x1a, 0x3a, 0x24,
+  0x1d, 0xb7, 0x02, 0xcb, 0x87, 0x87, 0xfd, 0x35, 0x4b, 0x55, 0xb4, 0x56,
+  0x4a, 0x4f, 0x4c, 0x82, 0x4b, 0x1f, 0x22, 0x4b, 0x01, 0x6d, 0x1a, 0x22,
+  0x21, 0x20, 0x46, 0x00, 0x00, 0x03, 0x00, 0x5e, 0x00, 0x00, 0x01, 0xbd,
+  0x02, 0xcb, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x24, 0x00, 0x7d, 0xb5, 0x06,
+  0x01, 0x00, 0x01, 0x01, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x2c,
+  0x02, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x03, 0x6d, 0x00, 0x08, 0x00,
+  0x04, 0x05, 0x08, 0x04, 0x5e, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x07,
+  0x07, 0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00, 0x05, 0x05, 0x06,
+  0x58, 0x09, 0x01, 0x06, 0x06, 0x10, 0x06, 0x49, 0x1b, 0x40, 0x29, 0x00,
+  0x01, 0x00, 0x01, 0x6f, 0x02, 0x01, 0x00, 0x03, 0x00, 0x6f, 0x00, 0x08,
+  0x00, 0x04, 0x05, 0x08, 0x04, 0x5e, 0x00, 0x07, 0x07, 0x03, 0x58, 0x00,
+  0x03, 0x03, 0x12, 0x48, 0x00, 0x05, 0x05, 0x06, 0x58, 0x09, 0x01, 0x06,
+  0x06, 0x10, 0x06, 0x49, 0x59, 0x40, 0x13, 0x07, 0x07, 0x24, 0x23, 0x20,
+  0x1d, 0x07, 0x1a, 0x07, 0x19, 0x23, 0x13, 0x37, 0x11, 0x11, 0x10, 0x0a,
+  0x05, 0x1a, 0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x02, 0x26,
+  0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x21, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x13, 0x34, 0x26, 0x23, 0x23, 0x22,
+  0x06, 0x15, 0x15, 0x33, 0xd3, 0x60, 0x70, 0x58, 0x71, 0x61, 0x3c, 0x5f,
+  0x52, 0x4a, 0x56, 0x2f, 0x47, 0x49, 0xfe, 0xf6, 0x26, 0x25, 0x9f, 0x95,
+  0x62, 0x22, 0x1a, 0x3a, 0x24, 0x1d, 0xb7, 0x02, 0x44, 0x87, 0x87, 0x4b,
+  0xfd, 0x71, 0x4b, 0x55, 0xb4, 0x56, 0x4a, 0x4f, 0x4c, 0x82, 0x4b, 0x1f,
+  0x22, 0x4b, 0x01, 0x6d, 0x1a, 0x22, 0x21, 0x20, 0x46, 0x00, 0x00, 0x04,
+  0x00, 0x5e, 0x00, 0x00, 0x01, 0xbd, 0x02, 0xa3, 0x00, 0x03, 0x00, 0x07,
+  0x00, 0x1b, 0x00, 0x25, 0x00, 0x4f, 0x40, 0x4c, 0x0b, 0x03, 0x0a, 0x03,
+  0x01, 0x02, 0x01, 0x00, 0x04, 0x01, 0x00, 0x5e, 0x00, 0x09, 0x00, 0x05,
+  0x06, 0x09, 0x05, 0x5e, 0x00, 0x08, 0x08, 0x04, 0x58, 0x00, 0x04, 0x04,
+  0x12, 0x48, 0x00, 0x06, 0x06, 0x07, 0x58, 0x0c, 0x01, 0x07, 0x07, 0x10,
+  0x07, 0x49, 0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x25, 0x24, 0x21, 0x1e,
+  0x08, 0x1b, 0x08, 0x1a, 0x19, 0x17, 0x14, 0x13, 0x10, 0x0d, 0x04, 0x07,
+  0x04, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0d, 0x05, 0x15,
+  0x2b, 0x13, 0x15, 0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x02, 0x26, 0x35,
+  0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x21, 0x15, 0x14,
+  0x16, 0x33, 0x33, 0x15, 0x23, 0x13, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06,
+  0x15, 0x15, 0x33, 0xda, 0x55, 0x01, 0x1d, 0x55, 0x9d, 0x52, 0x4a, 0x56,
+  0x2f, 0x47, 0x49, 0xfe, 0xf6, 0x26, 0x25, 0x9f, 0x95, 0x62, 0x22, 0x1a,
+  0x3a, 0x24, 0x1d, 0xb7, 0x02, 0xa3, 0x50, 0x50, 0x50, 0x50, 0xfd, 0x5d,
+  0x4b, 0x55, 0xb4, 0x56, 0x4a, 0x4f, 0x4c, 0x82, 0x4b, 0x1f, 0x22, 0x4b,
+  0x01, 0x6d, 0x1a, 0x22, 0x21, 0x20, 0x46, 0x00, 0x00, 0x03, 0x00, 0x5e,
+  0x00, 0x00, 0x01, 0xbd, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x17, 0x00, 0x21,
+  0x00, 0x7d, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x2c, 0x00, 0x00, 0x01,
+  0x02, 0x01, 0x00, 0x02, 0x6d, 0x00, 0x07, 0x00, 0x03, 0x04, 0x07, 0x03,
+  0x5e, 0x08, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x02, 0x58,
+  0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x04, 0x04, 0x05, 0x58, 0x09, 0x01,
+  0x05, 0x05, 0x10, 0x05, 0x49, 0x1b, 0x40, 0x29, 0x08, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x02, 0x00, 0x6f, 0x00, 0x07, 0x00, 0x03, 0x04,
+  0x07, 0x03, 0x5e, 0x00, 0x06, 0x06, 0x02, 0x58, 0x00, 0x02, 0x02, 0x12,
+  0x48, 0x00, 0x04, 0x04, 0x05, 0x58, 0x09, 0x01, 0x05, 0x05, 0x10, 0x05,
+  0x49, 0x59, 0x40, 0x1a, 0x04, 0x04, 0x00, 0x00, 0x21, 0x20, 0x1d, 0x1a,
+  0x04, 0x17, 0x04, 0x16, 0x15, 0x13, 0x10, 0x0f, 0x0c, 0x09, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x0a, 0x05, 0x15, 0x2b, 0x01, 0x17, 0x23, 0x27, 0x12,
+  0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x21,
+  0x15, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x13, 0x34, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x15, 0x15, 0x33, 0x01, 0x05, 0x68, 0x56, 0x7a, 0x13, 0x52,
+  0x4a, 0x56, 0x2f, 0x47, 0x49, 0xfe, 0xf6, 0x26, 0x25, 0x9f, 0x95, 0x62,
+  0x22, 0x1a, 0x3a, 0x24, 0x1d, 0xb7, 0x02, 0xcb, 0x87, 0x87, 0xfd, 0x35,
+  0x4b, 0x55, 0xb4, 0x56, 0x4a, 0x4f, 0x4c, 0x82, 0x4b, 0x1f, 0x22, 0x4b,
+  0x01, 0x6d, 0x1a, 0x22, 0x21, 0x20, 0x46, 0x00, 0x00, 0x01, 0x00, 0x63,
+  0x00, 0x00, 0x01, 0xb8, 0x02, 0xbc, 0x00, 0x17, 0x00, 0x37, 0x40, 0x34,
+  0x09, 0x01, 0x08, 0x08, 0x07, 0x58, 0x00, 0x07, 0x07, 0x0f, 0x48, 0x05,
+  0x01, 0x01, 0x01, 0x00, 0x56, 0x06, 0x01, 0x00, 0x00, 0x12, 0x48, 0x04,
+  0x01, 0x02, 0x02, 0x03, 0x56, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x00,
+  0x00, 0x00, 0x17, 0x00, 0x16, 0x23, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x13, 0x0a, 0x05, 0x1c, 0x2b, 0x00, 0x06, 0x15, 0x15, 0x33, 0x15, 0x23,
+  0x11, 0x33, 0x15, 0x21, 0x35, 0x33, 0x11, 0x23, 0x35, 0x33, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x15, 0x23, 0x01, 0x20, 0x13, 0xa1, 0xa1, 0x79, 0xfe,
+  0xdd, 0x55, 0x55, 0x55, 0x3a, 0x2e, 0x98, 0x88, 0x02, 0x71, 0x11, 0x0d,
+  0x5f, 0x4b, 0xfe, 0xa2, 0x4b, 0x4b, 0x01, 0x5e, 0x4b, 0x5a, 0x33, 0x3b,
+  0x4b, 0x00, 0x00, 0x02, 0x00, 0x48, 0xff, 0x56, 0x01, 0xd3, 0x01, 0xf4,
+  0x00, 0x21, 0x00, 0x2e, 0x00, 0x43, 0x40, 0x40, 0x24, 0x01, 0x07, 0x06,
+  0x0e, 0x01, 0x04, 0x07, 0x02, 0x47, 0x08, 0x01, 0x07, 0x00, 0x04, 0x05,
+  0x07, 0x04, 0x60, 0x00, 0x05, 0x00, 0x02, 0x01, 0x05, 0x02, 0x60, 0x00,
+  0x06, 0x06, 0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00, 0x01, 0x01,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x14, 0x00, 0x49, 0x22, 0x22, 0x22, 0x2e,
+  0x22, 0x2c, 0x27, 0x21, 0x23, 0x27, 0x25, 0x21, 0x21, 0x09, 0x05, 0x1b,
+  0x2b, 0x04, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34,
+  0x26, 0x23, 0x23, 0x35, 0x26, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33,
+  0x15, 0x14, 0x06, 0x23, 0x23, 0x15, 0x33, 0x32, 0x16, 0x15, 0x15, 0x02,
+  0x36, 0x37, 0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33,
+  0x01, 0xd3, 0x51, 0x56, 0xd0, 0xda, 0x24, 0x24, 0x24, 0x24, 0xad, 0x21,
+  0x20, 0x53, 0x57, 0xd2, 0x52, 0x44, 0x50, 0x4e, 0x56, 0x51, 0x86, 0x20,
+  0x02, 0x87, 0x25, 0x26, 0x26, 0x25, 0x46, 0x67, 0x43, 0x4b, 0x1c, 0x16,
+  0x20, 0x17, 0x1b, 0x8a, 0x12, 0x44, 0x36, 0x19, 0x54, 0x4c, 0xb9, 0x4b,
+  0x55, 0x2b, 0x43, 0x44, 0x0c, 0x01, 0x09, 0x28, 0x16, 0x85, 0x22, 0x1f,
+  0x41, 0x1f, 0x22, 0x00, 0x00, 0x01, 0x00, 0x57, 0x00, 0x00, 0x01, 0xc5,
+  0x02, 0xbc, 0x00, 0x14, 0x00, 0x2d, 0x40, 0x2a, 0x01, 0x01, 0x02, 0x00,
+  0x01, 0x47, 0x05, 0x01, 0x04, 0x04, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x12, 0x48, 0x03, 0x01, 0x01, 0x01, 0x10, 0x01,
+  0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x14, 0x13, 0x33, 0x13, 0x32, 0x06,
+  0x05, 0x18, 0x2b, 0x13, 0x15, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11,
+  0x23, 0x11, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11,
+  0xac, 0x1e, 0x2d, 0x2e, 0x51, 0x4f, 0x55, 0x23, 0x1e, 0x42, 0x20, 0x20,
+  0x01, 0x55, 0x02, 0xbc, 0xdc, 0x14, 0x4c, 0x54, 0xfe, 0xac, 0x01, 0x68,
+  0x1e, 0x23, 0x21, 0x13, 0xfe, 0x8b, 0x02, 0xbc, 0x00, 0x02, 0x00, 0x50,
+  0x00, 0x00, 0x01, 0xcc, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x3a,
+  0x40, 0x37, 0x00, 0x00, 0x00, 0x01, 0x56, 0x06, 0x01, 0x01, 0x01, 0x0f,
+  0x48, 0x07, 0x01, 0x05, 0x05, 0x02, 0x56, 0x00, 0x02, 0x02, 0x12, 0x48,
+  0x00, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x04,
+  0x04, 0x00, 0x00, 0x04, 0x0b, 0x04, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06,
+  0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x08, 0x05, 0x15, 0x2b, 0x01, 0x15,
+  0x23, 0x35, 0x03, 0x35, 0x33, 0x11, 0x33, 0x15, 0x23, 0x11, 0x01, 0x3d,
+  0x5f, 0x8e, 0xe8, 0x94, 0xe9, 0x02, 0xbc, 0x5a, 0x5a, 0xfe, 0xed, 0x4b,
+  0xfe, 0x57, 0x4b, 0x01, 0xa9, 0x00, 0x00, 0x01, 0x00, 0x50, 0x00, 0x00,
+  0x01, 0xcc, 0x01, 0xf4, 0x00, 0x07, 0x00, 0x25, 0x40, 0x22, 0x04, 0x01,
+  0x03, 0x03, 0x00, 0x56, 0x00, 0x00, 0x00, 0x12, 0x48, 0x00, 0x01, 0x01,
+  0x02, 0x56, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x00, 0x00, 0x00, 0x07,
+  0x00, 0x07, 0x11, 0x11, 0x11, 0x05, 0x05, 0x17, 0x2b, 0x13, 0x35, 0x33,
+  0x11, 0x33, 0x15, 0x23, 0x11, 0x50, 0xe8, 0x94, 0xe9, 0x01, 0xa9, 0x4b,
+  0xfe, 0x57, 0x4b, 0x01, 0xa9, 0x00, 0x00, 0x02, 0x00, 0x50, 0x00, 0x00,
+  0x01, 0xcc, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x69, 0x4b, 0xb0,
+  0x21, 0x50, 0x58, 0x40, 0x24, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x02,
+  0x6d, 0x06, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x07, 0x01, 0x05, 0x05, 0x02,
+  0x56, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x03, 0x03, 0x04, 0x57, 0x00,
+  0x04, 0x04, 0x10, 0x04, 0x49, 0x1b, 0x40, 0x21, 0x06, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x02, 0x00, 0x6f, 0x07, 0x01, 0x05, 0x05, 0x02,
+  0x56, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x03, 0x03, 0x04, 0x57, 0x00,
+  0x04, 0x04, 0x10, 0x04, 0x49, 0x59, 0x40, 0x16, 0x04, 0x04, 0x00, 0x00,
+  0x04, 0x0b, 0x04, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x08, 0x05, 0x15, 0x2b, 0x01, 0x07, 0x23, 0x37, 0x03,
+  0x35, 0x33, 0x11, 0x33, 0x15, 0x23, 0x11, 0x01, 0x9d, 0x7a, 0x56, 0x68,
+  0xe5, 0xe8, 0x94, 0xe9, 0x02, 0xcb, 0x87, 0x87, 0xfe, 0xde, 0x4b, 0xfe,
+  0x57, 0x4b, 0x01, 0xa9, 0x00, 0x02, 0x00, 0x50, 0x00, 0x00, 0x01, 0xcc,
+  0x02, 0xcb, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x69, 0xb5, 0x06, 0x01, 0x00,
+  0x01, 0x01, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x24, 0x02, 0x01,
+  0x00, 0x01, 0x03, 0x01, 0x00, 0x03, 0x6d, 0x00, 0x01, 0x01, 0x0f, 0x48,
+  0x07, 0x01, 0x06, 0x06, 0x03, 0x56, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00,
+  0x04, 0x04, 0x05, 0x57, 0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x1b, 0x40,
+  0x21, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02, 0x01, 0x00, 0x03, 0x00, 0x6f,
+  0x07, 0x01, 0x06, 0x06, 0x03, 0x56, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00,
+  0x04, 0x04, 0x05, 0x57, 0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x59, 0x40,
+  0x0f, 0x07, 0x07, 0x07, 0x0e, 0x07, 0x0e, 0x11, 0x11, 0x13, 0x11, 0x11,
+  0x10, 0x08, 0x05, 0x1a, 0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27,
+  0x07, 0x35, 0x33, 0x11, 0x33, 0x15, 0x23, 0x11, 0xd5, 0x60, 0x70, 0x58,
+  0x71, 0x61, 0x3c, 0xc1, 0xe8, 0x94, 0xe9, 0x02, 0x44, 0x87, 0x87, 0x4b,
+  0xe6, 0x4b, 0xfe, 0x57, 0x4b, 0x01, 0xa9, 0x00, 0x00, 0x03, 0x00, 0x50,
+  0x00, 0x00, 0x01, 0xcc, 0x02, 0xa3, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0f,
+  0x00, 0x43, 0x40, 0x40, 0x09, 0x03, 0x08, 0x03, 0x01, 0x02, 0x01, 0x00,
+  0x04, 0x01, 0x00, 0x5e, 0x0a, 0x01, 0x07, 0x07, 0x04, 0x56, 0x00, 0x04,
+  0x04, 0x12, 0x48, 0x00, 0x05, 0x05, 0x06, 0x56, 0x00, 0x06, 0x06, 0x10,
+  0x06, 0x49, 0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x08, 0x0f, 0x08, 0x0f,
+  0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05,
+  0x00, 0x03, 0x00, 0x03, 0x11, 0x0b, 0x05, 0x15, 0x2b, 0x13, 0x15, 0x23,
+  0x35, 0x21, 0x15, 0x23, 0x35, 0x07, 0x35, 0x33, 0x11, 0x33, 0x15, 0x23,
+  0x11, 0xd5, 0x55, 0x01, 0x1d, 0x55, 0xf8, 0xe8, 0x94, 0xe9, 0x02, 0xa3,
+  0x50, 0x50, 0x50, 0x50, 0xfa, 0x4b, 0xfe, 0x57, 0x4b, 0x01, 0xa9, 0x00,
+  0x00, 0x02, 0x00, 0x50, 0x00, 0x00, 0x01, 0xcc, 0x02, 0xcb, 0x00, 0x03,
+  0x00, 0x0b, 0x00, 0x69, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x24, 0x00,
+  0x00, 0x01, 0x02, 0x01, 0x00, 0x02, 0x6d, 0x06, 0x01, 0x01, 0x01, 0x0f,
+  0x48, 0x07, 0x01, 0x05, 0x05, 0x02, 0x56, 0x00, 0x02, 0x02, 0x12, 0x48,
+  0x00, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x1b,
+  0x40, 0x21, 0x06, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x02, 0x00,
+  0x6f, 0x07, 0x01, 0x05, 0x05, 0x02, 0x56, 0x00, 0x02, 0x02, 0x12, 0x48,
+  0x00, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x59,
+  0x40, 0x16, 0x04, 0x04, 0x00, 0x00, 0x04, 0x0b, 0x04, 0x0b, 0x0a, 0x09,
+  0x08, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x08, 0x05, 0x15,
+  0x2b, 0x13, 0x17, 0x23, 0x27, 0x03, 0x35, 0x33, 0x11, 0x33, 0x15, 0x23,
+  0x11, 0xfd, 0x68, 0x56, 0x7a, 0x45, 0xe8, 0x94, 0xe9, 0x02, 0xcb, 0x87,
+  0x87, 0xfe, 0xde, 0x4b, 0xfe, 0x57, 0x4b, 0x01, 0xa9, 0x00, 0x00, 0x02,
+  0x00, 0x89, 0xff, 0x56, 0x01, 0x92, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x11,
+  0x00, 0x3a, 0x40, 0x37, 0x00, 0x00, 0x00, 0x01, 0x56, 0x06, 0x01, 0x01,
+  0x01, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x03, 0x56, 0x00, 0x03, 0x03, 0x12,
+  0x48, 0x07, 0x01, 0x05, 0x05, 0x04, 0x58, 0x00, 0x04, 0x04, 0x14, 0x04,
+  0x49, 0x04, 0x04, 0x00, 0x00, 0x04, 0x11, 0x04, 0x10, 0x0f, 0x0d, 0x0a,
+  0x09, 0x08, 0x07, 0x00, 0x03, 0x00, 0x03, 0x11, 0x08, 0x05, 0x15, 0x2b,
+  0x01, 0x15, 0x23, 0x35, 0x02, 0x36, 0x35, 0x11, 0x23, 0x35, 0x33, 0x11,
+  0x14, 0x06, 0x23, 0x23, 0x35, 0x33, 0x01, 0x92, 0x5f, 0x0d, 0x13, 0x93,
+  0xe8, 0x3a, 0x2e, 0x9d, 0x8d, 0x02, 0xbc, 0x5a, 0x5a, 0xfc, 0xe5, 0x11,
+  0x0d, 0x01, 0xea, 0x4b, 0xfd, 0xd0, 0x33, 0x3b, 0x4b, 0x00, 0x00, 0x01,
+  0x00, 0x60, 0x00, 0x00, 0x01, 0xcb, 0x02, 0xbc, 0x00, 0x0b, 0x00, 0x24,
+  0x40, 0x21, 0x0b, 0x08, 0x05, 0x00, 0x04, 0x00, 0x02, 0x01, 0x47, 0x00,
+  0x01, 0x01, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x12, 0x48, 0x03, 0x01, 0x00,
+  0x00, 0x10, 0x00, 0x49, 0x12, 0x12, 0x11, 0x11, 0x04, 0x05, 0x18, 0x2b,
+  0x37, 0x15, 0x23, 0x11, 0x33, 0x11, 0x37, 0x33, 0x07, 0x13, 0x23, 0x27,
+  0xb5, 0x55, 0x55, 0x9d, 0x6b, 0xae, 0xbc, 0x69, 0x93, 0xd6, 0xd6, 0x02,
+  0xbc, 0xfe, 0x86, 0xb2, 0xc5, 0xfe, 0xd1, 0xf4, 0x00, 0x01, 0x00, 0x46,
+  0x00, 0x00, 0x01, 0xd6, 0x02, 0xbc, 0x00, 0x0d, 0x00, 0x25, 0x40, 0x22,
+  0x00, 0x00, 0x00, 0x01, 0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x02,
+  0x02, 0x03, 0x58, 0x04, 0x01, 0x03, 0x03, 0x10, 0x03, 0x49, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x0c, 0x23, 0x11, 0x13, 0x05, 0x05, 0x17, 0x2b, 0x20,
+  0x26, 0x35, 0x11, 0x23, 0x35, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x15,
+  0x23, 0x01, 0x0c, 0x33, 0x93, 0xe8, 0x10, 0x13, 0x85, 0xa8, 0x30, 0x34,
+  0x02, 0x0d, 0x4b, 0xfd, 0xad, 0x10, 0x0e, 0x4b, 0x00, 0x01, 0x00, 0x46,
+  0x00, 0x00, 0x01, 0xd6, 0x02, 0xbc, 0x00, 0x15, 0x00, 0x32, 0x40, 0x2f,
+  0x0e, 0x0d, 0x0c, 0x0b, 0x06, 0x05, 0x04, 0x03, 0x08, 0x02, 0x00, 0x01,
+  0x47, 0x00, 0x00, 0x00, 0x01, 0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00,
+  0x02, 0x02, 0x03, 0x58, 0x04, 0x01, 0x03, 0x03, 0x10, 0x03, 0x49, 0x00,
+  0x00, 0x00, 0x15, 0x00, 0x14, 0x27, 0x11, 0x17, 0x05, 0x05, 0x17, 0x2b,
+  0x20, 0x26, 0x35, 0x35, 0x07, 0x35, 0x37, 0x35, 0x23, 0x35, 0x33, 0x11,
+  0x37, 0x15, 0x07, 0x15, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x01, 0x0c,
+  0x33, 0x52, 0x52, 0x93, 0xe8, 0x68, 0x68, 0x10, 0x13, 0x85, 0xa8, 0x30,
+  0x34, 0xdf, 0x17, 0x4e, 0x18, 0xdf, 0x4b, 0xfe, 0xee, 0x1f, 0x4f, 0x1e,
+  0xf3, 0x10, 0x0e, 0x4b, 0x00, 0x01, 0x00, 0x2b, 0x00, 0x00, 0x01, 0xf1,
+  0x01, 0xf4, 0x00, 0x23, 0x00, 0x30, 0x40, 0x2d, 0x06, 0x01, 0x02, 0x03,
+  0x00, 0x01, 0x47, 0x05, 0x01, 0x03, 0x03, 0x00, 0x58, 0x08, 0x07, 0x01,
+  0x03, 0x00, 0x00, 0x12, 0x48, 0x06, 0x04, 0x02, 0x02, 0x02, 0x10, 0x02,
+  0x49, 0x00, 0x00, 0x00, 0x23, 0x00, 0x23, 0x13, 0x33, 0x13, 0x33, 0x13,
+  0x32, 0x32, 0x09, 0x05, 0x1b, 0x2b, 0x13, 0x15, 0x36, 0x33, 0x33, 0x32,
+  0x17, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x23, 0x11, 0x34, 0x26,
+  0x23, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x76, 0x1a, 0x24, 0x06, 0x46, 0x1d,
+  0x21, 0x36, 0x06, 0x3d, 0x3a, 0x50, 0x11, 0x1e, 0x06, 0x1e, 0x17, 0x01,
+  0x50, 0x14, 0x1a, 0x06, 0x1e, 0x18, 0x01, 0x50, 0x01, 0xf4, 0x17, 0x17,
+  0x28, 0x28, 0x3e, 0x4f, 0xfe, 0x99, 0x01, 0x68, 0x29, 0x20, 0x29, 0x19,
+  0xfe, 0x91, 0x01, 0x68, 0x2a, 0x1f, 0x23, 0x16, 0xfe, 0x88, 0x01, 0xf4,
+  0x00, 0x01, 0x00, 0x57, 0x00, 0x00, 0x01, 0xc5, 0x01, 0xf4, 0x00, 0x14,
+  0x00, 0x29, 0x40, 0x26, 0x01, 0x01, 0x02, 0x00, 0x01, 0x47, 0x00, 0x02,
+  0x02, 0x00, 0x58, 0x05, 0x04, 0x02, 0x00, 0x00, 0x12, 0x48, 0x03, 0x01,
+  0x01, 0x01, 0x10, 0x01, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x14, 0x13,
+  0x33, 0x13, 0x32, 0x06, 0x05, 0x18, 0x2b, 0x13, 0x15, 0x36, 0x33, 0x33,
+  0x32, 0x16, 0x15, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06,
+  0x15, 0x11, 0x23, 0x11, 0xa7, 0x1f, 0x31, 0x2e, 0x51, 0x4f, 0x55, 0x23,
+  0x1e, 0x42, 0x21, 0x20, 0x55, 0x01, 0xf4, 0x18, 0x18, 0x4c, 0x54, 0xfe,
+  0xac, 0x01, 0x68, 0x1e, 0x23, 0x23, 0x14, 0xfe, 0x8e, 0x01, 0xf4, 0x00,
+  0x00, 0x02, 0x00, 0x57, 0x00, 0x00, 0x01, 0xc5, 0x02, 0xbc, 0x00, 0x1a,
+  0x00, 0x2f, 0x00, 0x49, 0x40, 0x46, 0x1a, 0x0c, 0x02, 0x01, 0x00, 0x19,
+  0x0d, 0x02, 0x02, 0x03, 0x1c, 0x01, 0x06, 0x04, 0x03, 0x47, 0x00, 0x01,
+  0x00, 0x02, 0x04, 0x01, 0x02, 0x60, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00,
+  0x00, 0x00, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x04, 0x58, 0x09, 0x08, 0x02,
+  0x04, 0x04, 0x12, 0x48, 0x07, 0x01, 0x05, 0x05, 0x10, 0x05, 0x49, 0x1b,
+  0x1b, 0x1b, 0x2f, 0x1b, 0x2f, 0x13, 0x33, 0x13, 0x36, 0x33, 0x26, 0x24,
+  0x21, 0x0a, 0x05, 0x1c, 0x2b, 0x12, 0x36, 0x33, 0x33, 0x32, 0x16, 0x17,
+  0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22,
+  0x27, 0x26, 0x23, 0x23, 0x22, 0x06, 0x07, 0x35, 0x17, 0x15, 0x36, 0x33,
+  0x33, 0x32, 0x16, 0x15, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, 0x23, 0x22,
+  0x06, 0x15, 0x11, 0x23, 0x11, 0x92, 0x38, 0x0c, 0x0f, 0x08, 0x20, 0x11,
+  0x2a, 0x0c, 0x0a, 0x07, 0x33, 0x09, 0x08, 0x31, 0x0b, 0x0f, 0x05, 0x28,
+  0x34, 0x0d, 0x0a, 0x09, 0x3a, 0x0a, 0x1e, 0x1f, 0x31, 0x2e, 0x51, 0x4f,
+  0x55, 0x23, 0x1e, 0x42, 0x21, 0x20, 0x55, 0x02, 0xa0, 0x1c, 0x0c, 0x08,
+  0x14, 0x1e, 0x06, 0x48, 0x05, 0x1c, 0x11, 0x17, 0x1e, 0x06, 0x48, 0xa7,
+  0x18, 0x18, 0x4c, 0x54, 0xfe, 0xac, 0x01, 0x68, 0x1e, 0x23, 0x23, 0x14,
+  0xfe, 0x8e, 0x01, 0xf4, 0x00, 0x02, 0x00, 0x53, 0x00, 0x00, 0x01, 0xc8,
+  0x01, 0xf4, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x1f, 0x40, 0x1c, 0x00, 0x02,
+  0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x12, 0x48, 0x00, 0x03, 0x03, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x35, 0x35, 0x35, 0x31, 0x04,
+  0x05, 0x18, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23, 0x22,
+  0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x01,
+  0xc8, 0x53, 0x57, 0x21, 0x57, 0x53, 0x53, 0x57, 0x21, 0x57, 0x53, 0x55,
+  0x26, 0x25, 0x35, 0x25, 0x26, 0x26, 0x25, 0x35, 0x25, 0x26, 0x4c, 0x4c,
+  0x4c, 0x54, 0xb4, 0x54, 0x4c, 0x4c, 0x54, 0xb4, 0xe7, 0x22, 0x22, 0x1f,
+  0xdc, 0x1f, 0x22, 0x22, 0x1f, 0xdc, 0x00, 0x03, 0x00, 0x53, 0x00, 0x00,
+  0x01, 0xc8, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x13, 0x00, 0x23, 0x00, 0x63,
+  0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x23, 0x00, 0x00, 0x01, 0x03, 0x01,
+  0x00, 0x03, 0x6d, 0x06, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x04, 0x04,
+  0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00, 0x05, 0x05, 0x02, 0x58,
+  0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x1b, 0x40, 0x20, 0x06, 0x01, 0x01,
+  0x00, 0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x00, 0x04, 0x04, 0x03,
+  0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00, 0x05, 0x05, 0x02, 0x58, 0x00,
+  0x02, 0x02, 0x10, 0x02, 0x49, 0x59, 0x40, 0x12, 0x00, 0x00, 0x20, 0x1d,
+  0x18, 0x15, 0x10, 0x0d, 0x08, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x07,
+  0x05, 0x15, 0x2b, 0x01, 0x07, 0x23, 0x37, 0x12, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26,
+  0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x01, 0x79, 0x7a, 0x56, 0x68, 0xb7, 0x53, 0x57, 0x21,
+  0x57, 0x53, 0x53, 0x57, 0x21, 0x57, 0x53, 0x55, 0x26, 0x25, 0x35, 0x25,
+  0x26, 0x26, 0x25, 0x35, 0x25, 0x26, 0x02, 0xcb, 0x87, 0x87, 0xfd, 0x81,
+  0x4c, 0x4c, 0x54, 0xb4, 0x54, 0x4c, 0x4c, 0x54, 0xb4, 0xe7, 0x22, 0x22,
+  0x1f, 0xdc, 0x1f, 0x22, 0x22, 0x1f, 0xdc, 0x00, 0x00, 0x03, 0x00, 0x53,
+  0x00, 0x00, 0x01, 0xc8, 0x02, 0xcb, 0x00, 0x06, 0x00, 0x16, 0x00, 0x26,
+  0x00, 0x62, 0xb5, 0x06, 0x01, 0x00, 0x01, 0x01, 0x47, 0x4b, 0xb0, 0x21,
+  0x50, 0x58, 0x40, 0x23, 0x02, 0x01, 0x00, 0x01, 0x04, 0x01, 0x00, 0x04,
+  0x6d, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x05, 0x05, 0x04, 0x58, 0x00,
+  0x04, 0x04, 0x12, 0x48, 0x00, 0x06, 0x06, 0x03, 0x58, 0x00, 0x03, 0x03,
+  0x10, 0x03, 0x49, 0x1b, 0x40, 0x20, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02,
+  0x01, 0x00, 0x04, 0x00, 0x6f, 0x00, 0x05, 0x05, 0x04, 0x58, 0x00, 0x04,
+  0x04, 0x12, 0x48, 0x00, 0x06, 0x06, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10,
+  0x03, 0x49, 0x59, 0x40, 0x0a, 0x35, 0x35, 0x35, 0x33, 0x11, 0x11, 0x10,
+  0x07, 0x05, 0x1b, 0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x12,
+  0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32,
+  0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14,
+  0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0xd2, 0x60, 0x70, 0x58, 0x71,
+  0x61, 0x3c, 0xba, 0x53, 0x57, 0x21, 0x57, 0x53, 0x53, 0x57, 0x21, 0x57,
+  0x53, 0x55, 0x26, 0x25, 0x35, 0x25, 0x26, 0x26, 0x25, 0x35, 0x25, 0x26,
+  0x02, 0x44, 0x87, 0x87, 0x4b, 0xfd, 0xbd, 0x4c, 0x4c, 0x54, 0xb4, 0x54,
+  0x4c, 0x4c, 0x54, 0xb4, 0xe7, 0x22, 0x22, 0x1f, 0xdc, 0x1f, 0x22, 0x22,
+  0x1f, 0xdc, 0x00, 0x04, 0x00, 0x53, 0x00, 0x00, 0x01, 0xc8, 0x02, 0xa3,
+  0x00, 0x03, 0x00, 0x07, 0x00, 0x17, 0x00, 0x27, 0x00, 0x3e, 0x40, 0x3b,
+  0x09, 0x03, 0x08, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01, 0x00, 0x5e,
+  0x00, 0x06, 0x06, 0x05, 0x58, 0x00, 0x05, 0x05, 0x12, 0x48, 0x00, 0x07,
+  0x07, 0x04, 0x58, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x04, 0x04, 0x00,
+  0x00, 0x24, 0x21, 0x1c, 0x19, 0x14, 0x11, 0x0c, 0x09, 0x04, 0x07, 0x04,
+  0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x0a, 0x05, 0x15, 0x2b,
+  0x13, 0x15, 0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x12, 0x06, 0x23, 0x23,
+  0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15,
+  0x26, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33,
+  0x32, 0x36, 0x35, 0x35, 0xd5, 0x55, 0x01, 0x1d, 0x55, 0x80, 0x53, 0x57,
+  0x21, 0x57, 0x53, 0x53, 0x57, 0x21, 0x57, 0x53, 0x55, 0x26, 0x25, 0x35,
+  0x25, 0x26, 0x26, 0x25, 0x35, 0x25, 0x26, 0x02, 0xa3, 0x50, 0x50, 0x50,
+  0x50, 0xfd, 0xa9, 0x4c, 0x4c, 0x54, 0xb4, 0x54, 0x4c, 0x4c, 0x54, 0xb4,
+  0xe7, 0x22, 0x22, 0x1f, 0xdc, 0x1f, 0x22, 0x22, 0x1f, 0xdc, 0x00, 0x03,
+  0x00, 0x4f, 0x00, 0x00, 0x01, 0xc4, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x13,
+  0x00, 0x23, 0x00, 0x63, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x23, 0x00,
+  0x00, 0x01, 0x03, 0x01, 0x00, 0x03, 0x6d, 0x06, 0x01, 0x01, 0x01, 0x0f,
+  0x48, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00,
+  0x05, 0x05, 0x02, 0x58, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x1b, 0x40,
+  0x20, 0x06, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f,
+  0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x12, 0x48, 0x00, 0x05,
+  0x05, 0x02, 0x58, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x59, 0x40, 0x12,
+  0x00, 0x00, 0x20, 0x1d, 0x18, 0x15, 0x10, 0x0d, 0x08, 0x05, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x07, 0x05, 0x15, 0x2b, 0x01, 0x17, 0x23, 0x27, 0x00,
+  0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32,
+  0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14,
+  0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0x05, 0x68, 0x56, 0x7a,
+  0x01, 0x27, 0x53, 0x57, 0x21, 0x57, 0x53, 0x53, 0x57, 0x21, 0x57, 0x53,
+  0x55, 0x26, 0x25, 0x35, 0x25, 0x26, 0x26, 0x25, 0x35, 0x25, 0x26, 0x02,
+  0xcb, 0x87, 0x87, 0xfd, 0x81, 0x4c, 0x4c, 0x54, 0xb4, 0x54, 0x4c, 0x4c,
+  0x54, 0xb4, 0xe7, 0x22, 0x22, 0x1f, 0xdc, 0x1f, 0x22, 0x22, 0x1f, 0xdc,
+  0x00, 0x03, 0x00, 0x53, 0xff, 0xa7, 0x01, 0xc8, 0x02, 0x4d, 0x00, 0x17,
+  0x00, 0x1f, 0x00, 0x27, 0x00, 0x3a, 0x40, 0x37, 0x13, 0x01, 0x04, 0x02,
+  0x21, 0x19, 0x02, 0x05, 0x04, 0x06, 0x01, 0x00, 0x05, 0x03, 0x47, 0x00,
+  0x03, 0x02, 0x03, 0x6f, 0x00, 0x01, 0x00, 0x01, 0x70, 0x00, 0x04, 0x04,
+  0x02, 0x58, 0x00, 0x02, 0x02, 0x12, 0x48, 0x00, 0x05, 0x05, 0x00, 0x59,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x26, 0x28, 0x12, 0x37, 0x11, 0x21,
+  0x06, 0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x07, 0x23, 0x37, 0x26,
+  0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x17, 0x37, 0x33, 0x07,
+  0x16, 0x16, 0x15, 0x15, 0x04, 0x17, 0x13, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x36, 0x27, 0x03, 0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0xc8, 0x53, 0x57,
+  0x35, 0x1b, 0x4e, 0x1f, 0x26, 0x26, 0x53, 0x57, 0x21, 0x0e, 0x06, 0x1c,
+  0x4d, 0x20, 0x27, 0x26, 0xfe, 0xe0, 0x0f, 0x65, 0x29, 0x25, 0x26, 0xcb,
+  0x10, 0x64, 0x29, 0x25, 0x26, 0x4c, 0x4c, 0x59, 0x68, 0x11, 0x47, 0x39,
+  0xb4, 0x54, 0x4c, 0x01, 0x5a, 0x69, 0x11, 0x46, 0x39, 0xb4, 0x30, 0x11,
+  0x01, 0x4a, 0x22, 0x1f, 0xdc, 0xf8, 0x10, 0xfe, 0xb7, 0x22, 0x1f, 0xdc,
+  0x00, 0x03, 0x00, 0x53, 0x00, 0x00, 0x01, 0xc8, 0x02, 0xbc, 0x00, 0x1a,
+  0x00, 0x2a, 0x00, 0x3a, 0x00, 0x41, 0x40, 0x3e, 0x1a, 0x0c, 0x02, 0x01,
+  0x00, 0x19, 0x0d, 0x02, 0x02, 0x03, 0x02, 0x47, 0x00, 0x01, 0x00, 0x02,
+  0x05, 0x01, 0x02, 0x60, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00,
+  0x0f, 0x48, 0x00, 0x06, 0x06, 0x05, 0x58, 0x00, 0x05, 0x05, 0x12, 0x48,
+  0x00, 0x07, 0x07, 0x04, 0x58, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x35,
+  0x35, 0x35, 0x35, 0x33, 0x26, 0x24, 0x21, 0x08, 0x05, 0x1c, 0x2b, 0x12,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x17, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37,
+  0x15, 0x06, 0x06, 0x23, 0x23, 0x22, 0x27, 0x26, 0x23, 0x23, 0x22, 0x06,
+  0x07, 0x35, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36,
+  0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23, 0x22, 0x06,
+  0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x8b, 0x38,
+  0x0c, 0x0f, 0x08, 0x20, 0x11, 0x2a, 0x0c, 0x0a, 0x08, 0x32, 0x09, 0x08,
+  0x31, 0x0b, 0x0f, 0x05, 0x28, 0x34, 0x0d, 0x0a, 0x09, 0x3a, 0x0a, 0x01,
+  0x46, 0x53, 0x57, 0x21, 0x57, 0x53, 0x53, 0x57, 0x21, 0x57, 0x53, 0x55,
+  0x26, 0x25, 0x35, 0x25, 0x26, 0x26, 0x25, 0x35, 0x25, 0x26, 0x02, 0xa0,
+  0x1c, 0x0c, 0x08, 0x14, 0x1e, 0x06, 0x48, 0x05, 0x1c, 0x11, 0x17, 0x1e,
+  0x06, 0x48, 0xfd, 0xb1, 0x4c, 0x4c, 0x54, 0xb4, 0x54, 0x4c, 0x4c, 0x54,
+  0xb4, 0xe7, 0x22, 0x22, 0x1f, 0xdc, 0x1f, 0x22, 0x22, 0x1f, 0xdc, 0x00,
+  0x00, 0x03, 0x00, 0x1a, 0x00, 0x00, 0x02, 0x04, 0x01, 0xf4, 0x00, 0x21,
+  0x00, 0x2f, 0x00, 0x39, 0x00, 0x45, 0x40, 0x42, 0x11, 0x01, 0x06, 0x01,
+  0x02, 0x01, 0x00, 0x04, 0x02, 0x47, 0x00, 0x09, 0x00, 0x03, 0x04, 0x09,
+  0x03, 0x5e, 0x08, 0x01, 0x06, 0x06, 0x01, 0x58, 0x02, 0x01, 0x01, 0x01,
+  0x12, 0x48, 0x07, 0x01, 0x04, 0x04, 0x00, 0x58, 0x0a, 0x05, 0x02, 0x00,
+  0x00, 0x10, 0x00, 0x49, 0x00, 0x00, 0x39, 0x38, 0x35, 0x32, 0x2c, 0x29,
+  0x25, 0x22, 0x00, 0x21, 0x00, 0x20, 0x23, 0x13, 0x34, 0x35, 0x34, 0x0b,
+  0x05, 0x19, 0x2b, 0x20, 0x26, 0x27, 0x06, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x17, 0x36, 0x36, 0x33,
+  0x33, 0x32, 0x16, 0x15, 0x15, 0x23, 0x15, 0x14, 0x16, 0x33, 0x33, 0x15,
+  0x23, 0x02, 0x23, 0x23, 0x22, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x37, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x33, 0x01, 0x5d, 0x35, 0x10, 0x12, 0x2c, 0x2a, 0x03, 0x4e, 0x45, 0x45,
+  0x4e, 0x03, 0x27, 0x2b, 0x14, 0x10, 0x31, 0x28, 0x01, 0x44, 0x40, 0xc1,
+  0x24, 0x24, 0x5e, 0x5c, 0x9d, 0x36, 0x17, 0x36, 0x19, 0x1d, 0x17, 0x1d,
+  0x19, 0xc3, 0x17, 0x1d, 0x03, 0x22, 0x17, 0x70, 0x13, 0x14, 0x14, 0x13,
+  0x4a, 0x51, 0xbe, 0x54, 0x47, 0x14, 0x13, 0x13, 0x14, 0x46, 0x4b, 0x8c,
+  0x4d, 0x1f, 0x22, 0x49, 0x01, 0xab, 0x41, 0xe0, 0x20, 0x21, 0x21, 0x20,
+  0xe0, 0x05, 0x1d, 0x1f, 0x20, 0x21, 0x4a, 0x00, 0x00, 0x02, 0x00, 0x57,
+  0xff, 0x56, 0x01, 0xc5, 0x01, 0xf4, 0x00, 0x0f, 0x00, 0x1c, 0x00, 0x3a,
+  0x40, 0x37, 0x01, 0x01, 0x05, 0x00, 0x01, 0x47, 0x07, 0x01, 0x05, 0x05,
+  0x00, 0x58, 0x06, 0x03, 0x02, 0x00, 0x00, 0x12, 0x48, 0x00, 0x04, 0x04,
+  0x01, 0x58, 0x00, 0x01, 0x01, 0x10, 0x48, 0x00, 0x02, 0x02, 0x14, 0x02,
+  0x49, 0x10, 0x10, 0x00, 0x00, 0x10, 0x1c, 0x10, 0x1a, 0x15, 0x13, 0x00,
+  0x0f, 0x00, 0x0f, 0x11, 0x25, 0x32, 0x08, 0x05, 0x17, 0x2b, 0x13, 0x15,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x23, 0x15,
+  0x23, 0x11, 0x16, 0x06, 0x15, 0x11, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34,
+  0x26, 0x23, 0x23, 0xa7, 0x1f, 0x31, 0x24, 0x58, 0x52, 0x53, 0x57, 0x6f,
+  0x55, 0x75, 0x20, 0x79, 0x25, 0x26, 0x26, 0x25, 0x38, 0x01, 0xf4, 0x18,
+  0x18, 0x4b, 0x55, 0xb4, 0x54, 0x4c, 0xaa, 0x02, 0x9e, 0x4b, 0x23, 0x14,
+  0xfe, 0xd9, 0x22, 0x1f, 0xdc, 0x1f, 0x22, 0x00, 0x00, 0x02, 0x00, 0x61,
+  0xff, 0x56, 0x01, 0xc5, 0x02, 0xbc, 0x00, 0x0f, 0x00, 0x1c, 0x00, 0x39,
+  0x40, 0x36, 0x0c, 0x01, 0x04, 0x03, 0x01, 0x47, 0x00, 0x02, 0x02, 0x0f,
+  0x48, 0x00, 0x04, 0x04, 0x03, 0x58, 0x06, 0x01, 0x03, 0x03, 0x12, 0x48,
+  0x00, 0x05, 0x05, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x48, 0x00, 0x01,
+  0x01, 0x14, 0x01, 0x49, 0x00, 0x00, 0x19, 0x17, 0x14, 0x11, 0x00, 0x0f,
+  0x00, 0x0d, 0x11, 0x11, 0x25, 0x07, 0x05, 0x17, 0x2b, 0x00, 0x16, 0x15,
+  0x15, 0x14, 0x06, 0x23, 0x23, 0x15, 0x23, 0x11, 0x33, 0x15, 0x36, 0x33,
+  0x33, 0x16, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x33, 0x32, 0x36,
+  0x35, 0x35, 0x01, 0x73, 0x52, 0x53, 0x57, 0x65, 0x55, 0x55, 0x1f, 0x2c,
+  0x1a, 0x55, 0x26, 0x25, 0x2e, 0x21, 0x20, 0x6f, 0x25, 0x26, 0x01, 0xf4,
+  0x4b, 0x55, 0xb4, 0x54, 0x4c, 0xaa, 0x03, 0x66, 0xdc, 0x14, 0x6d, 0x22,
+  0x23, 0x14, 0xfe, 0xd9, 0x22, 0x1f, 0xdc, 0x00, 0x00, 0x02, 0x00, 0x54,
+  0xff, 0x56, 0x01, 0xc7, 0x01, 0xf4, 0x00, 0x0d, 0x00, 0x1a, 0x00, 0x31,
+  0x40, 0x2e, 0x0d, 0x01, 0x00, 0x04, 0x01, 0x47, 0x00, 0x03, 0x03, 0x01,
+  0x58, 0x00, 0x01, 0x01, 0x12, 0x48, 0x05, 0x01, 0x04, 0x04, 0x00, 0x58,
+  0x00, 0x00, 0x00, 0x10, 0x48, 0x00, 0x02, 0x02, 0x14, 0x02, 0x49, 0x0e,
+  0x0e, 0x0e, 0x1a, 0x0e, 0x18, 0x25, 0x11, 0x25, 0x30, 0x06, 0x05, 0x18,
+  0x2b, 0x20, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33,
+  0x11, 0x23, 0x35, 0x26, 0x36, 0x35, 0x11, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0x01, 0x53, 0x2c, 0x29, 0x58, 0x52, 0x53, 0x57,
+  0xc9, 0x55, 0x20, 0x20, 0x7e, 0x25, 0x26, 0x26, 0x25, 0x3d, 0x4b, 0x55,
+  0xb4, 0x54, 0x4c, 0xfd, 0x62, 0xbe, 0x37, 0x23, 0x14, 0x01, 0x27, 0x22,
+  0x1f, 0xdc, 0x1f, 0x22, 0x00, 0x01, 0x00, 0x64, 0x00, 0x00, 0x01, 0xb4,
+  0x01, 0xf4, 0x00, 0x12, 0x00, 0x60, 0xb5, 0x05, 0x01, 0x00, 0x01, 0x01,
+  0x47, 0x4b, 0xb0, 0x2d, 0x50, 0x58, 0x40, 0x19, 0x03, 0x01, 0x00, 0x00,
+  0x01, 0x58, 0x02, 0x01, 0x01, 0x01, 0x12, 0x48, 0x07, 0x06, 0x02, 0x04,
+  0x04, 0x05, 0x56, 0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x1b, 0x40, 0x23,
+  0x00, 0x00, 0x00, 0x01, 0x58, 0x02, 0x01, 0x01, 0x01, 0x12, 0x48, 0x00,
+  0x03, 0x03, 0x01, 0x58, 0x02, 0x01, 0x01, 0x01, 0x12, 0x48, 0x07, 0x06,
+  0x02, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x59,
+  0x40, 0x0f, 0x00, 0x00, 0x00, 0x12, 0x00, 0x12, 0x11, 0x13, 0x21, 0x22,
+  0x11, 0x11, 0x08, 0x05, 0x1a, 0x2b, 0x37, 0x11, 0x23, 0x35, 0x33, 0x15,
+  0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x07, 0x11, 0x33, 0x15, 0x21,
+  0x35, 0xad, 0x49, 0x99, 0x21, 0x2f, 0x67, 0x71, 0x20, 0x20, 0x01, 0x6d,
+  0xfe, 0xf5, 0x4b, 0x01, 0x5e, 0x4b, 0x1b, 0x1b, 0x50, 0x29, 0x15, 0xfe,
+  0xe5, 0x4b, 0x4b, 0x00, 0x00, 0x01, 0x00, 0x76, 0x00, 0x00, 0x01, 0xa6,
+  0x01, 0xf4, 0x00, 0x22, 0x00, 0x29, 0x40, 0x26, 0x00, 0x05, 0x00, 0x02,
+  0x01, 0x05, 0x02, 0x60, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03,
+  0x12, 0x48, 0x00, 0x01, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x49, 0x35, 0x21, 0x25, 0x34, 0x21, 0x21, 0x06, 0x05, 0x1a, 0x2b, 0x24,
+  0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x23, 0x23,
+  0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06,
+  0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x01, 0xa6,
+  0x4d, 0x49, 0x95, 0x9f, 0x1b, 0x1c, 0x2b, 0x25, 0x46, 0x45, 0x4c, 0x4a,
+  0x86, 0x90, 0x19, 0x1e, 0x1b, 0x15, 0x22, 0x43, 0x46, 0x3e, 0x3e, 0x4b,
+  0x17, 0x16, 0x35, 0x2d, 0x3d, 0x42, 0x1d, 0x43, 0x3b, 0x4b, 0x17, 0x16,
+  0x24, 0x17, 0x16, 0x41, 0x40, 0x2d, 0x00, 0x02, 0x00, 0x6f, 0x00, 0x00,
+  0x01, 0xb0, 0x02, 0xca, 0x00, 0x06, 0x00, 0x29, 0x00, 0x74, 0xb5, 0x06,
+  0x01, 0x01, 0x00, 0x01, 0x47, 0x4b, 0xb0, 0x23, 0x50, 0x58, 0x40, 0x2b,
+  0x00, 0x01, 0x00, 0x06, 0x00, 0x01, 0x06, 0x6d, 0x00, 0x08, 0x00, 0x05,
+  0x04, 0x08, 0x05, 0x60, 0x02, 0x01, 0x00, 0x00, 0x0f, 0x48, 0x00, 0x07,
+  0x07, 0x06, 0x58, 0x00, 0x06, 0x06, 0x12, 0x48, 0x00, 0x04, 0x04, 0x03,
+  0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x1b, 0x40, 0x28, 0x02, 0x01,
+  0x00, 0x01, 0x00, 0x6f, 0x00, 0x01, 0x06, 0x01, 0x6f, 0x00, 0x08, 0x00,
+  0x05, 0x04, 0x08, 0x05, 0x60, 0x00, 0x07, 0x07, 0x06, 0x58, 0x00, 0x06,
+  0x06, 0x12, 0x48, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10,
+  0x03, 0x49, 0x59, 0x40, 0x0c, 0x35, 0x21, 0x25, 0x34, 0x21, 0x23, 0x11,
+  0x11, 0x10, 0x09, 0x05, 0x1d, 0x2b, 0x01, 0x33, 0x07, 0x23, 0x27, 0x33,
+  0x17, 0x12, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34,
+  0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23,
+  0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15,
+  0x01, 0x50, 0x60, 0x70, 0x58, 0x71, 0x61, 0x3c, 0x8b, 0x4d, 0x49, 0x95,
+  0x9f, 0x1b, 0x1c, 0x2b, 0x25, 0x46, 0x45, 0x4c, 0x4a, 0x86, 0x90, 0x19,
+  0x1e, 0x1b, 0x15, 0x22, 0x43, 0x46, 0x02, 0xca, 0x87, 0x87, 0x4b, 0xfd,
+  0xbf, 0x3e, 0x4b, 0x17, 0x16, 0x35, 0x2d, 0x3d, 0x42, 0x1d, 0x43, 0x3b,
+  0x4b, 0x17, 0x16, 0x24, 0x17, 0x16, 0x41, 0x40, 0x2d, 0x00, 0x00, 0x01,
+  0x00, 0x4e, 0x00, 0x00, 0x01, 0xd2, 0x02, 0xbc, 0x00, 0x31, 0x00, 0x68,
+  0x4b, 0xb0, 0x1f, 0x50, 0x58, 0x40, 0x28, 0x00, 0x02, 0x00, 0x05, 0x04,
+  0x02, 0x05, 0x60, 0x00, 0x07, 0x07, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f,
+  0x48, 0x00, 0x01, 0x01, 0x06, 0x58, 0x00, 0x06, 0x06, 0x12, 0x48, 0x00,
+  0x04, 0x04, 0x03, 0x58, 0x08, 0x01, 0x03, 0x03, 0x10, 0x03, 0x49, 0x1b,
+  0x40, 0x26, 0x00, 0x06, 0x00, 0x01, 0x02, 0x06, 0x01, 0x60, 0x00, 0x02,
+  0x00, 0x05, 0x04, 0x02, 0x05, 0x60, 0x00, 0x07, 0x07, 0x00, 0x58, 0x00,
+  0x00, 0x00, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x03, 0x58, 0x08, 0x01, 0x03,
+  0x03, 0x10, 0x03, 0x49, 0x59, 0x40, 0x0c, 0x13, 0x33, 0x15, 0x24, 0x21,
+  0x25, 0x25, 0x23, 0x31, 0x09, 0x05, 0x1d, 0x2b, 0x12, 0x36, 0x33, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x35,
+  0x35, 0x34, 0x26, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x37, 0x35,
+  0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x23, 0x11, 0x4e, 0x56,
+  0x40, 0x27, 0x58, 0x52, 0x4e, 0x1e, 0x19, 0x17, 0x14, 0x37, 0x40, 0x46,
+  0x44, 0x70, 0x76, 0x2f, 0x15, 0x19, 0x33, 0x41, 0x44, 0x41, 0x26, 0x25,
+  0x36, 0x21, 0x1b, 0x55, 0x02, 0x76, 0x46, 0x4b, 0x55, 0x7d, 0x16, 0x17,
+  0x0f, 0x17, 0x16, 0x40, 0x38, 0x41, 0x38, 0x45, 0x4b, 0x2d, 0x46, 0x16,
+  0x17, 0x42, 0x37, 0x0a, 0x40, 0x35, 0x03, 0x4a, 0x1f, 0x22, 0x22, 0x15,
+  0xfd, 0xc6, 0x02, 0x30, 0x00, 0x01, 0x00, 0x6b, 0x00, 0x00, 0x01, 0xb1,
+  0x02, 0x6c, 0x00, 0x13, 0x00, 0x2f, 0x40, 0x2c, 0x00, 0x02, 0x01, 0x02,
+  0x6f, 0x04, 0x01, 0x00, 0x00, 0x01, 0x56, 0x03, 0x01, 0x01, 0x01, 0x12,
+  0x48, 0x00, 0x05, 0x05, 0x06, 0x59, 0x07, 0x01, 0x06, 0x06, 0x10, 0x06,
+  0x49, 0x00, 0x00, 0x00, 0x13, 0x00, 0x12, 0x23, 0x11, 0x11, 0x11, 0x11,
+  0x13, 0x08, 0x05, 0x1a, 0x2b, 0x20, 0x26, 0x35, 0x11, 0x23, 0x35, 0x33,
+  0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x11, 0x14, 0x16, 0x33, 0x33, 0x15,
+  0x23, 0x01, 0x00, 0x36, 0x5f, 0x5f, 0x55, 0x92, 0x92, 0x16, 0x17, 0x65,
+  0x7e, 0x42, 0x36, 0x01, 0x31, 0x4b, 0x78, 0x78, 0x4b, 0xfe, 0xca, 0x16,
+  0x12, 0x4b, 0x00, 0x01, 0x00, 0x5d, 0x00, 0x00, 0x01, 0xbf, 0x01, 0xf4,
+  0x00, 0x14, 0x00, 0x27, 0x40, 0x24, 0x0f, 0x01, 0x02, 0x01, 0x14, 0x01,
+  0x00, 0x02, 0x02, 0x47, 0x03, 0x01, 0x01, 0x01, 0x12, 0x48, 0x00, 0x02,
+  0x02, 0x00, 0x59, 0x04, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49, 0x11, 0x13,
+  0x33, 0x13, 0x30, 0x05, 0x05, 0x19, 0x2b, 0x20, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x11,
+  0x33, 0x11, 0x23, 0x35, 0x01, 0x4e, 0x2f, 0x22, 0x51, 0x4f, 0x55, 0x23,
+  0x1e, 0x36, 0x20, 0x1f, 0x02, 0x55, 0x50, 0x4c, 0x54, 0x01, 0x54, 0xfe,
+  0x98, 0x1e, 0x23, 0x20, 0x14, 0x01, 0x75, 0xfe, 0x0c, 0x17, 0x00, 0x02,
+  0x00, 0x5d, 0x00, 0x00, 0x01, 0xbf, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x18,
+  0x00, 0x6b, 0x40, 0x0a, 0x13, 0x01, 0x04, 0x03, 0x18, 0x01, 0x02, 0x04,
+  0x02, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x20, 0x00, 0x00, 0x01,
+  0x03, 0x01, 0x00, 0x03, 0x6d, 0x07, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x05,
+  0x01, 0x03, 0x03, 0x12, 0x48, 0x00, 0x04, 0x04, 0x02, 0x59, 0x06, 0x01,
+  0x02, 0x02, 0x10, 0x02, 0x49, 0x1b, 0x40, 0x1d, 0x07, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x03, 0x00, 0x6f, 0x05, 0x01, 0x03, 0x03, 0x12,
+  0x48, 0x00, 0x04, 0x04, 0x02, 0x59, 0x06, 0x01, 0x02, 0x02, 0x10, 0x02,
+  0x49, 0x59, 0x40, 0x14, 0x00, 0x00, 0x17, 0x16, 0x15, 0x14, 0x11, 0x0e,
+  0x0b, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x03, 0x11, 0x08, 0x05, 0x15,
+  0x2b, 0x01, 0x07, 0x23, 0x37, 0x12, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11,
+  0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x11, 0x33, 0x11,
+  0x23, 0x35, 0x01, 0xa9, 0x7a, 0x56, 0x68, 0x0d, 0x2f, 0x22, 0x51, 0x4f,
+  0x55, 0x23, 0x1e, 0x36, 0x20, 0x1f, 0x02, 0x55, 0x50, 0x02, 0xcb, 0x87,
+  0x87, 0xfd, 0x35, 0x4c, 0x54, 0x01, 0x54, 0xfe, 0x98, 0x1e, 0x23, 0x20,
+  0x14, 0x01, 0x75, 0xfe, 0x0c, 0x17, 0x00, 0x02, 0x00, 0x5d, 0x00, 0x00,
+  0x01, 0xbf, 0x02, 0xcb, 0x00, 0x06, 0x00, 0x1b, 0x00, 0x66, 0x40, 0x0e,
+  0x06, 0x01, 0x00, 0x01, 0x16, 0x01, 0x05, 0x04, 0x1b, 0x01, 0x03, 0x05,
+  0x03, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x20, 0x02, 0x01, 0x00,
+  0x01, 0x04, 0x01, 0x00, 0x04, 0x6d, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x06,
+  0x01, 0x04, 0x04, 0x12, 0x48, 0x00, 0x05, 0x05, 0x03, 0x59, 0x07, 0x01,
+  0x03, 0x03, 0x10, 0x03, 0x49, 0x1b, 0x40, 0x1d, 0x00, 0x01, 0x00, 0x01,
+  0x6f, 0x02, 0x01, 0x00, 0x04, 0x00, 0x6f, 0x06, 0x01, 0x04, 0x04, 0x12,
+  0x48, 0x00, 0x05, 0x05, 0x03, 0x59, 0x07, 0x01, 0x03, 0x03, 0x10, 0x03,
+  0x49, 0x59, 0x40, 0x0b, 0x11, 0x13, 0x33, 0x13, 0x32, 0x11, 0x11, 0x10,
+  0x08, 0x05, 0x1c, 0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0x12,
+  0x23, 0x23, 0x22, 0x26, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x33,
+  0x32, 0x36, 0x37, 0x11, 0x33, 0x11, 0x23, 0x35, 0xd1, 0x60, 0x70, 0x58,
+  0x71, 0x61, 0x3c, 0x41, 0x2f, 0x22, 0x51, 0x4f, 0x55, 0x23, 0x1e, 0x36,
+  0x20, 0x1f, 0x02, 0x55, 0x50, 0x02, 0x44, 0x87, 0x87, 0x4b, 0xfd, 0x71,
+  0x4c, 0x54, 0x01, 0x54, 0xfe, 0x98, 0x1e, 0x23, 0x20, 0x14, 0x01, 0x75,
+  0xfe, 0x0c, 0x17, 0x00, 0x00, 0x03, 0x00, 0x5d, 0x00, 0x00, 0x01, 0xbf,
+  0x02, 0xa3, 0x00, 0x03, 0x00, 0x07, 0x00, 0x1c, 0x00, 0x47, 0x40, 0x44,
+  0x17, 0x01, 0x06, 0x05, 0x1c, 0x01, 0x04, 0x06, 0x02, 0x47, 0x0a, 0x03,
+  0x09, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01, 0x00, 0x5e, 0x07, 0x01,
+  0x05, 0x05, 0x12, 0x48, 0x00, 0x06, 0x06, 0x04, 0x59, 0x08, 0x01, 0x04,
+  0x04, 0x10, 0x04, 0x49, 0x04, 0x04, 0x00, 0x00, 0x1b, 0x1a, 0x19, 0x18,
+  0x15, 0x12, 0x0f, 0x0e, 0x0b, 0x08, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05,
+  0x00, 0x03, 0x00, 0x03, 0x11, 0x0b, 0x05, 0x15, 0x2b, 0x13, 0x15, 0x23,
+  0x35, 0x21, 0x15, 0x23, 0x35, 0x12, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11,
+  0x33, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x11, 0x33, 0x11,
+  0x23, 0x35, 0xd2, 0x55, 0x01, 0x1d, 0x55, 0x09, 0x2f, 0x22, 0x51, 0x4f,
+  0x55, 0x23, 0x1e, 0x36, 0x20, 0x1f, 0x02, 0x55, 0x50, 0x02, 0xa3, 0x50,
+  0x50, 0x50, 0x50, 0xfd, 0x5d, 0x4c, 0x54, 0x01, 0x54, 0xfe, 0x98, 0x1e,
+  0x23, 0x20, 0x14, 0x01, 0x75, 0xfe, 0x0c, 0x17, 0x00, 0x02, 0x00, 0x5d,
+  0x00, 0x00, 0x01, 0xbf, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x18, 0x00, 0x6b,
+  0x40, 0x0a, 0x13, 0x01, 0x04, 0x03, 0x18, 0x01, 0x02, 0x04, 0x02, 0x47,
+  0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x20, 0x00, 0x00, 0x01, 0x03, 0x01,
+  0x00, 0x03, 0x6d, 0x07, 0x01, 0x01, 0x01, 0x0f, 0x48, 0x05, 0x01, 0x03,
+  0x03, 0x12, 0x48, 0x00, 0x04, 0x04, 0x02, 0x59, 0x06, 0x01, 0x02, 0x02,
+  0x10, 0x02, 0x49, 0x1b, 0x40, 0x1d, 0x07, 0x01, 0x01, 0x00, 0x01, 0x6f,
+  0x00, 0x00, 0x03, 0x00, 0x6f, 0x05, 0x01, 0x03, 0x03, 0x12, 0x48, 0x00,
+  0x04, 0x04, 0x02, 0x59, 0x06, 0x01, 0x02, 0x02, 0x10, 0x02, 0x49, 0x59,
+  0x40, 0x14, 0x00, 0x00, 0x17, 0x16, 0x15, 0x14, 0x11, 0x0e, 0x0b, 0x0a,
+  0x07, 0x04, 0x00, 0x03, 0x00, 0x03, 0x11, 0x08, 0x05, 0x15, 0x2b, 0x13,
+  0x17, 0x23, 0x27, 0x12, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11, 0x33, 0x11,
+  0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x11, 0x33, 0x11, 0x23, 0x35,
+  0xef, 0x68, 0x56, 0x7a, 0xc7, 0x2f, 0x22, 0x51, 0x4f, 0x55, 0x23, 0x1e,
+  0x36, 0x20, 0x1f, 0x02, 0x55, 0x50, 0x02, 0xcb, 0x87, 0x87, 0xfd, 0x35,
+  0x4c, 0x54, 0x01, 0x54, 0xfe, 0x98, 0x1e, 0x23, 0x20, 0x14, 0x01, 0x75,
+  0xfe, 0x0c, 0x17, 0x00, 0x00, 0x01, 0x00, 0x40, 0x00, 0x00, 0x01, 0xdc,
+  0x01, 0xf4, 0x00, 0x06, 0x00, 0x1b, 0x40, 0x18, 0x02, 0x01, 0x02, 0x00,
+  0x01, 0x47, 0x01, 0x01, 0x00, 0x00, 0x12, 0x48, 0x00, 0x02, 0x02, 0x10,
+  0x02, 0x49, 0x11, 0x12, 0x10, 0x03, 0x05, 0x17, 0x2b, 0x13, 0x33, 0x13,
+  0x13, 0x33, 0x03, 0x23, 0x40, 0x5c, 0x75, 0x72, 0x59, 0x90, 0x7b, 0x01,
+  0xf4, 0xfe, 0x51, 0x01, 0xaf, 0xfe, 0x0c, 0x00, 0x00, 0x01, 0x00, 0x23,
+  0x00, 0x00, 0x01, 0xf9, 0x01, 0xf4, 0x00, 0x0c, 0x00, 0x28, 0x40, 0x25,
+  0x08, 0x05, 0x00, 0x03, 0x00, 0x02, 0x01, 0x47, 0x00, 0x02, 0x01, 0x00,
+  0x01, 0x02, 0x00, 0x6d, 0x03, 0x01, 0x01, 0x01, 0x12, 0x48, 0x04, 0x01,
+  0x00, 0x00, 0x10, 0x00, 0x49, 0x11, 0x12, 0x12, 0x11, 0x11, 0x05, 0x05,
+  0x19, 0x2b, 0x25, 0x07, 0x23, 0x03, 0x33, 0x13, 0x13, 0x33, 0x13, 0x13,
+  0x33, 0x03, 0x23, 0x01, 0x10, 0x36, 0x5d, 0x5a, 0x55, 0x39, 0x42, 0x41,
+  0x3c, 0x39, 0x50, 0x59, 0x60, 0xfb, 0xfb, 0x01, 0xf4, 0xfe, 0x73, 0x01,
+  0x33, 0xfe, 0xcd, 0x01, 0x8d, 0xfe, 0x0c, 0x00, 0x00, 0x01, 0x00, 0x41,
+  0x00, 0x00, 0x01, 0xda, 0x01, 0xf4, 0x00, 0x0b, 0x00, 0x20, 0x40, 0x1d,
+  0x0b, 0x08, 0x05, 0x02, 0x04, 0x00, 0x01, 0x01, 0x47, 0x02, 0x01, 0x01,
+  0x01, 0x12, 0x48, 0x03, 0x01, 0x00, 0x00, 0x10, 0x00, 0x49, 0x12, 0x12,
+  0x12, 0x10, 0x04, 0x05, 0x18, 0x2b, 0x33, 0x23, 0x13, 0x27, 0x33, 0x17,
+  0x37, 0x33, 0x07, 0x13, 0x23, 0x27, 0x9f, 0x5e, 0x9c, 0x90, 0x63, 0x5f,
+  0x61, 0x5d, 0x92, 0x9f, 0x64, 0x69, 0x01, 0x02, 0xf2, 0xa8, 0xa8, 0xee,
+  0xfe, 0xfa, 0xbd, 0x00, 0x00, 0x01, 0x00, 0x3f, 0xff, 0x56, 0x01, 0xdc,
+  0x01, 0xf4, 0x00, 0x11, 0x00, 0x2d, 0x40, 0x2a, 0x07, 0x01, 0x00, 0x01,
+  0x01, 0x47, 0x02, 0x01, 0x01, 0x01, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10,
+  0x48, 0x05, 0x01, 0x04, 0x04, 0x03, 0x59, 0x00, 0x03, 0x03, 0x14, 0x03,
+  0x49, 0x00, 0x00, 0x00, 0x11, 0x00, 0x10, 0x24, 0x12, 0x11, 0x13, 0x06,
+  0x05, 0x18, 0x2b, 0x16, 0x36, 0x37, 0x37, 0x23, 0x03, 0x33, 0x13, 0x13,
+  0x33, 0x03, 0x0e, 0x02, 0x23, 0x23, 0x35, 0x33, 0xcc, 0x18, 0x06, 0x0e,
+  0x14, 0xa5, 0x5c, 0x7d, 0x6d, 0x57, 0x9b, 0x0d, 0x26, 0x2f, 0x25, 0x30,
+  0x2a, 0x5f, 0x12, 0x16, 0x37, 0x01, 0xf4, 0xfe, 0x5d, 0x01, 0xa3, 0xfd,
+  0xd6, 0x33, 0x32, 0x0f, 0x4b, 0x00, 0x00, 0x02, 0x00, 0x3f, 0xff, 0x56,
+  0x01, 0xdc, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x15, 0x00, 0x74, 0xb5, 0x0b,
+  0x01, 0x02, 0x03, 0x01, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x25,
+  0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x03, 0x6d, 0x07, 0x01, 0x01, 0x01,
+  0x0f, 0x48, 0x04, 0x01, 0x03, 0x03, 0x12, 0x48, 0x00, 0x02, 0x02, 0x10,
+  0x48, 0x08, 0x01, 0x06, 0x06, 0x05, 0x59, 0x00, 0x05, 0x05, 0x14, 0x05,
+  0x49, 0x1b, 0x40, 0x22, 0x07, 0x01, 0x01, 0x00, 0x01, 0x6f, 0x00, 0x00,
+  0x03, 0x00, 0x6f, 0x04, 0x01, 0x03, 0x03, 0x12, 0x48, 0x00, 0x02, 0x02,
+  0x10, 0x48, 0x08, 0x01, 0x06, 0x06, 0x05, 0x59, 0x00, 0x05, 0x05, 0x14,
+  0x05, 0x49, 0x59, 0x40, 0x18, 0x04, 0x04, 0x00, 0x00, 0x04, 0x15, 0x04,
+  0x14, 0x13, 0x11, 0x0d, 0x0c, 0x0a, 0x09, 0x08, 0x07, 0x00, 0x03, 0x00,
+  0x03, 0x11, 0x09, 0x05, 0x15, 0x2b, 0x01, 0x07, 0x23, 0x37, 0x02, 0x36,
+  0x37, 0x37, 0x23, 0x03, 0x33, 0x13, 0x13, 0x33, 0x03, 0x0e, 0x02, 0x23,
+  0x23, 0x35, 0x33, 0x01, 0x93, 0x7a, 0x56, 0x68, 0x5f, 0x18, 0x06, 0x0e,
+  0x14, 0xa5, 0x5c, 0x7d, 0x6d, 0x57, 0x9b, 0x0d, 0x26, 0x2f, 0x25, 0x30,
+  0x2a, 0x02, 0xcb, 0x87, 0x87, 0xfc, 0xd6, 0x12, 0x16, 0x37, 0x01, 0xf4,
+  0xfe, 0x5d, 0x01, 0xa3, 0xfd, 0xd6, 0x33, 0x32, 0x0f, 0x4b, 0x00, 0x03,
+  0x00, 0x3f, 0xff, 0x56, 0x01, 0xdc, 0x02, 0xa3, 0x00, 0x03, 0x00, 0x07,
+  0x00, 0x19, 0x00, 0x4c, 0x40, 0x49, 0x0f, 0x01, 0x04, 0x05, 0x01, 0x47,
+  0x0a, 0x03, 0x09, 0x03, 0x01, 0x02, 0x01, 0x00, 0x05, 0x01, 0x00, 0x5e,
+  0x06, 0x01, 0x05, 0x05, 0x12, 0x48, 0x00, 0x04, 0x04, 0x10, 0x48, 0x0b,
+  0x01, 0x08, 0x08, 0x07, 0x59, 0x00, 0x07, 0x07, 0x14, 0x07, 0x49, 0x08,
+  0x08, 0x04, 0x04, 0x00, 0x00, 0x08, 0x19, 0x08, 0x18, 0x17, 0x15, 0x11,
+  0x10, 0x0e, 0x0d, 0x0c, 0x0b, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00,
+  0x03, 0x00, 0x03, 0x11, 0x0c, 0x05, 0x15, 0x2b, 0x13, 0x15, 0x23, 0x35,
+  0x21, 0x15, 0x23, 0x35, 0x02, 0x36, 0x37, 0x37, 0x23, 0x03, 0x33, 0x13,
+  0x13, 0x33, 0x03, 0x0e, 0x02, 0x23, 0x23, 0x35, 0x33, 0xd4, 0x55, 0x01,
+  0x1d, 0x55, 0x7b, 0x18, 0x06, 0x0e, 0x14, 0xa5, 0x5c, 0x7d, 0x6d, 0x57,
+  0x9b, 0x0d, 0x26, 0x2f, 0x25, 0x30, 0x2a, 0x02, 0xa3, 0x50, 0x50, 0x50,
+  0x50, 0xfc, 0xfe, 0x12, 0x16, 0x37, 0x01, 0xf4, 0xfe, 0x5d, 0x01, 0xa3,
+  0xfd, 0xd6, 0x33, 0x32, 0x0f, 0x4b, 0x00, 0x01, 0x00, 0x6a, 0x00, 0x00,
+  0x01, 0xb2, 0x01, 0xf4, 0x00, 0x09, 0x00, 0x26, 0x40, 0x23, 0x07, 0x02,
+  0x02, 0x03, 0x01, 0x01, 0x47, 0x00, 0x01, 0x01, 0x02, 0x56, 0x00, 0x02,
+  0x02, 0x12, 0x48, 0x00, 0x03, 0x03, 0x00, 0x56, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x49, 0x12, 0x11, 0x12, 0x10, 0x04, 0x05, 0x18, 0x2b, 0x21, 0x21,
+  0x35, 0x13, 0x23, 0x35, 0x21, 0x15, 0x03, 0x33, 0x01, 0xa8, 0xfe, 0xc2,
+  0xea, 0xd6, 0x01, 0x34, 0xe8, 0xde, 0x50, 0x01, 0x5a, 0x4a, 0x59, 0xfe,
+  0xaf, 0x00, 0x00, 0x02, 0x00, 0xa7, 0x00, 0x00, 0x01, 0xf6, 0x02, 0xca,
+  0x00, 0x06, 0x00, 0x10, 0x00, 0x68, 0x40, 0x0b, 0x06, 0x01, 0x01, 0x00,
+  0x0e, 0x09, 0x02, 0x06, 0x04, 0x02, 0x47, 0x4b, 0xb0, 0x23, 0x50, 0x58,
+  0x40, 0x23, 0x00, 0x01, 0x00, 0x05, 0x00, 0x01, 0x05, 0x6d, 0x02, 0x01,
+  0x00, 0x00, 0x0f, 0x48, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05, 0x05,
+  0x12, 0x48, 0x00, 0x06, 0x06, 0x03, 0x57, 0x00, 0x03, 0x03, 0x10, 0x03,
+  0x49, 0x1b, 0x40, 0x20, 0x02, 0x01, 0x00, 0x01, 0x00, 0x6f, 0x00, 0x01,
+  0x05, 0x01, 0x6f, 0x00, 0x04, 0x04, 0x05, 0x56, 0x00, 0x05, 0x05, 0x12,
+  0x48, 0x00, 0x06, 0x06, 0x03, 0x57, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49,
+  0x59, 0x40, 0x0a, 0x12, 0x11, 0x12, 0x12, 0x11, 0x11, 0x10, 0x07, 0x05,
+  0x1b, 0x2b, 0x01, 0x33, 0x07, 0x23, 0x27, 0x33, 0x17, 0x13, 0x21, 0x35,
+  0x13, 0x23, 0x35, 0x21, 0x15, 0x03, 0x33, 0x01, 0x96, 0x60, 0x70, 0x58,
+  0x71, 0x61, 0x3c, 0x8b, 0xfe, 0xc2, 0xea, 0xd6, 0x01, 0x34, 0xe8, 0xde,
+  0x02, 0xca, 0x87, 0x87, 0x4b, 0xfd, 0x81, 0x50, 0x01, 0x5a, 0x4a, 0x59,
+  0xfe, 0xaf, 0xff, 0xff, 0x00, 0x63, 0x00, 0x00, 0x03, 0xe8, 0x02, 0xbc,
+  0x00, 0x22, 0x00, 0x52, 0x00, 0x00, 0x00, 0x03, 0x00, 0x55, 0x02, 0x1c,
+  0x00, 0x00, 0xff, 0xff, 0x00, 0x63, 0x00, 0x00, 0x03, 0xf2, 0x02, 0xbc,
+  0x00, 0x22, 0x00, 0x52, 0x00, 0x00, 0x00, 0x03, 0x00, 0x5d, 0x02, 0x1c,
+  0x00, 0x00, 0x00, 0x03, 0x00, 0x7d, 0x00, 0x00, 0x01, 0x9e, 0x02, 0xbc,
+  0x00, 0x1c, 0x00, 0x28, 0x00, 0x2c, 0x00, 0x8c, 0xb5, 0x02, 0x01, 0x00,
+  0x04, 0x01, 0x47, 0x4b, 0xb0, 0x27, 0x50, 0x58, 0x40, 0x2a, 0x00, 0x01,
+  0x00, 0x06, 0x04, 0x01, 0x06, 0x60, 0x0b, 0x07, 0x02, 0x04, 0x0a, 0x05,
+  0x02, 0x00, 0x09, 0x04, 0x00, 0x60, 0x00, 0x02, 0x02, 0x03, 0x58, 0x00,
+  0x03, 0x03, 0x0f, 0x48, 0x0c, 0x01, 0x09, 0x09, 0x08, 0x56, 0x00, 0x08,
+  0x08, 0x10, 0x08, 0x49, 0x1b, 0x40, 0x2f, 0x00, 0x01, 0x00, 0x06, 0x07,
+  0x01, 0x06, 0x60, 0x0b, 0x01, 0x07, 0x04, 0x00, 0x07, 0x54, 0x00, 0x04,
+  0x0a, 0x05, 0x02, 0x00, 0x09, 0x04, 0x00, 0x60, 0x00, 0x02, 0x02, 0x03,
+  0x58, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x0c, 0x01, 0x09, 0x09, 0x08, 0x56,
+  0x00, 0x08, 0x08, 0x10, 0x08, 0x49, 0x59, 0x40, 0x1e, 0x29, 0x29, 0x1d,
+  0x1d, 0x00, 0x00, 0x29, 0x2c, 0x29, 0x2c, 0x2b, 0x2a, 0x1d, 0x28, 0x1d,
+  0x26, 0x22, 0x20, 0x00, 0x1c, 0x00, 0x1b, 0x15, 0x21, 0x23, 0x24, 0x33,
+  0x0d, 0x05, 0x19, 0x2b, 0x00, 0x26, 0x27, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x35, 0x34, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x23, 0x26, 0x36, 0x35,
+  0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x33, 0x33, 0x13, 0x15, 0x23,
+  0x35, 0x01, 0x67, 0x16, 0x08, 0x11, 0x1a, 0x34, 0x39, 0x34, 0x6e, 0x4a,
+  0x19, 0x1c, 0x65, 0x5e, 0x41, 0x3f, 0x11, 0x14, 0x2d, 0x48, 0x0c, 0x47,
+  0x13, 0x1a, 0x25, 0x2c, 0x7c, 0xfb, 0x01, 0x44, 0x0b, 0x09, 0x14, 0x2f,
+  0x37, 0x0f, 0x74, 0x26, 0x17, 0x15, 0x3d, 0x39, 0x3f, 0xb5, 0x0c, 0x0a,
+  0x35, 0x3b, 0x14, 0x11, 0x4f, 0x19, 0x14, 0x20, 0x27, 0xfe, 0xcc, 0x4b,
+  0x4b, 0x00, 0x00, 0x03, 0x00, 0x84, 0x00, 0x00, 0x01, 0x98, 0x02, 0xbe,
+  0x00, 0x0f, 0x00, 0x1f, 0x00, 0x23, 0x00, 0x2f, 0x40, 0x2c, 0x00, 0x03,
+  0x00, 0x00, 0x05, 0x03, 0x00, 0x60, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00,
+  0x01, 0x01, 0x0f, 0x48, 0x06, 0x01, 0x05, 0x05, 0x04, 0x56, 0x00, 0x04,
+  0x04, 0x10, 0x04, 0x49, 0x20, 0x20, 0x20, 0x23, 0x20, 0x23, 0x15, 0x35,
+  0x35, 0x35, 0x31, 0x07, 0x05, 0x19, 0x2b, 0x00, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26,
+  0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x13, 0x15, 0x21, 0x35, 0x01, 0x90, 0x3e, 0x41, 0x0a,
+  0x42, 0x3e, 0x3e, 0x42, 0x0a, 0x41, 0x3e, 0x44, 0x1c, 0x1c, 0x11, 0x1b,
+  0x1d, 0x1d, 0x1b, 0x11, 0x1c, 0x1c, 0x4c, 0xfe, 0xec, 0x01, 0x7f, 0x39,
+  0x39, 0x3f, 0x88, 0x3f, 0x39, 0x39, 0x3f, 0x88, 0xaa, 0x19, 0x19, 0x17,
+  0x9e, 0x17, 0x19, 0x19, 0x17, 0x9e, 0xfd, 0xfa, 0x4b, 0x4b, 0x00, 0x02,
+  0x00, 0x32, 0x00, 0x00, 0x01, 0xea, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x06,
+  0x00, 0x08, 0xb5, 0x05, 0x04, 0x01, 0x00, 0x02, 0x2d, 0x2b, 0x01, 0x13,
+  0x21, 0x13, 0x13, 0x03, 0x03, 0x01, 0x49, 0xa1, 0xfe, 0x48, 0xa8, 0xa4,
+  0x6d, 0x73, 0x02, 0xbc, 0xfd, 0x44, 0x02, 0xbc, 0xfd, 0x8f, 0x02, 0x26,
+  0xfd, 0xda, 0x00, 0x01, 0x00, 0x2d, 0x00, 0x00, 0x01, 0xef, 0x02, 0xbc,
+  0x00, 0x23, 0x00, 0x06, 0xb3, 0x17, 0x0f, 0x01, 0x2d, 0x2b, 0x24, 0x36,
+  0x35, 0x11, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16,
+  0x33, 0x15, 0x23, 0x35, 0x33, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33,
+  0x32, 0x16, 0x15, 0x11, 0x14, 0x07, 0x33, 0x15, 0x23, 0x35, 0x01, 0x53,
+  0x26, 0x2e, 0x25, 0x36, 0x25, 0x2e, 0x29, 0x1e, 0xb7, 0x31, 0x18, 0x5d,
+  0x57, 0x22, 0x57, 0x5d, 0x17, 0x36, 0xb7, 0x4c, 0x2d, 0x1e, 0x01, 0x8e,
+  0x1f, 0x2c, 0x2c, 0x1f, 0xfe, 0x72, 0x1e, 0x2d, 0x4c, 0x4c, 0x2b, 0x33,
+  0x01, 0x68, 0x55, 0x55, 0x55, 0x55, 0xfe, 0x98, 0x35, 0x29, 0x4c, 0x4c,
+  0x00, 0x01, 0x00, 0x67, 0xff, 0x56, 0x01, 0xb5, 0x01, 0xf4, 0x00, 0x15,
+  0x00, 0x30, 0x40, 0x2d, 0x12, 0x0d, 0x02, 0x02, 0x00, 0x01, 0x47, 0x06,
+  0x05, 0x02, 0x01, 0x01, 0x12, 0x48, 0x00, 0x00, 0x00, 0x02, 0x58, 0x03,
+  0x01, 0x02, 0x02, 0x10, 0x48, 0x00, 0x04, 0x04, 0x14, 0x04, 0x49, 0x00,
+  0x00, 0x00, 0x15, 0x00, 0x15, 0x12, 0x32, 0x11, 0x13, 0x33, 0x07, 0x05,
+  0x19, 0x2b, 0x13, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11,
+  0x33, 0x11, 0x23, 0x35, 0x06, 0x23, 0x23, 0x22, 0x27, 0x15, 0x23, 0x11,
+  0xbc, 0x23, 0x1e, 0x22, 0x21, 0x20, 0x55, 0x50, 0x21, 0x2f, 0x0e, 0x2d,
+  0x1e, 0x55, 0x01, 0xf4, 0xfe, 0x98, 0x1e, 0x23, 0x23, 0x14, 0x01, 0x72,
+  0xfe, 0x0c, 0x17, 0x17, 0x0a, 0xb4, 0x02, 0x9e, 0x00, 0x01, 0x00, 0x67,
+  0xff, 0x56, 0x01, 0xb5, 0x01, 0xf4, 0x00, 0x15, 0x00, 0x06, 0xb3, 0x13,
+  0x00, 0x01, 0x2d, 0x2b, 0x13, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36,
+  0x35, 0x11, 0x33, 0x11, 0x23, 0x35, 0x06, 0x23, 0x23, 0x22, 0x27, 0x15,
+  0x23, 0x11, 0xbc, 0x23, 0x1e, 0x22, 0x21, 0x20, 0x55, 0x50, 0x21, 0x2f,
+  0x0e, 0x2d, 0x1e, 0x55, 0x01, 0xf4, 0xfe, 0x98, 0x1e, 0x23, 0x23, 0x14,
+  0x01, 0x72, 0xfe, 0x0c, 0x17, 0x17, 0x0a, 0xb4, 0x02, 0x9e, 0x00, 0x01,
+  0x00, 0x30, 0x00, 0x00, 0x01, 0xec, 0x01, 0xf4, 0x00, 0x13, 0x00, 0x06,
+  0xb3, 0x0a, 0x01, 0x01, 0x2d, 0x2b, 0x13, 0x35, 0x21, 0x15, 0x23, 0x11,
+  0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x22, 0x26, 0x35, 0x11, 0x23, 0x11,
+  0x23, 0x11, 0x30, 0x01, 0xbc, 0x5a, 0x10, 0x13, 0x0f, 0x32, 0x22, 0x33,
+  0x69, 0x55, 0x01, 0xab, 0x49, 0x49, 0xfe, 0xbe, 0x10, 0x0e, 0x4b, 0x30,
+  0x34, 0x01, 0x47, 0xfe, 0x55, 0x01, 0xab, 0x00, 0x00, 0x03, 0x00, 0x5c,
+  0x00, 0x00, 0x01, 0xc0, 0x02, 0xbc, 0x00, 0x0f, 0x00, 0x18, 0x00, 0x21,
+  0x00, 0x28, 0x40, 0x25, 0x21, 0x20, 0x18, 0x17, 0x04, 0x03, 0x02, 0x01,
+  0x47, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00,
+  0x03, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x36, 0x35,
+  0x35, 0x31, 0x04, 0x05, 0x18, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26,
+  0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x13, 0x02, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x11, 0x03, 0x01, 0xc0, 0x5b, 0x4d, 0x14, 0x4d, 0x5b, 0x5a,
+  0x4e, 0x14, 0x4e, 0x5a, 0x55, 0x2f, 0x24, 0x14, 0x24, 0x2f, 0xba, 0xba,
+  0x2f, 0x24, 0x14, 0x24, 0x2f, 0xba, 0x57, 0x57, 0x57, 0x53, 0x01, 0x68,
+  0x54, 0x56, 0x56, 0x54, 0xfe, 0x98, 0x01, 0x9a, 0x2d, 0x2d, 0x1f, 0xfe,
+  0xf1, 0x01, 0x0f, 0xfe, 0x53, 0x2d, 0x2d, 0x1f, 0x01, 0x0e, 0xfe, 0xf2,
+  0x00, 0x01, 0x00, 0x66, 0x00, 0x00, 0x01, 0xb5, 0x02, 0xbc, 0x00, 0x0a,
+  0x00, 0x29, 0x40, 0x26, 0x03, 0x02, 0x01, 0x03, 0x01, 0x00, 0x01, 0x47,
+  0x00, 0x00, 0x00, 0x0f, 0x48, 0x04, 0x03, 0x02, 0x01, 0x01, 0x02, 0x57,
+  0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x0a,
+  0x11, 0x11, 0x14, 0x05, 0x05, 0x17, 0x2b, 0x37, 0x11, 0x07, 0x35, 0x37,
+  0x33, 0x11, 0x33, 0x15, 0x21, 0x35, 0xf3, 0x8d, 0x83, 0x5f, 0x6d, 0xfe,
+  0xbb, 0x4b, 0x02, 0x22, 0x34, 0x51, 0x32, 0xfd, 0x8f, 0x4b, 0x4b, 0x00,
+  0x00, 0x01, 0x00, 0x69, 0x00, 0x00, 0x01, 0xb3, 0x02, 0xbc, 0x00, 0x18,
+  0x00, 0x25, 0x40, 0x22, 0x18, 0x01, 0x02, 0x00, 0x01, 0x47, 0x00, 0x00,
+  0x00, 0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x03,
+  0x56, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x11, 0x18, 0x21, 0x27, 0x04,
+  0x05, 0x18, 0x2b, 0x01, 0x3e, 0x02, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23,
+  0x35, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x06, 0x07, 0x07, 0x33,
+  0x15, 0x21, 0x35, 0x01, 0x09, 0x20, 0x17, 0x08, 0x2e, 0x25, 0x78, 0x6e,
+  0x57, 0x5d, 0x0e, 0x1a, 0x1e, 0x94, 0xee, 0xfe, 0xb6, 0x01, 0x3c, 0x2e,
+  0x27, 0x28, 0x26, 0x46, 0x1f, 0x2c, 0x4c, 0x55, 0x55, 0x2a, 0x32, 0x3e,
+  0x30, 0x2b, 0xd1, 0x4c, 0x58, 0x00, 0x00, 0x01, 0x00, 0x79, 0x00, 0x00,
+  0x01, 0xa3, 0x02, 0xbc, 0x00, 0x22, 0x00, 0x2f, 0x40, 0x2c, 0x1f, 0x01,
+  0x02, 0x03, 0x01, 0x47, 0x00, 0x03, 0x00, 0x02, 0x01, 0x03, 0x02, 0x60,
+  0x00, 0x04, 0x04, 0x05, 0x58, 0x00, 0x05, 0x05, 0x0f, 0x48, 0x00, 0x01,
+  0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x21, 0x25, 0x21,
+  0x25, 0x21, 0x21, 0x06, 0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x35,
+  0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x16, 0x15,
+  0x15, 0x14, 0x07, 0x16, 0x15, 0x15, 0x01, 0xa3, 0x50, 0x5a, 0x80, 0x89,
+  0x26, 0x24, 0x28, 0x21, 0x6b, 0x61, 0x1f, 0x2a, 0x23, 0x26, 0x80, 0x74,
+  0x55, 0x57, 0x37, 0x41, 0x4b, 0x4b, 0x4b, 0x23, 0x26, 0x67, 0x21, 0x27,
+  0x4b, 0x28, 0x21, 0x52, 0x26, 0x22, 0x4b, 0x4b, 0x51, 0x3f, 0x4d, 0x27,
+  0x24, 0x57, 0x54, 0x00, 0x00, 0x01, 0x00, 0x57, 0x00, 0x00, 0x01, 0xc5,
+  0x02, 0xbc, 0x00, 0x0e, 0x00, 0x33, 0x40, 0x30, 0x03, 0x01, 0x02, 0x03,
+  0x01, 0x47, 0x04, 0x01, 0x02, 0x05, 0x01, 0x00, 0x06, 0x02, 0x00, 0x5f,
+  0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x03, 0x03, 0x06, 0x56, 0x07, 0x01,
+  0x06, 0x06, 0x10, 0x06, 0x49, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x0e, 0x11,
+  0x11, 0x11, 0x11, 0x12, 0x11, 0x08, 0x05, 0x1a, 0x2b, 0x21, 0x35, 0x23,
+  0x35, 0x13, 0x33, 0x03, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x15,
+  0x01, 0x25, 0xce, 0x6b, 0x51, 0x66, 0x78, 0x55, 0x4b, 0x4b, 0x9c, 0x56,
+  0x01, 0xca, 0xfe, 0x29, 0xe4, 0xe4, 0x49, 0x9c, 0x00, 0x01, 0x00, 0x77,
+  0x00, 0x00, 0x01, 0xa4, 0x02, 0xbc, 0x00, 0x17, 0x00, 0x29, 0x40, 0x26,
+  0x00, 0x05, 0x00, 0x02, 0x01, 0x05, 0x02, 0x60, 0x00, 0x04, 0x04, 0x03,
+  0x56, 0x00, 0x03, 0x03, 0x0f, 0x48, 0x00, 0x01, 0x01, 0x00, 0x58, 0x00,
+  0x00, 0x00, 0x10, 0x00, 0x49, 0x21, 0x11, 0x11, 0x25, 0x21, 0x21, 0x06,
+  0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35,
+  0x35, 0x34, 0x26, 0x23, 0x23, 0x11, 0x21, 0x15, 0x23, 0x15, 0x33, 0x32,
+  0x16, 0x15, 0x15, 0x01, 0xa4, 0x50, 0x5a, 0x83, 0x8c, 0x26, 0x24, 0x28,
+  0x21, 0x83, 0x01, 0x14, 0xbf, 0x29, 0x4d, 0x58, 0x4b, 0x4b, 0x4b, 0x23,
+  0x26, 0x7f, 0x21, 0x27, 0x01, 0x61, 0x4b, 0xcb, 0x4c, 0x50, 0x6c, 0x00,
+  0x00, 0x02, 0x00, 0x61, 0x00, 0x00, 0x01, 0xc0, 0x02, 0xbc, 0x00, 0x16,
+  0x00, 0x23, 0x00, 0x29, 0x40, 0x26, 0x00, 0x03, 0x00, 0x05, 0x04, 0x03,
+  0x05, 0x60, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48,
+  0x00, 0x04, 0x04, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x25,
+  0x35, 0x23, 0x21, 0x25, 0x31, 0x06, 0x05, 0x1a, 0x2b, 0x24, 0x06, 0x23,
+  0x23, 0x22, 0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22,
+  0x06, 0x15, 0x15, 0x33, 0x32, 0x16, 0x15, 0x15, 0x04, 0x16, 0x33, 0x33,
+  0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x15, 0x01, 0xc0, 0x5a,
+  0x44, 0x23, 0x44, 0x5a, 0x5b, 0x57, 0x7d, 0x87, 0x25, 0x2e, 0x62, 0x56,
+  0x52, 0xfe, 0xf6, 0x2a, 0x24, 0x19, 0x24, 0x2a, 0x25, 0x24, 0x6c, 0x58,
+  0x58, 0x58, 0x52, 0x01, 0x68, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0x6d, 0x4c,
+  0x54, 0x6e, 0x33, 0x2c, 0x2c, 0x20, 0x94, 0x1f, 0x23, 0xd6, 0x00, 0x01,
+  0x00, 0x68, 0x00, 0x00, 0x01, 0xad, 0x02, 0xbc, 0x00, 0x06, 0x00, 0x1f,
+  0x40, 0x1c, 0x04, 0x01, 0x02, 0x00, 0x01, 0x47, 0x00, 0x00, 0x00, 0x01,
+  0x56, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49,
+  0x12, 0x11, 0x10, 0x03, 0x05, 0x17, 0x2b, 0x01, 0x23, 0x35, 0x21, 0x15,
+  0x03, 0x23, 0x01, 0x5a, 0xf2, 0x01, 0x45, 0xb0, 0x59, 0x02, 0x71, 0x4b,
+  0x61, 0xfd, 0xa5, 0x00, 0x00, 0x03, 0x00, 0x56, 0x00, 0x00, 0x01, 0xc6,
+  0x02, 0xbc, 0x00, 0x19, 0x00, 0x29, 0x00, 0x39, 0x00, 0x38, 0x40, 0x35,
+  0x16, 0x09, 0x02, 0x04, 0x02, 0x01, 0x47, 0x00, 0x02, 0x00, 0x04, 0x05,
+  0x02, 0x04, 0x60, 0x06, 0x01, 0x03, 0x03, 0x01, 0x58, 0x00, 0x01, 0x01,
+  0x0f, 0x48, 0x00, 0x05, 0x05, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x49, 0x1a, 0x1a, 0x36, 0x33, 0x2e, 0x2b, 0x1a, 0x29, 0x1a, 0x27, 0x2f,
+  0x3a, 0x31, 0x07, 0x05, 0x17, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22, 0x26,
+  0x35, 0x35, 0x34, 0x37, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32,
+  0x16, 0x15, 0x15, 0x14, 0x07, 0x16, 0x15, 0x15, 0x02, 0x06, 0x15, 0x15,
+  0x14, 0x16, 0x17, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23,
+  0x12, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33,
+  0x32, 0x36, 0x35, 0x35, 0x01, 0xc6, 0x50, 0x5a, 0x1c, 0x5a, 0x50, 0x41,
+  0x35, 0x54, 0x4e, 0x14, 0x4e, 0x54, 0x35, 0x41, 0xf0, 0x1d, 0x25, 0x1c,
+  0x22, 0x1f, 0x28, 0x21, 0x26, 0x24, 0x77, 0x28, 0x21, 0x30, 0x21, 0x28,
+  0x20, 0x22, 0x36, 0x26, 0x24, 0x4b, 0x4b, 0x4b, 0x53, 0x54, 0x57, 0x24,
+  0x25, 0x4f, 0x3f, 0x50, 0x4c, 0x4c, 0x50, 0x3f, 0x4f, 0x25, 0x24, 0x57,
+  0x54, 0x01, 0xd2, 0x23, 0x24, 0x52, 0x20, 0x27, 0x02, 0x28, 0x21, 0x52,
+  0x26, 0x22, 0xfe, 0xab, 0x27, 0x27, 0x21, 0x67, 0x25, 0x24, 0x23, 0x26,
+  0x67, 0x00, 0x00, 0x02, 0x00, 0x60, 0x00, 0x00, 0x01, 0xbf, 0x02, 0xbc,
+  0x00, 0x16, 0x00, 0x23, 0x00, 0x29, 0x40, 0x26, 0x00, 0x05, 0x00, 0x03,
+  0x02, 0x05, 0x03, 0x60, 0x00, 0x04, 0x04, 0x00, 0x58, 0x00, 0x00, 0x00,
+  0x0f, 0x48, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x10, 0x01,
+  0x49, 0x25, 0x35, 0x23, 0x21, 0x25, 0x31, 0x06, 0x05, 0x1a, 0x2b, 0x12,
+  0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x14, 0x06, 0x23, 0x23, 0x35,
+  0x33, 0x32, 0x36, 0x35, 0x35, 0x23, 0x22, 0x26, 0x35, 0x35, 0x24, 0x26,
+  0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x35, 0x60,
+  0x5a, 0x44, 0x23, 0x44, 0x5a, 0x5b, 0x57, 0x73, 0x7d, 0x25, 0x2e, 0x62,
+  0x56, 0x52, 0x01, 0x0a, 0x2a, 0x24, 0x19, 0x24, 0x2a, 0x25, 0x24, 0x6c,
+  0x02, 0x64, 0x58, 0x58, 0x52, 0xfe, 0x98, 0x55, 0x55, 0x4c, 0x2c, 0x1f,
+  0x6d, 0x4c, 0x54, 0x6e, 0x33, 0x2c, 0x2c, 0x20, 0x94, 0x1f, 0x23, 0xd6,
+  0x00, 0x01, 0x00, 0x69, 0xff, 0x92, 0x01, 0xb3, 0x03, 0x2a, 0x00, 0x03,
+  0x00, 0x11, 0x40, 0x0e, 0x00, 0x00, 0x01, 0x00, 0x6f, 0x00, 0x01, 0x01,
+  0x66, 0x11, 0x10, 0x02, 0x05, 0x16, 0x2b, 0x01, 0x33, 0x01, 0x23, 0x01,
+  0x69, 0x4a, 0xff, 0x00, 0x4a, 0x03, 0x2a, 0xfc, 0x68, 0x00, 0x00, 0x03,
+  0x00, 0x0b, 0xff, 0x92, 0x02, 0x17, 0x03, 0x2a, 0x00, 0x03, 0x00, 0x0e,
+  0x00, 0x25, 0x00, 0x53, 0x40, 0x50, 0x07, 0x06, 0x05, 0x03, 0x07, 0x02,
+  0x25, 0x01, 0x08, 0x04, 0x02, 0x47, 0x00, 0x00, 0x02, 0x00, 0x6f, 0x00,
+  0x01, 0x09, 0x01, 0x70, 0x0a, 0x05, 0x02, 0x03, 0x00, 0x04, 0x08, 0x03,
+  0x04, 0x5f, 0x00, 0x02, 0x02, 0x0f, 0x48, 0x00, 0x06, 0x06, 0x07, 0x58,
+  0x00, 0x07, 0x07, 0x12, 0x48, 0x00, 0x08, 0x08, 0x09, 0x56, 0x00, 0x09,
+  0x09, 0x10, 0x09, 0x49, 0x04, 0x04, 0x24, 0x23, 0x22, 0x21, 0x19, 0x17,
+  0x16, 0x14, 0x04, 0x0e, 0x04, 0x0e, 0x11, 0x11, 0x15, 0x11, 0x10, 0x0b,
+  0x05, 0x19, 0x2b, 0x01, 0x33, 0x01, 0x23, 0x03, 0x11, 0x07, 0x35, 0x37,
+  0x33, 0x11, 0x33, 0x15, 0x23, 0x35, 0x05, 0x36, 0x36, 0x35, 0x35, 0x34,
+  0x23, 0x23, 0x35, 0x33, 0x32, 0x16, 0x16, 0x15, 0x15, 0x14, 0x06, 0x07,
+  0x07, 0x33, 0x15, 0x23, 0x35, 0x01, 0x6d, 0x58, 0xff, 0x00, 0x4a, 0x2e,
+  0x42, 0x44, 0x48, 0x22, 0x9c, 0x01, 0x9e, 0x09, 0x05, 0x29, 0x24, 0x1d,
+  0x31, 0x34, 0x14, 0x06, 0x0c, 0x47, 0x5e, 0xaa, 0x03, 0x2a, 0xfc, 0x68,
+  0x01, 0x7b, 0x01, 0x69, 0x27, 0x47, 0x26, 0xfe, 0x51, 0x40, 0x40, 0x17,
+  0x14, 0x23, 0x2d, 0x2e, 0x27, 0x40, 0x15, 0x2f, 0x29, 0x21, 0x43, 0x30,
+  0x16, 0x98, 0x40, 0x49, 0x00, 0x03, 0x00, 0x0b, 0xff, 0x92, 0x02, 0x10,
+  0x03, 0x2a, 0x00, 0x03, 0x00, 0x0e, 0x00, 0x1d, 0x00, 0x63, 0x40, 0x60,
+  0x07, 0x06, 0x05, 0x03, 0x07, 0x02, 0x12, 0x01, 0x08, 0x04, 0x02, 0x47,
+  0x00, 0x00, 0x02, 0x00, 0x6f, 0x00, 0x01, 0x0c, 0x01, 0x70, 0x0d, 0x05,
+  0x02, 0x03, 0x00, 0x04, 0x08, 0x03, 0x04, 0x5f, 0x0a, 0x01, 0x08, 0x0b,
+  0x01, 0x06, 0x0c, 0x08, 0x06, 0x5f, 0x00, 0x02, 0x02, 0x0f, 0x48, 0x00,
+  0x07, 0x07, 0x12, 0x48, 0x00, 0x09, 0x09, 0x0c, 0x56, 0x0e, 0x01, 0x0c,
+  0x0c, 0x10, 0x0c, 0x49, 0x0f, 0x0f, 0x04, 0x04, 0x0f, 0x1d, 0x0f, 0x1d,
+  0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x11, 0x10,
+  0x04, 0x0e, 0x04, 0x0e, 0x11, 0x11, 0x15, 0x11, 0x10, 0x0f, 0x05, 0x19,
+  0x2b, 0x01, 0x33, 0x01, 0x23, 0x03, 0x11, 0x07, 0x35, 0x37, 0x33, 0x11,
+  0x33, 0x15, 0x23, 0x35, 0x01, 0x35, 0x23, 0x35, 0x13, 0x33, 0x03, 0x33,
+  0x37, 0x33, 0x15, 0x33, 0x15, 0x23, 0x15, 0x01, 0x77, 0x4a, 0xff, 0x00,
+  0x4a, 0x2a, 0x42, 0x44, 0x48, 0x22, 0x9c, 0x01, 0x8f, 0x65, 0x36, 0x45,
+  0x3e, 0x24, 0x1b, 0x2f, 0x1e, 0x1e, 0x03, 0x2a, 0xfc, 0x68, 0x01, 0x7b,
+  0x01, 0x69, 0x27, 0x47, 0x26, 0xfe, 0x51, 0x40, 0x40, 0xfe, 0xf3, 0x75,
+  0x4a, 0x01, 0x30, 0xfe, 0xc6, 0x8f, 0x8f, 0x40, 0x75, 0x00, 0x00, 0x03,
+  0x00, 0x15, 0xff, 0x92, 0x02, 0x10, 0x03, 0x2a, 0x00, 0x03, 0x00, 0x27,
+  0x00, 0x36, 0x00, 0xfc, 0x40, 0x0a, 0x24, 0x01, 0x04, 0x05, 0x2b, 0x01,
+  0x0a, 0x02, 0x02, 0x47, 0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x3d, 0x00,
+  0x00, 0x07, 0x00, 0x6f, 0x00, 0x01, 0x0e, 0x01, 0x70, 0x00, 0x03, 0x00,
+  0x02, 0x0a, 0x03, 0x02, 0x60, 0x0c, 0x01, 0x0a, 0x0d, 0x01, 0x08, 0x0e,
+  0x0a, 0x08, 0x5f, 0x00, 0x06, 0x06, 0x07, 0x58, 0x00, 0x07, 0x07, 0x0f,
+  0x48, 0x00, 0x04, 0x04, 0x05, 0x58, 0x09, 0x01, 0x05, 0x05, 0x12, 0x48,
+  0x00, 0x0b, 0x0b, 0x0e, 0x56, 0x0f, 0x01, 0x0e, 0x0e, 0x10, 0x0e, 0x49,
+  0x1b, 0x4b, 0xb0, 0x29, 0x50, 0x58, 0x40, 0x41, 0x00, 0x00, 0x07, 0x00,
+  0x6f, 0x00, 0x01, 0x0e, 0x01, 0x70, 0x00, 0x03, 0x00, 0x02, 0x0a, 0x03,
+  0x02, 0x60, 0x0c, 0x01, 0x0a, 0x0d, 0x01, 0x08, 0x0e, 0x0a, 0x08, 0x5f,
+  0x00, 0x06, 0x06, 0x07, 0x58, 0x00, 0x07, 0x07, 0x0f, 0x48, 0x00, 0x09,
+  0x09, 0x12, 0x48, 0x00, 0x04, 0x04, 0x05, 0x58, 0x00, 0x05, 0x05, 0x12,
+  0x48, 0x00, 0x0b, 0x0b, 0x0e, 0x56, 0x0f, 0x01, 0x0e, 0x0e, 0x10, 0x0e,
+  0x49, 0x1b, 0x40, 0x3f, 0x00, 0x00, 0x07, 0x00, 0x6f, 0x00, 0x01, 0x0e,
+  0x01, 0x70, 0x00, 0x05, 0x00, 0x04, 0x0b, 0x05, 0x04, 0x60, 0x00, 0x03,
+  0x00, 0x02, 0x0a, 0x03, 0x02, 0x60, 0x0c, 0x01, 0x0a, 0x0d, 0x01, 0x08,
+  0x0e, 0x0a, 0x08, 0x5f, 0x00, 0x06, 0x06, 0x07, 0x58, 0x00, 0x07, 0x07,
+  0x0f, 0x48, 0x00, 0x09, 0x09, 0x12, 0x48, 0x00, 0x0b, 0x0b, 0x0e, 0x56,
+  0x0f, 0x01, 0x0e, 0x0e, 0x10, 0x0e, 0x49, 0x59, 0x59, 0x40, 0x1c, 0x28,
+  0x28, 0x28, 0x36, 0x28, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30, 0x2f,
+  0x2e, 0x2d, 0x2c, 0x1b, 0x21, 0x25, 0x21, 0x25, 0x21, 0x22, 0x11, 0x10,
+  0x10, 0x05, 0x1d, 0x2b, 0x01, 0x33, 0x01, 0x23, 0x12, 0x06, 0x23, 0x23,
+  0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33,
+  0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x16,
+  0x15, 0x15, 0x14, 0x06, 0x07, 0x16, 0x15, 0x15, 0x13, 0x35, 0x23, 0x35,
+  0x13, 0x33, 0x03, 0x33, 0x37, 0x33, 0x15, 0x33, 0x15, 0x23, 0x15, 0x01,
+  0x71, 0x4a, 0xff, 0x00, 0x4a, 0x55, 0x36, 0x43, 0x38, 0x35, 0x1b, 0x1b,
+  0x1d, 0x18, 0x1f, 0x17, 0x18, 0x1d, 0x18, 0x1d, 0x2e, 0x2f, 0x3f, 0x3c,
+  0x18, 0x14, 0x33, 0xe6, 0x65, 0x36, 0x45, 0x3e, 0x24, 0x1b, 0x2f, 0x1e,
+  0x1e, 0x03, 0x2a, 0xfc, 0x68, 0x01, 0x72, 0x37, 0x3e, 0x17, 0x1b, 0x3b,
+  0x18, 0x1c, 0x3c, 0x1b, 0x19, 0x2e, 0x1d, 0x17, 0x3e, 0x38, 0x3d, 0x23,
+  0x1c, 0x2d, 0x0e, 0x1b, 0x41, 0x2d, 0xfe, 0xbc, 0x75, 0x4a, 0x01, 0x30,
+  0xfe, 0xc6, 0x8f, 0x8f, 0x40, 0x75, 0x00, 0x01, 0x00, 0x92, 0x00, 0xcd,
+  0x01, 0x89, 0x02, 0xbc, 0x00, 0x0a, 0x00, 0x26, 0x40, 0x23, 0x03, 0x02,
+  0x01, 0x03, 0x01, 0x00, 0x01, 0x47, 0x04, 0x03, 0x02, 0x01, 0x00, 0x02,
+  0x01, 0x02, 0x5b, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x49, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x0a, 0x11, 0x11, 0x14, 0x05, 0x05, 0x17, 0x2b, 0x13, 0x11,
+  0x07, 0x35, 0x37, 0x33, 0x11, 0x33, 0x15, 0x23, 0x35, 0xf5, 0x63, 0x5b,
+  0x52, 0x4a, 0xef, 0x01, 0x0d, 0x01, 0x6c, 0x27, 0x44, 0x26, 0xfe, 0x51,
+  0x40, 0x40, 0x00, 0x01, 0x00, 0x96, 0x00, 0xcd, 0x01, 0x86, 0x02, 0xbc,
+  0x00, 0x16, 0x00, 0x22, 0x40, 0x1f, 0x16, 0x01, 0x02, 0x00, 0x01, 0x47,
+  0x00, 0x02, 0x00, 0x03, 0x02, 0x03, 0x5a, 0x00, 0x00, 0x00, 0x01, 0x58,
+  0x00, 0x01, 0x01, 0x0f, 0x00, 0x49, 0x11, 0x18, 0x21, 0x25, 0x04, 0x05,
+  0x18, 0x2b, 0x01, 0x36, 0x36, 0x35, 0x35, 0x34, 0x23, 0x23, 0x35, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x06, 0x07, 0x07, 0x33, 0x15, 0x23,
+  0x35, 0x01, 0x06, 0x21, 0x11, 0x3d, 0x56, 0x4f, 0x4a, 0x43, 0x0a, 0x12,
+  0x1a, 0x67, 0xa2, 0xf0, 0x01, 0xaf, 0x2d, 0x26, 0x25, 0x24, 0x31, 0x40,
+  0x39, 0x3e, 0x17, 0x28, 0x2d, 0x1e, 0x23, 0x8b, 0x40, 0x49, 0x00, 0x01,
+  0x00, 0x9e, 0x00, 0xcd, 0x01, 0x7d, 0x02, 0xbc, 0x00, 0x22, 0x00, 0x54,
+  0xb5, 0x1f, 0x01, 0x02, 0x03, 0x01, 0x47, 0x4b, 0xb0, 0x31, 0x50, 0x58,
+  0x40, 0x1c, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x5c, 0x00, 0x04, 0x04,
+  0x05, 0x58, 0x00, 0x05, 0x05, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x03, 0x58,
+  0x00, 0x03, 0x03, 0x12, 0x02, 0x49, 0x1b, 0x40, 0x1a, 0x00, 0x03, 0x00,
+  0x02, 0x01, 0x03, 0x02, 0x60, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x5c,
+  0x00, 0x04, 0x04, 0x05, 0x58, 0x00, 0x05, 0x05, 0x0f, 0x04, 0x49, 0x59,
+  0x40, 0x09, 0x21, 0x25, 0x21, 0x25, 0x21, 0x21, 0x06, 0x05, 0x1a, 0x2b,
+  0x00, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26,
+  0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23,
+  0x35, 0x33, 0x32, 0x15, 0x15, 0x14, 0x06, 0x07, 0x16, 0x15, 0x15, 0x01,
+  0x7d, 0x3b, 0x44, 0x60, 0x5d, 0x1c, 0x1c, 0x1e, 0x19, 0x47, 0x3f, 0x18,
+  0x1f, 0x1a, 0x1d, 0x56, 0x57, 0x81, 0x18, 0x14, 0x33, 0x01, 0x05, 0x38,
+  0x40, 0x17, 0x1b, 0x37, 0x18, 0x1c, 0x40, 0x1b, 0x19, 0x2a, 0x1d, 0x17,
+  0x40, 0x75, 0x23, 0x1c, 0x2d, 0x0e, 0x1b, 0x41, 0x2d, 0x00, 0x00, 0x01,
+  0x00, 0x46, 0x01, 0x54, 0x01, 0xd6, 0x02, 0xd2, 0x00, 0x0e, 0x00, 0x2b,
+  0x40, 0x10, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x07, 0x06, 0x05, 0x04, 0x03,
+  0x02, 0x01, 0x00, 0x0d, 0x00, 0x44, 0x4b, 0xb0, 0x17, 0x50, 0x58, 0xb5,
+  0x00, 0x00, 0x00, 0x0f, 0x00, 0x49, 0x1b, 0xb3, 0x00, 0x00, 0x00, 0x66,
+  0x59, 0xb3, 0x18, 0x01, 0x05, 0x15, 0x2b, 0x01, 0x27, 0x07, 0x27, 0x37,
+  0x27, 0x37, 0x17, 0x27, 0x33, 0x07, 0x37, 0x17, 0x07, 0x17, 0x01, 0x65,
+  0x58, 0x5b, 0x46, 0x6b, 0x91, 0x1b, 0x8d, 0x0d, 0x5a, 0x0d, 0x8f, 0x19,
+  0x93, 0x6a, 0x01, 0x54, 0x8e, 0x8e, 0x35, 0x7a, 0x20, 0x50, 0x39, 0x98,
+  0x98, 0x37, 0x4f, 0x1f, 0x7b, 0x00, 0x00, 0x01, 0x00, 0x32, 0xff, 0x92,
+  0x01, 0xea, 0x03, 0x2a, 0x00, 0x03, 0x00, 0x11, 0x40, 0x0e, 0x00, 0x01,
+  0x00, 0x01, 0x6f, 0x00, 0x00, 0x00, 0x66, 0x11, 0x10, 0x02, 0x05, 0x16,
+  0x2b, 0x05, 0x23, 0x01, 0x33, 0x01, 0xea, 0x54, 0xfe, 0x9c, 0x54, 0x6e,
+  0x03, 0x98, 0x00, 0x01, 0x00, 0xdc, 0x01, 0x04, 0x01, 0x40, 0x01, 0x68,
+  0x00, 0x03, 0x00, 0x1f, 0x40, 0x1c, 0x02, 0x01, 0x01, 0x00, 0x00, 0x01,
+  0x52, 0x02, 0x01, 0x01, 0x01, 0x00, 0x56, 0x00, 0x00, 0x01, 0x00, 0x4a,
+  0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x01,
+  0x15, 0x23, 0x35, 0x01, 0x40, 0x64, 0x01, 0x68, 0x64, 0x64, 0x00, 0x01,
+  0x00, 0xc3, 0x00, 0xeb, 0x01, 0x59, 0x01, 0x86, 0x00, 0x03, 0x00, 0x1f,
+  0x40, 0x1c, 0x02, 0x01, 0x01, 0x00, 0x00, 0x01, 0x52, 0x02, 0x01, 0x01,
+  0x01, 0x00, 0x56, 0x00, 0x00, 0x01, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x01,
+  0x59, 0x96, 0x01, 0x86, 0x9b, 0x9b, 0x00, 0x02, 0x00, 0xdc, 0x00, 0x00,
+  0x01, 0x40, 0x01, 0xf4, 0x00, 0x03, 0x00, 0x07, 0x00, 0x2c, 0x40, 0x29,
+  0x00, 0x00, 0x00, 0x01, 0x56, 0x04, 0x01, 0x01, 0x01, 0x12, 0x48, 0x05,
+  0x01, 0x03, 0x03, 0x02, 0x56, 0x00, 0x02, 0x02, 0x10, 0x02, 0x49, 0x04,
+  0x04, 0x00, 0x00, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00,
+  0x03, 0x11, 0x06, 0x05, 0x15, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x13, 0x15,
+  0x23, 0x35, 0x01, 0x40, 0x64, 0x64, 0x64, 0x01, 0xf4, 0x64, 0x64, 0xfe,
+  0x70, 0x64, 0x64, 0x00, 0x00, 0x01, 0x00, 0xc8, 0xff, 0x74, 0x01, 0x54,
+  0x00, 0x64, 0x00, 0x05, 0x00, 0x1f, 0x40, 0x1c, 0x03, 0x00, 0x02, 0x01,
+  0x00, 0x01, 0x47, 0x00, 0x00, 0x01, 0x01, 0x00, 0x52, 0x00, 0x00, 0x00,
+  0x01, 0x56, 0x00, 0x01, 0x00, 0x01, 0x4a, 0x12, 0x11, 0x02, 0x05, 0x16,
+  0x2b, 0x33, 0x35, 0x33, 0x15, 0x07, 0x23, 0xf0, 0x64, 0x3e, 0x4e, 0x64,
+  0x64, 0x8c, 0x00, 0x03, 0x00, 0x28, 0x00, 0x00, 0x01, 0xf4, 0x00, 0x64,
+  0x00, 0x03, 0x00, 0x07, 0x00, 0x0b, 0x00, 0x2f, 0x40, 0x2c, 0x08, 0x05,
+  0x07, 0x03, 0x06, 0x05, 0x01, 0x01, 0x00, 0x56, 0x04, 0x02, 0x02, 0x00,
+  0x00, 0x10, 0x00, 0x49, 0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x08, 0x0b,
+  0x08, 0x0b, 0x0a, 0x09, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x09, 0x05, 0x15, 0x2b, 0x37, 0x15, 0x23, 0x35, 0x21,
+  0x15, 0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0x8c, 0x64, 0x01, 0x18, 0x64,
+  0x01, 0x18, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x00, 0x02,
+  0x00, 0xdc, 0x00, 0x00, 0x01, 0x40, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x07,
+  0x00, 0x2c, 0x40, 0x29, 0x00, 0x00, 0x00, 0x01, 0x56, 0x04, 0x01, 0x01,
+  0x01, 0x0f, 0x48, 0x05, 0x01, 0x03, 0x03, 0x02, 0x56, 0x00, 0x02, 0x02,
+  0x10, 0x02, 0x49, 0x04, 0x04, 0x00, 0x00, 0x04, 0x07, 0x04, 0x07, 0x06,
+  0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x06, 0x05, 0x15, 0x2b, 0x01, 0x11,
+  0x23, 0x11, 0x13, 0x15, 0x23, 0x35, 0x01, 0x38, 0x55, 0x5d, 0x64, 0x02,
+  0xbc, 0xfe, 0x14, 0x01, 0xec, 0xfd, 0xa8, 0x64, 0x64, 0x00, 0x00, 0x02,
+  0x00, 0xdc, 0xff, 0x38, 0x01, 0x40, 0x01, 0xf4, 0x00, 0x03, 0x00, 0x07,
+  0x00, 0x29, 0x40, 0x26, 0x00, 0x02, 0x05, 0x01, 0x03, 0x02, 0x03, 0x5a,
+  0x04, 0x01, 0x01, 0x01, 0x00, 0x56, 0x00, 0x00, 0x00, 0x12, 0x01, 0x49,
+  0x04, 0x04, 0x00, 0x00, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x06, 0x05, 0x15, 0x2b, 0x13, 0x35, 0x33, 0x15, 0x03,
+  0x11, 0x33, 0x11, 0xdc, 0x64, 0x5c, 0x55, 0x01, 0x90, 0x64, 0x64, 0xfd,
+  0xa8, 0x01, 0xec, 0xfe, 0x14, 0x00, 0x00, 0x02, 0x00, 0x50, 0x00, 0x00,
+  0x01, 0xcc, 0x02, 0xbc, 0x00, 0x1b, 0x00, 0x1f, 0x00, 0x47, 0x40, 0x44,
+  0x09, 0x07, 0x02, 0x05, 0x0f, 0x0a, 0x02, 0x04, 0x03, 0x05, 0x04, 0x5e,
+  0x0e, 0x0b, 0x02, 0x03, 0x0c, 0x02, 0x02, 0x00, 0x01, 0x03, 0x00, 0x5e,
+  0x08, 0x01, 0x06, 0x06, 0x0f, 0x48, 0x10, 0x0d, 0x02, 0x01, 0x01, 0x10,
+  0x01, 0x49, 0x00, 0x00, 0x1f, 0x1e, 0x1d, 0x1c, 0x00, 0x1b, 0x00, 0x1b,
+  0x1a, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x05, 0x1d, 0x2b, 0x21, 0x35, 0x23,
+  0x15, 0x23, 0x35, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x35, 0x33,
+  0x15, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23,
+  0x15, 0x27, 0x33, 0x35, 0x23, 0x01, 0x36, 0x50, 0x50, 0x46, 0x46, 0x46,
+  0x46, 0x50, 0x50, 0x50, 0x46, 0x46, 0x46, 0x46, 0xa0, 0x50, 0x50, 0xb4,
+  0xb4, 0xb4, 0x4b, 0xc8, 0x4b, 0xaa, 0xaa, 0xaa, 0xaa, 0x4b, 0xc8, 0x4b,
+  0xb4, 0xff, 0xc8, 0x00, 0x00, 0x01, 0x00, 0xdc, 0x00, 0x00, 0x01, 0x40,
+  0x00, 0x64, 0x00, 0x03, 0x00, 0x19, 0x40, 0x16, 0x02, 0x01, 0x01, 0x01,
+  0x00, 0x56, 0x00, 0x00, 0x00, 0x10, 0x00, 0x49, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x25, 0x15, 0x23, 0x35, 0x01,
+  0x40, 0x64, 0x64, 0x64, 0x64, 0x00, 0x00, 0x02, 0x00, 0x7e, 0x00, 0x00,
+  0x01, 0x99, 0x02, 0xbc, 0x00, 0x16, 0x00, 0x1a, 0x00, 0x35, 0x40, 0x32,
+  0x07, 0x04, 0x02, 0x00, 0x01, 0x01, 0x47, 0x00, 0x00, 0x01, 0x04, 0x01,
+  0x00, 0x04, 0x6d, 0x00, 0x01, 0x01, 0x02, 0x58, 0x00, 0x02, 0x02, 0x0f,
+  0x48, 0x05, 0x01, 0x04, 0x04, 0x03, 0x56, 0x00, 0x03, 0x03, 0x10, 0x03,
+  0x49, 0x17, 0x17, 0x17, 0x1a, 0x17, 0x1a, 0x14, 0x21, 0x29, 0x15, 0x06,
+  0x05, 0x18, 0x2b, 0x00, 0x06, 0x06, 0x07, 0x07, 0x15, 0x23, 0x35, 0x37,
+  0x3e, 0x02, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32, 0x15,
+  0x15, 0x03, 0x15, 0x23, 0x35, 0x01, 0x99, 0x08, 0x1c, 0x23, 0x35, 0x55,
+  0x3a, 0x20, 0x1a, 0x08, 0x24, 0x25, 0x7d, 0x73, 0xa8, 0x74, 0x64, 0x01,
+  0xdc, 0x29, 0x29, 0x24, 0x36, 0x60, 0x79, 0x3d, 0x22, 0x22, 0x1b, 0x18,
+  0x32, 0x1f, 0x22, 0x4c, 0x96, 0x20, 0xfe, 0x5e, 0x64, 0x64, 0x00, 0x02,
+  0x00, 0x83, 0xff, 0x38, 0x01, 0x9e, 0x01, 0xf4, 0x00, 0x03, 0x00, 0x1a,
+  0x00, 0x35, 0x40, 0x32, 0x0b, 0x08, 0x02, 0x03, 0x02, 0x01, 0x47, 0x00,
+  0x02, 0x01, 0x03, 0x01, 0x02, 0x03, 0x6d, 0x00, 0x03, 0x00, 0x04, 0x03,
+  0x04, 0x5d, 0x05, 0x01, 0x01, 0x01, 0x00, 0x56, 0x00, 0x00, 0x00, 0x12,
+  0x01, 0x49, 0x00, 0x00, 0x18, 0x16, 0x15, 0x13, 0x0a, 0x09, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x06, 0x05, 0x15, 0x2b, 0x13, 0x35, 0x33, 0x15, 0x02,
+  0x36, 0x36, 0x37, 0x37, 0x35, 0x33, 0x15, 0x07, 0x0e, 0x02, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x22, 0x35, 0x35, 0xf7, 0x64, 0xd8,
+  0x08, 0x1c, 0x23, 0x35, 0x55, 0x3a, 0x20, 0x1a, 0x08, 0x24, 0x25, 0x7d,
+  0x73, 0xa8, 0x01, 0x90, 0x64, 0x64, 0xfe, 0x88, 0x29, 0x29, 0x24, 0x36,
+  0x60, 0x79, 0x3d, 0x21, 0x23, 0x1b, 0x18, 0x32, 0x1f, 0x22, 0x4c, 0x96,
+  0x20, 0x00, 0x00, 0x02, 0x00, 0x91, 0x01, 0xc5, 0x01, 0x8b, 0x02, 0xbc,
+  0x00, 0x05, 0x00, 0x0b, 0x00, 0x20, 0x40, 0x1d, 0x09, 0x06, 0x03, 0x00,
+  0x04, 0x01, 0x00, 0x01, 0x47, 0x03, 0x01, 0x01, 0x01, 0x00, 0x56, 0x02,
+  0x01, 0x00, 0x00, 0x0f, 0x01, 0x49, 0x12, 0x12, 0x12, 0x11, 0x04, 0x05,
+  0x18, 0x2b, 0x13, 0x35, 0x33, 0x15, 0x07, 0x23, 0x37, 0x35, 0x33, 0x15,
+  0x07, 0x23, 0x91, 0x5f, 0x14, 0x37, 0x87, 0x5f, 0x14, 0x37, 0x02, 0x62,
+  0x5a, 0x5a, 0x9d, 0x9d, 0x5a, 0x5a, 0x9d, 0x00, 0x00, 0x01, 0x00, 0xde,
+  0x01, 0xc5, 0x01, 0x3d, 0x02, 0xbc, 0x00, 0x05, 0x00, 0x1a, 0x40, 0x17,
+  0x03, 0x00, 0x02, 0x01, 0x00, 0x01, 0x47, 0x00, 0x01, 0x01, 0x00, 0x56,
+  0x00, 0x00, 0x00, 0x0f, 0x01, 0x49, 0x12, 0x11, 0x02, 0x05, 0x16, 0x2b,
+  0x13, 0x35, 0x33, 0x15, 0x07, 0x23, 0xde, 0x5f, 0x14, 0x37, 0x02, 0x62,
+  0x5a, 0x5a, 0x9d, 0x00, 0x00, 0x02, 0x00, 0xc8, 0xff, 0x74, 0x01, 0x54,
+  0x01, 0xf4, 0x00, 0x03, 0x00, 0x09, 0x00, 0x2b, 0x40, 0x28, 0x07, 0x04,
+  0x02, 0x03, 0x02, 0x01, 0x47, 0x00, 0x02, 0x00, 0x03, 0x02, 0x03, 0x5a,
+  0x00, 0x00, 0x00, 0x01, 0x56, 0x04, 0x01, 0x01, 0x01, 0x12, 0x00, 0x49,
+  0x00, 0x00, 0x09, 0x08, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x05,
+  0x05, 0x15, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x11, 0x35, 0x33, 0x15, 0x07,
+  0x23, 0x01, 0x54, 0x64, 0x64, 0x3e, 0x4e, 0x01, 0xf4, 0x64, 0x64, 0xfe,
+  0x0c, 0x64, 0x64, 0x8c, 0x00, 0x01, 0x00, 0x32, 0xff, 0x92, 0x01, 0xea,
+  0x03, 0x2a, 0x00, 0x03, 0x00, 0x11, 0x40, 0x0e, 0x00, 0x00, 0x01, 0x00,
+  0x6f, 0x00, 0x01, 0x01, 0x66, 0x11, 0x10, 0x02, 0x05, 0x16, 0x2b, 0x01,
+  0x33, 0x01, 0x23, 0x01, 0x96, 0x54, 0xfe, 0x9c, 0x54, 0x03, 0x2a, 0xfc,
+  0x68, 0x00, 0x00, 0x01, 0x00, 0x12, 0xff, 0x56, 0x02, 0x0a, 0xff, 0xa1,
+  0x00, 0x03, 0x00, 0x19, 0x40, 0x16, 0x02, 0x01, 0x01, 0x01, 0x00, 0x56,
+  0x00, 0x00, 0x00, 0x14, 0x00, 0x49, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03,
+  0x11, 0x03, 0x05, 0x15, 0x2b, 0x05, 0x15, 0x21, 0x35, 0x02, 0x0a, 0xfe,
+  0x08, 0x5f, 0x4b, 0x4b, 0x00, 0x01, 0x00, 0x93, 0xff, 0x88, 0x01, 0x88,
+  0x03, 0x34, 0x00, 0x22, 0x00, 0x38, 0x40, 0x35, 0x10, 0x01, 0x04, 0x05,
+  0x01, 0x47, 0x00, 0x00, 0x00, 0x01, 0x05, 0x00, 0x01, 0x60, 0x06, 0x01,
+  0x05, 0x00, 0x04, 0x02, 0x05, 0x04, 0x60, 0x00, 0x02, 0x03, 0x03, 0x02,
+  0x54, 0x00, 0x02, 0x02, 0x03, 0x58, 0x00, 0x03, 0x02, 0x03, 0x4c, 0x00,
+  0x00, 0x00, 0x22, 0x00, 0x22, 0x15, 0x21, 0x2c, 0x21, 0x25, 0x07, 0x05,
+  0x19, 0x2b, 0x12, 0x36, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23,
+  0x22, 0x06, 0x15, 0x15, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x15, 0x14,
+  0x16, 0x33, 0x33, 0x15, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x26, 0x23,
+  0x35, 0xbb, 0x1f, 0x32, 0x3b, 0x41, 0x33, 0x18, 0x15, 0x31, 0x24, 0x24,
+  0x31, 0x15, 0x18, 0x33, 0x41, 0x3b, 0x32, 0x1f, 0x28, 0x01, 0x95, 0x19,
+  0x27, 0xe5, 0x43, 0x37, 0x46, 0x0f, 0x16, 0xf4, 0x32, 0x40, 0x06, 0x04,
+  0x40, 0x32, 0xf4, 0x16, 0x0f, 0x46, 0x37, 0x43, 0xe5, 0x27, 0x19, 0x6e,
+  0x00, 0x01, 0x00, 0x93, 0xff, 0x88, 0x01, 0x88, 0x03, 0x34, 0x00, 0x22,
+  0x00, 0x38, 0x40, 0x35, 0x10, 0x01, 0x05, 0x04, 0x01, 0x47, 0x00, 0x03,
+  0x00, 0x02, 0x04, 0x03, 0x02, 0x60, 0x00, 0x04, 0x06, 0x01, 0x05, 0x01,
+  0x04, 0x05, 0x60, 0x00, 0x01, 0x00, 0x00, 0x01, 0x54, 0x00, 0x01, 0x01,
+  0x00, 0x58, 0x00, 0x00, 0x01, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x22, 0x00,
+  0x22, 0x15, 0x21, 0x2c, 0x21, 0x25, 0x07, 0x05, 0x19, 0x2b, 0x00, 0x06,
+  0x15, 0x15, 0x14, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35,
+  0x34, 0x36, 0x37, 0x26, 0x26, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35,
+  0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x01, 0x60, 0x1f,
+  0x32, 0x3b, 0x41, 0x33, 0x18, 0x15, 0x31, 0x24, 0x24, 0x31, 0x15, 0x18,
+  0x33, 0x41, 0x3b, 0x32, 0x1f, 0x28, 0x01, 0x27, 0x19, 0x27, 0xe5, 0x43,
+  0x37, 0x46, 0x0f, 0x16, 0xf4, 0x32, 0x40, 0x04, 0x06, 0x40, 0x32, 0xf4,
+  0x16, 0x0f, 0x46, 0x37, 0x43, 0xe5, 0x27, 0x19, 0x6e, 0x00, 0x00, 0x01,
+  0x00, 0xa5, 0xff, 0x88, 0x01, 0x77, 0x03, 0x34, 0x00, 0x07, 0x00, 0x28,
+  0x40, 0x25, 0x04, 0x01, 0x03, 0x00, 0x00, 0x01, 0x03, 0x00, 0x5e, 0x00,
+  0x01, 0x02, 0x02, 0x01, 0x52, 0x00, 0x01, 0x01, 0x02, 0x56, 0x00, 0x02,
+  0x01, 0x02, 0x4a, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x11, 0x11, 0x11,
+  0x05, 0x05, 0x17, 0x2b, 0x01, 0x15, 0x23, 0x11, 0x33, 0x15, 0x23, 0x11,
+  0x01, 0x77, 0x82, 0x82, 0xd2, 0x03, 0x34, 0x4b, 0xfc, 0xea, 0x4b, 0x03,
+  0xac, 0x00, 0x00, 0x01, 0x00, 0xa5, 0xff, 0x88, 0x01, 0x77, 0x03, 0x34,
+  0x00, 0x07, 0x00, 0x29, 0x40, 0x26, 0x00, 0x01, 0x00, 0x00, 0x03, 0x01,
+  0x00, 0x5e, 0x04, 0x01, 0x03, 0x02, 0x02, 0x03, 0x52, 0x04, 0x01, 0x03,
+  0x03, 0x02, 0x56, 0x00, 0x02, 0x03, 0x02, 0x4a, 0x00, 0x00, 0x00, 0x07,
+  0x00, 0x07, 0x11, 0x11, 0x11, 0x05, 0x05, 0x17, 0x2b, 0x05, 0x11, 0x23,
+  0x35, 0x33, 0x11, 0x23, 0x35, 0x01, 0x27, 0x82, 0xd2, 0xd2, 0x2d, 0x03,
+  0x16, 0x4b, 0xfc, 0x54, 0x4b, 0x00, 0x00, 0x01, 0x00, 0xaa, 0xff, 0x88,
+  0x01, 0x72, 0x03, 0x34, 0x00, 0x11, 0x00, 0x11, 0x40, 0x0e, 0x00, 0x00,
+  0x01, 0x00, 0x6f, 0x00, 0x01, 0x01, 0x66, 0x19, 0x12, 0x02, 0x05, 0x16,
+  0x2b, 0x12, 0x36, 0x37, 0x33, 0x0e, 0x02, 0x15, 0x11, 0x14, 0x16, 0x16,
+  0x17, 0x23, 0x26, 0x26, 0x35, 0x11, 0xaa, 0x3b, 0x35, 0x58, 0x30, 0x2e,
+  0x15, 0x15, 0x2e, 0x30, 0x58, 0x35, 0x3b, 0x02, 0x6d, 0x90, 0x37, 0x3a,
+  0x4f, 0x62, 0x4e, 0xfe, 0xc6, 0x4e, 0x62, 0x4f, 0x3a, 0x37, 0x90, 0x74,
+  0x01, 0x36, 0x00, 0x01, 0x00, 0xaa, 0xff, 0x88, 0x01, 0x72, 0x03, 0x34,
+  0x00, 0x11, 0x00, 0x11, 0x40, 0x0e, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x00,
+  0x00, 0x00, 0x66, 0x19, 0x12, 0x02, 0x05, 0x16, 0x2b, 0x24, 0x06, 0x07,
+  0x23, 0x3e, 0x02, 0x35, 0x11, 0x34, 0x26, 0x26, 0x27, 0x33, 0x16, 0x16,
+  0x15, 0x11, 0x01, 0x72, 0x3b, 0x35, 0x58, 0x30, 0x2e, 0x15, 0x15, 0x2e,
+  0x30, 0x58, 0x35, 0x3b, 0x4f, 0x90, 0x37, 0x3a, 0x4f, 0x62, 0x4e, 0x01,
+  0x3a, 0x4e, 0x62, 0x4f, 0x3a, 0x37, 0x90, 0x74, 0xfe, 0xca, 0x00, 0x01,
+  0x00, 0x20, 0x01, 0x13, 0x01, 0xfb, 0x01, 0x5e, 0x00, 0x03, 0x00, 0x1f,
+  0x40, 0x1c, 0x02, 0x01, 0x01, 0x00, 0x00, 0x01, 0x52, 0x02, 0x01, 0x01,
+  0x01, 0x00, 0x56, 0x00, 0x00, 0x01, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x01, 0x15, 0x21, 0x35, 0x01,
+  0xfb, 0xfe, 0x25, 0x01, 0x5e, 0x4b, 0x4b, 0x00, 0x00, 0x01, 0x00, 0x50,
+  0x01, 0x13, 0x01, 0xcc, 0x01, 0x5e, 0x00, 0x03, 0x00, 0x1f, 0x40, 0x1c,
+  0x02, 0x01, 0x01, 0x00, 0x00, 0x01, 0x52, 0x02, 0x01, 0x01, 0x01, 0x00,
+  0x56, 0x00, 0x00, 0x01, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03,
+  0x11, 0x03, 0x05, 0x15, 0x2b, 0x01, 0x15, 0x21, 0x35, 0x01, 0xcc, 0xfe,
+  0x84, 0x01, 0x5e, 0x4b, 0x4b, 0x00, 0x00, 0x01, 0x00, 0x6b, 0x01, 0x13,
+  0x01, 0xb0, 0x01, 0x5e, 0x00, 0x03, 0x00, 0x1f, 0x40, 0x1c, 0x02, 0x01,
+  0x01, 0x00, 0x00, 0x01, 0x52, 0x02, 0x01, 0x01, 0x01, 0x00, 0x56, 0x00,
+  0x00, 0x01, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03,
+  0x05, 0x15, 0x2b, 0x01, 0x15, 0x21, 0x35, 0x01, 0xb0, 0xfe, 0xbb, 0x01,
+  0x5e, 0x4b, 0x4b, 0x00, 0x00, 0x01, 0x00, 0x6b, 0x01, 0x13, 0x01, 0xb0,
+  0x01, 0x5e, 0x00, 0x03, 0x00, 0x1f, 0x40, 0x1c, 0x02, 0x01, 0x01, 0x00,
+  0x00, 0x01, 0x52, 0x02, 0x01, 0x01, 0x01, 0x00, 0x56, 0x00, 0x00, 0x01,
+  0x00, 0x4a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03, 0x05, 0x15,
+  0x2b, 0x01, 0x15, 0x21, 0x35, 0x01, 0xb0, 0xfe, 0xbb, 0x01, 0x5e, 0x4b,
+  0x4b, 0x00, 0x00, 0x02, 0x00, 0x70, 0x00, 0x5c, 0x01, 0xab, 0x01, 0xfa,
+  0x00, 0x05, 0x00, 0x0b, 0x00, 0x20, 0x40, 0x1d, 0x0b, 0x08, 0x05, 0x02,
+  0x04, 0x01, 0x00, 0x01, 0x47, 0x03, 0x01, 0x01, 0x01, 0x00, 0x56, 0x02,
+  0x01, 0x00, 0x00, 0x12, 0x01, 0x49, 0x12, 0x12, 0x12, 0x10, 0x04, 0x05,
+  0x18, 0x2b, 0x13, 0x33, 0x07, 0x17, 0x23, 0x27, 0x37, 0x33, 0x07, 0x17,
+  0x23, 0x27, 0xc9, 0x42, 0x3f, 0x3f, 0x42, 0x59, 0xf9, 0x42, 0x3f, 0x3f,
+  0x42, 0x59, 0x01, 0xfa, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0x00,
+  0x00, 0x02, 0x00, 0x70, 0x00, 0x5c, 0x01, 0xab, 0x01, 0xfa, 0x00, 0x05,
+  0x00, 0x0b, 0x00, 0x20, 0x40, 0x1d, 0x0b, 0x08, 0x05, 0x02, 0x04, 0x01,
+  0x00, 0x01, 0x47, 0x03, 0x01, 0x01, 0x01, 0x00, 0x56, 0x02, 0x01, 0x00,
+  0x00, 0x12, 0x01, 0x49, 0x12, 0x12, 0x12, 0x10, 0x04, 0x05, 0x18, 0x2b,
+  0x13, 0x33, 0x17, 0x07, 0x23, 0x37, 0x37, 0x33, 0x17, 0x07, 0x23, 0x37,
+  0x70, 0x42, 0x59, 0x59, 0x42, 0x3f, 0x61, 0x42, 0x59, 0x59, 0x42, 0x3f,
+  0x01, 0xfa, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x01,
+  0x00, 0xc0, 0x00, 0x5c, 0x01, 0x5b, 0x01, 0xfa, 0x00, 0x05, 0x00, 0x1a,
+  0x40, 0x17, 0x05, 0x02, 0x02, 0x01, 0x00, 0x01, 0x47, 0x00, 0x01, 0x01,
+  0x00, 0x56, 0x00, 0x00, 0x00, 0x12, 0x01, 0x49, 0x12, 0x10, 0x02, 0x05,
+  0x16, 0x2b, 0x01, 0x33, 0x07, 0x17, 0x23, 0x27, 0x01, 0x19, 0x42, 0x3f,
+  0x3f, 0x42, 0x59, 0x01, 0xfa, 0xcf, 0xcf, 0xcf, 0x00, 0x01, 0x00, 0xc0,
+  0x00, 0x5c, 0x01, 0x5b, 0x01, 0xfa, 0x00, 0x05, 0x00, 0x1a, 0x40, 0x17,
+  0x05, 0x02, 0x02, 0x01, 0x00, 0x01, 0x47, 0x00, 0x01, 0x01, 0x00, 0x56,
+  0x00, 0x00, 0x00, 0x12, 0x01, 0x49, 0x12, 0x10, 0x02, 0x05, 0x16, 0x2b,
+  0x13, 0x33, 0x17, 0x07, 0x23, 0x37, 0xc0, 0x42, 0x59, 0x59, 0x42, 0x3f,
+  0x01, 0xfa, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x02, 0x00, 0x82, 0xff, 0x63,
+  0x01, 0x9a, 0x00, 0x5a, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x3f, 0x40, 0x09,
+  0x09, 0x06, 0x03, 0x00, 0x04, 0x01, 0x00, 0x01, 0x47, 0x4b, 0xb0, 0x25,
+  0x50, 0x58, 0x40, 0x0d, 0x02, 0x01, 0x00, 0x00, 0x01, 0x56, 0x03, 0x01,
+  0x01, 0x01, 0x14, 0x01, 0x49, 0x1b, 0x40, 0x13, 0x02, 0x01, 0x00, 0x01,
+  0x01, 0x00, 0x52, 0x02, 0x01, 0x00, 0x00, 0x01, 0x56, 0x03, 0x01, 0x01,
+  0x00, 0x01, 0x4a, 0x59, 0xb6, 0x12, 0x12, 0x12, 0x11, 0x04, 0x05, 0x18,
+  0x2b, 0x33, 0x35, 0x33, 0x15, 0x07, 0x23, 0x37, 0x35, 0x33, 0x15, 0x07,
+  0x23, 0xa0, 0x5f, 0x37, 0x46, 0xb9, 0x5f, 0x37, 0x46, 0x5a, 0x5a, 0x9d,
+  0x9d, 0x5a, 0x5a, 0x9d, 0x00, 0x02, 0x00, 0x82, 0x01, 0xc4, 0x01, 0x9a,
+  0x02, 0xbb, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x20, 0x40, 0x1d, 0x09, 0x06,
+  0x03, 0x00, 0x04, 0x00, 0x01, 0x01, 0x47, 0x02, 0x01, 0x00, 0x00, 0x01,
+  0x56, 0x03, 0x01, 0x01, 0x01, 0x0f, 0x00, 0x49, 0x12, 0x12, 0x12, 0x11,
+  0x04, 0x05, 0x18, 0x2b, 0x13, 0x15, 0x23, 0x35, 0x37, 0x33, 0x17, 0x15,
+  0x23, 0x35, 0x37, 0x33, 0xe1, 0x5f, 0x37, 0x46, 0x7d, 0x5f, 0x37, 0x46,
+  0x02, 0x1e, 0x5a, 0x5a, 0x9d, 0x9d, 0x5a, 0x5a, 0x9d, 0x00, 0x00, 0x02,
+  0x00, 0x82, 0x01, 0xc5, 0x01, 0x9a, 0x02, 0xbc, 0x00, 0x05, 0x00, 0x0b,
+  0x00, 0x20, 0x40, 0x1d, 0x09, 0x06, 0x03, 0x00, 0x04, 0x01, 0x00, 0x01,
+  0x47, 0x03, 0x01, 0x01, 0x01, 0x00, 0x56, 0x02, 0x01, 0x00, 0x00, 0x0f,
+  0x01, 0x49, 0x12, 0x12, 0x12, 0x11, 0x04, 0x05, 0x18, 0x2b, 0x13, 0x35,
+  0x33, 0x15, 0x07, 0x23, 0x37, 0x35, 0x33, 0x15, 0x07, 0x23, 0xa0, 0x5f,
+  0x37, 0x46, 0xb9, 0x5f, 0x37, 0x46, 0x02, 0x62, 0x5a, 0x5a, 0x9d, 0x9d,
+  0x5a, 0x5a, 0x9d, 0x00, 0x00, 0x01, 0x00, 0xcf, 0x01, 0xc4, 0x01, 0x4c,
+  0x02, 0xbb, 0x00, 0x05, 0x00, 0x1a, 0x40, 0x17, 0x03, 0x00, 0x02, 0x00,
+  0x01, 0x01, 0x47, 0x00, 0x00, 0x00, 0x01, 0x56, 0x00, 0x01, 0x01, 0x0f,
+  0x00, 0x49, 0x12, 0x11, 0x02, 0x05, 0x16, 0x2b, 0x01, 0x15, 0x23, 0x35,
+  0x37, 0x33, 0x01, 0x2e, 0x5f, 0x37, 0x46, 0x02, 0x1e, 0x5a, 0x5a, 0x9d,
+  0x00, 0x01, 0x00, 0xcf, 0x01, 0xc5, 0x01, 0x4c, 0x02, 0xbc, 0x00, 0x05,
+  0x00, 0x1a, 0x40, 0x17, 0x03, 0x00, 0x02, 0x01, 0x00, 0x01, 0x47, 0x00,
+  0x01, 0x01, 0x00, 0x56, 0x00, 0x00, 0x00, 0x0f, 0x01, 0x49, 0x12, 0x11,
+  0x02, 0x05, 0x16, 0x2b, 0x13, 0x35, 0x33, 0x15, 0x07, 0x23, 0xed, 0x5f,
+  0x37, 0x46, 0x02, 0x62, 0x5a, 0x5a, 0x9d, 0x00, 0x00, 0x01, 0x00, 0xcf,
+  0xff, 0x63, 0x01, 0x4c, 0x00, 0x5a, 0x00, 0x05, 0x00, 0x35, 0xb6, 0x03,
+  0x00, 0x02, 0x01, 0x00, 0x01, 0x47, 0x4b, 0xb0, 0x25, 0x50, 0x58, 0x40,
+  0x0b, 0x00, 0x00, 0x00, 0x01, 0x56, 0x00, 0x01, 0x01, 0x14, 0x01, 0x49,
+  0x1b, 0x40, 0x10, 0x00, 0x00, 0x01, 0x01, 0x00, 0x52, 0x00, 0x00, 0x00,
+  0x01, 0x56, 0x00, 0x01, 0x00, 0x01, 0x4a, 0x59, 0xb4, 0x12, 0x11, 0x02,
+  0x05, 0x16, 0x2b, 0x33, 0x35, 0x33, 0x15, 0x07, 0x23, 0xed, 0x5f, 0x37,
+  0x46, 0x5a, 0x5a, 0x9d, 0x00, 0x01, 0x00, 0x59, 0x00, 0x00, 0x01, 0xc3,
+  0x02, 0xbc, 0x00, 0x23, 0x00, 0x74, 0x4b, 0xb0, 0x19, 0x50, 0x58, 0x40,
+  0x2b, 0x05, 0x01, 0x00, 0x04, 0x01, 0x01, 0x02, 0x00, 0x01, 0x5e, 0x00,
+  0x09, 0x09, 0x08, 0x58, 0x00, 0x08, 0x08, 0x0f, 0x48, 0x0b, 0x01, 0x06,
+  0x06, 0x07, 0x56, 0x0a, 0x01, 0x07, 0x07, 0x12, 0x48, 0x00, 0x02, 0x02,
+  0x03, 0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49, 0x1b, 0x40, 0x29, 0x0a,
+  0x01, 0x07, 0x0b, 0x01, 0x06, 0x00, 0x07, 0x06, 0x5e, 0x05, 0x01, 0x00,
+  0x04, 0x01, 0x01, 0x02, 0x00, 0x01, 0x5e, 0x00, 0x09, 0x09, 0x08, 0x58,
+  0x00, 0x08, 0x08, 0x0f, 0x48, 0x00, 0x02, 0x02, 0x03, 0x58, 0x00, 0x03,
+  0x03, 0x10, 0x03, 0x49, 0x59, 0x40, 0x12, 0x23, 0x22, 0x21, 0x20, 0x1d,
+  0x1b, 0x23, 0x11, 0x11, 0x11, 0x13, 0x21, 0x23, 0x11, 0x10, 0x0c, 0x05,
+  0x1d, 0x2b, 0x13, 0x33, 0x15, 0x23, 0x15, 0x14, 0x16, 0x33, 0x33, 0x15,
+  0x23, 0x22, 0x26, 0x35, 0x35, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33,
+  0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x33,
+  0x15, 0x23, 0xf6, 0xa9, 0xa9, 0x2e, 0x25, 0x7a, 0x70, 0x57, 0x5d, 0x46,
+  0x46, 0x46, 0x46, 0x5d, 0x57, 0x70, 0x7a, 0x25, 0x2e, 0xa9, 0xa9, 0x01,
+  0x36, 0x49, 0x56, 0x1f, 0x2c, 0x4c, 0x55, 0x55, 0x43, 0x49, 0x61, 0x49,
+  0x32, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0x45, 0x49, 0x00, 0x01, 0x00, 0x78,
+  0xff, 0x92, 0x01, 0xa3, 0x02, 0x58, 0x00, 0x19, 0x00, 0x8c, 0x40, 0x0a,
+  0x06, 0x01, 0x02, 0x01, 0x19, 0x01, 0x04, 0x03, 0x02, 0x47, 0x4b, 0xb0,
+  0x0b, 0x50, 0x58, 0x40, 0x21, 0x00, 0x00, 0x01, 0x01, 0x00, 0x63, 0x00,
+  0x05, 0x04, 0x04, 0x05, 0x64, 0x00, 0x02, 0x02, 0x01, 0x56, 0x00, 0x01,
+  0x01, 0x12, 0x48, 0x00, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04, 0x04, 0x10,
+  0x04, 0x49, 0x1b, 0x4b, 0xb0, 0x0d, 0x50, 0x58, 0x40, 0x20, 0x00, 0x00,
+  0x01, 0x01, 0x00, 0x63, 0x00, 0x05, 0x04, 0x05, 0x70, 0x00, 0x02, 0x02,
+  0x01, 0x56, 0x00, 0x01, 0x01, 0x12, 0x48, 0x00, 0x03, 0x03, 0x04, 0x56,
+  0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x1b, 0x40, 0x1f, 0x00, 0x00, 0x01,
+  0x00, 0x6f, 0x00, 0x05, 0x04, 0x05, 0x70, 0x00, 0x02, 0x02, 0x01, 0x56,
+  0x00, 0x01, 0x01, 0x12, 0x48, 0x00, 0x03, 0x03, 0x04, 0x56, 0x00, 0x04,
+  0x04, 0x10, 0x04, 0x49, 0x59, 0x59, 0x40, 0x09, 0x11, 0x11, 0x25, 0x21,
+  0x11, 0x17, 0x06, 0x05, 0x1a, 0x2b, 0x36, 0x26, 0x35, 0x35, 0x34, 0x36,
+  0x37, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14,
+  0x16, 0x33, 0x33, 0x15, 0x23, 0x15, 0x23, 0x35, 0xbc, 0x44, 0x44, 0x48,
+  0x50, 0x4f, 0x8b, 0x25, 0x26, 0x26, 0x25, 0x8b, 0x4f, 0x50, 0x06, 0x4b,
+  0x4e, 0xb4, 0x4d, 0x4b, 0x06, 0x67, 0x65, 0x4b, 0x22, 0x1f, 0xdc, 0x1f,
+  0x22, 0x4b, 0x6d, 0x6e, 0x00, 0x02, 0x00, 0x0e, 0x00, 0x2e, 0x02, 0x0e,
+  0x02, 0x2e, 0x00, 0x1f, 0x00, 0x2f, 0x00, 0x61, 0x40, 0x21, 0x0e, 0x0c,
+  0x07, 0x05, 0x04, 0x02, 0x00, 0x1f, 0x14, 0x0f, 0x04, 0x04, 0x03, 0x02,
+  0x1e, 0x1c, 0x17, 0x15, 0x04, 0x01, 0x03, 0x03, 0x47, 0x0d, 0x06, 0x02,
+  0x00, 0x45, 0x1d, 0x16, 0x02, 0x01, 0x44, 0x4b, 0xb0, 0x31, 0x50, 0x58,
+  0x40, 0x12, 0x00, 0x03, 0x00, 0x01, 0x03, 0x01, 0x5c, 0x00, 0x02, 0x02,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x12, 0x02, 0x49, 0x1b, 0x40, 0x18, 0x00,
+  0x00, 0x00, 0x02, 0x03, 0x00, 0x02, 0x60, 0x00, 0x03, 0x01, 0x01, 0x03,
+  0x54, 0x00, 0x03, 0x03, 0x01, 0x58, 0x00, 0x01, 0x03, 0x01, 0x4c, 0x59,
+  0xb6, 0x35, 0x36, 0x3d, 0x38, 0x04, 0x05, 0x18, 0x2b, 0x36, 0x35, 0x35,
+  0x34, 0x37, 0x27, 0x37, 0x17, 0x36, 0x33, 0x33, 0x32, 0x17, 0x37, 0x17,
+  0x07, 0x16, 0x15, 0x15, 0x14, 0x07, 0x17, 0x07, 0x27, 0x06, 0x23, 0x23,
+  0x22, 0x27, 0x07, 0x27, 0x37, 0x24, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15,
+  0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x49, 0x0c, 0x47,
+  0x39, 0x44, 0x25, 0x43, 0x35, 0x41, 0x27, 0x45, 0x39, 0x49, 0x0d, 0x0c,
+  0x48, 0x39, 0x43, 0x28, 0x42, 0x35, 0x45, 0x24, 0x43, 0x39, 0x47, 0x01,
+  0x28, 0x26, 0x25, 0x49, 0x25, 0x26, 0x26, 0x25, 0x49, 0x25, 0x26, 0xce,
+  0x2e, 0x62, 0x30, 0x1f, 0x48, 0x39, 0x44, 0x14, 0x15, 0x45, 0x39, 0x49,
+  0x1e, 0x30, 0x62, 0x2d, 0x20, 0x48, 0x39, 0x43, 0x15, 0x15, 0x43, 0x39,
+  0x47, 0xe3, 0x22, 0x22, 0x1f, 0x8a, 0x1f, 0x22, 0x22, 0x1f, 0x8a, 0x00,
+  0x00, 0x01, 0x00, 0x69, 0xff, 0x92, 0x01, 0xb2, 0x03, 0x0c, 0x00, 0x28,
+  0x00, 0x78, 0x40, 0x0a, 0x10, 0x01, 0x04, 0x03, 0x25, 0x01, 0x07, 0x00,
+  0x02, 0x47, 0x4b, 0xb0, 0x0b, 0x50, 0x58, 0x40, 0x28, 0x00, 0x02, 0x03,
+  0x03, 0x02, 0x63, 0x00, 0x06, 0x07, 0x07, 0x06, 0x64, 0x00, 0x03, 0x00,
+  0x04, 0x05, 0x03, 0x04, 0x61, 0x00, 0x05, 0x00, 0x01, 0x00, 0x05, 0x01,
+  0x60, 0x00, 0x00, 0x00, 0x07, 0x56, 0x08, 0x01, 0x07, 0x07, 0x10, 0x07,
+  0x49, 0x1b, 0x40, 0x26, 0x00, 0x02, 0x03, 0x02, 0x6f, 0x00, 0x06, 0x07,
+  0x06, 0x70, 0x00, 0x03, 0x00, 0x04, 0x05, 0x03, 0x04, 0x61, 0x00, 0x05,
+  0x00, 0x01, 0x00, 0x05, 0x01, 0x60, 0x00, 0x00, 0x00, 0x07, 0x56, 0x08,
+  0x01, 0x07, 0x07, 0x10, 0x07, 0x49, 0x59, 0x40, 0x10, 0x00, 0x00, 0x00,
+  0x28, 0x00, 0x28, 0x17, 0x35, 0x21, 0x11, 0x16, 0x35, 0x21, 0x09, 0x05,
+  0x1b, 0x2b, 0x33, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23,
+  0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x37, 0x35, 0x33, 0x15, 0x33, 0x15,
+  0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x16, 0x15,
+  0x15, 0x14, 0x06, 0x07, 0x15, 0x23, 0x35, 0x7a, 0x8e, 0x25, 0x2e, 0x1f,
+  0x1f, 0x14, 0x4a, 0x56, 0x7a, 0x55, 0x6a, 0x8f, 0x25, 0x2e, 0x28, 0x20,
+  0x14, 0x47, 0x4f, 0x3f, 0x3b, 0x55, 0x4c, 0x2c, 0x1f, 0x54, 0x1e, 0x25,
+  0x57, 0x53, 0x1c, 0x8a, 0x1a, 0x74, 0x6e, 0x4c, 0x2c, 0x1f, 0x42, 0x1f,
+  0x29, 0x52, 0x53, 0x2e, 0x45, 0x53, 0x0d, 0x73, 0x6e, 0x00, 0x00, 0x01,
+  0x00, 0x4f, 0xff, 0x56, 0x01, 0xe1, 0x02, 0xbc, 0x00, 0x1b, 0x00, 0x35,
+  0x40, 0x32, 0x08, 0x01, 0x07, 0x07, 0x06, 0x58, 0x00, 0x06, 0x06, 0x0f,
+  0x48, 0x04, 0x01, 0x01, 0x01, 0x00, 0x56, 0x05, 0x01, 0x00, 0x00, 0x12,
+  0x48, 0x00, 0x03, 0x03, 0x02, 0x58, 0x00, 0x02, 0x02, 0x14, 0x02, 0x49,
+  0x00, 0x00, 0x00, 0x1b, 0x00, 0x1a, 0x23, 0x11, 0x13, 0x21, 0x23, 0x11,
+  0x13, 0x09, 0x05, 0x1b, 0x2b, 0x00, 0x06, 0x15, 0x15, 0x33, 0x15, 0x23,
+  0x11, 0x14, 0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x11, 0x23,
+  0x35, 0x33, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x01, 0x49, 0x13,
+  0xa1, 0xa1, 0x3a, 0x2e, 0x7f, 0x6f, 0x10, 0x13, 0x55, 0x55, 0x3a, 0x2e,
+  0x98, 0x88, 0x02, 0x71, 0x11, 0x0d, 0x5f, 0x4b, 0xfe, 0x1b, 0x33, 0x3b,
+  0x4b, 0x11, 0x0d, 0x01, 0xea, 0x4b, 0x5a, 0x33, 0x3b, 0x4b, 0x00, 0x01,
+  0x00, 0x5c, 0x00, 0x00, 0x01, 0xbf, 0x02, 0xbc, 0x00, 0x17, 0x00, 0x2f,
+  0x40, 0x2c, 0x08, 0x01, 0x02, 0x07, 0x01, 0x03, 0x04, 0x02, 0x03, 0x5e,
+  0x00, 0x01, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f, 0x48, 0x06, 0x01,
+  0x04, 0x04, 0x05, 0x56, 0x00, 0x05, 0x05, 0x10, 0x05, 0x49, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x13, 0x21, 0x22, 0x09, 0x05, 0x1d, 0x2b, 0x13,
+  0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x33, 0x15,
+  0x23, 0x11, 0x33, 0x15, 0x21, 0x35, 0x33, 0x11, 0x23, 0x35, 0x33, 0xa2,
+  0x5d, 0x57, 0x61, 0x6b, 0x25, 0x2e, 0x80, 0x80, 0xc6, 0xfe, 0x9d, 0x46,
+  0x46, 0x46, 0x02, 0x12, 0x55, 0x55, 0x4c, 0x2c, 0x1f, 0x88, 0x49, 0xfe,
+  0xf5, 0x49, 0x49, 0x01, 0x0b, 0x49, 0x00, 0x01, 0x00, 0x37, 0x00, 0x00,
+  0x01, 0xe5, 0x02, 0xbc, 0x00, 0x16, 0x00, 0x3e, 0x40, 0x3b, 0x0b, 0x01,
+  0x03, 0x04, 0x01, 0x47, 0x06, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03,
+  0x02, 0x5f, 0x08, 0x01, 0x01, 0x09, 0x01, 0x00, 0x0a, 0x01, 0x00, 0x5e,
+  0x05, 0x01, 0x04, 0x04, 0x0f, 0x48, 0x0b, 0x01, 0x0a, 0x0a, 0x10, 0x0a,
+  0x49, 0x00, 0x00, 0x00, 0x16, 0x00, 0x16, 0x15, 0x14, 0x11, 0x11, 0x11,
+  0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0c, 0x05, 0x1d, 0x2b, 0x33, 0x35,
+  0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x03, 0x33, 0x13, 0x13, 0x33,
+  0x03, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23, 0x15, 0xe0, 0x82, 0x82,
+  0x82, 0x7f, 0xa6, 0x60, 0x7a, 0x79, 0x5b, 0xa9, 0x80, 0x82, 0x82, 0x82,
+  0x73, 0x4b, 0x4b, 0x4b, 0x01, 0x68, 0xfe, 0xef, 0x01, 0x11, 0xfe, 0x98,
+  0x4b, 0x4b, 0x4b, 0x73, 0x00, 0x02, 0x00, 0x64, 0x00, 0xaa, 0x01, 0xb8,
+  0x01, 0xca, 0x00, 0x19, 0x00, 0x33, 0x00, 0x08, 0xb5, 0x28, 0x1b, 0x0e,
+  0x01, 0x02, 0x2d, 0x2b, 0x12, 0x36, 0x33, 0x33, 0x32, 0x17, 0x16, 0x33,
+  0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22, 0x27, 0x26,
+  0x23, 0x23, 0x22, 0x06, 0x07, 0x35, 0x16, 0x36, 0x33, 0x33, 0x32, 0x17,
+  0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22,
+  0x27, 0x26, 0x23, 0x23, 0x22, 0x06, 0x07, 0x35, 0x70, 0x49, 0x0c, 0x0f,
+  0x0d, 0x36, 0x34, 0x0c, 0x0a, 0x07, 0x44, 0x0c, 0x0b, 0x42, 0x0b, 0x0f,
+  0x06, 0x2f, 0x41, 0x0c, 0x0a, 0x09, 0x4b, 0x0d, 0x0c, 0x49, 0x0c, 0x0f,
+  0x0d, 0x36, 0x34, 0x0c, 0x0a, 0x07, 0x44, 0x0c, 0x0b, 0x42, 0x0b, 0x0f,
+  0x06, 0x2f, 0x41, 0x0c, 0x0a, 0x09, 0x4b, 0x0d, 0x01, 0xad, 0x1d, 0x14,
+  0x14, 0x1e, 0x06, 0x50, 0x06, 0x1d, 0x11, 0x17, 0x1e, 0x06, 0x50, 0xa3,
+  0x1d, 0x14, 0x14, 0x1e, 0x06, 0x50, 0x06, 0x1d, 0x11, 0x17, 0x1e, 0x06,
+  0x50, 0x00, 0x00, 0x01, 0x00, 0x64, 0x01, 0x06, 0x01, 0xb8, 0x01, 0x7d,
+  0x00, 0x19, 0x00, 0x2e, 0x40, 0x2b, 0x19, 0x0b, 0x02, 0x01, 0x00, 0x18,
+  0x0c, 0x02, 0x02, 0x03, 0x02, 0x47, 0x00, 0x01, 0x03, 0x02, 0x01, 0x54,
+  0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x03, 0x60, 0x00, 0x01, 0x01, 0x02,
+  0x58, 0x00, 0x02, 0x01, 0x02, 0x4c, 0x33, 0x26, 0x22, 0x31, 0x04, 0x05,
+  0x18, 0x2b, 0x12, 0x36, 0x33, 0x33, 0x32, 0x17, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x23, 0x22, 0x27, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x07, 0x35, 0x70, 0x49, 0x0c, 0x0f, 0x0d, 0x36, 0x34, 0x0c,
+  0x0a, 0x07, 0x44, 0x0c, 0x0b, 0x42, 0x0b, 0x0f, 0x06, 0x2f, 0x41, 0x0c,
+  0x0a, 0x09, 0x4b, 0x0d, 0x01, 0x60, 0x1d, 0x14, 0x14, 0x1e, 0x06, 0x50,
+  0x06, 0x1d, 0x11, 0x17, 0x1e, 0x06, 0x50, 0x00, 0x00, 0x03, 0x00, 0x50,
+  0x00, 0x41, 0x01, 0xcc, 0x02, 0x30, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0b,
+  0x00, 0x41, 0x40, 0x3e, 0x06, 0x01, 0x01, 0x00, 0x00, 0x03, 0x01, 0x00,
+  0x5e, 0x07, 0x01, 0x03, 0x00, 0x02, 0x05, 0x03, 0x02, 0x5e, 0x08, 0x01,
+  0x05, 0x04, 0x04, 0x05, 0x52, 0x08, 0x01, 0x05, 0x05, 0x04, 0x56, 0x00,
+  0x04, 0x05, 0x04, 0x4a, 0x08, 0x08, 0x04, 0x04, 0x00, 0x00, 0x08, 0x0b,
+  0x08, 0x0b, 0x0a, 0x09, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03,
+  0x00, 0x03, 0x11, 0x09, 0x05, 0x15, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x17,
+  0x15, 0x21, 0x35, 0x17, 0x15, 0x23, 0x35, 0x01, 0x40, 0x64, 0xf0, 0xfe,
+  0x84, 0xf0, 0x64, 0x02, 0x30, 0x64, 0x64, 0xd2, 0x4b, 0x4b, 0xb9, 0x64,
+  0x64, 0x00, 0x00, 0x01, 0x00, 0xdc, 0x01, 0x04, 0x01, 0x40, 0x01, 0x68,
+  0x00, 0x03, 0x00, 0x06, 0xb3, 0x01, 0x00, 0x01, 0x2d, 0x2b, 0x01, 0x15,
+  0x23, 0x35, 0x01, 0x40, 0x64, 0x01, 0x68, 0x64, 0x64, 0x00, 0x00, 0x02,
+  0x00, 0x50, 0x00, 0xaf, 0x01, 0xcc, 0x01, 0xc2, 0x00, 0x03, 0x00, 0x07,
+  0x00, 0x30, 0x40, 0x2d, 0x04, 0x01, 0x01, 0x00, 0x00, 0x03, 0x01, 0x00,
+  0x5e, 0x05, 0x01, 0x03, 0x02, 0x02, 0x03, 0x52, 0x05, 0x01, 0x03, 0x03,
+  0x02, 0x56, 0x00, 0x02, 0x03, 0x02, 0x4a, 0x04, 0x04, 0x00, 0x00, 0x04,
+  0x07, 0x04, 0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x06, 0x05,
+  0x15, 0x2b, 0x01, 0x15, 0x21, 0x35, 0x05, 0x15, 0x21, 0x35, 0x01, 0xcc,
+  0xfe, 0x84, 0x01, 0x7c, 0xfe, 0x84, 0x01, 0xc2, 0x4b, 0x4b, 0xc8, 0x4b,
+  0x4b, 0x00, 0x00, 0x01, 0x00, 0x50, 0x00, 0x69, 0x01, 0xcc, 0x02, 0x34,
+  0x00, 0x06, 0x00, 0x06, 0xb3, 0x05, 0x02, 0x01, 0x2d, 0x2b, 0x01, 0x25,
+  0x35, 0x05, 0x15, 0x05, 0x35, 0x01, 0x8c, 0xfe, 0xc4, 0x01, 0x7c, 0xfe,
+  0x84, 0x01, 0x50, 0x88, 0x5c, 0xb3, 0x69, 0xaf, 0x5e, 0x00, 0x00, 0x02,
+  0x00, 0x50, 0x00, 0x00, 0x01, 0xcc, 0x02, 0x34, 0x00, 0x06, 0x00, 0x0a,
+  0x00, 0x08, 0xb5, 0x08, 0x07, 0x05, 0x02, 0x02, 0x2d, 0x2b, 0x01, 0x25,
+  0x35, 0x05, 0x15, 0x05, 0x35, 0x05, 0x15, 0x21, 0x35, 0x01, 0x84, 0xfe,
+  0xcc, 0x01, 0x7c, 0xfe, 0x84, 0x01, 0x7c, 0xfe, 0x84, 0x01, 0x50, 0x88,
+  0x5c, 0xb3, 0x69, 0x9b, 0x5e, 0x90, 0x4b, 0x4b, 0x00, 0x03, 0x00, 0x0d,
+  0x00, 0x8d, 0x02, 0x0f, 0x01, 0xdb, 0x00, 0x1d, 0x00, 0x2d, 0x00, 0x3d,
+  0x00, 0x0a, 0xb7, 0x37, 0x2f, 0x27, 0x1f, 0x09, 0x01, 0x03, 0x2d, 0x2b,
+  0x36, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33,
+  0x32, 0x16, 0x17, 0x36, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14,
+  0x06, 0x23, 0x23, 0x22, 0x26, 0x27, 0x26, 0x16, 0x33, 0x33, 0x32, 0x36,
+  0x37, 0x35, 0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x24, 0x26,
+  0x23, 0x23, 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36,
+  0x35, 0x35, 0xfb, 0x31, 0x26, 0x0a, 0x4f, 0x3e, 0x3e, 0x4f, 0x0a, 0x26,
+  0x33, 0x13, 0x13, 0x2f, 0x26, 0x0a, 0x4f, 0x3e, 0x3f, 0x4e, 0x0a, 0x26,
+  0x31, 0x13, 0xb0, 0x1d, 0x24, 0x07, 0x1f, 0x1e, 0x02, 0x1f, 0x20, 0x07,
+  0x26, 0x1d, 0x01, 0x62, 0x1d, 0x24, 0x07, 0x1f, 0x1e, 0x02, 0x1f, 0x20,
+  0x07, 0x26, 0x1d, 0xa7, 0x1a, 0x4d, 0x50, 0x14, 0x50, 0x4d, 0x1a, 0x1b,
+  0x1b, 0x1a, 0x4d, 0x50, 0x0f, 0x50, 0x52, 0x1a, 0x1b, 0x2e, 0x1d, 0x23,
+  0x1e, 0x3a, 0x20, 0x27, 0x21, 0x26, 0x3c, 0x66, 0x1d, 0x23, 0x1e, 0x3a,
+  0x20, 0x27, 0x21, 0x26, 0x3c, 0x00, 0x00, 0x01, 0x00, 0x45, 0xff, 0x15,
+  0x01, 0xd7, 0x03, 0x34, 0x00, 0x13, 0x00, 0x06, 0xb3, 0x0f, 0x05, 0x01,
+  0x2d, 0x2b, 0x16, 0x36, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23,
+  0x22, 0x06, 0x15, 0x11, 0x14, 0x06, 0x23, 0x23, 0x35, 0x33, 0xce, 0x13,
+  0x3a, 0x2e, 0x8e, 0x7e, 0x10, 0x13, 0x3a, 0x2e, 0x89, 0x79, 0xa0, 0x11,
+  0x0d, 0x03, 0x48, 0x33, 0x3b, 0x4b, 0x11, 0x0d, 0xfc, 0xb8, 0x33, 0x3b,
+  0x4b, 0x00, 0x00, 0x01, 0x00, 0x50, 0x00, 0x69, 0x01, 0xcc, 0x02, 0x34,
+  0x00, 0x06, 0x00, 0x06, 0xb3, 0x04, 0x00, 0x01, 0x2d, 0x2b, 0x01, 0x15,
+  0x05, 0x05, 0x15, 0x25, 0x35, 0x01, 0xcc, 0xfe, 0xca, 0x01, 0x36, 0xfe,
+  0x84, 0x02, 0x34, 0x5c, 0x88, 0x89, 0x5e, 0xaf, 0x69, 0x00, 0x00, 0x02,
+  0x00, 0x50, 0x00, 0x00, 0x01, 0xcc, 0x02, 0x34, 0x00, 0x06, 0x00, 0x0a,
+  0x00, 0x08, 0xb5, 0x08, 0x07, 0x04, 0x00, 0x02, 0x2d, 0x2b, 0x01, 0x15,
+  0x05, 0x05, 0x15, 0x25, 0x35, 0x01, 0x15, 0x21, 0x35, 0x01, 0xcc, 0xfe,
+  0xcc, 0x01, 0x34, 0xfe, 0x84, 0x01, 0x7c, 0xfe, 0x84, 0x02, 0x34, 0x5c,
+  0x88, 0x75, 0x5e, 0x9b, 0x69, 0xfe, 0xca, 0x4b, 0x4b, 0x00, 0x00, 0x01,
+  0x00, 0xdc, 0x01, 0x04, 0x01, 0x40, 0x01, 0x68, 0x00, 0x03, 0x00, 0x06,
+  0xb3, 0x01, 0x00, 0x01, 0x2d, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x01, 0x40,
+  0x64, 0x01, 0x68, 0x64, 0x64, 0x00, 0x00, 0x01, 0x00, 0x3e, 0x00, 0x6a,
+  0x01, 0xdd, 0x01, 0x5e, 0x00, 0x05, 0x00, 0x24, 0x40, 0x21, 0x00, 0x01,
+  0x02, 0x01, 0x70, 0x00, 0x00, 0x02, 0x02, 0x00, 0x52, 0x00, 0x00, 0x00,
+  0x02, 0x56, 0x03, 0x01, 0x02, 0x00, 0x02, 0x4a, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x05, 0x11, 0x11, 0x04, 0x05, 0x16, 0x2b, 0x13, 0x35, 0x21, 0x15,
+  0x23, 0x35, 0x3e, 0x01, 0x9f, 0x55, 0x01, 0x13, 0x4b, 0xf4, 0xa9, 0x00,
+  0x00, 0x01, 0x00, 0x50, 0x01, 0x13, 0x01, 0xcc, 0x01, 0x5e, 0x00, 0x03,
+  0x00, 0x06, 0xb3, 0x01, 0x00, 0x01, 0x2d, 0x2b, 0x01, 0x15, 0x21, 0x35,
+  0x01, 0xcc, 0xfe, 0x84, 0x01, 0x5e, 0x4b, 0x4b, 0x00, 0x01, 0x00, 0x61,
+  0x00, 0x89, 0x01, 0xbb, 0x01, 0xe3, 0x00, 0x0b, 0x00, 0x06, 0xb3, 0x09,
+  0x03, 0x01, 0x2d, 0x2b, 0x37, 0x37, 0x27, 0x37, 0x17, 0x37, 0x17, 0x07,
+  0x17, 0x07, 0x27, 0x07, 0x61, 0x74, 0x74, 0x38, 0x75, 0x75, 0x38, 0x74,
+  0x74, 0x38, 0x75, 0x75, 0xc1, 0x75, 0x75, 0x38, 0x74, 0x74, 0x38, 0x75,
+  0x75, 0x38, 0x74, 0x74, 0x00, 0x01, 0x00, 0x50, 0x00, 0x46, 0x01, 0xcc,
+  0x02, 0x2b, 0x00, 0x13, 0x00, 0x06, 0xb3, 0x0d, 0x03, 0x01, 0x2d, 0x2b,
+  0x25, 0x15, 0x23, 0x07, 0x23, 0x37, 0x23, 0x35, 0x33, 0x37, 0x23, 0x35,
+  0x33, 0x37, 0x33, 0x07, 0x33, 0x15, 0x23, 0x07, 0x01, 0xcc, 0xeb, 0x41,
+  0x50, 0x41, 0x41, 0x6f, 0x4e, 0xbd, 0xeb, 0x41, 0x50, 0x41, 0x41, 0x6f,
+  0x4e, 0xfa, 0x4b, 0x69, 0x69, 0x4b, 0x7d, 0x4b, 0x69, 0x69, 0x4b, 0x7d,
+  0x00, 0x02, 0x00, 0x60, 0x00, 0x00, 0x01, 0xbf, 0x02, 0xbc, 0x00, 0x16,
+  0x00, 0x23, 0x00, 0x08, 0xb5, 0x1c, 0x17, 0x10, 0x09, 0x02, 0x2d, 0x2b,
+  0x12, 0x36, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x32,
+  0x16, 0x15, 0x11, 0x14, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x36,
+  0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x23,
+  0x60, 0x52, 0x56, 0x62, 0x2e, 0x25, 0x87, 0x7d, 0x57, 0x5b, 0x5a, 0x44,
+  0x23, 0x44, 0x5a, 0x7a, 0x25, 0x2a, 0x24, 0x19, 0x24, 0x2a, 0x6c, 0x01,
+  0x6c, 0x4c, 0x6d, 0x1f, 0x2c, 0x4c, 0x55, 0x55, 0xfe, 0x98, 0x52, 0x58,
+  0x58, 0x52, 0x6e, 0x55, 0x23, 0x1f, 0x94, 0x20, 0x2c, 0x2c, 0x20, 0xd6,
+  0x00, 0x05, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x0f, 0x02, 0xbc, 0x00, 0x0f,
+  0x00, 0x1f, 0x00, 0x23, 0x00, 0x33, 0x00, 0x43, 0x00, 0x42, 0x40, 0x3f,
+  0x20, 0x01, 0x00, 0x03, 0x23, 0x21, 0x02, 0x05, 0x00, 0x22, 0x01, 0x06,
+  0x05, 0x03, 0x47, 0x00, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x60, 0x00,
+  0x05, 0x00, 0x06, 0x07, 0x05, 0x06, 0x60, 0x00, 0x02, 0x02, 0x01, 0x58,
+  0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x07, 0x07, 0x04, 0x58, 0x00, 0x04,
+  0x04, 0x10, 0x04, 0x49, 0x35, 0x35, 0x35, 0x39, 0x35, 0x35, 0x35, 0x31,
+  0x08, 0x05, 0x1c, 0x2b, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35,
+  0x05, 0x15, 0x05, 0x35, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35,
+  0x01, 0x21, 0x40, 0x3a, 0x08, 0x3a, 0x40, 0x40, 0x3a, 0x08, 0x3a, 0x40,
+  0x46, 0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x01,
+  0x34, 0xfd, 0xfd, 0x01, 0xe7, 0x40, 0x3a, 0x08, 0x3a, 0x40, 0x40, 0x3a,
+  0x08, 0x3a, 0x40, 0x46, 0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x1a, 0x1a, 0x08,
+  0x1a, 0x1a, 0x01, 0xd5, 0x41, 0x41, 0x3f, 0x28, 0x3f, 0x41, 0x41, 0x3f,
+  0x28, 0x4c, 0x20, 0x20, 0x19, 0x3e, 0x19, 0x20, 0x20, 0x19, 0x3e, 0xa7,
+  0x3e, 0x49, 0x3e, 0xfe, 0xea, 0x41, 0x41, 0x3f, 0x28, 0x3f, 0x41, 0x41,
+  0x3f, 0x28, 0x4c, 0x20, 0x20, 0x19, 0x3e, 0x19, 0x20, 0x20, 0x19, 0x3e,
+  0x00, 0x07, 0x00, 0x09, 0x00, 0x00, 0x02, 0x13, 0x02, 0xbc, 0x00, 0x0f,
+  0x00, 0x1f, 0x00, 0x23, 0x00, 0x33, 0x00, 0x43, 0x00, 0x53, 0x00, 0x63,
+  0x00, 0x4a, 0x40, 0x47, 0x20, 0x01, 0x00, 0x03, 0x23, 0x22, 0x21, 0x03,
+  0x05, 0x00, 0x02, 0x47, 0x00, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x60,
+  0x07, 0x01, 0x05, 0x0a, 0x01, 0x08, 0x09, 0x05, 0x08, 0x60, 0x00, 0x02,
+  0x02, 0x01, 0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x0b, 0x01, 0x09, 0x09,
+  0x04, 0x58, 0x06, 0x01, 0x04, 0x04, 0x10, 0x04, 0x49, 0x60, 0x5d, 0x58,
+  0x55, 0x50, 0x4d, 0x35, 0x35, 0x35, 0x35, 0x39, 0x35, 0x35, 0x35, 0x31,
+  0x0c, 0x05, 0x1d, 0x2b, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23,
+  0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35,
+  0x05, 0x15, 0x05, 0x35, 0x12, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x04, 0x06, 0x23, 0x23,
+  0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15,
+  0x24, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33,
+  0x32, 0x36, 0x35, 0x35, 0x24, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0x05, 0x40, 0x3a,
+  0x08, 0x3a, 0x40, 0x40, 0x3a, 0x08, 0x3a, 0x40, 0x46, 0x1a, 0x1a, 0x08,
+  0x1a, 0x1a, 0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x01, 0x52, 0xfd, 0xfd, 0xf7,
+  0x40, 0x3a, 0x08, 0x3a, 0x40, 0x40, 0x3a, 0x08, 0x3a, 0x40, 0x01, 0x0e,
+  0x40, 0x3a, 0x08, 0x3a, 0x40, 0x40, 0x3a, 0x08, 0x3a, 0x40, 0xfe, 0xac,
+  0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x01, 0x0e,
+  0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x1a, 0x1a, 0x08, 0x1a, 0x1a, 0x01, 0xd5,
+  0x41, 0x41, 0x3f, 0x28, 0x3f, 0x41, 0x41, 0x3f, 0x28, 0x4c, 0x20, 0x20,
+  0x19, 0x3e, 0x19, 0x20, 0x20, 0x19, 0x3e, 0x93, 0x3e, 0x49, 0x3e, 0xfe,
+  0xd6, 0x41, 0x41, 0x3f, 0x28, 0x3f, 0x41, 0x41, 0x3f, 0x28, 0x3f, 0x41,
+  0x41, 0x3f, 0x28, 0x3f, 0x41, 0x41, 0x3f, 0x28, 0x4c, 0x20, 0x20, 0x19,
+  0x3e, 0x19, 0x20, 0x20, 0x19, 0x3e, 0x19, 0x20, 0x20, 0x19, 0x3e, 0x19,
+  0x20, 0x20, 0x19, 0x3e, 0x00, 0x01, 0x00, 0x4f, 0x00, 0x76, 0x01, 0xcc,
+  0x01, 0xfc, 0x00, 0x0b, 0x00, 0x27, 0x40, 0x24, 0x03, 0x01, 0x01, 0x04,
+  0x01, 0x00, 0x05, 0x01, 0x00, 0x5e, 0x06, 0x01, 0x05, 0x05, 0x02, 0x56,
+  0x00, 0x02, 0x02, 0x12, 0x05, 0x49, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x0b,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x07, 0x05, 0x19, 0x2b, 0x37, 0x35, 0x23,
+  0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x15, 0xe6, 0x97, 0x97,
+  0x50, 0x96, 0x96, 0x76, 0x9d, 0x4b, 0x9e, 0x9e, 0x4b, 0x9d, 0x00, 0x02,
+  0x00, 0x50, 0x00, 0x00, 0x01, 0xcc, 0x01, 0xfc, 0x00, 0x0b, 0x00, 0x0f,
+  0x00, 0x3a, 0x40, 0x37, 0x03, 0x01, 0x01, 0x04, 0x01, 0x00, 0x05, 0x01,
+  0x00, 0x5e, 0x08, 0x01, 0x05, 0x05, 0x02, 0x56, 0x00, 0x02, 0x02, 0x12,
+  0x48, 0x09, 0x01, 0x07, 0x07, 0x06, 0x56, 0x00, 0x06, 0x06, 0x10, 0x06,
+  0x49, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x0f, 0x0c, 0x0f, 0x0e, 0x0d, 0x00,
+  0x0b, 0x00, 0x0b, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x05, 0x19, 0x2b,
+  0x37, 0x35, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x15,
+  0x17, 0x15, 0x21, 0x35, 0xe6, 0x96, 0x96, 0x50, 0x96, 0x96, 0x96, 0xfe,
+  0x84, 0x8f, 0x84, 0x4b, 0x9e, 0x9e, 0x4b, 0x84, 0x44, 0x4b, 0x4b, 0x00,
+  0x00, 0x01, 0x00, 0x2b, 0x00, 0x00, 0x01, 0xf1, 0x02, 0xbc, 0x00, 0x13,
+  0x00, 0x06, 0xb3, 0x0a, 0x01, 0x01, 0x2d, 0x2b, 0x13, 0x35, 0x21, 0x15,
+  0x23, 0x11, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x22, 0x26, 0x35, 0x11,
+  0x23, 0x11, 0x23, 0x11, 0x2b, 0x01, 0xc6, 0x5b, 0x0e, 0x13, 0x0f, 0x32,
+  0x22, 0x33, 0x6e, 0x57, 0x02, 0x71, 0x4b, 0x4b, 0xfd, 0xf8, 0x10, 0x0e,
+  0x4b, 0x30, 0x34, 0x02, 0x0d, 0xfd, 0x8f, 0x02, 0x71, 0x00, 0x00, 0x01,
+  0x00, 0x16, 0x00, 0x00, 0x02, 0x05, 0x03, 0x34, 0x00, 0x08, 0x00, 0x06,
+  0xb3, 0x04, 0x00, 0x01, 0x2d, 0x2b, 0x33, 0x03, 0x33, 0x13, 0x13, 0x33,
+  0x15, 0x23, 0x03, 0x79, 0x63, 0x59, 0x48, 0x9d, 0xb1, 0x6a, 0xa5, 0x01,
+  0x88, 0xfe, 0xc9, 0x02, 0xe3, 0x4b, 0xfd, 0x17, 0x00, 0x01, 0x00, 0x4d,
+  0xff, 0x56, 0x01, 0xce, 0x02, 0xbc, 0x00, 0x0b, 0x00, 0x06, 0xb3, 0x09,
+  0x02, 0x01, 0x2d, 0x2b, 0x13, 0x03, 0x35, 0x21, 0x15, 0x21, 0x13, 0x03,
+  0x21, 0x15, 0x21, 0x35, 0xf5, 0x9b, 0x01, 0x69, 0xfe, 0xef, 0xa2, 0xb1,
+  0x01, 0x2b, 0xfe, 0x7f, 0x01, 0x0b, 0x01, 0x52, 0x5f, 0x4b, 0xfe, 0x9a,
+  0xfe, 0x95, 0x4a, 0x5e, 0x00, 0x01, 0x00, 0x46, 0xff, 0x9c, 0x01, 0xd6,
+  0x03, 0x2a, 0x00, 0x03, 0x00, 0x06, 0xb3, 0x02, 0x00, 0x01, 0x2d, 0x2b,
+  0x01, 0x33, 0x01, 0x23, 0x01, 0x86, 0x50, 0xfe, 0xc0, 0x50, 0x03, 0x2a,
+  0xfc, 0x72, 0x00, 0x01, 0x00, 0xdc, 0x01, 0x04, 0x01, 0x40, 0x01, 0x68,
+  0x00, 0x03, 0x00, 0x06, 0xb3, 0x01, 0x00, 0x01, 0x2d, 0x2b, 0x01, 0x15,
+  0x23, 0x35, 0x01, 0x40, 0x64, 0x01, 0x68, 0x64, 0x64, 0x00, 0x00, 0x01,
+  0x00, 0xdc, 0x01, 0x04, 0x01, 0x40, 0x01, 0x68, 0x00, 0x03, 0x00, 0x06,
+  0xb3, 0x01, 0x00, 0x01, 0x2d, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x01, 0x40,
+  0x64, 0x01, 0x68, 0x64, 0x64, 0x00, 0x00, 0x02, 0x00, 0x4b, 0x00, 0x00,
+  0x01, 0xd1, 0x02, 0xbc, 0x00, 0x05, 0x00, 0x09, 0x00, 0x08, 0xb5, 0x08,
+  0x06, 0x04, 0x01, 0x02, 0x2d, 0x2b, 0x13, 0x13, 0x33, 0x13, 0x03, 0x23,
+  0x37, 0x13, 0x03, 0x03, 0x4b, 0x8c, 0x6e, 0x8c, 0x8c, 0x70, 0x39, 0x6c,
+  0x6c, 0x6c, 0x01, 0x5e, 0x01, 0x5e, 0xfe, 0xa2, 0xfe, 0xa2, 0x46, 0x01,
+  0x18, 0x01, 0x18, 0xfe, 0xe8, 0x00, 0x00, 0x02, 0x00, 0x54, 0x00, 0x00,
+  0x01, 0xc8, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x07, 0x00, 0x08, 0xb5, 0x05,
+  0x04, 0x02, 0x00, 0x02, 0x2d, 0x2b, 0x21, 0x21, 0x11, 0x21, 0x05, 0x11,
+  0x33, 0x11, 0x01, 0xc8, 0xfe, 0x8c, 0x01, 0x74, 0xfe, 0xd7, 0xde, 0x02,
+  0xbc, 0x48, 0xfd, 0xd4, 0x02, 0x2c, 0x00, 0x08, 0xff, 0xe2, 0x00, 0x17,
+  0x02, 0x3a, 0x02, 0x1b, 0x00, 0x12, 0x00, 0x27, 0x00, 0x3c, 0x00, 0x48,
+  0x00, 0x54, 0x00, 0x5e, 0x00, 0x73, 0x00, 0x88, 0x00, 0x15, 0x40, 0x12,
+  0x87, 0x81, 0x72, 0x61, 0x58, 0x55, 0x4d, 0x49, 0x41, 0x3d, 0x32, 0x28,
+  0x17, 0x13, 0x08, 0x00, 0x08, 0x2d, 0x2b, 0x00, 0x16, 0x16, 0x15, 0x14,
+  0x07, 0x15, 0x07, 0x07, 0x23, 0x27, 0x27, 0x35, 0x26, 0x35, 0x34, 0x36,
+  0x36, 0x33, 0x06, 0x16, 0x17, 0x17, 0x15, 0x27, 0x06, 0x06, 0x23, 0x22,
+  0x26, 0x35, 0x34, 0x36, 0x37, 0x37, 0x26, 0x35, 0x34, 0x36, 0x33, 0x20,
+  0x16, 0x15, 0x14, 0x07, 0x17, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22,
+  0x26, 0x27, 0x07, 0x35, 0x37, 0x36, 0x36, 0x33, 0x04, 0x06, 0x15, 0x14,
+  0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x32, 0x06, 0x15, 0x14,
+  0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x06, 0x06, 0x07, 0x15,
+  0x37, 0x17, 0x35, 0x26, 0x26, 0x23, 0x07, 0x06, 0x06, 0x23, 0x22, 0x26,
+  0x35, 0x34, 0x37, 0x27, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16,
+  0x17, 0x37, 0x17, 0x24, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23,
+  0x07, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x27, 0x37, 0x17,
+  0x01, 0x3c, 0x4a, 0x2a, 0x1c, 0x1a, 0x2b, 0x81, 0x2b, 0x19, 0x1d, 0x2a,
+  0x4a, 0x2e, 0xe0, 0x11, 0x05, 0x1c, 0x33, 0x11, 0x15, 0x0b, 0x0b, 0x10,
+  0x12, 0x0f, 0x0d, 0x08, 0x0c, 0x0a, 0x01, 0xeb, 0x0c, 0x08, 0x0d, 0x0e,
+  0x12, 0x10, 0x0a, 0x0b, 0x15, 0x12, 0x33, 0x1c, 0x05, 0x11, 0x12, 0xfe,
+  0xb6, 0x17, 0x17, 0x10, 0x11, 0x17, 0x17, 0x11, 0x82, 0x17, 0x17, 0x11,
+  0x10, 0x18, 0x18, 0x10, 0x51, 0x15, 0x06, 0x23, 0x22, 0x06, 0x14, 0x08,
+  0xb3, 0x03, 0x10, 0x0f, 0x0c, 0x0e, 0x05, 0x0d, 0x0e, 0x15, 0x0f, 0x0d,
+  0x09, 0x17, 0x0f, 0x48, 0x1a, 0x01, 0x4a, 0x18, 0x09, 0x0c, 0x0f, 0x14,
+  0x0e, 0x0e, 0x06, 0x0f, 0x0c, 0x0f, 0x10, 0x03, 0x45, 0x1a, 0x47, 0x02,
+  0x1b, 0x28, 0x46, 0x2b, 0x39, 0x2d, 0x34, 0x12, 0x4b, 0x4b, 0x12, 0x34,
+  0x2c, 0x3a, 0x2b, 0x46, 0x28, 0xac, 0x20, 0x1a, 0x10, 0x37, 0x15, 0x0b,
+  0x08, 0x0b, 0x0b, 0x0c, 0x11, 0x02, 0x1b, 0x09, 0x0e, 0x09, 0x0f, 0x0f,
+  0x09, 0x0e, 0x09, 0x1b, 0x02, 0x11, 0x0c, 0x0a, 0x0c, 0x08, 0x0b, 0x11,
+  0x33, 0x10, 0x1a, 0x20, 0x05, 0x17, 0x11, 0x11, 0x18, 0x18, 0x11, 0x11,
+  0x17, 0x17, 0x11, 0x11, 0x18, 0x19, 0x10, 0x11, 0x17, 0x52, 0x1d, 0x10,
+  0x1d, 0x07, 0x07, 0x1d, 0x10, 0x1d, 0xc1, 0x1e, 0x22, 0x10, 0x0c, 0x07,
+  0x0d, 0x18, 0x11, 0x0c, 0x0b, 0x0e, 0x09, 0x07, 0x27, 0x2a, 0x0a, 0x09,
+  0x0e, 0x0b, 0x0c, 0x11, 0x18, 0x0c, 0x08, 0x0c, 0x10, 0x22, 0x1e, 0x2b,
+  0x2a, 0x27, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x02, 0x1c, 0x02, 0x1b,
+  0x00, 0x0f, 0x00, 0x1f, 0x00, 0x2b, 0x00, 0x37, 0x00, 0x43, 0x00, 0x0f,
+  0x40, 0x0c, 0x3d, 0x39, 0x30, 0x2c, 0x24, 0x20, 0x16, 0x10, 0x06, 0x00,
+  0x05, 0x2d, 0x2b, 0x00, 0x16, 0x16, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22,
+  0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x0e, 0x02, 0x15, 0x14, 0x16,
+  0x16, 0x33, 0x32, 0x36, 0x36, 0x35, 0x34, 0x26, 0x26, 0x23, 0x06, 0x16,
+  0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16,
+  0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x16, 0x06,
+  0x23, 0x22, 0x26, 0x27, 0x33, 0x16, 0x33, 0x32, 0x37, 0x33, 0x01, 0x57,
+  0x7c, 0x49, 0x49, 0x7c, 0x49, 0x4a, 0x7c, 0x48, 0x48, 0x7c, 0x4a, 0x3b,
+  0x60, 0x38, 0x38, 0x60, 0x3b, 0x3a, 0x61, 0x38, 0x38, 0x61, 0x3a, 0x3d,
+  0x1b, 0x1b, 0x15, 0x15, 0x1b, 0x1b, 0x15, 0xb5, 0x1b, 0x1b, 0x15, 0x15,
+  0x1b, 0x1b, 0x15, 0x3a, 0x4e, 0x3a, 0x3a, 0x4e, 0x07, 0x2c, 0x16, 0x4d,
+  0x4d, 0x16, 0x2c, 0x02, 0x1b, 0x48, 0x7c, 0x49, 0x4a, 0x7c, 0x48, 0x48,
+  0x7c, 0x4a, 0x49, 0x7c, 0x48, 0x34, 0x3b, 0x64, 0x3a, 0x3b, 0x64, 0x3b,
+  0x3b, 0x64, 0x3b, 0x3a, 0x64, 0x3b, 0x60, 0x1a, 0x13, 0x14, 0x1b, 0x1b,
+  0x14, 0x13, 0x1a, 0x1a, 0x13, 0x14, 0x1b, 0x1b, 0x14, 0x13, 0x1a, 0xd0,
+  0x4d, 0x4d, 0x39, 0x59, 0x59, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+  0x02, 0x1c, 0x02, 0x1b, 0x00, 0x0f, 0x00, 0x1b, 0x00, 0x27, 0x00, 0x35,
+  0x00, 0x0d, 0x40, 0x0a, 0x30, 0x2d, 0x20, 0x1c, 0x14, 0x10, 0x06, 0x00,
+  0x04, 0x2d, 0x2b, 0x00, 0x16, 0x16, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22,
+  0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x06, 0x06, 0x15, 0x14, 0x16,
+  0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x32, 0x06, 0x15, 0x14, 0x16,
+  0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x16, 0x06, 0x23, 0x22, 0x26,
+  0x27, 0x23, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x23, 0x01, 0x57, 0x7c,
+  0x49, 0x49, 0x7c, 0x49, 0x4a, 0x7c, 0x48, 0x48, 0x7c, 0x4a, 0x6c, 0x1b,
+  0x1b, 0x15, 0x15, 0x1b, 0x1b, 0x15, 0x95, 0x1b, 0x1b, 0x15, 0x15, 0x1b,
+  0x1b, 0x15, 0x0b, 0x35, 0x29, 0x29, 0x35, 0x0a, 0x2b, 0x07, 0x52, 0x3a,
+  0x3a, 0x52, 0x07, 0x2b, 0x02, 0x1b, 0x48, 0x7c, 0x49, 0x4a, 0x7c, 0x48,
+  0x48, 0x7c, 0x4a, 0x49, 0x7c, 0x48, 0x8f, 0x1a, 0x13, 0x14, 0x1b, 0x1b,
+  0x14, 0x13, 0x1a, 0x1a, 0x13, 0x14, 0x1b, 0x1b, 0x14, 0x13, 0x1a, 0xca,
+  0x30, 0x30, 0x29, 0x38, 0x4d, 0x4d, 0x38, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x02, 0x1c, 0x02, 0x0f, 0x00, 0x27, 0x00, 0x33, 0x00, 0x08,
+  0xb5, 0x2c, 0x28, 0x25, 0x11, 0x02, 0x2d, 0x2b, 0x00, 0x17, 0x37, 0x17,
+  0x07, 0x16, 0x17, 0x33, 0x15, 0x23, 0x06, 0x07, 0x17, 0x07, 0x27, 0x06,
+  0x07, 0x15, 0x23, 0x35, 0x26, 0x27, 0x07, 0x27, 0x37, 0x26, 0x27, 0x23,
+  0x35, 0x33, 0x36, 0x37, 0x27, 0x37, 0x17, 0x36, 0x37, 0x35, 0x33, 0x15,
+  0x06, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23,
+  0x01, 0x4a, 0x20, 0x51, 0x24, 0x51, 0x19, 0x06, 0x6f, 0x6f, 0x06, 0x17,
+  0x4f, 0x24, 0x4f, 0x20, 0x26, 0x30, 0x28, 0x1e, 0x4f, 0x24, 0x4f, 0x18,
+  0x05, 0x6f, 0x6f, 0x06, 0x18, 0x50, 0x24, 0x50, 0x21, 0x24, 0x30, 0x48,
+  0x3d, 0x3d, 0x30, 0x30, 0x3e, 0x3e, 0x30, 0x01, 0xa0, 0x17, 0x52, 0x24,
+  0x50, 0x1f, 0x29, 0x2f, 0x28, 0x1d, 0x4e, 0x24, 0x50, 0x15, 0x06, 0x6e,
+  0x6e, 0x06, 0x15, 0x50, 0x24, 0x4e, 0x22, 0x23, 0x2f, 0x28, 0x20, 0x50,
+  0x24, 0x52, 0x17, 0x04, 0x6b, 0x6b, 0x2c, 0x40, 0x30, 0x30, 0x3f, 0x3f,
+  0x30, 0x30, 0x40, 0x00, 0x00, 0x01, 0x00, 0x28, 0x00, 0x00, 0x01, 0xf4,
+  0x02, 0x1b, 0x00, 0x1a, 0x00, 0x06, 0xb3, 0x1a, 0x0c, 0x01, 0x2d, 0x2b,
+  0x00, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x17, 0x33,
+  0x17, 0x21, 0x37, 0x33, 0x37, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34,
+  0x36, 0x36, 0x37, 0x01, 0x69, 0x56, 0x35, 0x35, 0x2d, 0x26, 0x37, 0x15,
+  0x10, 0x9c, 0x28, 0xfe, 0x34, 0x28, 0x9c, 0x10, 0x15, 0x37, 0x26, 0x2d,
+  0x35, 0x35, 0x56, 0x5b, 0x01, 0xc7, 0x57, 0x56, 0x2b, 0x30, 0x39, 0x20,
+  0x22, 0x87, 0x41, 0x41, 0x87, 0x22, 0x20, 0x39, 0x30, 0x2b, 0x56, 0x57,
+  0x54, 0x00, 0x00, 0x01, 0x00, 0x28, 0x00, 0x00, 0x01, 0xf4, 0x02, 0x1b,
+  0x00, 0x2a, 0x00, 0x06, 0xb3, 0x14, 0x00, 0x01, 0x2d, 0x2b, 0x00, 0x16,
+  0x15, 0x14, 0x06, 0x07, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06,
+  0x23, 0x22, 0x26, 0x27, 0x17, 0x33, 0x17, 0x21, 0x37, 0x33, 0x37, 0x06,
+  0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17, 0x26,
+  0x26, 0x35, 0x34, 0x36, 0x33, 0x01, 0x46, 0x40, 0x1c, 0x1a, 0x14, 0x19,
+  0x16, 0x2f, 0x32, 0x3b, 0x2d, 0x24, 0x34, 0x14, 0x10, 0x9c, 0x28, 0xfe,
+  0x34, 0x28, 0x9c, 0x10, 0x15, 0x34, 0x23, 0x2d, 0x3b, 0x32, 0x2f, 0x16,
+  0x19, 0x14, 0x1a, 0x1c, 0x40, 0x38, 0x02, 0x1b, 0x30, 0x2f, 0x24, 0x2d,
+  0x15, 0x09, 0x05, 0x3d, 0x38, 0x2e, 0x3b, 0x20, 0x22, 0x87, 0x41, 0x41,
+  0x87, 0x22, 0x20, 0x3b, 0x2e, 0x38, 0x3d, 0x05, 0x09, 0x15, 0x2d, 0x24,
+  0x2f, 0x30, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x02, 0x08, 0x02, 0x1b,
+  0x00, 0x13, 0x00, 0x06, 0xb3, 0x06, 0x00, 0x01, 0x2d, 0x2b, 0x00, 0x16,
+  0x15, 0x14, 0x06, 0x06, 0x07, 0x2e, 0x02, 0x35, 0x34, 0x36, 0x33, 0x32,
+  0x16, 0x17, 0x36, 0x36, 0x33, 0x01, 0xc9, 0x3f, 0x3f, 0x62, 0x59, 0x59,
+  0x62, 0x3f, 0x3f, 0x35, 0x31, 0x3d, 0x18, 0x18, 0x3d, 0x31, 0x02, 0x1b,
+  0x48, 0x34, 0x37, 0x7e, 0x81, 0x69, 0x6a, 0x80, 0x7d, 0x38, 0x34, 0x48,
+  0x32, 0x34, 0x34, 0x32, 0x00, 0x01, 0x00, 0x4a, 0xff, 0xf4, 0x01, 0xd2,
+  0x02, 0x1b, 0x00, 0x03, 0x00, 0x06, 0xb3, 0x02, 0x00, 0x01, 0x2d, 0x2b,
+  0x05, 0x03, 0x13, 0x13, 0x01, 0x0e, 0xc4, 0xc4, 0xc4, 0x0c, 0x01, 0x16,
+  0x01, 0x11, 0xfe, 0xef, 0x00, 0x01, 0x00, 0x5b, 0xff, 0xf4, 0x01, 0xc0,
+  0x02, 0x0f, 0x00, 0x19, 0x00, 0x06, 0xb3, 0x17, 0x0d, 0x01, 0x2d, 0x2b,
+  0x00, 0x16, 0x15, 0x14, 0x07, 0x27, 0x34, 0x26, 0x27, 0x27, 0x11, 0x14,
+  0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x11,
+  0x33, 0x17, 0x01, 0x9c, 0x24, 0x12, 0x1d, 0x18, 0x22, 0x17, 0x20, 0x39,
+  0x23, 0x31, 0x38, 0x49, 0x34, 0x20, 0x18, 0x30, 0x2f, 0x01, 0xd2, 0x36,
+  0x27, 0x28, 0x26, 0x0c, 0x3b, 0x39, 0x16, 0x0f, 0xfe, 0x82, 0x14, 0x2a,
+  0x1c, 0x24, 0x22, 0x26, 0x34, 0x0d, 0x01, 0x88, 0x1f, 0x00, 0x00, 0x01,
+  0x00, 0x0e, 0xff, 0xf4, 0x02, 0x0e, 0x02, 0x41, 0x00, 0x1d, 0x00, 0x06,
+  0xb3, 0x1c, 0x11, 0x01, 0x2d, 0x2b, 0x24, 0x06, 0x06, 0x23, 0x22, 0x26,
+  0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x11, 0x07, 0x11, 0x14, 0x06, 0x06,
+  0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x11, 0x25, 0x11,
+  0x02, 0x0e, 0x20, 0x39, 0x23, 0x31, 0x38, 0x49, 0x34, 0x20, 0x18, 0xeb,
+  0x20, 0x39, 0x23, 0x31, 0x38, 0x49, 0x34, 0x20, 0x18, 0x01, 0x4b, 0x6c,
+  0x2a, 0x1c, 0x24, 0x22, 0x26, 0x34, 0x0d, 0x01, 0x37, 0x3b, 0xfe, 0x99,
+  0x14, 0x2a, 0x1c, 0x24, 0x22, 0x26, 0x34, 0x0d, 0x01, 0x64, 0x56, 0xfe,
+  0x3f, 0x00, 0x00, 0x01, 0x00, 0xe6, 0xff, 0x92, 0x01, 0x36, 0x03, 0x2a,
+  0x00, 0x03, 0x00, 0x17, 0x40, 0x14, 0x02, 0x01, 0x01, 0x00, 0x01, 0x6f,
+  0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03,
+  0x05, 0x15, 0x2b, 0x01, 0x11, 0x23, 0x11, 0x01, 0x36, 0x50, 0x03, 0x2a,
+  0xfc, 0x68, 0x03, 0x98, 0x00, 0x02, 0x00, 0xe6, 0xff, 0x92, 0x01, 0x36,
+  0x03, 0x2a, 0x00, 0x03, 0x00, 0x07, 0x00, 0x30, 0x40, 0x2d, 0x04, 0x01,
+  0x01, 0x00, 0x00, 0x03, 0x01, 0x00, 0x5e, 0x05, 0x01, 0x03, 0x02, 0x02,
+  0x03, 0x52, 0x05, 0x01, 0x03, 0x03, 0x02, 0x56, 0x00, 0x02, 0x03, 0x02,
+  0x4a, 0x04, 0x04, 0x00, 0x00, 0x04, 0x07, 0x04, 0x07, 0x06, 0x05, 0x00,
+  0x03, 0x00, 0x03, 0x11, 0x06, 0x05, 0x15, 0x2b, 0x01, 0x11, 0x23, 0x11,
+  0x13, 0x11, 0x23, 0x11, 0x01, 0x36, 0x50, 0x50, 0x50, 0x03, 0x2a, 0xfe,
+  0x98, 0x01, 0x68, 0xfd, 0xd0, 0xfe, 0x98, 0x01, 0x68, 0x00, 0x00, 0x02,
+  0x00, 0x1d, 0x00, 0x00, 0x01, 0xff, 0x02, 0xbc, 0x00, 0x32, 0x00, 0x3e,
+  0x00, 0x50, 0x40, 0x4d, 0x11, 0x01, 0x04, 0x09, 0x01, 0x47, 0x00, 0x03,
+  0x00, 0x08, 0x09, 0x03, 0x08, 0x60, 0x0b, 0x01, 0x09, 0x00, 0x02, 0x01,
+  0x09, 0x02, 0x60, 0x00, 0x04, 0x00, 0x01, 0x06, 0x04, 0x01, 0x60, 0x00,
+  0x05, 0x05, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f, 0x48, 0x00, 0x06, 0x06,
+  0x07, 0x58, 0x0a, 0x01, 0x07, 0x07, 0x10, 0x07, 0x49, 0x33, 0x33, 0x00,
+  0x00, 0x33, 0x3e, 0x33, 0x3d, 0x38, 0x36, 0x00, 0x32, 0x00, 0x31, 0x24,
+  0x35, 0x23, 0x26, 0x24, 0x25, 0x35, 0x0c, 0x05, 0x1b, 0x2b, 0x32, 0x26,
+  0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x14, 0x06,
+  0x23, 0x22, 0x26, 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34,
+  0x36, 0x36, 0x33, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11,
+  0x34, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x33, 0x33, 0x15,
+  0x23, 0x36, 0x36, 0x35, 0x35, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16,
+  0x33, 0x5f, 0x42, 0x4b, 0x55, 0xa5, 0x54, 0x49, 0x31, 0x33, 0x21, 0x2b,
+  0x03, 0x0f, 0x24, 0x1e, 0x33, 0x2e, 0x1e, 0x41, 0x3b, 0x48, 0x0d, 0x11,
+  0x13, 0x0c, 0x24, 0x29, 0xb9, 0x2b, 0x25, 0x43, 0xb9, 0xb9, 0x78, 0x1a,
+  0x0f, 0x2b, 0x20, 0x0f, 0x17, 0x41, 0x4b, 0x01, 0x9a, 0x4f, 0x47, 0x45,
+  0x51, 0xfe, 0xb9, 0x3c, 0x30, 0x1f, 0x1d, 0x10, 0x0f, 0x33, 0x40, 0x90,
+  0x36, 0x3b, 0x17, 0xfe, 0xb8, 0x15, 0x14, 0x12, 0x1c, 0x01, 0x58, 0x26,
+  0x27, 0x26, 0x27, 0xfe, 0x52, 0x43, 0x3f, 0xca, 0x1f, 0x15, 0xe4, 0x1d,
+  0x2c, 0x9c, 0x18, 0x1b, 0x00, 0x02, 0x00, 0x53, 0x00, 0x00, 0x01, 0xf0,
+  0x02, 0xbc, 0x00, 0x1a, 0x00, 0x24, 0x00, 0x3e, 0x40, 0x3b, 0x05, 0x01,
+  0x03, 0x02, 0x01, 0x47, 0x00, 0x02, 0x08, 0x06, 0x02, 0x03, 0x05, 0x02,
+  0x03, 0x60, 0x00, 0x01, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f, 0x48,
+  0x00, 0x05, 0x05, 0x04, 0x58, 0x07, 0x01, 0x04, 0x04, 0x10, 0x04, 0x49,
+  0x1b, 0x1b, 0x00, 0x00, 0x1b, 0x24, 0x1b, 0x23, 0x22, 0x20, 0x00, 0x1a,
+  0x00, 0x19, 0x11, 0x25, 0x21, 0x2a, 0x09, 0x05, 0x18, 0x2b, 0x32, 0x26,
+  0x35, 0x35, 0x34, 0x37, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15,
+  0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x11,
+  0x23, 0x02, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x11, 0x23, 0xa3,
+  0x50, 0x41, 0x37, 0x57, 0x55, 0x6a, 0x76, 0x26, 0x23, 0x2a, 0x1f, 0xf3,
+  0x4f, 0xa4, 0x2b, 0x28, 0x24, 0x26, 0x5c, 0x5d, 0x4b, 0x53, 0x7e, 0x57,
+  0x24, 0x27, 0x4d, 0x15, 0x51, 0x4b, 0x4b, 0x22, 0x26, 0x28, 0x21, 0x28,
+  0x4b, 0xfe, 0x93, 0x01, 0x6d, 0x27, 0x21, 0x91, 0x26, 0x23, 0x01, 0x22,
+  0x00, 0x02, 0x00, 0x3e, 0x00, 0x00, 0x01, 0xc5, 0x02, 0xbc, 0x00, 0x15,
+  0x00, 0x19, 0x00, 0x38, 0x40, 0x35, 0x00, 0x03, 0x07, 0x01, 0x00, 0x04,
+  0x03, 0x00, 0x60, 0x00, 0x02, 0x02, 0x01, 0x58, 0x08, 0x06, 0x02, 0x01,
+  0x01, 0x0f, 0x48, 0x05, 0x01, 0x04, 0x04, 0x10, 0x04, 0x49, 0x16, 0x16,
+  0x01, 0x00, 0x16, 0x19, 0x16, 0x19, 0x18, 0x17, 0x14, 0x13, 0x12, 0x10,
+  0x0b, 0x09, 0x08, 0x06, 0x00, 0x15, 0x01, 0x15, 0x09, 0x05, 0x14, 0x2b,
+  0x13, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22,
+  0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x11, 0x23, 0x11, 0x13, 0x11,
+  0x23, 0x11, 0xe5, 0x58, 0x4f, 0x50, 0x57, 0x59, 0x64, 0x24, 0x27, 0x26,
+  0x25, 0x64, 0x53, 0xda, 0x50, 0x01, 0x76, 0x45, 0x54, 0x0d, 0x55, 0x4b,
+  0x46, 0x27, 0x1f, 0x35, 0x1f, 0x22, 0xfe, 0x46, 0x01, 0x76, 0x01, 0x46,
+  0xfd, 0x44, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x02, 0x03,
+  0x02, 0xbc, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x33, 0x00, 0x39, 0x40, 0x36,
+  0x00, 0x04, 0x00, 0x05, 0x06, 0x04, 0x05, 0x60, 0x00, 0x06, 0x08, 0x01,
+  0x07, 0x03, 0x06, 0x07, 0x60, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01,
+  0x01, 0x0f, 0x48, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x49, 0x20, 0x20, 0x20, 0x33, 0x20, 0x32, 0x25, 0x21, 0x29, 0x35,
+  0x35, 0x35, 0x31, 0x09, 0x05, 0x1b, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22,
+  0x26, 0x35, 0x11, 0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02,
+  0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x11, 0x02, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33, 0x15,
+  0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0x02,
+  0x03, 0x56, 0x4d, 0xa4, 0x4d, 0x56, 0x56, 0x4d, 0xa4, 0x4d, 0x56, 0x48,
+  0x31, 0x2a, 0xa4, 0x2b, 0x30, 0x30, 0x2b, 0xa4, 0x2b, 0x30, 0xd4, 0x38,
+  0x38, 0x34, 0x4b, 0x50, 0x15, 0x19, 0x19, 0x15, 0x4f, 0x4a, 0x56, 0x56,
+  0x56, 0x54, 0x01, 0x68, 0x54, 0x56, 0x56, 0x54, 0xfe, 0x98, 0x01, 0x9f,
+  0x33, 0x33, 0x21, 0xfe, 0x6b, 0x21, 0x33, 0x33, 0x21, 0x01, 0x95, 0xfe,
+  0x75, 0x2f, 0x2f, 0xc6, 0x2f, 0x2f, 0x33, 0x18, 0x12, 0xc8, 0x11, 0x19,
+  0x33, 0x00, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x02, 0x03, 0x02, 0xbc,
+  0x00, 0x0f, 0x00, 0x1f, 0x00, 0x2c, 0x00, 0x36, 0x00, 0x4c, 0x40, 0x49,
+  0x29, 0x01, 0x07, 0x09, 0x01, 0x47, 0x06, 0x01, 0x04, 0x07, 0x03, 0x07,
+  0x04, 0x03, 0x6d, 0x00, 0x05, 0x00, 0x08, 0x09, 0x05, 0x08, 0x60, 0x00,
+  0x09, 0x0a, 0x01, 0x07, 0x04, 0x09, 0x07, 0x5e, 0x00, 0x02, 0x02, 0x01,
+  0x58, 0x00, 0x01, 0x01, 0x0f, 0x48, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00,
+  0x00, 0x00, 0x10, 0x00, 0x49, 0x20, 0x20, 0x33, 0x31, 0x30, 0x2e, 0x20,
+  0x2c, 0x20, 0x2c, 0x15, 0x21, 0x15, 0x35, 0x35, 0x35, 0x31, 0x0b, 0x05,
+  0x1b, 0x2b, 0x24, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x11, 0x34, 0x36,
+  0x33, 0x33, 0x32, 0x16, 0x15, 0x11, 0x02, 0x26, 0x23, 0x23, 0x22, 0x06,
+  0x15, 0x11, 0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x11, 0x07, 0x15,
+  0x23, 0x11, 0x33, 0x32, 0x15, 0x15, 0x14, 0x07, 0x17, 0x23, 0x27, 0x36,
+  0x26, 0x23, 0x23, 0x15, 0x33, 0x32, 0x36, 0x35, 0x35, 0x02, 0x03, 0x56,
+  0x4d, 0xa4, 0x4d, 0x56, 0x56, 0x4d, 0xa4, 0x4d, 0x56, 0x48, 0x31, 0x2a,
+  0xa4, 0x2b, 0x30, 0x30, 0x2b, 0xa4, 0x2b, 0x30, 0xda, 0x38, 0x6b, 0x68,
+  0x36, 0x53, 0x3d, 0x4e, 0x31, 0x14, 0x17, 0x33, 0x33, 0x17, 0x14, 0x56,
+  0x56, 0x56, 0x54, 0x01, 0x68, 0x54, 0x56, 0x56, 0x54, 0xfe, 0x98, 0x01,
+  0x9f, 0x33, 0x33, 0x21, 0xfe, 0x6b, 0x21, 0x33, 0x33, 0x21, 0x01, 0x95,
+  0xeb, 0x9e, 0x01, 0x80, 0x56, 0x35, 0x3e, 0x10, 0xa7, 0x9e, 0xa1, 0x12,
+  0x85, 0x13, 0x15, 0x36, 0x00, 0x02, 0x00, 0x71, 0x00, 0x00, 0x01, 0xaa,
+  0x02, 0xbc, 0x00, 0x2d, 0x00, 0x3d, 0x00, 0x45, 0x40, 0x42, 0x02, 0x01,
+  0x07, 0x02, 0x19, 0x01, 0x05, 0x06, 0x02, 0x47, 0x00, 0x06, 0x00, 0x05,
+  0x04, 0x06, 0x05, 0x60, 0x00, 0x01, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00,
+  0x0f, 0x48, 0x08, 0x01, 0x07, 0x07, 0x02, 0x58, 0x00, 0x02, 0x02, 0x12,
+  0x48, 0x00, 0x04, 0x04, 0x03, 0x58, 0x00, 0x03, 0x03, 0x10, 0x03, 0x49,
+  0x2e, 0x2e, 0x2e, 0x3d, 0x2e, 0x3b, 0x38, 0x34, 0x21, 0x2a, 0x35, 0x21,
+  0x28, 0x09, 0x05, 0x1b, 0x2b, 0x12, 0x36, 0x37, 0x26, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x15, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16,
+  0x33, 0x33, 0x32, 0x15, 0x15, 0x14, 0x07, 0x16, 0x16, 0x15, 0x15, 0x14,
+  0x06, 0x23, 0x23, 0x35, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x23, 0x23,
+  0x22, 0x35, 0x35, 0x36, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32,
+  0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x23, 0x71, 0x19, 0x13, 0x0e, 0x10,
+  0x4c, 0x4a, 0x7c, 0x86, 0x18, 0x1f, 0x1a, 0x16, 0x1d, 0x89, 0x2c, 0x0e,
+  0x10, 0x4c, 0x4a, 0x7c, 0x86, 0x18, 0x1f, 0x2c, 0x21, 0x89, 0x67, 0x12,
+  0x1a, 0x1b, 0x37, 0x10, 0x13, 0x16, 0x1e, 0x38, 0x01, 0x87, 0x39, 0x0e,
+  0x0f, 0x2d, 0x1c, 0x0a, 0x49, 0x43, 0x4b, 0x17, 0x16, 0x28, 0x17, 0x16,
+  0x91, 0x05, 0x44, 0x27, 0x0a, 0x31, 0x1d, 0x0a, 0x49, 0x43, 0x4b, 0x17,
+  0x16, 0x28, 0x2d, 0x91, 0x05, 0x41, 0x17, 0x16, 0x2d, 0x17, 0x1b, 0x17,
+  0x16, 0x2d, 0x18, 0x1a, 0x00, 0x01, 0x00, 0x0e, 0x00, 0xc2, 0x02, 0x0c,
+  0x02, 0xbc, 0x00, 0x12, 0x00, 0x06, 0xb3, 0x0b, 0x03, 0x01, 0x2d, 0x2b,
+  0x01, 0x23, 0x27, 0x11, 0x23, 0x11, 0x23, 0x11, 0x23, 0x11, 0x23, 0x35,
+  0x21, 0x17, 0x37, 0x33, 0x11, 0x23, 0x11, 0x01, 0x95, 0x35, 0x36, 0x41,
+  0x41, 0x44, 0x56, 0x01, 0x45, 0x2a, 0x28, 0x67, 0x42, 0x01, 0x69, 0xfd,
+  0xfe, 0x5c, 0x01, 0xbf, 0xfe, 0x41, 0x01, 0xbf, 0x3b, 0xcf, 0xcf, 0xfe,
+  0x06, 0x01, 0xa4, 0x00, 0x00, 0x02, 0x00, 0x81, 0x01, 0x8d, 0x01, 0x9b,
+  0x02, 0xbd, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x1c, 0x40, 0x19, 0x00, 0x03,
+  0x00, 0x00, 0x03, 0x00, 0x5c, 0x00, 0x02, 0x02, 0x01, 0x58, 0x00, 0x01,
+  0x01, 0x0f, 0x02, 0x49, 0x35, 0x35, 0x35, 0x31, 0x04, 0x05, 0x18, 0x2b,
+  0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x33,
+  0x32, 0x16, 0x15, 0x15, 0x26, 0x26, 0x23, 0x23, 0x22, 0x06, 0x15, 0x15,
+  0x14, 0x16, 0x33, 0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0x9b, 0x48, 0x37,
+  0x1c, 0x37, 0x48, 0x47, 0x38, 0x1c, 0x38, 0x47, 0x45, 0x21, 0x19, 0x1c,
+  0x19, 0x21, 0x21, 0x19, 0x1c, 0x19, 0x21, 0x01, 0xca, 0x3d, 0x3d, 0x3a,
+  0x42, 0x3a, 0x3d, 0x3d, 0x3a, 0x42, 0x5b, 0x20, 0x20, 0x16, 0x48, 0x16,
+  0x20, 0x20, 0x16, 0x48, 0x00, 0x01, 0x00, 0x47, 0x01, 0xa4, 0x01, 0xd4,
+  0x02, 0xf8, 0x00, 0x06, 0x00, 0x19, 0x40, 0x16, 0x06, 0x01, 0x00, 0x01,
+  0x01, 0x47, 0x00, 0x01, 0x00, 0x01, 0x6f, 0x02, 0x01, 0x00, 0x00, 0x66,
+  0x11, 0x11, 0x10, 0x03, 0x05, 0x17, 0x2b, 0x13, 0x23, 0x13, 0x33, 0x13,
+  0x23, 0x03, 0x9f, 0x58, 0x90, 0x72, 0x8b, 0x5b, 0x68, 0x01, 0xa4, 0x01,
+  0x54, 0xfe, 0xac, 0x01, 0x18, 0x00, 0x00, 0x01, 0x00, 0x59, 0x00, 0x00,
+  0x01, 0xc2, 0x02, 0xbc, 0x00, 0x0b, 0x00, 0x29, 0x40, 0x26, 0x00, 0x01,
+  0x01, 0x0f, 0x48, 0x06, 0x05, 0x02, 0x03, 0x03, 0x00, 0x56, 0x02, 0x01,
+  0x00, 0x00, 0x12, 0x48, 0x00, 0x04, 0x04, 0x10, 0x04, 0x49, 0x00, 0x00,
+  0x00, 0x0b, 0x00, 0x0b, 0x11, 0x11, 0x11, 0x11, 0x11, 0x07, 0x05, 0x19,
+  0x2b, 0x13, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x11, 0x23,
+  0x11, 0x59, 0x8d, 0x50, 0x8c, 0x8c, 0x50, 0x01, 0xa9, 0x4b, 0xc8, 0xc8,
+  0x4b, 0xfe, 0x57, 0x01, 0xa9, 0x00, 0x00, 0x01, 0x00, 0x59, 0x00, 0x00,
+  0x01, 0xc2, 0x02, 0xbc, 0x00, 0x13, 0x00, 0x37, 0x40, 0x34, 0x06, 0x01,
+  0x00, 0x0a, 0x09, 0x02, 0x07, 0x08, 0x00, 0x07, 0x5e, 0x00, 0x03, 0x03,
+  0x0f, 0x48, 0x05, 0x01, 0x01, 0x01, 0x02, 0x56, 0x04, 0x01, 0x02, 0x02,
+  0x12, 0x48, 0x00, 0x08, 0x08, 0x10, 0x08, 0x49, 0x00, 0x00, 0x00, 0x13,
+  0x00, 0x13, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0b,
+  0x05, 0x1d, 0x2b, 0x37, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x35, 0x33,
+  0x15, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23, 0x15, 0x23, 0x35, 0x59,
+  0x8d, 0x8d, 0x8d, 0x50, 0x8c, 0x8c, 0x8c, 0x8c, 0x50, 0xd2, 0x4b, 0x8c,
+  0x4b, 0xc8, 0xc8, 0x4b, 0x8c, 0x4b, 0xd2, 0xd2, 0x00, 0x01, 0x00, 0xa8,
+  0x02, 0x44, 0x01, 0x78, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x2e, 0x4b, 0xb0,
+  0x21, 0x50, 0x58, 0x40, 0x0c, 0x00, 0x00, 0x01, 0x00, 0x70, 0x02, 0x01,
+  0x01, 0x01, 0x0f, 0x01, 0x49, 0x1b, 0x40, 0x0a, 0x02, 0x01, 0x01, 0x00,
+  0x01, 0x6f, 0x00, 0x00, 0x00, 0x66, 0x59, 0x40, 0x0a, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x01, 0x07, 0x23, 0x37,
+  0x01, 0x78, 0x7a, 0x56, 0x68, 0x02, 0xcb, 0x87, 0x87, 0x00, 0x00, 0x01,
+  0x00, 0x80, 0x02, 0x49, 0x01, 0x9c, 0x02, 0xcb, 0x00, 0x0f, 0x00, 0x41,
+  0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x0f, 0x04, 0x01, 0x03, 0x00, 0x01,
+  0x03, 0x01, 0x5d, 0x02, 0x01, 0x00, 0x00, 0x0f, 0x00, 0x49, 0x1b, 0x40,
+  0x18, 0x02, 0x01, 0x00, 0x03, 0x00, 0x6f, 0x04, 0x01, 0x03, 0x01, 0x01,
+  0x03, 0x54, 0x04, 0x01, 0x03, 0x03, 0x01, 0x59, 0x00, 0x01, 0x03, 0x01,
+  0x4d, 0x59, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x0d, 0x12, 0x32,
+  0x12, 0x05, 0x05, 0x17, 0x2b, 0x00, 0x36, 0x35, 0x33, 0x14, 0x06, 0x23,
+  0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x33, 0x01, 0x36, 0x14,
+  0x52, 0x3d, 0x47, 0x14, 0x47, 0x3d, 0x52, 0x14, 0x1e, 0x14, 0x02, 0x89,
+  0x22, 0x20, 0x33, 0x4f, 0x4f, 0x33, 0x20, 0x22, 0x00, 0x01, 0x00, 0x71,
+  0x02, 0x43, 0x01, 0xaa, 0x02, 0xca, 0x00, 0x06, 0x00, 0x30, 0xb5, 0x06,
+  0x01, 0x01, 0x00, 0x01, 0x47, 0x4b, 0xb0, 0x23, 0x50, 0x58, 0x40, 0x0c,
+  0x00, 0x01, 0x00, 0x01, 0x70, 0x02, 0x01, 0x00, 0x00, 0x0f, 0x00, 0x49,
+  0x1b, 0x40, 0x0a, 0x02, 0x01, 0x00, 0x01, 0x00, 0x6f, 0x00, 0x01, 0x01,
+  0x66, 0x59, 0xb5, 0x11, 0x11, 0x10, 0x03, 0x05, 0x17, 0x2b, 0x01, 0x33,
+  0x07, 0x23, 0x27, 0x33, 0x17, 0x01, 0x4a, 0x60, 0x70, 0x58, 0x71, 0x61,
+  0x3c, 0x02, 0xca, 0x87, 0x87, 0x4b, 0x00, 0x01, 0x00, 0xb7, 0xff, 0x38,
+  0x01, 0x64, 0x00, 0x32, 0x00, 0x11, 0x00, 0x62, 0x4b, 0xb0, 0x0b, 0x50,
+  0x58, 0x40, 0x21, 0x00, 0x03, 0x02, 0x01, 0x00, 0x03, 0x65, 0x00, 0x02,
+  0x00, 0x01, 0x00, 0x02, 0x01, 0x60, 0x05, 0x01, 0x00, 0x04, 0x04, 0x00,
+  0x54, 0x05, 0x01, 0x00, 0x00, 0x04, 0x59, 0x00, 0x04, 0x00, 0x04, 0x4d,
+  0x1b, 0x40, 0x22, 0x00, 0x03, 0x02, 0x01, 0x02, 0x03, 0x01, 0x6d, 0x00,
+  0x02, 0x00, 0x01, 0x00, 0x02, 0x01, 0x60, 0x05, 0x01, 0x00, 0x04, 0x04,
+  0x00, 0x54, 0x05, 0x01, 0x00, 0x00, 0x04, 0x59, 0x00, 0x04, 0x00, 0x04,
+  0x4d, 0x59, 0x40, 0x11, 0x01, 0x00, 0x10, 0x0e, 0x0a, 0x09, 0x08, 0x07,
+  0x06, 0x04, 0x00, 0x11, 0x01, 0x11, 0x06, 0x05, 0x14, 0x2b, 0x17, 0x32,
+  0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x33, 0x15, 0x32, 0x16, 0x15, 0x14,
+  0x06, 0x23, 0x23, 0x35, 0xfa, 0x21, 0x11, 0x12, 0x31, 0x46, 0x2e, 0x29,
+  0x33, 0x25, 0x55, 0x88, 0x1f, 0x11, 0x0c, 0x7e, 0x47, 0x23, 0x31, 0x3a,
+  0x25, 0x40, 0x00, 0x01, 0x00, 0x71, 0x02, 0x44, 0x01, 0xaa, 0x02, 0xcb,
+  0x00, 0x06, 0x00, 0x30, 0xb5, 0x06, 0x01, 0x00, 0x01, 0x01, 0x47, 0x4b,
+  0xb0, 0x21, 0x50, 0x58, 0x40, 0x0c, 0x02, 0x01, 0x00, 0x01, 0x00, 0x70,
+  0x00, 0x01, 0x01, 0x0f, 0x01, 0x49, 0x1b, 0x40, 0x0a, 0x00, 0x01, 0x00,
+  0x01, 0x6f, 0x02, 0x01, 0x00, 0x00, 0x66, 0x59, 0xb5, 0x11, 0x11, 0x10,
+  0x03, 0x05, 0x17, 0x2b, 0x13, 0x23, 0x37, 0x33, 0x17, 0x23, 0x27, 0xd1,
+  0x60, 0x70, 0x58, 0x71, 0x61, 0x3c, 0x02, 0x44, 0x87, 0x87, 0x4b, 0x00,
+  0x00, 0x02, 0x00, 0x7f, 0x02, 0x53, 0x01, 0x9c, 0x02, 0xa3, 0x00, 0x03,
+  0x00, 0x07, 0x00, 0x2c, 0x40, 0x29, 0x05, 0x03, 0x04, 0x03, 0x01, 0x00,
+  0x00, 0x01, 0x52, 0x05, 0x03, 0x04, 0x03, 0x01, 0x01, 0x00, 0x56, 0x02,
+  0x01, 0x00, 0x01, 0x00, 0x4a, 0x04, 0x04, 0x00, 0x00, 0x04, 0x07, 0x04,
+  0x07, 0x06, 0x05, 0x00, 0x03, 0x00, 0x03, 0x11, 0x06, 0x05, 0x15, 0x2b,
+  0x13, 0x15, 0x23, 0x35, 0x21, 0x15, 0x23, 0x35, 0xd4, 0x55, 0x01, 0x1d,
+  0x55, 0x02, 0xa3, 0x50, 0x50, 0x50, 0x50, 0x00, 0x00, 0x01, 0x00, 0xe3,
+  0x02, 0x67, 0x01, 0x38, 0x02, 0xbc, 0x00, 0x03, 0x00, 0x19, 0x40, 0x16,
+  0x00, 0x00, 0x00, 0x01, 0x56, 0x02, 0x01, 0x01, 0x01, 0x0f, 0x00, 0x49,
+  0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x01,
+  0x15, 0x23, 0x35, 0x01, 0x38, 0x55, 0x02, 0xbc, 0x55, 0x55, 0x00, 0x01,
+  0x00, 0xa3, 0x02, 0x44, 0x01, 0x73, 0x02, 0xcb, 0x00, 0x03, 0x00, 0x2e,
+  0x4b, 0xb0, 0x21, 0x50, 0x58, 0x40, 0x0c, 0x00, 0x00, 0x01, 0x00, 0x70,
+  0x02, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x49, 0x1b, 0x40, 0x0a, 0x02, 0x01,
+  0x01, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x00, 0x66, 0x59, 0x40, 0x0a, 0x00,
+  0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03, 0x05, 0x15, 0x2b, 0x01, 0x17,
+  0x23, 0x27, 0x01, 0x0b, 0x68, 0x56, 0x7a, 0x02, 0xcb, 0x87, 0x87, 0x00,
+  0x00, 0x02, 0x00, 0x4d, 0x02, 0x56, 0x01, 0xd1, 0x02, 0xe9, 0x00, 0x03,
+  0x00, 0x07, 0x00, 0x1d, 0x40, 0x1a, 0x02, 0x01, 0x00, 0x01, 0x01, 0x00,
+  0x52, 0x02, 0x01, 0x00, 0x00, 0x01, 0x56, 0x03, 0x01, 0x01, 0x00, 0x01,
+  0x4a, 0x11, 0x11, 0x11, 0x10, 0x04, 0x05, 0x18, 0x2b, 0x13, 0x33, 0x07,
+  0x23, 0x25, 0x33, 0x07, 0x23, 0xb4, 0x73, 0x7f, 0x5b, 0x01, 0x11, 0x73,
+  0x7f, 0x5b, 0x02, 0xe9, 0x93, 0x93, 0x93, 0x00, 0x00, 0x01, 0x00, 0x8e,
+  0x02, 0x5d, 0x01, 0x8d, 0x02, 0xa3, 0x00, 0x03, 0x00, 0x1f, 0x40, 0x1c,
+  0x02, 0x01, 0x01, 0x00, 0x00, 0x01, 0x52, 0x02, 0x01, 0x01, 0x01, 0x00,
+  0x56, 0x00, 0x00, 0x01, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03,
+  0x11, 0x03, 0x05, 0x15, 0x2b, 0x01, 0x15, 0x23, 0x35, 0x01, 0x8d, 0xff,
+  0x02, 0xa3, 0x46, 0x46, 0x00, 0x01, 0x00, 0xb5, 0xff, 0x4c, 0x01, 0x66,
+  0x00, 0x3c, 0x00, 0x0b, 0x00, 0x40, 0x4b, 0xb0, 0x31, 0x50, 0x58, 0x40,
+  0x11, 0x00, 0x00, 0x01, 0x00, 0x6f, 0x00, 0x01, 0x01, 0x02, 0x59, 0x03,
+  0x01, 0x02, 0x02, 0x14, 0x02, 0x49, 0x1b, 0x40, 0x16, 0x00, 0x00, 0x01,
+  0x00, 0x6f, 0x00, 0x01, 0x02, 0x02, 0x01, 0x54, 0x00, 0x01, 0x01, 0x02,
+  0x59, 0x03, 0x01, 0x02, 0x01, 0x02, 0x4d, 0x59, 0x40, 0x0b, 0x00, 0x00,
+  0x00, 0x0b, 0x00, 0x0a, 0x23, 0x13, 0x04, 0x05, 0x16, 0x2b, 0x16, 0x26,
+  0x35, 0x35, 0x33, 0x15, 0x14, 0x16, 0x33, 0x33, 0x15, 0x23, 0xe8, 0x33,
+  0x4a, 0x0f, 0x11, 0x47, 0x59, 0xb4, 0x25, 0x3a, 0x91, 0x91, 0x10, 0x0c,
+  0x43, 0x00, 0x00, 0x02, 0x00, 0xb2, 0x02, 0x24, 0x01, 0x6a, 0x02, 0xeb,
+  0x00, 0x0f, 0x00, 0x1d, 0x00, 0x22, 0x40, 0x1f, 0x00, 0x01, 0x00, 0x02,
+  0x03, 0x01, 0x02, 0x60, 0x00, 0x03, 0x00, 0x00, 0x03, 0x54, 0x00, 0x03,
+  0x03, 0x00, 0x58, 0x00, 0x00, 0x03, 0x00, 0x4c, 0x35, 0x34, 0x35, 0x31,
+  0x04, 0x05, 0x18, 0x2b, 0x00, 0x06, 0x23, 0x23, 0x22, 0x26, 0x35, 0x35,
+  0x34, 0x36, 0x33, 0x33, 0x32, 0x16, 0x15, 0x15, 0x26, 0x23, 0x23, 0x22,
+  0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x33, 0x32, 0x35, 0x35, 0x01, 0x6a,
+  0x32, 0x27, 0x06, 0x27, 0x32, 0x31, 0x28, 0x06, 0x28, 0x31, 0x39, 0x20,
+  0x06, 0x12, 0x10, 0x10, 0x12, 0x06, 0x20, 0x02, 0x50, 0x2c, 0x2c, 0x29,
+  0x1d, 0x2a, 0x2b, 0x2b, 0x2a, 0x1d, 0x44, 0x15, 0x11, 0x1f, 0x11, 0x15,
+  0x26, 0x1f, 0x00, 0x01, 0x00, 0x82, 0x02, 0x4f, 0x01, 0x9a, 0x02, 0xbc,
+  0x00, 0x1a, 0x00, 0x28, 0x40, 0x25, 0x1a, 0x0c, 0x02, 0x01, 0x00, 0x19,
+  0x0d, 0x02, 0x02, 0x03, 0x02, 0x47, 0x00, 0x01, 0x00, 0x02, 0x01, 0x02,
+  0x5c, 0x00, 0x03, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0f, 0x03, 0x49,
+  0x33, 0x26, 0x24, 0x21, 0x04, 0x05, 0x18, 0x2b, 0x12, 0x36, 0x33, 0x33,
+  0x32, 0x16, 0x17, 0x16, 0x33, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06,
+  0x23, 0x23, 0x22, 0x27, 0x26, 0x23, 0x23, 0x22, 0x06, 0x07, 0x35, 0x8b,
+  0x38, 0x0c, 0x0f, 0x08, 0x20, 0x11, 0x2a, 0x0c, 0x0a, 0x08, 0x32, 0x09,
+  0x08, 0x31, 0x0b, 0x0f, 0x05, 0x28, 0x34, 0x0d, 0x0a, 0x09, 0x3a, 0x0a,
+  0x02, 0xa0, 0x1c, 0x0c, 0x08, 0x14, 0x1e, 0x06, 0x48, 0x05, 0x1c, 0x11,
+  0x17, 0x1e, 0x06, 0x48, 0x00, 0x01, 0x00, 0x8e, 0x02, 0x5d, 0x01, 0x8d,
+  0x02, 0xa3, 0x00, 0x03, 0x00, 0x1f, 0x40, 0x1c, 0x02, 0x01, 0x01, 0x00,
+  0x00, 0x01, 0x52, 0x02, 0x01, 0x01, 0x01, 0x00, 0x56, 0x00, 0x00, 0x01,
+  0x00, 0x4a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x11, 0x03, 0x05, 0x15,
+  0x2b, 0x01, 0x15, 0x23, 0x35, 0x01, 0x8d, 0xff, 0x02, 0xa3, 0x46, 0x46,
+  0x00, 0x02, 0x00, 0x6d, 0x00, 0x00, 0x01, 0xae, 0x02, 0x1b, 0x00, 0x18,
+  0x00, 0x24, 0x00, 0x08, 0xb5, 0x1d, 0x19, 0x0b, 0x00, 0x02, 0x2d, 0x2b,
+  0x00, 0x16, 0x16, 0x15, 0x14, 0x06, 0x07, 0x15, 0x33, 0x15, 0x23, 0x15,
+  0x23, 0x35, 0x23, 0x35, 0x33, 0x35, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36,
+  0x33, 0x06, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26,
+  0x23, 0x01, 0x39, 0x4a, 0x2b, 0x4d, 0x3b, 0x60, 0x60, 0x30, 0x60, 0x60,
+  0x3b, 0x4e, 0x2b, 0x49, 0x2c, 0x30, 0x3d, 0x3d, 0x30, 0x30, 0x3e, 0x3e,
+  0x30, 0x02, 0x1b, 0x2a, 0x48, 0x2c, 0x3c, 0x55, 0x08, 0x53, 0x28, 0x69,
+  0x69, 0x28, 0x52, 0x08, 0x56, 0x3c, 0x2c, 0x48, 0x2a, 0x2e, 0x40, 0x30,
+  0x30, 0x3f, 0x3f, 0x30, 0x30, 0x40, 0x00, 0x02, 0x00, 0x1e, 0x00, 0x00,
+  0x01, 0xfe, 0x01, 0xe7, 0x00, 0x1d, 0x00, 0x29, 0x00, 0x08, 0xb5, 0x22,
+  0x1e, 0x1c, 0x0b, 0x02, 0x2d, 0x2b, 0x01, 0x07, 0x27, 0x26, 0x37, 0x27,
+  0x07, 0x16, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x34,
+  0x36, 0x36, 0x33, 0x32, 0x17, 0x37, 0x27, 0x07, 0x27, 0x27, 0x37, 0x17,
+  0x04, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23,
+  0x01, 0xfe, 0x2c, 0x05, 0x01, 0x04, 0x02, 0x94, 0x25, 0x2b, 0x4a, 0x2c,
+  0x2c, 0x49, 0x2b, 0x2b, 0x49, 0x2c, 0x2d, 0x2a, 0x98, 0x01, 0x17, 0x18,
+  0x64, 0x04, 0xd6, 0xfe, 0x9b, 0x3d, 0x3d, 0x30, 0x30, 0x3e, 0x3e, 0x30,
+  0x01, 0x06, 0x02, 0x63, 0x18, 0x18, 0x01, 0x97, 0x2d, 0x39, 0x2c, 0x47,
+  0x28, 0x28, 0x47, 0x2c, 0x2c, 0x48, 0x2a, 0x19, 0x97, 0x02, 0x01, 0x01,
+  0x04, 0x2a, 0x0b, 0xd1, 0x40, 0x30, 0x30, 0x3f, 0x3f, 0x30, 0x30, 0x40,
+  0x00, 0x01, 0x00, 0x00, 0x01, 0x0c, 0x00, 0x89, 0x00, 0x08, 0x00, 0x26,
+  0x00, 0x03, 0x00, 0x02, 0x00, 0x22, 0x00, 0x32, 0x00, 0x73, 0x00, 0x00,
+  0x00, 0x7c, 0x0b, 0x70, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+  0x00, 0x18, 0x00, 0x18, 0x00, 0x4a, 0x00, 0x8e, 0x00, 0xd4, 0x01, 0x21,
+  0x01, 0x65, 0x01, 0xba, 0x02, 0x1e, 0x02, 0x60, 0x02, 0xab, 0x02, 0xdc,
+  0x03, 0x69, 0x03, 0x9b, 0x03, 0xdc, 0x04, 0x09, 0x04, 0x63, 0x04, 0xbf,
+  0x05, 0x07, 0x05, 0x61, 0x05, 0x8a, 0x05, 0xc4, 0x05, 0xef, 0x06, 0x19,
+  0x06, 0x6e, 0x06, 0xc5, 0x07, 0x0b, 0x07, 0x60, 0x07, 0x88, 0x07, 0xb2,
+  0x07, 0xd1, 0x07, 0xfe, 0x08, 0x2c, 0x08, 0x50, 0x08, 0xa7, 0x08, 0xe7,
+  0x09, 0x4f, 0x09, 0xba, 0x0a, 0x15, 0x0a, 0x7d, 0x0a, 0xd7, 0x0b, 0x4a,
+  0x0b, 0x9a, 0x0b, 0xcf, 0x0c, 0x07, 0x0c, 0x52, 0x0c, 0x93, 0x0c, 0xd8,
+  0x0d, 0x4c, 0x0d, 0x6d, 0x0d, 0x9b, 0x0d, 0xdb, 0x0e, 0x1d, 0x0e, 0x66,
+  0x0e, 0xa6, 0x0e, 0xc6, 0x0e, 0xf7, 0x0f, 0x20, 0x0f, 0x47, 0x0f, 0x80,
+  0x0f, 0xc2, 0x0f, 0xeb, 0x10, 0x40, 0x10, 0xb4, 0x11, 0x5d, 0x12, 0x07,
+  0x12, 0x9d, 0x13, 0x46, 0x13, 0xf2, 0x14, 0xa4, 0x15, 0x1f, 0x15, 0x61,
+  0x15, 0x91, 0x16, 0x1d, 0x16, 0x60, 0x16, 0xd9, 0x17, 0x1c, 0x17, 0x8e,
+  0x18, 0x03, 0x18, 0x62, 0x18, 0xd4, 0x19, 0x13, 0x19, 0x74, 0x19, 0xac,
+  0x19, 0xe1, 0x1a, 0x05, 0x1a, 0x52, 0x1a, 0xa2, 0x1a, 0xe0, 0x1b, 0x2d,
+  0x1b, 0x69, 0x1b, 0x92, 0x1b, 0xbc, 0x1b, 0xf6, 0x1c, 0x42, 0x1c, 0x78,
+  0x1c, 0xe0, 0x1d, 0x1d, 0x1d, 0x84, 0x1d, 0xed, 0x1e, 0x45, 0x1e, 0xac,
+  0x1f, 0x06, 0x1f, 0x78, 0x1f, 0xe8, 0x20, 0x30, 0x20, 0x78, 0x20, 0xb8,
+  0x21, 0x06, 0x21, 0x49, 0x21, 0xbd, 0x22, 0x32, 0x22, 0x67, 0x22, 0x9b,
+  0x22, 0xf9, 0x23, 0x58, 0x23, 0xa8, 0x24, 0x06, 0x24, 0x26, 0x24, 0x56,
+  0x24, 0x7e, 0x24, 0xb5, 0x25, 0x17, 0x25, 0x69, 0x25, 0x91, 0x25, 0xe5,
+  0x25, 0xf1, 0x25, 0xfd, 0x26, 0x81, 0x26, 0xcd, 0x26, 0xe7, 0x27, 0x1c,
+  0x27, 0x56, 0x27, 0x7b, 0x27, 0x9e, 0x27, 0xe8, 0x28, 0x12, 0x28, 0x4b,
+  0x28, 0x92, 0x28, 0xc4, 0x28, 0xfc, 0x29, 0x43, 0x29, 0x64, 0x29, 0xcf,
+  0x2a, 0x16, 0x2a, 0x2d, 0x2a, 0x90, 0x2a, 0xf3, 0x2b, 0xbd, 0x2b, 0xe5,
+  0x2c, 0x19, 0x2c, 0x73, 0x2c, 0xa7, 0x2c, 0xbd, 0x2c, 0xd9, 0x2c, 0xf5,
+  0x2d, 0x1e, 0x2d, 0x3b, 0x2d, 0x69, 0x2d, 0x93, 0x2d, 0xbb, 0x2e, 0x08,
+  0x2e, 0x21, 0x2e, 0x65, 0x2e, 0xa9, 0x2e, 0xd0, 0x2e, 0xec, 0x2f, 0x16,
+  0x2f, 0x2d, 0x2f, 0x46, 0x2f, 0x92, 0x2f, 0xdf, 0x30, 0x05, 0x30, 0x2b,
+  0x30, 0x53, 0x30, 0x7b, 0x30, 0x98, 0x30, 0xb5, 0x30, 0xd2, 0x30, 0xef,
+  0x31, 0x18, 0x31, 0x41, 0x31, 0x5e, 0x31, 0x7b, 0x31, 0xb0, 0x31, 0xd7,
+  0x31, 0xfe, 0x32, 0x1a, 0x32, 0x36, 0x32, 0x5e, 0x32, 0x5e, 0x32, 0x5e,
+  0x32, 0xc6, 0x33, 0x30, 0x33, 0xa6, 0x34, 0x17, 0x34, 0x59, 0x34, 0x93,
+  0x34, 0xd4, 0x35, 0x21, 0x35, 0x60, 0x35, 0x99, 0x35, 0xa9, 0x35, 0xd5,
+  0x35, 0xeb, 0x36, 0x08, 0x36, 0x61, 0x36, 0x83, 0x36, 0x99, 0x36, 0xb7,
+  0x36, 0xc7, 0x36, 0xe8, 0x36, 0xf8, 0x37, 0x14, 0x37, 0x36, 0x37, 0x6c,
+  0x37, 0xea, 0x38, 0x94, 0x38, 0xbb, 0x38, 0xf2, 0x39, 0x15, 0x39, 0x2c,
+  0x39, 0x48, 0x39, 0x59, 0x39, 0x69, 0x39, 0x79, 0x39, 0x97, 0x39, 0xaf,
+  0x3a, 0x79, 0x3a, 0xe1, 0x3b, 0x36, 0x3b, 0x88, 0x3b, 0xb7, 0x3b, 0xf9,
+  0x3c, 0x1e, 0x3c, 0x30, 0x3c, 0x5d, 0x3c, 0x8f, 0x3c, 0xa8, 0x3c, 0xd5,
+  0x3d, 0x50, 0x3d, 0xa2, 0x3d, 0xe6, 0x3e, 0x4b, 0x3e, 0xbe, 0x3f, 0x30,
+  0x3f, 0x54, 0x3f, 0x90, 0x3f, 0xaf, 0x3f, 0xd9, 0x40, 0x10, 0x40, 0x35,
+  0x40, 0x70, 0x40, 0x99, 0x40, 0xe5, 0x41, 0x0e, 0x41, 0x36, 0x41, 0x4f,
+  0x41, 0x74, 0x41, 0x96, 0x41, 0xb2, 0x41, 0xe7, 0x42, 0x23, 0x42, 0x60,
+  0x42, 0x7c, 0x42, 0xb5, 0x42, 0xfa, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0xc5, 0x96, 0x3f, 0x7f, 0x9a, 0x5f, 0x0f, 0x3c, 0xf5,
+  0x00, 0x03, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x24, 0x8b, 0xec,
+  0x00, 0x00, 0x00, 0x00, 0xd1, 0xc8, 0xfb, 0x3d, 0xff, 0xe2, 0xff, 0x15,
+  0x03, 0xf2, 0x03, 0x57, 0x00, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x54, 0x02, 0x1c, 0x00, 0x00,
+  0x02, 0x1c, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x2d, 0x02, 0x1c, 0x00, 0x2d,
+  0x02, 0x1c, 0x00, 0x2d, 0x02, 0x1c, 0x00, 0x2d, 0x02, 0x1c, 0x00, 0x2d,
+  0x02, 0x1c, 0x00, 0x2d, 0x02, 0x1c, 0x00, 0x2d, 0x02, 0x1c, 0x00, 0x0f,
+  0x02, 0x1c, 0x00, 0x55, 0x02, 0x1c, 0x00, 0x6d, 0x02, 0x1c, 0x00, 0x6d,
+  0x02, 0x1c, 0x00, 0x52, 0x02, 0x1c, 0x00, 0x22, 0x02, 0x1c, 0x00, 0x67,
+  0x02, 0x1c, 0x00, 0x67, 0x02, 0x1c, 0x00, 0x67, 0x02, 0x1c, 0x00, 0x67,
+  0x02, 0x1c, 0x00, 0x67, 0x02, 0x1c, 0x00, 0x6a, 0x02, 0x1c, 0x00, 0x5e,
+  0x02, 0x1c, 0x00, 0x50, 0x02, 0x1c, 0x00, 0x88, 0x02, 0x1c, 0x00, 0x88,
+  0x02, 0x1c, 0x00, 0x72, 0x02, 0x1c, 0x00, 0x80, 0x02, 0x1c, 0x00, 0x88,
+  0x02, 0x1c, 0x00, 0x7d, 0x02, 0x1c, 0x00, 0x51, 0x02, 0x1c, 0x00, 0x73,
+  0x02, 0x1c, 0x00, 0x4b, 0x02, 0x1c, 0x00, 0x35, 0x02, 0x1c, 0x00, 0x4f,
+  0x02, 0x1c, 0x00, 0x4f, 0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x46,
+  0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x46,
+  0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x1a,
+  0x02, 0x1c, 0x00, 0x5a, 0x02, 0x1c, 0x00, 0x5e, 0x02, 0x1c, 0x00, 0x46,
+  0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x64, 0x02, 0x1c, 0x00, 0x64,
+  0x02, 0x1c, 0x00, 0x43, 0x02, 0x1c, 0x00, 0x4d, 0x02, 0x1c, 0x00, 0x4d,
+  0x02, 0x1c, 0x00, 0x4d, 0x02, 0x1c, 0x00, 0x4d, 0x02, 0x1c, 0x00, 0x4d,
+  0x02, 0x1c, 0x00, 0x38, 0x02, 0x1c, 0x00, 0x33, 0x02, 0x1c, 0x00, 0x33,
+  0x02, 0x1c, 0x00, 0x2c, 0x02, 0x1c, 0x00, 0x2c, 0x02, 0x1c, 0x00, 0x2c,
+  0x02, 0x1c, 0x00, 0x57, 0x02, 0x1c, 0x00, 0x57, 0x02, 0x1c, 0x00, 0x43,
+  0x02, 0x1c, 0x00, 0x43, 0x02, 0x1c, 0x00, 0x43, 0x02, 0x1c, 0x00, 0x43,
+  0x02, 0x1c, 0x00, 0x43, 0x02, 0x1c, 0x00, 0x43, 0x02, 0x1c, 0x00, 0x43,
+  0x02, 0x1c, 0x00, 0x19, 0x02, 0x1c, 0x00, 0x57, 0x02, 0x1c, 0x00, 0x78,
+  0x02, 0x1c, 0x00, 0x78, 0x02, 0x1c, 0x00, 0x54, 0x02, 0x1c, 0x00, 0x5e,
+  0x02, 0x1c, 0x00, 0x5e, 0x02, 0x1c, 0x00, 0x5e, 0x02, 0x1c, 0x00, 0x5e,
+  0x02, 0x1c, 0x00, 0x5e, 0x02, 0x1c, 0x00, 0x5e, 0x02, 0x1c, 0x00, 0x63,
+  0x02, 0x1c, 0x00, 0x48, 0x02, 0x1c, 0x00, 0x57, 0x02, 0x1c, 0x00, 0x50,
+  0x02, 0x1c, 0x00, 0x50, 0x02, 0x1c, 0x00, 0x50, 0x02, 0x1c, 0x00, 0x50,
+  0x02, 0x1c, 0x00, 0x50, 0x02, 0x1c, 0x00, 0x50, 0x02, 0x1c, 0x00, 0x89,
+  0x02, 0x1c, 0x00, 0x60, 0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x46,
+  0x02, 0x1c, 0x00, 0x2b, 0x02, 0x1c, 0x00, 0x57, 0x02, 0x1c, 0x00, 0x57,
+  0x02, 0x1c, 0x00, 0x53, 0x02, 0x1c, 0x00, 0x53, 0x02, 0x1c, 0x00, 0x53,
+  0x02, 0x1c, 0x00, 0x53, 0x02, 0x1c, 0x00, 0x4f, 0x02, 0x1c, 0x00, 0x53,
+  0x02, 0x1c, 0x00, 0x53, 0x02, 0x1c, 0x00, 0x1a, 0x02, 0x1c, 0x00, 0x57,
+  0x02, 0x1c, 0x00, 0x61, 0x02, 0x1c, 0x00, 0x54, 0x02, 0x1c, 0x00, 0x64,
+  0x02, 0x1c, 0x00, 0x76, 0x02, 0x1c, 0x00, 0x6f, 0x02, 0x1c, 0x00, 0x4e,
+  0x02, 0x1c, 0x00, 0x6b, 0x02, 0x1c, 0x00, 0x5d, 0x02, 0x1c, 0x00, 0x5d,
+  0x02, 0x1c, 0x00, 0x5d, 0x02, 0x1c, 0x00, 0x5d, 0x02, 0x1c, 0x00, 0x5d,
+  0x02, 0x1c, 0x00, 0x40, 0x02, 0x1c, 0x00, 0x23, 0x02, 0x1c, 0x00, 0x41,
+  0x02, 0x1c, 0x00, 0x3f, 0x02, 0x1c, 0x00, 0x3f, 0x02, 0x1c, 0x00, 0x3f,
+  0x02, 0x1c, 0x00, 0x6a, 0x02, 0x1c, 0x00, 0xa7, 0x04, 0x38, 0x00, 0x63,
+  0x04, 0x38, 0x00, 0x63, 0x02, 0x1c, 0x00, 0x7d, 0x02, 0x1c, 0x00, 0x84,
+  0x02, 0x1c, 0x00, 0x32, 0x02, 0x1c, 0x00, 0x2d, 0x02, 0x1c, 0x00, 0x67,
+  0x02, 0x1c, 0x00, 0x67, 0x02, 0x1c, 0x00, 0x30, 0x02, 0x1c, 0x00, 0x5c,
+  0x02, 0x1c, 0x00, 0x66, 0x02, 0x1c, 0x00, 0x69, 0x02, 0x1c, 0x00, 0x79,
+  0x02, 0x1c, 0x00, 0x57, 0x02, 0x1c, 0x00, 0x77, 0x02, 0x1c, 0x00, 0x61,
+  0x02, 0x1c, 0x00, 0x68, 0x02, 0x1c, 0x00, 0x56, 0x02, 0x1c, 0x00, 0x60,
+  0x02, 0x1c, 0x00, 0x69, 0x02, 0x1c, 0x00, 0x0b, 0x02, 0x1c, 0x00, 0x0b,
+  0x02, 0x1c, 0x00, 0x15, 0x02, 0x1c, 0x00, 0x92, 0x02, 0x1c, 0x00, 0x96,
+  0x02, 0x1c, 0x00, 0x9e, 0x02, 0x1c, 0x00, 0x46, 0x02, 0x1c, 0x00, 0x32,
+  0x02, 0x1c, 0x00, 0xdc, 0x02, 0x1c, 0x00, 0xc3, 0x02, 0x1c, 0x00, 0xdc,
+  0x02, 0x1c, 0x00, 0xc8, 0x02, 0x1c, 0x00, 0x28, 0x02, 0x1c, 0x00, 0xdc,
+  0x02, 0x1c, 0x00, 0xdc, 0x02, 0x1c, 0x00, 0x50, 0x02, 0x1c, 0x00, 0xdc,
+  0x02, 0x1c, 0x00, 0x7e, 0x02, 0x1c, 0x00, 0x83, 0x02, 0x1c, 0x00, 0x91,
+  0x02, 0x1c, 0x00, 0xde, 0x02, 0x1c, 0x00, 0xc8, 0x02, 0x1c, 0x00, 0x32,
+  0x02, 0x1c, 0x00, 0x12, 0x02, 0x1c, 0x00, 0x93, 0x02, 0x1c, 0x00, 0x93,
+  0x02, 0x1c, 0x00, 0xa5, 0x02, 0x1c, 0x00, 0xa5, 0x02, 0x1c, 0x00, 0xaa,
+  0x02, 0x1c, 0x00, 0xaa, 0x02, 0x1c, 0x00, 0x20, 0x02, 0x1c, 0x00, 0x50,
+  0x02, 0x1c, 0x00, 0x6b, 0x02, 0x1c, 0x00, 0x6b, 0x02, 0x1c, 0x00, 0x70,
+  0x02, 0x1c, 0x00, 0x70, 0x02, 0x1c, 0x00, 0xc0, 0x02, 0x1c, 0x00, 0xc0,
+  0x02, 0x1c, 0x00, 0x82, 0x02, 0x1c, 0x00, 0x82, 0x02, 0x1c, 0x00, 0x82,
+  0x02, 0x1c, 0x00, 0xcf, 0x02, 0x1c, 0x00, 0xcf, 0x02, 0x1c, 0x00, 0xcf,
+  0x02, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x59,
+  0x00, 0x78, 0x00, 0x0e, 0x00, 0x69, 0x00, 0x4f, 0x00, 0x5c, 0x00, 0x37,
+  0x00, 0x64, 0x00, 0x64, 0x00, 0x50, 0x00, 0xdc, 0x00, 0x50, 0x00, 0x50,
+  0x00, 0x50, 0x00, 0x0d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x50, 0x00, 0xdc,
+  0x00, 0x3e, 0x00, 0x50, 0x00, 0x61, 0x00, 0x50, 0x00, 0x60, 0x00, 0x0c,
+  0x00, 0x09, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x2b, 0x00, 0x16, 0x00, 0x4d,
+  0x00, 0x46, 0x00, 0xdc, 0x00, 0xdc, 0x00, 0x4b, 0x00, 0x54, 0xff, 0xe2,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x28, 0x00, 0x14,
+  0x00, 0x4a, 0x00, 0x5b, 0x00, 0x0e, 0x00, 0xe6, 0x00, 0xe6, 0x00, 0x1d,
+  0x00, 0x53, 0x00, 0x3e, 0x00, 0x19, 0x00, 0x19, 0x00, 0x71, 0x00, 0x0e,
+  0x00, 0x81, 0x00, 0x47, 0x00, 0x59, 0x00, 0x59, 0x00, 0xa8, 0x00, 0x80,
+  0x00, 0x71, 0x00, 0xb7, 0x00, 0x71, 0x00, 0x7f, 0x00, 0xe3, 0x00, 0xa3,
+  0x00, 0x4d, 0x00, 0x8e, 0x00, 0xb5, 0x00, 0xb2, 0x00, 0x82, 0x00, 0x8e,
+  0x00, 0x6d, 0x00, 0x1e, 0x00, 0x01, 0x00, 0x00, 0x03, 0x75, 0xff, 0x0e,
+  0x00, 0x00, 0x04, 0x38, 0xff, 0xe2, 0xff, 0xe2, 0x03, 0xf2, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xc2, 0x00, 0x03, 0x02, 0x20, 0x01, 0x90, 0x00, 0x05,
+  0x00, 0x00, 0x02, 0x8a, 0x02, 0x58, 0x00, 0x00, 0x00, 0x4b, 0x02, 0x8a,
+  0x02, 0x58, 0x00, 0x00, 0x01, 0x5e, 0x00, 0x32, 0x01, 0x2c, 0x00, 0x00,
+  0x02, 0x0b, 0x05, 0x09, 0x05, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x55, 0x4b, 0x57, 0x4e, 0x00, 0x40, 0x00, 0x00, 0xfb, 0x02,
+  0x03, 0x75, 0xff, 0x0e, 0x00, 0x00, 0x03, 0x75, 0x00, 0xf2, 0x20, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf4, 0x02, 0xbc, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x14, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x14,
+  0x00, 0x04, 0x03, 0x6e, 0x00, 0x00, 0x00, 0x6e, 0x00, 0x40, 0x00, 0x05,
+  0x00, 0x2e, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x2f, 0x00, 0x39, 0x00, 0x7e,
+  0x00, 0xff, 0x01, 0x31, 0x01, 0x42, 0x01, 0x53, 0x01, 0x61, 0x01, 0x78,
+  0x01, 0x7e, 0x01, 0x92, 0x02, 0xc7, 0x02, 0xc9, 0x02, 0xdd, 0x03, 0xbc,
+  0x03, 0xc0, 0x20, 0x14, 0x20, 0x1a, 0x20, 0x1e, 0x20, 0x22, 0x20, 0x26,
+  0x20, 0x30, 0x20, 0x3a, 0x20, 0x44, 0x20, 0xac, 0x21, 0x22, 0x21, 0x26,
+  0x22, 0x02, 0x22, 0x06, 0x22, 0x0f, 0x22, 0x12, 0x22, 0x15, 0x22, 0x1a,
+  0x22, 0x1e, 0x22, 0x24, 0x22, 0x27, 0x22, 0x2b, 0x22, 0x48, 0x22, 0x60,
+  0x22, 0x65, 0x22, 0xc5, 0x25, 0xaf, 0x25, 0xca, 0x26, 0x20, 0x26, 0x3c,
+  0x26, 0x40, 0x26, 0x42, 0x26, 0x60, 0x26, 0x63, 0x26, 0x66, 0x26, 0x6b,
+  0xfb, 0x02, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x20,
+  0x00, 0x30, 0x00, 0x3a, 0x00, 0xa0, 0x01, 0x31, 0x01, 0x41, 0x01, 0x52,
+  0x01, 0x60, 0x01, 0x78, 0x01, 0x7d, 0x01, 0x92, 0x02, 0xc6, 0x02, 0xc9,
+  0x02, 0xd8, 0x03, 0xbc, 0x03, 0xc0, 0x20, 0x13, 0x20, 0x18, 0x20, 0x1c,
+  0x20, 0x20, 0x20, 0x26, 0x20, 0x30, 0x20, 0x39, 0x20, 0x44, 0x20, 0xac,
+  0x21, 0x22, 0x21, 0x26, 0x22, 0x02, 0x22, 0x06, 0x22, 0x0f, 0x22, 0x11,
+  0x22, 0x15, 0x22, 0x19, 0x22, 0x1e, 0x22, 0x24, 0x22, 0x27, 0x22, 0x2b,
+  0x22, 0x48, 0x22, 0x60, 0x22, 0x64, 0x22, 0xc5, 0x25, 0xaf, 0x25, 0xca,
+  0x26, 0x20, 0x26, 0x3a, 0x26, 0x40, 0x26, 0x42, 0x26, 0x60, 0x26, 0x63,
+  0x26, 0x65, 0x26, 0x6a, 0xfb, 0x01, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xf4,
+  0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0xff, 0x25, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xfe, 0xc5, 0x00, 0x00, 0xff, 0x33, 0x00, 0x00,
+  0xfe, 0x40, 0x00, 0x00, 0xfc, 0xca, 0xfc, 0xc7, 0x00, 0x00, 0xe0, 0xa4,
+  0x00, 0x00, 0x00, 0x00, 0xe0, 0x79, 0xe0, 0xaa, 0xe0, 0x7e, 0xe0, 0x4e,
+  0xe0, 0x15, 0xdf, 0xd5, 0xdf, 0x5e, 0xde, 0xd6, 0xde, 0x7d, 0xde, 0xce,
+  0x00, 0x00, 0xde, 0xcb, 0x00, 0x00, 0xde, 0xb1, 0xde, 0xbe, 0xde, 0xac,
+  0xde, 0xa5, 0xde, 0x80, 0xde, 0x77, 0x00, 0x00, 0xde, 0x06, 0xdb, 0x35,
+  0xdb, 0x19, 0xda, 0xc5, 0xda, 0xac, 0xda, 0xca, 0xda, 0xc9, 0xda, 0x89,
+  0xda, 0x87, 0xda, 0x86, 0xda, 0x83, 0x05, 0x7e, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x86, 0x01, 0x0e, 0x00, 0x00,
+  0x01, 0xca, 0x01, 0xcc, 0x01, 0xce, 0x00, 0x00, 0x01, 0xce, 0x00, 0x00,
+  0x01, 0xce, 0x00, 0x00, 0x01, 0xce, 0x00, 0x00, 0x00, 0x00, 0x01, 0xd4,
+  0x00, 0x00, 0x01, 0xd4, 0x01, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x01, 0xc8, 0x00, 0x00, 0x01, 0xc8, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xbe, 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, 0x02, 0x00, 0xa0, 0x00, 0xa6, 0x00, 0xa2, 0x00, 0xc4, 0x00, 0xd9,
+  0x00, 0xf2, 0x00, 0xa7, 0x00, 0xaf, 0x00, 0xb0, 0x00, 0x99, 0x00, 0xdb,
+  0x00, 0x9e, 0x00, 0xb3, 0x00, 0xa3, 0x00, 0xa9, 0x00, 0x9d, 0x00, 0xa8,
+  0x00, 0xd1, 0x00, 0xcc, 0x00, 0xcd, 0x00, 0xa4, 0x00, 0xf1, 0x00, 0x03,
+  0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0e, 0x00, 0x10, 0x00, 0x15, 0x00, 0x16,
+  0x00, 0x17, 0x00, 0x18, 0x00, 0x1d, 0x00, 0x1e, 0x00, 0x1f, 0x00, 0x21,
+  0x00, 0x22, 0x00, 0x24, 0x00, 0x2c, 0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30,
+  0x00, 0x32, 0x00, 0x33, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b,
+  0x00, 0x3e, 0x00, 0xad, 0x00, 0x9a, 0x00, 0xae, 0x00, 0xf9, 0x00, 0xaa,
+  0x01, 0x03, 0x00, 0x40, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4b, 0x00, 0x4d,
+  0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x5b, 0x00, 0x5c,
+  0x00, 0x5d, 0x00, 0x5f, 0x00, 0x60, 0x00, 0x62, 0x00, 0x6a, 0x00, 0x6c,
+  0x00, 0x6d, 0x00, 0x6e, 0x00, 0x71, 0x00, 0x72, 0x00, 0x77, 0x00, 0x78,
+  0x00, 0x79, 0x00, 0x7a, 0x00, 0x7d, 0x00, 0xab, 0x00, 0xef, 0x00, 0xac,
+  0x00, 0xc9, 0x00, 0xbf, 0x00, 0xa1, 0x00, 0xc2, 0x00, 0xc6, 0x00, 0xc3,
+  0x00, 0xc7, 0x00, 0xf0, 0x00, 0xf6, 0x01, 0x01, 0x00, 0xf4, 0x00, 0x81,
+  0x00, 0xb5, 0x00, 0xd4, 0x00, 0xb4, 0x00, 0xf5, 0x01, 0x05, 0x00, 0xf8,
+  0x00, 0xdc, 0x00, 0x97, 0x00, 0x98, 0x00, 0xfc, 0x00, 0x85, 0x00, 0xf3,
+  0x00, 0x9b, 0x00, 0xff, 0x00, 0x96, 0x00, 0x82, 0x00, 0xb6, 0x00, 0x94,
+  0x00, 0x93, 0x00, 0x95, 0x00, 0xa5, 0x00, 0x07, 0x00, 0x04, 0x00, 0x05,
+  0x00, 0x09, 0x00, 0x06, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x0d, 0x00, 0x14,
+  0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x1c, 0x00, 0x19, 0x00, 0x1a,
+  0x00, 0x1b, 0x00, 0x0f, 0x00, 0x23, 0x00, 0x28, 0x00, 0x25, 0x00, 0x26,
+  0x00, 0x2a, 0x00, 0x27, 0x00, 0xd6, 0x00, 0x29, 0x00, 0x37, 0x00, 0x34,
+  0x00, 0x35, 0x00, 0x36, 0x00, 0x3c, 0x00, 0x2d, 0x00, 0x70, 0x00, 0x44,
+  0x00, 0x41, 0x00, 0x42, 0x00, 0x46, 0x00, 0x43, 0x00, 0x45, 0x00, 0x47,
+  0x00, 0x4a, 0x00, 0x51, 0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x5a,
+  0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x4c, 0x00, 0x61, 0x00, 0x66,
+  0x00, 0x63, 0x00, 0x64, 0x00, 0x68, 0x00, 0x65, 0x00, 0xca, 0x00, 0x67,
+  0x00, 0x76, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x7b, 0x00, 0x6b,
+  0x00, 0x7c, 0x00, 0x20, 0x00, 0x5e, 0x00, 0x2b, 0x00, 0x69, 0x00, 0x31,
+  0x00, 0x6f, 0x00, 0x3f, 0x00, 0x7e, 0x01, 0x00, 0x00, 0xfe, 0x00, 0xfd,
+  0x01, 0x02, 0x01, 0x07, 0x01, 0x06, 0x01, 0x08, 0x01, 0x04, 0x00, 0xb2,
+  0x00, 0xb1, 0x00, 0xba, 0x00, 0xbb, 0x00, 0xb9, 0x00, 0xfa, 0x00, 0xfb,
+  0x00, 0x9c, 0x00, 0xdf, 0x00, 0xd5, 0x00, 0xe1, 0x00, 0xde, 0x00, 0xd2,
+  0x00, 0xce, 0x00, 0x00, 0xb0, 0x00, 0x2c, 0x20, 0xb0, 0x00, 0x55, 0x58,
+  0x45, 0x59, 0x20, 0x20, 0x4b, 0xb0, 0x0e, 0x51, 0x4b, 0xb0, 0x06, 0x53,
+  0x5a, 0x58, 0xb0, 0x34, 0x1b, 0xb0, 0x28, 0x59, 0x60, 0x66, 0x20, 0x8a,
+  0x55, 0x58, 0xb0, 0x02, 0x25, 0x61, 0xb9, 0x08, 0x00, 0x08, 0x00, 0x63,
+  0x63, 0x23, 0x62, 0x1b, 0x21, 0x21, 0xb0, 0x00, 0x59, 0xb0, 0x00, 0x43,
+  0x23, 0x44, 0xb2, 0x00, 0x01, 0x00, 0x43, 0x60, 0x42, 0x2d, 0xb0, 0x01,
+  0x2c, 0xb0, 0x20, 0x60, 0x66, 0x2d, 0xb0, 0x02, 0x2c, 0x20, 0x64, 0x20,
+  0xb0, 0xc0, 0x50, 0xb0, 0x04, 0x26, 0x5a, 0xb2, 0x28, 0x01, 0x0a, 0x43,
+  0x45, 0x63, 0x45, 0x52, 0x5b, 0x58, 0x21, 0x23, 0x21, 0x1b, 0x8a, 0x58,
+  0x20, 0xb0, 0x50, 0x50, 0x58, 0x21, 0xb0, 0x40, 0x59, 0x1b, 0x20, 0xb0,
+  0x38, 0x50, 0x58, 0x21, 0xb0, 0x38, 0x59, 0x59, 0x20, 0xb1, 0x01, 0x0a,
+  0x43, 0x45, 0x63, 0x45, 0x61, 0x64, 0xb0, 0x28, 0x50, 0x58, 0x21, 0xb1,
+  0x01, 0x0a, 0x43, 0x45, 0x63, 0x45, 0x20, 0xb0, 0x30, 0x50, 0x58, 0x21,
+  0xb0, 0x30, 0x59, 0x1b, 0x20, 0xb0, 0xc0, 0x50, 0x58, 0x20, 0x66, 0x20,
+  0x8a, 0x8a, 0x61, 0x20, 0xb0, 0x0a, 0x50, 0x58, 0x60, 0x1b, 0x20, 0xb0,
+  0x20, 0x50, 0x58, 0x21, 0xb0, 0x0a, 0x60, 0x1b, 0x20, 0xb0, 0x36, 0x50,
+  0x58, 0x21, 0xb0, 0x36, 0x60, 0x1b, 0x60, 0x59, 0x59, 0x59, 0x1b, 0xb0,
+  0x01, 0x2b, 0x59, 0x59, 0x23, 0xb0, 0x00, 0x50, 0x58, 0x65, 0x59, 0x59,
+  0x2d, 0xb0, 0x03, 0x2c, 0x20, 0x45, 0x20, 0xb0, 0x04, 0x25, 0x61, 0x64,
+  0x20, 0xb0, 0x05, 0x43, 0x50, 0x58, 0xb0, 0x05, 0x23, 0x42, 0xb0, 0x06,
+  0x23, 0x42, 0x1b, 0x21, 0x21, 0x59, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x04,
+  0x2c, 0x23, 0x21, 0x23, 0x21, 0x20, 0x64, 0xb1, 0x05, 0x62, 0x42, 0x20,
+  0xb0, 0x06, 0x23, 0x42, 0xb1, 0x01, 0x0a, 0x43, 0x45, 0x63, 0xb1, 0x01,
+  0x0a, 0x43, 0xb0, 0x02, 0x60, 0x45, 0x63, 0xb0, 0x03, 0x2a, 0x21, 0x20,
+  0xb0, 0x06, 0x43, 0x20, 0x8a, 0x20, 0x8a, 0xb0, 0x01, 0x2b, 0xb1, 0x30,
+  0x05, 0x25, 0xb0, 0x04, 0x26, 0x51, 0x58, 0x60, 0x50, 0x1b, 0x61, 0x52,
+  0x59, 0x58, 0x23, 0x59, 0x21, 0x20, 0xb0, 0x40, 0x53, 0x58, 0xb0, 0x01,
+  0x2b, 0x1b, 0x21, 0xb0, 0x40, 0x59, 0x23, 0xb0, 0x00, 0x50, 0x58, 0x65,
+  0x59, 0x2d, 0xb0, 0x05, 0x2c, 0xb0, 0x07, 0x43, 0x2b, 0xb2, 0x00, 0x02,
+  0x00, 0x43, 0x60, 0x42, 0x2d, 0xb0, 0x06, 0x2c, 0xb0, 0x07, 0x23, 0x42,
+  0x23, 0x20, 0xb0, 0x00, 0x23, 0x42, 0x61, 0xb0, 0x02, 0x62, 0x66, 0xb0,
+  0x01, 0x63, 0xb0, 0x01, 0x60, 0xb0, 0x05, 0x2a, 0x2d, 0xb0, 0x07, 0x2c,
+  0x20, 0x20, 0x45, 0x20, 0xb0, 0x0b, 0x43, 0x63, 0xb8, 0x04, 0x00, 0x62,
+  0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01,
+  0x63, 0x60, 0x44, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x08, 0x2c, 0xb2, 0x07,
+  0x0b, 0x00, 0x43, 0x45, 0x42, 0x2a, 0x21, 0xb2, 0x00, 0x01, 0x00, 0x43,
+  0x60, 0x42, 0x2d, 0xb0, 0x09, 0x2c, 0xb0, 0x00, 0x43, 0x23, 0x44, 0xb2,
+  0x00, 0x01, 0x00, 0x43, 0x60, 0x42, 0x2d, 0xb0, 0x0a, 0x2c, 0x20, 0x20,
+  0x45, 0x20, 0xb0, 0x01, 0x2b, 0x23, 0xb0, 0x00, 0x43, 0xb0, 0x04, 0x25,
+  0x60, 0x20, 0x45, 0x8a, 0x23, 0x61, 0x20, 0x64, 0x20, 0xb0, 0x20, 0x50,
+  0x58, 0x21, 0xb0, 0x00, 0x1b, 0xb0, 0x30, 0x50, 0x58, 0xb0, 0x20, 0x1b,
+  0xb0, 0x40, 0x59, 0x59, 0x23, 0xb0, 0x00, 0x50, 0x58, 0x65, 0x59, 0xb0,
+  0x03, 0x25, 0x23, 0x61, 0x44, 0x44, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x0b,
+  0x2c, 0x20, 0x20, 0x45, 0x20, 0xb0, 0x01, 0x2b, 0x23, 0xb0, 0x00, 0x43,
+  0xb0, 0x04, 0x25, 0x60, 0x20, 0x45, 0x8a, 0x23, 0x61, 0x20, 0x64, 0xb0,
+  0x24, 0x50, 0x58, 0xb0, 0x00, 0x1b, 0xb0, 0x40, 0x59, 0x23, 0xb0, 0x00,
+  0x50, 0x58, 0x65, 0x59, 0xb0, 0x03, 0x25, 0x23, 0x61, 0x44, 0x44, 0xb0,
+  0x01, 0x60, 0x2d, 0xb0, 0x0c, 0x2c, 0x20, 0xb0, 0x00, 0x23, 0x42, 0xb2,
+  0x0b, 0x0a, 0x03, 0x45, 0x58, 0x21, 0x1b, 0x23, 0x21, 0x59, 0x2a, 0x21,
+  0x2d, 0xb0, 0x0d, 0x2c, 0xb1, 0x02, 0x02, 0x45, 0xb0, 0x64, 0x61, 0x44,
+  0x2d, 0xb0, 0x0e, 0x2c, 0xb0, 0x01, 0x60, 0x20, 0x20, 0xb0, 0x0c, 0x43,
+  0x4a, 0xb0, 0x00, 0x50, 0x58, 0x20, 0xb0, 0x0c, 0x23, 0x42, 0x59, 0xb0,
+  0x0d, 0x43, 0x4a, 0xb0, 0x00, 0x52, 0x58, 0x20, 0xb0, 0x0d, 0x23, 0x42,
+  0x59, 0x2d, 0xb0, 0x0f, 0x2c, 0x20, 0xb0, 0x10, 0x62, 0x66, 0xb0, 0x01,
+  0x63, 0x20, 0xb8, 0x04, 0x00, 0x63, 0x8a, 0x23, 0x61, 0xb0, 0x0e, 0x43,
+  0x60, 0x20, 0x8a, 0x60, 0x20, 0xb0, 0x0e, 0x23, 0x42, 0x23, 0x2d, 0xb0,
+  0x10, 0x2c, 0x4b, 0x54, 0x58, 0xb1, 0x04, 0x64, 0x44, 0x59, 0x24, 0xb0,
+  0x0d, 0x65, 0x23, 0x78, 0x2d, 0xb0, 0x11, 0x2c, 0x4b, 0x51, 0x58, 0x4b,
+  0x53, 0x58, 0xb1, 0x04, 0x64, 0x44, 0x59, 0x1b, 0x21, 0x59, 0x24, 0xb0,
+  0x13, 0x65, 0x23, 0x78, 0x2d, 0xb0, 0x12, 0x2c, 0xb1, 0x00, 0x0f, 0x43,
+  0x55, 0x58, 0xb1, 0x0f, 0x0f, 0x43, 0xb0, 0x01, 0x61, 0x42, 0xb0, 0x0f,
+  0x2b, 0x59, 0xb0, 0x00, 0x43, 0xb0, 0x02, 0x25, 0x42, 0xb1, 0x0c, 0x02,
+  0x25, 0x42, 0xb1, 0x0d, 0x02, 0x25, 0x42, 0xb0, 0x01, 0x16, 0x23, 0x20,
+  0xb0, 0x03, 0x25, 0x50, 0x58, 0xb1, 0x01, 0x00, 0x43, 0x60, 0xb0, 0x04,
+  0x25, 0x42, 0x8a, 0x8a, 0x20, 0x8a, 0x23, 0x61, 0xb0, 0x0e, 0x2a, 0x21,
+  0x23, 0xb0, 0x01, 0x61, 0x20, 0x8a, 0x23, 0x61, 0xb0, 0x0e, 0x2a, 0x21,
+  0x1b, 0xb1, 0x01, 0x00, 0x43, 0x60, 0xb0, 0x02, 0x25, 0x42, 0xb0, 0x02,
+  0x25, 0x61, 0xb0, 0x0e, 0x2a, 0x21, 0x59, 0xb0, 0x0c, 0x43, 0x47, 0xb0,
+  0x0d, 0x43, 0x47, 0x60, 0xb0, 0x02, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58,
+  0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0x20, 0xb0, 0x0b, 0x43,
+  0x63, 0xb8, 0x04, 0x00, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40,
+  0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0x60, 0xb1, 0x00, 0x00, 0x13, 0x23,
+  0x44, 0xb0, 0x01, 0x43, 0xb0, 0x00, 0x3e, 0xb2, 0x01, 0x01, 0x01, 0x43,
+  0x60, 0x42, 0x2d, 0xb0, 0x13, 0x2c, 0x00, 0xb1, 0x00, 0x02, 0x45, 0x54,
+  0x58, 0xb0, 0x0f, 0x23, 0x42, 0x20, 0x45, 0xb0, 0x0b, 0x23, 0x42, 0xb0,
+  0x0a, 0x23, 0xb0, 0x02, 0x60, 0x42, 0x20, 0x60, 0xb0, 0x01, 0x61, 0xb5,
+  0x10, 0x10, 0x01, 0x00, 0x0e, 0x00, 0x42, 0x42, 0x8a, 0x60, 0xb1, 0x12,
+  0x06, 0x2b, 0xb0, 0x72, 0x2b, 0x1b, 0x22, 0x59, 0x2d, 0xb0, 0x14, 0x2c,
+  0xb1, 0x00, 0x13, 0x2b, 0x2d, 0xb0, 0x15, 0x2c, 0xb1, 0x01, 0x13, 0x2b,
+  0x2d, 0xb0, 0x16, 0x2c, 0xb1, 0x02, 0x13, 0x2b, 0x2d, 0xb0, 0x17, 0x2c,
+  0xb1, 0x03, 0x13, 0x2b, 0x2d, 0xb0, 0x18, 0x2c, 0xb1, 0x04, 0x13, 0x2b,
+  0x2d, 0xb0, 0x19, 0x2c, 0xb1, 0x05, 0x13, 0x2b, 0x2d, 0xb0, 0x1a, 0x2c,
+  0xb1, 0x06, 0x13, 0x2b, 0x2d, 0xb0, 0x1b, 0x2c, 0xb1, 0x07, 0x13, 0x2b,
+  0x2d, 0xb0, 0x1c, 0x2c, 0xb1, 0x08, 0x13, 0x2b, 0x2d, 0xb0, 0x1d, 0x2c,
+  0xb1, 0x09, 0x13, 0x2b, 0x2d, 0xb0, 0x1e, 0x2c, 0x00, 0xb0, 0x0d, 0x2b,
+  0xb1, 0x00, 0x02, 0x45, 0x54, 0x58, 0xb0, 0x0f, 0x23, 0x42, 0x20, 0x45,
+  0xb0, 0x0b, 0x23, 0x42, 0xb0, 0x0a, 0x23, 0xb0, 0x02, 0x60, 0x42, 0x20,
+  0x60, 0xb0, 0x01, 0x61, 0xb5, 0x10, 0x10, 0x01, 0x00, 0x0e, 0x00, 0x42,
+  0x42, 0x8a, 0x60, 0xb1, 0x12, 0x06, 0x2b, 0xb0, 0x72, 0x2b, 0x1b, 0x22,
+  0x59, 0x2d, 0xb0, 0x1f, 0x2c, 0xb1, 0x00, 0x1e, 0x2b, 0x2d, 0xb0, 0x20,
+  0x2c, 0xb1, 0x01, 0x1e, 0x2b, 0x2d, 0xb0, 0x21, 0x2c, 0xb1, 0x02, 0x1e,
+  0x2b, 0x2d, 0xb0, 0x22, 0x2c, 0xb1, 0x03, 0x1e, 0x2b, 0x2d, 0xb0, 0x23,
+  0x2c, 0xb1, 0x04, 0x1e, 0x2b, 0x2d, 0xb0, 0x24, 0x2c, 0xb1, 0x05, 0x1e,
+  0x2b, 0x2d, 0xb0, 0x25, 0x2c, 0xb1, 0x06, 0x1e, 0x2b, 0x2d, 0xb0, 0x26,
+  0x2c, 0xb1, 0x07, 0x1e, 0x2b, 0x2d, 0xb0, 0x27, 0x2c, 0xb1, 0x08, 0x1e,
+  0x2b, 0x2d, 0xb0, 0x28, 0x2c, 0xb1, 0x09, 0x1e, 0x2b, 0x2d, 0xb0, 0x29,
+  0x2c, 0x20, 0x3c, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x2a, 0x2c, 0x20, 0x60,
+  0xb0, 0x10, 0x60, 0x20, 0x43, 0x23, 0xb0, 0x01, 0x60, 0x43, 0xb0, 0x02,
+  0x25, 0x61, 0xb0, 0x01, 0x60, 0xb0, 0x29, 0x2a, 0x21, 0x2d, 0xb0, 0x2b,
+  0x2c, 0xb0, 0x2a, 0x2b, 0xb0, 0x2a, 0x2a, 0x2d, 0xb0, 0x2c, 0x2c, 0x20,
+  0x20, 0x47, 0x20, 0x20, 0xb0, 0x0b, 0x43, 0x63, 0xb8, 0x04, 0x00, 0x62,
+  0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01,
+  0x63, 0x60, 0x23, 0x61, 0x38, 0x23, 0x20, 0x8a, 0x55, 0x58, 0x20, 0x47,
+  0x20, 0x20, 0xb0, 0x0b, 0x43, 0x63, 0xb8, 0x04, 0x00, 0x62, 0x20, 0xb0,
+  0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0x60,
+  0x23, 0x61, 0x38, 0x1b, 0x21, 0x59, 0x2d, 0xb0, 0x2d, 0x2c, 0x00, 0xb1,
+  0x00, 0x02, 0x45, 0x54, 0x58, 0xb0, 0x01, 0x16, 0xb0, 0x2c, 0x2a, 0xb0,
+  0x01, 0x15, 0x30, 0x1b, 0x22, 0x59, 0x2d, 0xb0, 0x2e, 0x2c, 0x00, 0xb0,
+  0x0d, 0x2b, 0xb1, 0x00, 0x02, 0x45, 0x54, 0x58, 0xb0, 0x01, 0x16, 0xb0,
+  0x2c, 0x2a, 0xb0, 0x01, 0x15, 0x30, 0x1b, 0x22, 0x59, 0x2d, 0xb0, 0x2f,
+  0x2c, 0x20, 0x35, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x30, 0x2c, 0x00, 0xb0,
+  0x01, 0x45, 0x63, 0xb8, 0x04, 0x00, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58,
+  0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0xb0, 0x01, 0x2b, 0xb0,
+  0x0b, 0x43, 0x63, 0xb8, 0x04, 0x00, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58,
+  0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0xb0, 0x01, 0x2b, 0xb0,
+  0x00, 0x16, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x3e, 0x23, 0x38,
+  0xb1, 0x2f, 0x01, 0x15, 0x2a, 0x2d, 0xb0, 0x31, 0x2c, 0x20, 0x3c, 0x20,
+  0x47, 0x20, 0xb0, 0x0b, 0x43, 0x63, 0xb8, 0x04, 0x00, 0x62, 0x20, 0xb0,
+  0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0x60,
+  0xb0, 0x00, 0x43, 0x61, 0x38, 0x2d, 0xb0, 0x32, 0x2c, 0x2e, 0x17, 0x3c,
+  0x2d, 0xb0, 0x33, 0x2c, 0x20, 0x3c, 0x20, 0x47, 0x20, 0xb0, 0x0b, 0x43,
+  0x63, 0xb8, 0x04, 0x00, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40,
+  0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0x60, 0xb0, 0x00, 0x43, 0x61, 0xb0,
+  0x01, 0x43, 0x63, 0x38, 0x2d, 0xb0, 0x34, 0x2c, 0xb1, 0x02, 0x00, 0x16,
+  0x25, 0x20, 0x2e, 0x20, 0x47, 0xb0, 0x00, 0x23, 0x42, 0xb0, 0x02, 0x25,
+  0x49, 0x8a, 0x8a, 0x47, 0x23, 0x47, 0x23, 0x61, 0x20, 0x58, 0x62, 0x1b,
+  0x21, 0x59, 0xb0, 0x01, 0x23, 0x42, 0xb2, 0x33, 0x01, 0x01, 0x15, 0x14,
+  0x2a, 0x2d, 0xb0, 0x35, 0x2c, 0xb0, 0x00, 0x16, 0xb0, 0x04, 0x25, 0xb0,
+  0x04, 0x25, 0x47, 0x23, 0x47, 0x23, 0x61, 0xb0, 0x09, 0x43, 0x2b, 0x65,
+  0x8a, 0x2e, 0x23, 0x20, 0x20, 0x3c, 0x8a, 0x38, 0x2d, 0xb0, 0x36, 0x2c,
+  0xb0, 0x00, 0x16, 0xb0, 0x04, 0x25, 0xb0, 0x04, 0x25, 0x20, 0x2e, 0x47,
+  0x23, 0x47, 0x23, 0x61, 0x20, 0xb0, 0x04, 0x23, 0x42, 0xb0, 0x09, 0x43,
+  0x2b, 0x20, 0xb0, 0x60, 0x50, 0x58, 0x20, 0xb0, 0x40, 0x51, 0x58, 0xb3,
+  0x02, 0x20, 0x03, 0x20, 0x1b, 0xb3, 0x02, 0x26, 0x03, 0x1a, 0x59, 0x42,
+  0x42, 0x23, 0x20, 0xb0, 0x08, 0x43, 0x20, 0x8a, 0x23, 0x47, 0x23, 0x47,
+  0x23, 0x61, 0x23, 0x46, 0x60, 0xb0, 0x04, 0x43, 0xb0, 0x02, 0x62, 0x20,
+  0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01, 0x63,
+  0x60, 0x20, 0xb0, 0x01, 0x2b, 0x20, 0x8a, 0x8a, 0x61, 0x20, 0xb0, 0x02,
+  0x43, 0x60, 0x64, 0x23, 0xb0, 0x03, 0x43, 0x61, 0x64, 0x50, 0x58, 0xb0,
+  0x02, 0x43, 0x61, 0x1b, 0xb0, 0x03, 0x43, 0x60, 0x59, 0xb0, 0x03, 0x25,
+  0xb0, 0x02, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59,
+  0x66, 0xb0, 0x01, 0x63, 0x61, 0x23, 0x20, 0x20, 0xb0, 0x04, 0x26, 0x23,
+  0x46, 0x61, 0x38, 0x1b, 0x23, 0xb0, 0x08, 0x43, 0x46, 0xb0, 0x02, 0x25,
+  0xb0, 0x08, 0x43, 0x47, 0x23, 0x47, 0x23, 0x61, 0x60, 0x20, 0xb0, 0x04,
+  0x43, 0xb0, 0x02, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60,
+  0x59, 0x66, 0xb0, 0x01, 0x63, 0x60, 0x23, 0x20, 0xb0, 0x01, 0x2b, 0x23,
+  0xb0, 0x04, 0x43, 0x60, 0xb0, 0x01, 0x2b, 0xb0, 0x05, 0x25, 0x61, 0xb0,
+  0x05, 0x25, 0xb0, 0x02, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40,
+  0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0xb0, 0x04, 0x26, 0x61, 0x20, 0xb0,
+  0x04, 0x25, 0x60, 0x64, 0x23, 0xb0, 0x03, 0x25, 0x60, 0x64, 0x50, 0x58,
+  0x21, 0x1b, 0x23, 0x21, 0x59, 0x23, 0x20, 0x20, 0xb0, 0x04, 0x26, 0x23,
+  0x46, 0x61, 0x38, 0x59, 0x2d, 0xb0, 0x37, 0x2c, 0xb0, 0x00, 0x16, 0x20,
+  0x20, 0x20, 0xb0, 0x05, 0x26, 0x20, 0x2e, 0x47, 0x23, 0x47, 0x23, 0x61,
+  0x23, 0x3c, 0x38, 0x2d, 0xb0, 0x38, 0x2c, 0xb0, 0x00, 0x16, 0x20, 0xb0,
+  0x08, 0x23, 0x42, 0x20, 0x20, 0x20, 0x46, 0x23, 0x47, 0xb0, 0x01, 0x2b,
+  0x23, 0x61, 0x38, 0x2d, 0xb0, 0x39, 0x2c, 0xb0, 0x00, 0x16, 0xb0, 0x03,
+  0x25, 0xb0, 0x02, 0x25, 0x47, 0x23, 0x47, 0x23, 0x61, 0xb0, 0x00, 0x54,
+  0x58, 0x2e, 0x20, 0x3c, 0x23, 0x21, 0x1b, 0xb0, 0x02, 0x25, 0xb0, 0x02,
+  0x25, 0x47, 0x23, 0x47, 0x23, 0x61, 0x20, 0xb0, 0x05, 0x25, 0xb0, 0x04,
+  0x25, 0x47, 0x23, 0x47, 0x23, 0x61, 0xb0, 0x06, 0x25, 0xb0, 0x05, 0x25,
+  0x49, 0xb0, 0x02, 0x25, 0x61, 0xb9, 0x08, 0x00, 0x08, 0x00, 0x63, 0x63,
+  0x23, 0x20, 0x58, 0x62, 0x1b, 0x21, 0x59, 0x63, 0xb8, 0x04, 0x00, 0x62,
+  0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0, 0x01,
+  0x63, 0x60, 0x23, 0x2e, 0x23, 0x20, 0x20, 0x3c, 0x8a, 0x38, 0x23, 0x21,
+  0x59, 0x2d, 0xb0, 0x3a, 0x2c, 0xb0, 0x00, 0x16, 0x20, 0xb0, 0x08, 0x43,
+  0x20, 0x2e, 0x47, 0x23, 0x47, 0x23, 0x61, 0x20, 0x60, 0xb0, 0x20, 0x60,
+  0x66, 0xb0, 0x02, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60,
+  0x59, 0x66, 0xb0, 0x01, 0x63, 0x23, 0x20, 0x20, 0x3c, 0x8a, 0x38, 0x2d,
+  0xb0, 0x3b, 0x2c, 0x23, 0x20, 0x2e, 0x46, 0xb0, 0x02, 0x25, 0x46, 0x52,
+  0x58, 0x20, 0x3c, 0x59, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0x2d, 0xb0,
+  0x3c, 0x2c, 0x23, 0x20, 0x2e, 0x46, 0xb0, 0x02, 0x25, 0x46, 0x50, 0x58,
+  0x20, 0x3c, 0x59, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0x2d, 0xb0, 0x3d,
+  0x2c, 0x23, 0x20, 0x2e, 0x46, 0xb0, 0x02, 0x25, 0x46, 0x52, 0x58, 0x20,
+  0x3c, 0x59, 0x23, 0x20, 0x2e, 0x46, 0xb0, 0x02, 0x25, 0x46, 0x50, 0x58,
+  0x20, 0x3c, 0x59, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0x2d, 0xb0, 0x3e,
+  0x2c, 0xb0, 0x35, 0x2b, 0x23, 0x20, 0x2e, 0x46, 0xb0, 0x02, 0x25, 0x46,
+  0x52, 0x58, 0x20, 0x3c, 0x59, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0x2d,
+  0xb0, 0x3f, 0x2c, 0xb0, 0x36, 0x2b, 0x8a, 0x20, 0x20, 0x3c, 0xb0, 0x04,
+  0x23, 0x42, 0x8a, 0x38, 0x23, 0x20, 0x2e, 0x46, 0xb0, 0x02, 0x25, 0x46,
+  0x52, 0x58, 0x20, 0x3c, 0x59, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0xb0,
+  0x04, 0x43, 0x2e, 0xb0, 0x2b, 0x2b, 0x2d, 0xb0, 0x40, 0x2c, 0xb0, 0x00,
+  0x16, 0xb0, 0x04, 0x25, 0xb0, 0x04, 0x26, 0x20, 0x2e, 0x47, 0x23, 0x47,
+  0x23, 0x61, 0xb0, 0x09, 0x43, 0x2b, 0x23, 0x20, 0x3c, 0x20, 0x2e, 0x23,
+  0x38, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0x2d, 0xb0, 0x41, 0x2c, 0xb1, 0x08,
+  0x04, 0x25, 0x42, 0xb0, 0x00, 0x16, 0xb0, 0x04, 0x25, 0xb0, 0x04, 0x25,
+  0x20, 0x2e, 0x47, 0x23, 0x47, 0x23, 0x61, 0x20, 0xb0, 0x04, 0x23, 0x42,
+  0xb0, 0x09, 0x43, 0x2b, 0x20, 0xb0, 0x60, 0x50, 0x58, 0x20, 0xb0, 0x40,
+  0x51, 0x58, 0xb3, 0x02, 0x20, 0x03, 0x20, 0x1b, 0xb3, 0x02, 0x26, 0x03,
+  0x1a, 0x59, 0x42, 0x42, 0x23, 0x20, 0x47, 0xb0, 0x04, 0x43, 0xb0, 0x02,
+  0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40, 0x60, 0x59, 0x66, 0xb0,
+  0x01, 0x63, 0x60, 0x20, 0xb0, 0x01, 0x2b, 0x20, 0x8a, 0x8a, 0x61, 0x20,
+  0xb0, 0x02, 0x43, 0x60, 0x64, 0x23, 0xb0, 0x03, 0x43, 0x61, 0x64, 0x50,
+  0x58, 0xb0, 0x02, 0x43, 0x61, 0x1b, 0xb0, 0x03, 0x43, 0x60, 0x59, 0xb0,
+  0x03, 0x25, 0xb0, 0x02, 0x62, 0x20, 0xb0, 0x00, 0x50, 0x58, 0xb0, 0x40,
+  0x60, 0x59, 0x66, 0xb0, 0x01, 0x63, 0x61, 0xb0, 0x02, 0x25, 0x46, 0x61,
+  0x38, 0x23, 0x20, 0x3c, 0x23, 0x38, 0x1b, 0x21, 0x20, 0x20, 0x46, 0x23,
+  0x47, 0xb0, 0x01, 0x2b, 0x23, 0x61, 0x38, 0x21, 0x59, 0xb1, 0x2b, 0x01,
+  0x14, 0x2b, 0x2d, 0xb0, 0x42, 0x2c, 0xb0, 0x35, 0x2b, 0x2e, 0xb1, 0x2b,
+  0x01, 0x14, 0x2b, 0x2d, 0xb0, 0x43, 0x2c, 0xb0, 0x36, 0x2b, 0x21, 0x23,
+  0x20, 0x20, 0x3c, 0xb0, 0x04, 0x23, 0x42, 0x23, 0x38, 0xb1, 0x2b, 0x01,
+  0x14, 0x2b, 0xb0, 0x04, 0x43, 0x2e, 0xb0, 0x2b, 0x2b, 0x2d, 0xb0, 0x44,
+  0x2c, 0xb0, 0x00, 0x15, 0x20, 0x47, 0xb0, 0x00, 0x23, 0x42, 0xb2, 0x00,
+  0x01, 0x01, 0x15, 0x14, 0x13, 0x2e, 0xb0, 0x31, 0x2a, 0x2d, 0xb0, 0x45,
+  0x2c, 0xb0, 0x00, 0x15, 0x20, 0x47, 0xb0, 0x00, 0x23, 0x42, 0xb2, 0x00,
+  0x01, 0x01, 0x15, 0x14, 0x13, 0x2e, 0xb0, 0x31, 0x2a, 0x2d, 0xb0, 0x46,
+  0x2c, 0xb1, 0x00, 0x01, 0x14, 0x13, 0xb0, 0x32, 0x2a, 0x2d, 0xb0, 0x47,
+  0x2c, 0xb0, 0x34, 0x2a, 0x2d, 0xb0, 0x48, 0x2c, 0xb0, 0x00, 0x16, 0x45,
+  0x23, 0x20, 0x2e, 0x20, 0x46, 0x8a, 0x23, 0x61, 0x38, 0xb1, 0x2b, 0x01,
+  0x14, 0x2b, 0x2d, 0xb0, 0x49, 0x2c, 0xb0, 0x08, 0x23, 0x42, 0xb0, 0x48,
+  0x2b, 0x2d, 0xb0, 0x4a, 0x2c, 0xb2, 0x00, 0x00, 0x41, 0x2b, 0x2d, 0xb0,
+  0x4b, 0x2c, 0xb2, 0x00, 0x01, 0x41, 0x2b, 0x2d, 0xb0, 0x4c, 0x2c, 0xb2,
+  0x01, 0x00, 0x41, 0x2b, 0x2d, 0xb0, 0x4d, 0x2c, 0xb2, 0x01, 0x01, 0x41,
+  0x2b, 0x2d, 0xb0, 0x4e, 0x2c, 0xb2, 0x00, 0x00, 0x42, 0x2b, 0x2d, 0xb0,
+  0x4f, 0x2c, 0xb2, 0x00, 0x01, 0x42, 0x2b, 0x2d, 0xb0, 0x50, 0x2c, 0xb2,
+  0x01, 0x00, 0x42, 0x2b, 0x2d, 0xb0, 0x51, 0x2c, 0xb2, 0x01, 0x01, 0x42,
+  0x2b, 0x2d, 0xb0, 0x52, 0x2c, 0xb2, 0x00, 0x00, 0x3e, 0x2b, 0x2d, 0xb0,
+  0x53, 0x2c, 0xb2, 0x00, 0x01, 0x3e, 0x2b, 0x2d, 0xb0, 0x54, 0x2c, 0xb2,
+  0x01, 0x00, 0x3e, 0x2b, 0x2d, 0xb0, 0x55, 0x2c, 0xb2, 0x01, 0x01, 0x3e,
+  0x2b, 0x2d, 0xb0, 0x56, 0x2c, 0xb2, 0x00, 0x00, 0x40, 0x2b, 0x2d, 0xb0,
+  0x57, 0x2c, 0xb2, 0x00, 0x01, 0x40, 0x2b, 0x2d, 0xb0, 0x58, 0x2c, 0xb2,
+  0x01, 0x00, 0x40, 0x2b, 0x2d, 0xb0, 0x59, 0x2c, 0xb2, 0x01, 0x01, 0x40,
+  0x2b, 0x2d, 0xb0, 0x5a, 0x2c, 0xb2, 0x00, 0x00, 0x43, 0x2b, 0x2d, 0xb0,
+  0x5b, 0x2c, 0xb2, 0x00, 0x01, 0x43, 0x2b, 0x2d, 0xb0, 0x5c, 0x2c, 0xb2,
+  0x01, 0x00, 0x43, 0x2b, 0x2d, 0xb0, 0x5d, 0x2c, 0xb2, 0x01, 0x01, 0x43,
+  0x2b, 0x2d, 0xb0, 0x5e, 0x2c, 0xb2, 0x00, 0x00, 0x3f, 0x2b, 0x2d, 0xb0,
+  0x5f, 0x2c, 0xb2, 0x00, 0x01, 0x3f, 0x2b, 0x2d, 0xb0, 0x60, 0x2c, 0xb2,
+  0x01, 0x00, 0x3f, 0x2b, 0x2d, 0xb0, 0x61, 0x2c, 0xb2, 0x01, 0x01, 0x3f,
+  0x2b, 0x2d, 0xb0, 0x62, 0x2c, 0xb0, 0x37, 0x2b, 0x2e, 0xb1, 0x2b, 0x01,
+  0x14, 0x2b, 0x2d, 0xb0, 0x63, 0x2c, 0xb0, 0x37, 0x2b, 0xb0, 0x3b, 0x2b,
+  0x2d, 0xb0, 0x64, 0x2c, 0xb0, 0x37, 0x2b, 0xb0, 0x3c, 0x2b, 0x2d, 0xb0,
+  0x65, 0x2c, 0xb0, 0x00, 0x16, 0xb0, 0x37, 0x2b, 0xb0, 0x3d, 0x2b, 0x2d,
+  0xb0, 0x66, 0x2c, 0xb0, 0x38, 0x2b, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b,
+  0x2d, 0xb0, 0x67, 0x2c, 0xb0, 0x38, 0x2b, 0xb0, 0x3b, 0x2b, 0x2d, 0xb0,
+  0x68, 0x2c, 0xb0, 0x38, 0x2b, 0xb0, 0x3c, 0x2b, 0x2d, 0xb0, 0x69, 0x2c,
+  0xb0, 0x38, 0x2b, 0xb0, 0x3d, 0x2b, 0x2d, 0xb0, 0x6a, 0x2c, 0xb0, 0x39,
+  0x2b, 0x2e, 0xb1, 0x2b, 0x01, 0x14, 0x2b, 0x2d, 0xb0, 0x6b, 0x2c, 0xb0,
+  0x39, 0x2b, 0xb0, 0x3b, 0x2b, 0x2d, 0xb0, 0x6c, 0x2c, 0xb0, 0x39, 0x2b,
+  0xb0, 0x3c, 0x2b, 0x2d, 0xb0, 0x6d, 0x2c, 0xb0, 0x39, 0x2b, 0xb0, 0x3d,
+  0x2b, 0x2d, 0xb0, 0x6e, 0x2c, 0xb0, 0x3a, 0x2b, 0x2e, 0xb1, 0x2b, 0x01,
+  0x14, 0x2b, 0x2d, 0xb0, 0x6f, 0x2c, 0xb0, 0x3a, 0x2b, 0xb0, 0x3b, 0x2b,
+  0x2d, 0xb0, 0x70, 0x2c, 0xb0, 0x3a, 0x2b, 0xb0, 0x3c, 0x2b, 0x2d, 0xb0,
+  0x71, 0x2c, 0xb0, 0x3a, 0x2b, 0xb0, 0x3d, 0x2b, 0x2d, 0xb0, 0x72, 0x2c,
+  0xb3, 0x09, 0x04, 0x02, 0x03, 0x45, 0x58, 0x21, 0x1b, 0x23, 0x21, 0x59,
+  0x42, 0x2b, 0xb0, 0x08, 0x65, 0xb0, 0x03, 0x24, 0x50, 0x78, 0xb0, 0x01,
+  0x15, 0x30, 0x2d, 0x00, 0x00, 0x4b, 0xb0, 0xc8, 0x52, 0x58, 0xb1, 0x01,
+  0x01, 0x8e, 0x59, 0xba, 0x00, 0x01, 0x08, 0x00, 0x08, 0x00, 0x63, 0x70,
+  0xb1, 0x00, 0x05, 0x42, 0xb3, 0x00, 0x1a, 0x02, 0x00, 0x2a, 0xb1, 0x00,
+  0x05, 0x42, 0xb5, 0x20, 0x01, 0x0d, 0x08, 0x02, 0x08, 0x2a, 0xb1, 0x00,
+  0x05, 0x42, 0xb5, 0x21, 0x00, 0x17, 0x06, 0x02, 0x08, 0x2a, 0xb1, 0x00,
+  0x07, 0x42, 0xb9, 0x08, 0x40, 0x03, 0x80, 0xb1, 0x02, 0x09, 0x2a, 0xb1,
+  0x00, 0x09, 0x42, 0xb3, 0x00, 0x40, 0x02, 0x09, 0x2a, 0xb1, 0x03, 0x00,
+  0x44, 0xb1, 0x24, 0x01, 0x88, 0x51, 0x58, 0xb0, 0x40, 0x88, 0x58, 0xb1,
+  0x03, 0x64, 0x44, 0xb1, 0x26, 0x01, 0x88, 0x51, 0x58, 0xba, 0x08, 0x80,
+  0x00, 0x01, 0x04, 0x40, 0x88, 0x63, 0x54, 0x58, 0xb1, 0x03, 0x00, 0x44,
+  0x59, 0x59, 0x59, 0x59, 0xb5, 0x21, 0x00, 0x0f, 0x08, 0x02, 0x0c, 0x2a,
+  0xb8, 0x01, 0xff, 0x85, 0xb0, 0x04, 0x8d, 0xb1, 0x02, 0x00, 0x44, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55,
+  0x00, 0x55, 0x00, 0x4b, 0x00, 0x4b, 0x02, 0xbc, 0x00, 0x00, 0x02, 0xbc,
+  0x01, 0xf4, 0x00, 0x00, 0xff, 0x56, 0x03, 0x75, 0xff, 0x0e, 0x02, 0xbc,
+  0x00, 0x00, 0x02, 0xbc, 0x01, 0xf4, 0x00, 0x00, 0xff, 0x56, 0x03, 0x75,
+  0xff, 0x0e, 0x00, 0x32, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+  0x00, 0xa2, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x00, 0x00, 0xfa,
+  0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x1e,
+  0x00, 0xfa, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x02, 0x00, 0x0e,
+  0x01, 0x18, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x03, 0x00, 0x56,
+  0x01, 0x26, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x04, 0x00, 0x1e,
+  0x00, 0xfa, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x05, 0x00, 0x1a,
+  0x01, 0x7c, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x06, 0x00, 0x2a,
+  0x01, 0x96, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x08, 0x00, 0x2e,
+  0x01, 0xc0, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x09, 0x00, 0x2e,
+  0x01, 0xc0, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0b, 0x00, 0x2c,
+  0x01, 0xee, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0c, 0x00, 0x2c,
+  0x01, 0xee, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0d, 0x01, 0x20,
+  0x02, 0x1a, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0e, 0x00, 0x34,
+  0x03, 0x3a, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x79, 0x00, 0x72,
+  0x00, 0x69, 0x00, 0x67, 0x00, 0x68, 0x00, 0x74, 0x00, 0x20, 0x00, 0x28,
+  0x00, 0x63, 0x00, 0x29, 0x00, 0x20, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31,
+  0x00, 0x32, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x72,
+  0x00, 0x72, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x54,
+  0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x20, 0x00, 0x44, 0x00, 0x65,
+  0x00, 0x73, 0x00, 0x69, 0x00, 0x67, 0x00, 0x6e, 0x00, 0x2c, 0x00, 0x20,
+  0x00, 0x52, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x70, 0x00, 0x68, 0x00, 0x20,
+  0x00, 0x64, 0x00, 0x75, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x72,
+  0x00, 0x72, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x28,
+  0x00, 0x70, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x74, 0x00, 0x40, 0x00, 0x63,
+  0x00, 0x61, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x73,
+  0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x20, 0x00, 0x77,
+  0x00, 0x77, 0x00, 0x77, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x61, 0x00, 0x72,
+  0x00, 0x72, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x63,
+  0x00, 0x6f, 0x00, 0x6d, 0x00, 0x29, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x77,
+  0x00, 0x69, 0x00, 0x74, 0x00, 0x68, 0x00, 0x20, 0x00, 0x52, 0x00, 0x65,
+  0x00, 0x73, 0x00, 0x65, 0x00, 0x72, 0x00, 0x76, 0x00, 0x65, 0x00, 0x64,
+  0x00, 0x20, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x20,
+  0x00, 0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x20, 0x00, 0x27,
+  0x00, 0x53, 0x00, 0x68, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x27,
+  0x00, 0x53, 0x00, 0x68, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x20,
+  0x00, 0x54, 0x00, 0x65, 0x00, 0x63, 0x00, 0x68, 0x00, 0x20, 0x00, 0x4d,
+  0x00, 0x6f, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67,
+  0x00, 0x75, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x72, 0x00, 0x52, 0x00, 0x61,
+  0x00, 0x6c, 0x00, 0x70, 0x00, 0x68, 0x00, 0x4f, 0x00, 0x6c, 0x00, 0x69,
+  0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00, 0x64, 0x00, 0x75, 0x00, 0x43,
+  0x00, 0x61, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x73,
+  0x00, 0x3a, 0x00, 0x20, 0x00, 0x53, 0x00, 0x68, 0x00, 0x61, 0x00, 0x72,
+  0x00, 0x65, 0x00, 0x20, 0x00, 0x54, 0x00, 0x65, 0x00, 0x63, 0x00, 0x68,
+  0x00, 0x20, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x3a,
+  0x00, 0x20, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x34, 0x00, 0x56,
+  0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e,
+  0x00, 0x20, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x33,
+  0x00, 0x53, 0x00, 0x68, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x54,
+  0x00, 0x65, 0x00, 0x63, 0x00, 0x68, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x6e,
+  0x00, 0x6f, 0x00, 0x2d, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67, 0x00, 0x75,
+  0x00, 0x6c, 0x00, 0x61, 0x00, 0x72, 0x00, 0x52, 0x00, 0x61, 0x00, 0x6c,
+  0x00, 0x70, 0x00, 0x68, 0x00, 0x20, 0x00, 0x4f, 0x00, 0x6c, 0x00, 0x69,
+  0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x64, 0x00, 0x75,
+  0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6f,
+  0x00, 0x69, 0x00, 0x73, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70,
+  0x00, 0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x77, 0x00, 0x77,
+  0x00, 0x2e, 0x00, 0x63, 0x00, 0x61, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6f,
+  0x00, 0x69, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d,
+  0x00, 0x54, 0x00, 0x68, 0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x46,
+  0x00, 0x6f, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x20, 0x00, 0x53, 0x00, 0x6f,
+  0x00, 0x66, 0x00, 0x74, 0x00, 0x77, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65,
+  0x00, 0x20, 0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x6c, 0x00, 0x69,
+  0x00, 0x63, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x65, 0x00, 0x64,
+  0x00, 0x20, 0x00, 0x75, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x65, 0x00, 0x72,
+  0x00, 0x20, 0x00, 0x74, 0x00, 0x68, 0x00, 0x65, 0x00, 0x20, 0x00, 0x53,
+  0x00, 0x49, 0x00, 0x4c, 0x00, 0x20, 0x00, 0x4f, 0x00, 0x70, 0x00, 0x65,
+  0x00, 0x6e, 0x00, 0x20, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x74,
+  0x00, 0x20, 0x00, 0x4c, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x6e,
+  0x00, 0x73, 0x00, 0x65, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x56, 0x00, 0x65,
+  0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20,
+  0x00, 0x31, 0x00, 0x2e, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x20, 0x00, 0x54,
+  0x00, 0x68, 0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x6c, 0x00, 0x69,
+  0x00, 0x63, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x65, 0x00, 0x20,
+  0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x61, 0x00, 0x76, 0x00, 0x61,
+  0x00, 0x69, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x62, 0x00, 0x6c, 0x00, 0x65,
+  0x00, 0x20, 0x00, 0x77, 0x00, 0x69, 0x00, 0x74, 0x00, 0x68, 0x00, 0x20,
+  0x00, 0x61, 0x00, 0x20, 0x00, 0x46, 0x00, 0x41, 0x00, 0x51, 0x00, 0x20,
+  0x00, 0x61, 0x00, 0x74, 0x00, 0x3a, 0x00, 0x20, 0x00, 0x68, 0x00, 0x74,
+  0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x73,
+  0x00, 0x63, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70, 0x00, 0x74, 0x00, 0x73,
+  0x00, 0x2e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x2e, 0x00, 0x6f,
+  0x00, 0x72, 0x00, 0x67, 0x00, 0x2f, 0x00, 0x4f, 0x00, 0x46, 0x00, 0x4c,
+  0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f,
+  0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70,
+  0x00, 0x74, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6c,
+  0x00, 0x2e, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x67, 0x00, 0x2f, 0x00, 0x4f,
+  0x00, 0x46, 0x00, 0x4c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xff, 0x92, 0x00, 0x32, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x24, 0x00, 0xc9,
+  0x00, 0xc7, 0x00, 0x62, 0x00, 0xad, 0x00, 0x63, 0x00, 0xae, 0x00, 0x90,
+  0x00, 0x25, 0x00, 0x26, 0x00, 0x64, 0x00, 0x27, 0x00, 0xe9, 0x00, 0x28,
+  0x00, 0x65, 0x00, 0xc8, 0x00, 0xca, 0x00, 0xcb, 0x00, 0x29, 0x00, 0x2a,
+  0x00, 0x2b, 0x00, 0x2c, 0x00, 0xcc, 0x00, 0xcd, 0x00, 0xce, 0x00, 0xcf,
+  0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f, 0x00, 0xe2, 0x00, 0x30, 0x00, 0x31,
+  0x00, 0x66, 0x00, 0x32, 0x00, 0xd0, 0x00, 0xd1, 0x00, 0x67, 0x00, 0xd3,
+  0x00, 0x91, 0x00, 0xaf, 0x00, 0xb0, 0x00, 0x33, 0x00, 0xed, 0x00, 0x34,
+  0x00, 0x35, 0x00, 0x36, 0x00, 0xe4, 0x00, 0x37, 0x00, 0x38, 0x00, 0xd4,
+  0x00, 0xd5, 0x00, 0x68, 0x00, 0xd6, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b,
+  0x00, 0x3c, 0x00, 0xeb, 0x00, 0xbb, 0x00, 0x3d, 0x00, 0xe6, 0x00, 0x44,
+  0x00, 0x69, 0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6a, 0x00, 0x6e, 0x00, 0x6d,
+  0x00, 0xa0, 0x00, 0x45, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x47, 0x00, 0xea,
+  0x00, 0x48, 0x00, 0x70, 0x00, 0x72, 0x00, 0x73, 0x00, 0x71, 0x00, 0x49,
+  0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0xd7, 0x00, 0x74, 0x00, 0x76,
+  0x00, 0x77, 0x00, 0x75, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f, 0x00, 0xe3,
+  0x00, 0x50, 0x00, 0x51, 0x00, 0x78, 0x00, 0x52, 0x00, 0x79, 0x00, 0x7b,
+  0x00, 0x7c, 0x00, 0x7a, 0x00, 0xa1, 0x00, 0x7d, 0x00, 0xb1, 0x00, 0x53,
+  0x00, 0xee, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0xe5, 0x00, 0x89,
+  0x00, 0x57, 0x00, 0x58, 0x00, 0x7e, 0x00, 0x80, 0x00, 0x81, 0x00, 0x7f,
+  0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0xec, 0x00, 0xba,
+  0x00, 0x5d, 0x00, 0xe7, 0x00, 0xc0, 0x00, 0xc1, 0x00, 0x9d, 0x00, 0x9e,
+  0x00, 0xa8, 0x00, 0x9f, 0x00, 0x97, 0x01, 0x02, 0x00, 0x9b, 0x00, 0x13,
+  0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19,
+  0x00, 0x1a, 0x00, 0x1b, 0x00, 0x1c, 0x00, 0xbc, 0x00, 0xf4, 0x00, 0xf5,
+  0x00, 0xf6, 0x00, 0xf1, 0x00, 0xf2, 0x00, 0xf3, 0x00, 0x0d, 0x00, 0x3f,
+  0x00, 0xc3, 0x00, 0x87, 0x00, 0x1d, 0x00, 0x0f, 0x00, 0xab, 0x00, 0x04,
+  0x00, 0xa3, 0x00, 0x06, 0x00, 0x11, 0x00, 0x22, 0x00, 0xa2, 0x00, 0x05,
+  0x00, 0x0a, 0x00, 0x1e, 0x00, 0x12, 0x00, 0x42, 0x00, 0x5e, 0x00, 0x60,
+  0x00, 0x3e, 0x00, 0x40, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0xb3, 0x00, 0xb2,
+  0x00, 0x10, 0x01, 0x03, 0x00, 0xa9, 0x00, 0xaa, 0x00, 0xbe, 0x00, 0xbf,
+  0x00, 0xc5, 0x00, 0xb4, 0x00, 0xb5, 0x00, 0xb6, 0x00, 0xb7, 0x00, 0xc4,
+  0x01, 0x04, 0x00, 0x01, 0x01, 0x05, 0x00, 0x84, 0x00, 0xbd, 0x00, 0x07,
+  0x00, 0xa6, 0x00, 0x85, 0x00, 0x96, 0x00, 0xa7, 0x00, 0x61, 0x00, 0xb8,
+  0x01, 0x06, 0x00, 0x20, 0x00, 0x21, 0x00, 0x95, 0x00, 0x92, 0x00, 0x9c,
+  0x00, 0x1f, 0x00, 0x94, 0x01, 0x07, 0x00, 0xa4, 0x00, 0xef, 0x00, 0xf0,
+  0x00, 0x8f, 0x00, 0x98, 0x00, 0x08, 0x00, 0xc6, 0x00, 0x0e, 0x00, 0x93,
+  0x00, 0x9a, 0x00, 0xa5, 0x00, 0x99, 0x01, 0x08, 0x01, 0x09, 0x01, 0x0a,
+  0x00, 0xb9, 0x01, 0x0b, 0x01, 0x0c, 0x01, 0x0d, 0x01, 0x0e, 0x01, 0x0f,
+  0x01, 0x10, 0x01, 0x11, 0x01, 0x12, 0x01, 0x13, 0x01, 0x14, 0x01, 0x15,
+  0x00, 0x5f, 0x00, 0xe8, 0x00, 0x23, 0x00, 0x09, 0x00, 0x88, 0x00, 0x8b,
+  0x00, 0x8a, 0x00, 0x86, 0x00, 0x8c, 0x00, 0x83, 0x00, 0x41, 0x00, 0x82,
+  0x00, 0xc2, 0x00, 0x8d, 0x00, 0xdb, 0x00, 0xe1, 0x00, 0xde, 0x00, 0xd8,
+  0x00, 0x8e, 0x00, 0xdc, 0x00, 0x43, 0x00, 0xdf, 0x00, 0xda, 0x00, 0xe0,
+  0x00, 0xdd, 0x00, 0xd9, 0x01, 0x16, 0x01, 0x17, 0x01, 0x18, 0x07, 0x75,
+  0x6e, 0x69, 0x30, 0x33, 0x42, 0x43, 0x07, 0x75, 0x6e, 0x69, 0x30, 0x30,
+  0x41, 0x44, 0x07, 0x75, 0x6e, 0x69, 0x30, 0x30, 0x41, 0x30, 0x04, 0x45,
+  0x75, 0x72, 0x6f, 0x07, 0x64, 0x6f, 0x74, 0x6d, 0x61, 0x74, 0x68, 0x0a,
+  0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x61, 0x6e, 0x64, 0x07, 0x75,
+  0x6e, 0x69, 0x32, 0x32, 0x31, 0x35, 0x07, 0x75, 0x6e, 0x69, 0x32, 0x32,
+  0x31, 0x39, 0x07, 0x75, 0x6e, 0x69, 0x32, 0x32, 0x32, 0x34, 0x07, 0x75,
+  0x6e, 0x69, 0x32, 0x35, 0x41, 0x46, 0x07, 0x75, 0x6e, 0x69, 0x32, 0x36,
+  0x32, 0x30, 0x09, 0x73, 0x6d, 0x69, 0x6c, 0x65, 0x66, 0x61, 0x63, 0x65,
+  0x0c, 0x69, 0x6e, 0x76, 0x73, 0x6d, 0x69, 0x6c, 0x65, 0x66, 0x61, 0x63,
+  0x65, 0x03, 0x73, 0x75, 0x6e, 0x05, 0x73, 0x70, 0x61, 0x64, 0x65, 0x04,
+  0x63, 0x6c, 0x75, 0x62, 0x05, 0x68, 0x65, 0x61, 0x72, 0x74, 0x07, 0x64,
+  0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x0b, 0x6d, 0x75, 0x73, 0x69, 0x63,
+  0x61, 0x6c, 0x6e, 0x6f, 0x74, 0x65, 0x0e, 0x6d, 0x75, 0x73, 0x69, 0x63,
+  0x61, 0x6c, 0x6e, 0x6f, 0x74, 0x65, 0x64, 0x62, 0x6c, 0x07, 0x75, 0x6e,
+  0x69, 0x30, 0x32, 0x43, 0x39, 0x06, 0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65,
+  0x04, 0x6d, 0x61, 0x6c, 0x65, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
+  0xff, 0xff, 0x00, 0x0f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x42,
+  0x00, 0x5c, 0x00, 0x03, 0x44, 0x46, 0x4c, 0x54, 0x00, 0x14, 0x67, 0x72,
+  0x65, 0x6b, 0x00, 0x20, 0x6c, 0x61, 0x74, 0x6e, 0x00, 0x2c, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x01, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03,
+  0x63, 0x70, 0x73, 0x70, 0x00, 0x14, 0x63, 0x70, 0x73, 0x70, 0x00, 0x14,
+  0x63, 0x70, 0x73, 0x70, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08,
+  0x00, 0x01, 0x00, 0x0a, 0x00, 0x05, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x02,
+  0x00, 0x02, 0x00, 0x03, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x83, 0x00, 0x84,
+  0x00, 0x3d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x60,
+  0x00, 0xf2, 0x00, 0x03, 0x44, 0x46, 0x4c, 0x54, 0x00, 0x14, 0x67, 0x72,
+  0x65, 0x6b, 0x00, 0x2a, 0x6c, 0x61, 0x74, 0x6e, 0x00, 0x40, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x06, 0x00, 0x09, 0x00, 0x0c, 0x00, 0x0f, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0xff, 0xff, 0x00, 0x06, 0x00, 0x01, 0x00, 0x04, 0x00, 0x07,
+  0x00, 0x0a, 0x00, 0x0d, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0x00, 0x06, 0x00, 0x02, 0x00, 0x05, 0x00, 0x08, 0x00, 0x0b,
+  0x00, 0x0e, 0x00, 0x11, 0x00, 0x12, 0x61, 0x61, 0x6c, 0x74, 0x00, 0x6e,
+  0x61, 0x61, 0x6c, 0x74, 0x00, 0x6e, 0x61, 0x61, 0x6c, 0x74, 0x00, 0x6e,
+  0x64, 0x6c, 0x69, 0x67, 0x00, 0x74, 0x64, 0x6c, 0x69, 0x67, 0x00, 0x74,
+  0x64, 0x6c, 0x69, 0x67, 0x00, 0x74, 0x66, 0x72, 0x61, 0x63, 0x00, 0x7a,
+  0x66, 0x72, 0x61, 0x63, 0x00, 0x7a, 0x66, 0x72, 0x61, 0x63, 0x00, 0x7a,
+  0x6c, 0x69, 0x67, 0x61, 0x00, 0x80, 0x6c, 0x69, 0x67, 0x61, 0x00, 0x80,
+  0x6c, 0x69, 0x67, 0x61, 0x00, 0x80, 0x6f, 0x72, 0x64, 0x6e, 0x00, 0x86,
+  0x6f, 0x72, 0x64, 0x6e, 0x00, 0x86, 0x6f, 0x72, 0x64, 0x6e, 0x00, 0x86,
+  0x73, 0x75, 0x70, 0x73, 0x00, 0x8c, 0x73, 0x75, 0x70, 0x73, 0x00, 0x8c,
+  0x73, 0x75, 0x70, 0x73, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x07, 0x00, 0x10, 0x00, 0x3e,
+  0x00, 0x56, 0x00, 0x92, 0x00, 0xda, 0x00, 0xda, 0x01, 0x02, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x14, 0x00, 0x07,
+  0x00, 0x81, 0x00, 0x82, 0x00, 0x81, 0x00, 0x82, 0x00, 0x96, 0x00, 0x97,
+  0x00, 0x98, 0x00, 0x01, 0x00, 0x07, 0x00, 0x03, 0x00, 0x24, 0x00, 0x40,
+  0x00, 0x62, 0x00, 0x89, 0x00, 0x8a, 0x00, 0x8b, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x00, 0x0d, 0x00, 0x01,
+  0x00, 0x03, 0x00, 0x89, 0x00, 0x8a, 0x00, 0x8b, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x2c, 0x00, 0x02, 0x00, 0x0a,
+  0x00, 0x20, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x93, 0x00, 0x03,
+  0x00, 0xa9, 0x00, 0x8a, 0x00, 0x94, 0x00, 0x03, 0x00, 0xa9, 0x00, 0x8c,
+  0x00, 0x01, 0x00, 0x04, 0x00, 0x95, 0x00, 0x03, 0x00, 0xa9, 0x00, 0x8c,
+  0x00, 0x01, 0x00, 0x02, 0x00, 0x89, 0x00, 0x8b, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x02, 0x00, 0x0a, 0x00, 0x24, 0x00, 0x03, 0x00, 0x01, 0x00, 0x2c,
+  0x00, 0x01, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+  0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x40, 0x00, 0x03, 0x00, 0x01,
+  0x00, 0x12, 0x00, 0x01, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x06, 0x00, 0x02, 0x00, 0x01, 0x00, 0x88, 0x00, 0x91, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x02, 0x00, 0x24, 0x00, 0x62, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x1a, 0x00, 0x01, 0x00, 0x08,
+  0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x00, 0x7f, 0x00, 0x02, 0x00, 0x55,
+  0x00, 0x80, 0x00, 0x02, 0x00, 0x5d, 0x00, 0x01, 0x00, 0x01, 0x00, 0x52,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x0e,
+  0x00, 0x04, 0x00, 0x81, 0x00, 0x82, 0x00, 0x81, 0x00, 0x82, 0x00, 0x01,
+  0x00, 0x04, 0x00, 0x03, 0x00, 0x24, 0x00, 0x40, 0x00, 0x62, 0x00, 0x00
+};
+unsigned int ShareTechMono_Regular_ttf_len = 42756;
diff --git a/src/share-tech-mono.hpp b/src/share-tech-mono.hpp
new file mode 100644
index 0000000..30612ca
--- /dev/null
+++ b/src/share-tech-mono.hpp
@@ -0,0 +1,7 @@
+#ifndef _SHARE_TECH_MONO_HPP_
+#define _SHARE_TECH_MONO_HPP_
+
+extern unsigned char ShareTechMono_Regular_ttf[];
+extern unsigned int ShareTechMono_Regular_ttf_len;
+
+#endif
diff --git a/src/specgram.cpp b/src/specgram.cpp
new file mode 100644
index 0000000..72c1462
--- /dev/null
+++ b/src/specgram.cpp
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "configuration.hpp"
+#include "input-parser.hpp"
+#include "input-reader.hpp"
+#include "color-map.hpp"
+#include "value-map.hpp"
+#include "window-function.hpp"
+#include "fft.hpp"
+#include "live.hpp"
+
+#include <spdlog/spdlog.h>
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <csignal>
+#include <list>
+
+/* main loop exit condition */
+volatile bool main_loop_running = true;
+
+/*
+ * SIGINT handler
+ */
+void
+sigint_handler(int)
+{
+    /* no longer loop */
+    main_loop_running = false;
+
+    /* uninstall handler in case user REALLY does not want to wait for wrap-up */
+    std::signal(SIGINT, nullptr);
+}
+
+/*
+ * printing functions
+ */
+void print_complex_window(const std::string& name, const ComplexWindow& window)
+{
+    std::cout << name << ": [";
+    for (const auto& v : window) {
+        std::cout << " " << std::setprecision(3) << std::fixed << v.real()
+                  << std::showpos << v.imag() << "j";
+    }
+    std::cout << "]" << std::endl;
+}
+
+void print_real_window(const std::string& name, const RealWindow& window)
+{
+    std::cout << name << ": [";
+    for (const auto& v : window) {
+        std::cout << " " << std::setprecision(3) << std::fixed << v;
+    }
+    std::cout << "]" << std::endl;
+}
+
+/*
+ * entry point
+ */
+int
+main(int argc, char** argv)
+{
+    /* parse command line arguments into global settings */
+    auto [conf, conf_rc, conf_must_exit] = Configuration::FromArgs(argc, argv);
+    if (conf_must_exit) {
+        return conf_rc;
+    }
+
+    /* create window function */
+    auto win_function = WindowFunction::FromType(conf.GetWindowFunction(), conf.GetFFTWidth());
+
+    /* create FFT */
+    spdlog::info("Creating {}-wide FFTW plan", conf.GetFFTWidth());
+    FFT fft(conf.GetFFTWidth(), win_function);
+
+    /* create value map */
+    std::unique_ptr<ValueMap> value_map = nullptr;
+    if (conf.GetScale() == ValueMapType::kdBFS) {
+        value_map = std::make_unique<dBFSValueMap>(conf.GetScaleLowerBound());
+    } else {
+        assert(false);
+        spdlog::error("Internal error: unknown scale");
+        return 1;
+    }
+
+    /* create color map */
+    auto color_map = ColorMap::FromType(conf.GetColorMap(),
+                                        conf.GetBackgroundColor(),
+                                        conf.GetColorMapCustomColor());
+
+    /* create live window */
+    std::unique_ptr<LiveOutput> live = nullptr;
+    if (conf.IsLive()) {
+        live = std::make_unique<LiveOutput>(conf, *color_map, *value_map);
+    }
+
+    /* create input parser */
+    auto input = InputParser::FromDataType(conf.GetDataType(), conf.GetPrescaleFactor(), conf.HasComplexInput());
+    if (input == nullptr) {
+        return 1;
+    }
+
+    /* create input reader */
+    std::istream *input_stream = nullptr;
+    std::unique_ptr<InputReader> reader = nullptr;
+    if (conf.GetInputFilename().has_value()) {
+        input_stream = new std::ifstream(*conf.GetInputFilename(), std::ios::in | std::ios::binary);
+        assert(input_stream != nullptr);
+        if (!input_stream->good()) {
+            spdlog::error("Failed to open input file '{}'", *conf.GetInputFilename());
+            return 1;
+        }
+        reader = std::make_unique<SyncInputReader>(input_stream,
+                                                   input->GetDataTypeSize() * conf.GetBlockSize());
+    } else {
+        input_stream = &std::cin;
+        reader = std::make_unique<AsyncInputReader>(input_stream,
+                                                    input->GetDataTypeSize() * conf.GetBlockSize());
+    }
+
+    /* display initialization info */
+    if (input->IsFloatingPoint()) {
+        spdlog::info("Input stream: {}{}bit floating point at {}Hz",
+                     input->IsComplex() ? "complex " : "",
+                     input->GetDataTypeSize() * 8, conf.GetRate());
+    } else {
+        spdlog::info("Input stream: {}{} {}bit integer at {}Hz",
+                     input->IsComplex() ? "complex " : "",
+                     input->IsSigned() ? "signed" : "unsigned",
+                     input->GetDataTypeSize() * 8, conf.GetRate());
+    }
+
+    /* install SIGINT handler for CTRL+C */
+    std::signal(SIGINT, sigint_handler);
+
+    /* FFT window history */
+    std::list<std::vector<uint8_t>> history;
+
+    /* window average */
+    RealWindow window_sum;
+    window_sum.resize(conf.GetWidth());
+    std::size_t window_sum_count = 0;
+
+    /* main loop */
+    while (main_loop_running && !reader->ReachedEOF()) {
+        /* check for window events (if necessary) */
+        if (live != nullptr) {
+            if (!live->HandleEvents()) {
+                /* exited by closing window */
+                main_loop_running = false;
+                /* uninstall signal so that reader thread can exit successfully */
+                std::signal(SIGINT, nullptr);
+            }
+        }
+
+        /* check for a complete block */
+        auto block = reader->GetBlock();
+        if (!block) {
+            /* block not finished yet */
+            continue;
+        }
+
+        /* take whatever is available from input stream */
+        auto pvc = input->ParseBlock(*block);
+        assert(pvc == block->size() / input->GetDataTypeSize());
+
+        /* check if we have enough for a new FFT window */
+        if ((input->GetBufferedValueCount() < conf.GetFFTWidth())
+            || (input->GetBufferedValueCount() < conf.GetFFTStride())) {
+            /* wait until we get enough values for a window and the spacing between windows */
+            continue;
+        }
+
+        /* retrieve window and remove values that won't be used further */
+        auto window_values = input->PeekValues(conf.GetFFTWidth());
+        input->RemoveValues(conf.GetFFTStride());
+        if (conf.MustPrintInput()) {
+            print_complex_window("input", window_values);
+        }
+
+        /* compute FFT on fetched window */
+        auto fft_values = fft.Compute(window_values);
+        if (conf.MustPrintFFT()) {
+            print_complex_window("fft", fft_values);
+        }
+
+        /* compute magnitude */
+        auto fft_magnitude = FFT::GetMagnitude(fft_values, conf.IsAliasingNegativeFrequencies());
+
+        /* map magnitude to [0..1] domain */
+        auto normalized_magnitude = value_map->Map(fft_magnitude);
+
+        if (conf.CanResample()) {
+            /* resample to display width */
+            normalized_magnitude = FFT::Resample(normalized_magnitude, conf.GetRate(), conf.GetWidth(),
+                                                 conf.GetMinFreq(), conf.GetMaxFreq());
+        } else {
+            /* crop to display width */
+            normalized_magnitude = FFT::Crop(normalized_magnitude, conf.GetRate(),
+                                             conf.GetMinFreq(), conf.GetMaxFreq());
+        }
+        if (conf.MustPrintOutput()) {
+            print_real_window("output", normalized_magnitude);
+        }
+
+        /* add to running total */
+        assert(window_sum.size() == normalized_magnitude.size());
+        assert(conf.GetAverageCount() > 0);
+        for (std::size_t i = 0; i < window_sum.size(); i++) {
+            window_sum[i] += normalized_magnitude[i] / conf.GetAverageCount();
+        }
+        window_sum_count++;
+
+        if (window_sum_count < conf.GetAverageCount()) {
+            /* we still have to compute some more windows before we show */
+            continue;
+        }
+
+        /* colorize FFT */
+        auto colorized = color_map->Map(window_sum);
+
+        /* add to live */
+        if (live != nullptr) {
+            live->AddWindow(colorized, window_sum);
+        }
+
+        /* add to history */
+        if (conf.GetOutputFilename().has_value()) {
+            history.push_back(colorized);
+        }
+
+        /* reset */
+        window_sum_count = 0;
+        for (auto& v : window_sum) {
+            v = 0.0f;
+        }
+    }
+    spdlog::info("Terminating ...");
+
+    /* close input file */
+    if (conf.GetInputFilename().has_value()) {
+        assert(input_stream != nullptr);
+        assert(input_stream != &std::cin);
+        delete input_stream;
+        input_stream = nullptr;
+    }
+
+    /* save file */
+    if (conf.GetOutputFilename().has_value()) {
+        Renderer file_renderer(conf, *color_map, *value_map, history.size());
+        file_renderer.RenderFFTArea(history);
+        auto image = file_renderer.GetCanvas().copyToImage();
+
+        if (conf.IsHorizontal()) {
+            std::size_t w = image.getSize().x;
+            std::size_t h = image.getSize().y;
+
+            /* allocate memory */
+            auto iptr = reinterpret_cast<const uint32_t *>(image.getPixelsPtr());
+            uint32_t *optr = new uint32_t[w * h];
+
+            /* copy 4 bytes (one pixel) at a time */
+            for (std::size_t l = 0; l < h; l ++) {
+                auto in = iptr + l * w;
+                auto out = optr + (w-1) * h + l;
+                for (std::size_t c = 0; c < w; c++, in++, out -= h) {
+                    *out = *in;
+                }
+            }
+
+            /* create rotated image */
+            sf::Image rimage;
+            rimage.create(h, w, reinterpret_cast<const uint8_t *>(optr));
+            delete[] optr;
+            rimage.saveToFile(*conf.GetOutputFilename());
+        } else {
+            image.saveToFile(*conf.GetOutputFilename());
+        }
+    }
+
+    /* all ok */
+    return 0;
+}
\ No newline at end of file
diff --git a/src/specgram.hpp.in b/src/specgram.hpp.in
new file mode 100644
index 0000000..4bb42d3
--- /dev/null
+++ b/src/specgram.hpp.in
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef _SPECGRAM_HPP_
+#define _SPECGRAM_HPP_
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * version
+ */
+#define SPECGRAM_VERSION_MAJOR @specgram_VERSION_MAJOR@
+#define SPECGRAM_VERSION_MINOR @specgram_VERSION_MINOR@
+#define SPECGRAM_VERSION_PATCH @specgram_VERSION_PATCH@
+#define SPECGRAM_VERSION_BUILD "@GIT_HASH@"
+
+#ifdef GIT_BUILD
+#define SPECGRAM_VERSION "@VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@.@GIT_HASH@"
+#else
+#define SPECGRAM_VERSION "@VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@"
+#endif
+
+#endif
\ No newline at end of file
diff --git a/src/value-map.cpp b/src/value-map.cpp
new file mode 100644
index 0000000..4e6a231
--- /dev/null
+++ b/src/value-map.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "value-map.hpp"
+
+ValueMap::ValueMap(double lower, double upper) : lower_(lower), upper_(upper)
+{
+}
+
+dBFSValueMap::dBFSValueMap(double mindb) : ValueMap(mindb, 0)
+{
+}
+
+RealWindow
+dBFSValueMap::Map(const RealWindow& input)
+{
+    auto n = input.size();
+    RealWindow output;
+    output.resize(n);
+
+    for (unsigned int i = 0; i < n; i ++) {
+        output[i] = 20.0 * std::log10(input[i] / n);
+        output[i] = std::clamp<double>(output[i], this->lower_, 0.0f);
+        output[i] = 1.0f - output[i] / this->lower_;
+    }
+
+    return output;
+}
\ No newline at end of file
diff --git a/src/value-map.hpp b/src/value-map.hpp
new file mode 100644
index 0000000..b1cf604
--- /dev/null
+++ b/src/value-map.hpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef _VALUE_MAP_HPP_
+#define _VALUE_MAP_HPP_
+
+#include "input-parser.hpp"
+
+#include <string>
+#include <vector>
+#include <complex>
+
+enum class ValueMapType {
+    kdBFS
+};
+
+class ValueMap {
+protected:
+    const double lower_;
+    const double upper_;
+
+    ValueMap(double lower_, double upper);
+public:
+    ValueMap() = delete;
+
+    auto GetLowerBound() const { return lower_; }
+    auto GetUpperBound() const { return upper_; }
+
+    virtual RealWindow Map(const RealWindow& input) = 0;
+    virtual std::string GetUnit() const = 0;
+    virtual std::string GetName() const = 0;
+};
+
+class dBFSValueMap : public ValueMap {
+private:
+public:
+    explicit dBFSValueMap(double mindb);
+
+    RealWindow Map(const RealWindow& input) override;
+    std::string GetUnit() const override { return "dBFS"; }
+    std::string GetName() const override { return "dBFS"; }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/window-function.cpp b/src/window-function.cpp
new file mode 100644
index 0000000..8f381ec
--- /dev/null
+++ b/src/window-function.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#include "window-function.hpp"
+
+#include <cassert>
+
+WindowFunction::WindowFunction(std::size_t window_size) : window_size_(window_size)
+{
+    cached_factors_.resize(window_size);
+}
+
+std::unique_ptr<WindowFunction>
+WindowFunction::FromType(WindowFunctionType type, std::size_t window_size)
+{
+    switch (type) {
+        case WindowFunctionType::kNone:
+            return nullptr; /* no window needed */
+
+        case WindowFunctionType::kHann:
+            return std::make_unique<HannWindowFunction>(window_size);
+
+        case WindowFunctionType::kHamming:
+            return std::make_unique<HammingWindowFunction>(window_size);
+
+        case WindowFunctionType::kBlackman:
+            return std::make_unique<BlackmanWindowFunction>(window_size);
+
+        case WindowFunctionType::kNuttall:
+            return std::make_unique<NuttallWindowFunction>(window_size);
+
+        default:
+            throw std::runtime_error("unknown window function");
+    }
+}
+
+ComplexWindow
+WindowFunction::Apply(const ComplexWindow& window) const
+{
+    /* only matching windows */
+    if (window.size() != this->window_size_) {
+        throw std::runtime_error("incorrect window size for window function application");
+    }
+    assert(this->cached_factors_.size() == this->window_size_);
+
+    ComplexWindow output;
+    output.resize(this->window_size_);
+    for (std::size_t i = 0; i < this->window_size_; i++) {
+        output[i] = window[i] * this->cached_factors_[i];
+    }
+    return output;
+}
+
+GeneralizedCosineWindowFunction::GeneralizedCosineWindowFunction(std::size_t window_size,
+                                                                 const std::vector<double>& a)
+    : WindowFunction(window_size)
+{
+    for (std::size_t n = 0; n < this->window_size_; n++) {
+        this->cached_factors_[n] = 0;
+        for (unsigned int k = 0; k < a.size(); k++) {
+            this->cached_factors_[n] +=
+                std::pow<double>(-1.0f, k) * a[k] * std::cos(2.0f * (double)M_PI * k * n / this->window_size_);
+        }
+    }
+}
+
+HannWindowFunction::HannWindowFunction(std::size_t window_size)
+    : GeneralizedCosineWindowFunction(window_size, { 0.5f, 0.5f })
+{
+}
+
+HammingWindowFunction::HammingWindowFunction(std::size_t window_size)
+        : GeneralizedCosineWindowFunction(window_size, { 0.53836f, 0.46164f })
+{
+}
+
+BlackmanWindowFunction::BlackmanWindowFunction(std::size_t window_size)
+        : GeneralizedCosineWindowFunction(window_size, { 7938.0f / 18608.0f, 9240.0f / 18608.0f, 1430.0f / 18608.0f })
+{
+}
+
+NuttallWindowFunction::NuttallWindowFunction(std::size_t window_size)
+        : GeneralizedCosineWindowFunction(window_size, { 0.355768f, 0.487396f, 0.144232f, 0.012604f })
+{
+}
\ No newline at end of file
diff --git a/src/window-function.hpp b/src/window-function.hpp
new file mode 100644
index 0000000..123a17e
--- /dev/null
+++ b/src/window-function.hpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2020-2021 Vasile Vilvoiu <vasi.vilvoiu@gmail.com>
+ *
+ * specgram is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+#ifndef _WINDOW_FUNCTION_HPP_
+#define _WINDOW_FUNCTION_HPP_
+
+#include "input-parser.hpp"
+
+#include <vector>
+#include <complex>
+#include <memory>
+
+enum class WindowFunctionType {
+    kNone,
+    kHann,
+    kHamming,
+    kBlackman,
+    kNuttall
+};
+
+class WindowFunction {
+protected:
+    const std::size_t window_size_;
+    std::vector<double> cached_factors_;
+
+    explicit WindowFunction(std::size_t window_size);
+
+public:
+    WindowFunction() = delete;
+
+    ComplexWindow Apply(const ComplexWindow& window) const;
+
+    static std::unique_ptr<WindowFunction> FromType(WindowFunctionType type, std::size_t window_size);
+};
+
+class GeneralizedCosineWindowFunction : public WindowFunction {
+protected:
+public:
+    GeneralizedCosineWindowFunction(std::size_t window_size, const std::vector<double>& a);
+};
+
+class HannWindowFunction : public GeneralizedCosineWindowFunction {
+public:
+    explicit HannWindowFunction(std::size_t window_size);
+};
+
+class HammingWindowFunction : public GeneralizedCosineWindowFunction {
+public:
+    explicit HammingWindowFunction(std::size_t window_size);
+};
+
+class BlackmanWindowFunction : public GeneralizedCosineWindowFunction {
+public:
+    explicit BlackmanWindowFunction(std::size_t window_size);
+};
+
+class NuttallWindowFunction : public GeneralizedCosineWindowFunction {
+public:
+    explicit NuttallWindowFunction(std::size_t window_size);
+};
+
+#endif
\ No newline at end of file