diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/.gitignore | 1 | ||||
| -rw-r--r-- | src/args.hxx | 4311 | ||||
| -rw-r--r-- | src/color-map.cpp | 150 | ||||
| -rw-r--r-- | src/color-map.hpp | 80 | ||||
| -rw-r--r-- | src/configuration.cpp | 491 | ||||
| -rw-r--r-- | src/configuration.hpp | 131 | ||||
| -rw-r--r-- | src/fft.cpp | 234 | ||||
| -rw-r--r-- | src/fft.hpp | 48 | ||||
| -rw-r--r-- | src/input-parser.cpp | 153 | ||||
| -rw-r--r-- | src/input-parser.hpp | 106 | ||||
| -rw-r--r-- | src/input-reader.cpp | 164 | ||||
| -rw-r--r-- | src/input-reader.hpp | 77 | ||||
| -rw-r--r-- | src/live.cpp | 77 | ||||
| -rw-r--r-- | src/live.hpp | 40 | ||||
| -rw-r--r-- | src/renderer.cpp | 502 | ||||
| -rw-r--r-- | src/renderer.hpp | 75 | ||||
| -rw-r--r-- | src/share-tech-mono.cpp | 3566 | ||||
| -rw-r--r-- | src/share-tech-mono.hpp | 7 | ||||
| -rw-r--r-- | src/specgram.cpp | 287 | ||||
| -rw-r--r-- | src/specgram.hpp.in | 28 | ||||
| -rw-r--r-- | src/value-map.cpp | 31 | ||||
| -rw-r--r-- | src/value-map.hpp | 48 | ||||
| -rw-r--r-- | src/window-function.cpp | 88 | ||||
| -rw-r--r-- | src/window-function.hpp | 65 |
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 ¶ms) 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 ¶ms) const + { + return choicesStringManual ? choicesStrings : GetChoicesStrings(params); + } + + virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams ¶ms, 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 ¶ms) 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 ¶ms) 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 ¶ms) 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 ¶ms, 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 ¶ms) 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 ¶ms_); + + ~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 ¶ms) 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 ¶ms) 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 ¶ms) 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 ¶ms, 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 ¶ms_): 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 |