first working version

CMakeLists.txt

@@ -7,9 +7,12 @@ endif()
 
 project(curly.hpp)
 
-add_library(${PROJECT_NAME} INTERFACE)
-target_include_directories(${PROJECT_NAME} INTERFACE headers)
-target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_17)
+add_library(${PROJECT_NAME} STATIC
+    headers/curly.hpp/curly.hpp
+    sources/curly.cpp)
+target_include_directories(${PROJECT_NAME} PUBLIC headers)
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_17)
+target_link_libraries(${PROJECT_NAME} PUBLIC curl)
 
 if(BUILD_AS_STANDALONE)
     option(BUILD_WITH_UNTESTS "Build with unit tests" ON)

headers/curly.hpp/curly.hpp

@@ -6,6 +6,182 @@
 
 #pragma once
 
+#include <cstdint>
+#include <cstddef>
+
+#include <atomic>
+#include <thread>
+
+#include <map>
+#include <chrono>
+#include <memory>
+#include <string>
+#include <vector>
+#include <stdexcept>
+
 namespace curly_hpp
 {
+    class exception : public std::runtime_error {
+    public:
+        explicit exception(const char* what);
+        explicit exception(const std::string& what);
+    };
+
+    struct case_insensitive_compare {
+        bool operator()(const std::string& l, const std::string& r) const noexcept;
+    };
+
+    enum class methods {
+        put,
+        get,
+        head,
+        post
+    };
+
+    using headers_t = std::map<
+        std::string, std::string,
+        case_insensitive_compare>;
+
+    using body_t = std::vector<char>;
+    using response_code_t = std::uint16_t;
+
+    using sec_t = std::chrono::seconds;
+    using ms_t = std::chrono::milliseconds;
+
+    class upload_handler {
+    public:
+        virtual ~upload_handler() {}
+        virtual std::size_t size() const = 0;
+        virtual std::size_t upload(void* dst, std::size_t size) = 0;
+    };
+
+    class download_handler {
+    public:
+        virtual ~download_handler() {}
+        virtual std::size_t download(const void* src, std::size_t size) = 0;
+    };
+
+    using uploader_uptr = std::unique_ptr<upload_handler>;
+    using downloader_uptr = std::unique_ptr<download_handler>;
+
+    class request_builder {
+    public:
+        request_builder() = default;
+
+        request_builder(request_builder&&) = default;
+        request_builder& operator=(request_builder&&) = default;
+
+        request_builder(const request_builder&) = delete;
+        request_builder& operator=(const request_builder&) = delete;
+
+        explicit request_builder(methods m) noexcept;
+        explicit request_builder(std::string u) noexcept;
+        explicit request_builder(methods m, std::string u) noexcept;
+
+        request_builder& url(std::string u) noexcept;
+        request_builder& method(methods m) noexcept;
+        request_builder& header(std::string key, std::string value);
+
+        request_builder& verbose(bool v) noexcept;
+        request_builder& verification(bool v) noexcept;
+        request_builder& response_timeout(sec_t t) noexcept;
+        request_builder& connection_timeout(sec_t t) noexcept;
+        request_builder& redirections(std::uint32_t r) noexcept;
+
+        request_builder& body(body_t b) noexcept;
+        request_builder& body(std::string_view b);
+        request_builder& uploader(uploader_uptr u) noexcept;
+        request_builder& downloader(downloader_uptr d) noexcept;
+
+        [[nodiscard]] const std::string& url() const noexcept;
+        [[nodiscard]] methods method() const noexcept;
+        [[nodiscard]] const headers_t& headers() const noexcept;
+
+        [[nodiscard]] bool verbose() const noexcept;
+        [[nodiscard]] bool verification() const noexcept;
+        [[nodiscard]] sec_t response_timeout() const noexcept;
+        [[nodiscard]] sec_t connection_timeout() const noexcept;
+        [[nodiscard]] std::uint32_t redirections() const noexcept;
+
+        [[nodiscard]] body_t& body() noexcept;
+        [[nodiscard]] const body_t& body() const noexcept;
+
+        [[nodiscard]] uploader_uptr& uploader() noexcept;
+        [[nodiscard]] const uploader_uptr& uploader() const noexcept;
+
+        [[nodiscard]] downloader_uptr& downloader() noexcept;
+        [[nodiscard]] const downloader_uptr& downloader() const noexcept;
+    private:
+        std::string url_;
+        methods method_{methods::get};
+        headers_t headers_;
+        bool verbose_{false};
+        bool verification_{true};
+        sec_t response_timeout_{60u};
+        sec_t connection_timeout_{20u};
+        std::uint32_t redirections_{~0u};
+    private:
+        body_t body_;
+        uploader_uptr uploader_;
+        downloader_uptr downloader_;
+    };
+
+    class response {
+    public:
+        response() = default;
+        response(response_code_t c, body_t b, headers_t h);
+
+        response_code_t code() const noexcept;
+        const body_t& body() const noexcept;
+        const headers_t& headers() const noexcept;
+        std::string_view body_as_string() const noexcept;
+    private:
+        response_code_t code_{0u};
+        body_t body_;
+        headers_t headers_;
+    };
+
+    class request {
+    public:
+        enum class statuses {
+            done,
+            failed,
+            timeout,
+            pending,
+            canceled
+        };
+    public:
+        class internal_state;
+        using internal_state_ptr = std::shared_ptr<internal_state>;
+    public:
+        request(internal_state_ptr);
+
+        bool cancel() noexcept;
+        statuses wait() const noexcept;
+        statuses status() const noexcept;
+
+        const response& get() const;
+        const std::string& error() const noexcept;
+    private:
+        internal_state_ptr state_;
+    };
+
+    class auto_updater {
+    public:
+        auto_updater();
+        ~auto_updater() noexcept;
+
+        ms_t wait_activity() const noexcept;
+        void wait_activity(ms_t ms) noexcept;
+    private:
+        std::thread thread_;
+        ms_t wait_activity_{100};
+        std::atomic<bool> done_{false};
+    };
+
+    void update();
+    void wait_activity(ms_t ms);
+
+    request perform(request_builder& rb);
+    request perform(request_builder&& rb);
 }

scripts/gen_xcode_project.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -e
+BUILD_DIR=`dirname "$BASH_SOURCE"`/../build
+mkdir -p $BUILD_DIR/xcode
+cd $BUILD_DIR/xcode
+cmake -G Xcode ../..
+open curly.hpp.xcodeproj

sources/curly.cpp

@@ -0,0 +1,734 @@
+/*******************************************************************************
+ * This file is part of the "https://github.com/blackmatov/curly.hpp"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <curly.hpp/curly.hpp>
+
+#include <cctype>
+#include <cstring>
+
+#include <mutex>
+#include <algorithm>
+#include <functional>
+
+#include <curl/curl.h>
+
+// -----------------------------------------------------------------------------
+//
+// utils
+//
+// -----------------------------------------------------------------------------
+
+namespace
+{
+    using namespace curly_hpp;
+
+    using slist_t = std::unique_ptr<
+        curl_slist,
+        void(*)(curl_slist*)>;
+
+    using handle_t = std::unique_ptr<
+        CURL,
+        void(*)(CURL*)>;
+
+    using time_point_t = std::chrono::steady_clock::time_point;
+    using req_state_t = std::shared_ptr<request::internal_state>;
+    std::map<CURL*, req_state_t> handles;
+
+    slist_t make_header_slist(const headers_t& headers) {
+        std::string header_builder;
+        curl_slist* result = nullptr;
+        for ( const auto& [key,value] : headers ) {
+            if ( key.empty() ) {
+                continue;
+            }
+            try {
+                header_builder.clear();
+                header_builder.append(key);
+                if ( !value.empty() ) {
+                    header_builder.append(": ");
+                    header_builder.append(value);
+                } else {
+                    header_builder.append(";");
+                }
+                result = curl_slist_append(result, header_builder.c_str());
+            } catch (...) {
+                curl_slist_free_all(result);
+                throw;
+            }
+        }
+        return {result, &curl_slist_free_all};
+    }
+}
+
+// -----------------------------------------------------------------------------
+//
+// curl_state
+//
+// -----------------------------------------------------------------------------
+
+namespace
+{
+    using namespace curly_hpp;
+
+    class curl_state {
+    public:
+        template < typename F >
+        static std::invoke_result_t<F, CURLM*> with(F&& f) {
+            std::lock_guard<std::mutex> guard(mutex_);
+            if ( !self_ ) {
+                self_ = std::make_unique<curl_state>();
+            }
+            return std::forward<F>(f)(self_->curlm_);
+        }
+    public:
+        curl_state() {
+            if ( 0 != curl_global_init(CURL_GLOBAL_ALL) ) {
+                throw exception("curly_hpp: failed to curl_global_init");
+            }
+            curlm_ = curl_multi_init();
+            if ( !curlm_ ) {
+                curl_global_cleanup();
+                throw exception("curly_hpp: failed to curl_multi_init");
+            }
+        }
+
+        ~curl_state() noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            if ( curlm_ ) {
+                curl_multi_cleanup(curlm_);
+                curl_global_cleanup();
+                curlm_ = nullptr;
+            }
+        }
+    private:
+        CURLM* curlm_{nullptr};
+        static std::mutex mutex_;
+        static std::unique_ptr<curl_state> self_;
+    };
+
+    std::mutex curl_state::mutex_;
+    std::unique_ptr<curl_state> curl_state::self_;
+}
+
+// -----------------------------------------------------------------------------
+//
+// exception
+//
+// -----------------------------------------------------------------------------
+
+namespace curly_hpp
+{
+    exception::exception(const char* what)
+    : std::runtime_error(what) {}
+
+    exception::exception(const std::string& what)
+    : std::runtime_error(what) {}
+}
+
+// -----------------------------------------------------------------------------
+//
+// case_insensitive_compare
+//
+// -----------------------------------------------------------------------------
+
+namespace curly_hpp
+{
+    bool case_insensitive_compare::operator()(
+        const std::string& l,
+        const std::string& r) const noexcept
+    {
+        return std::lexicographical_compare(
+            l.begin(), l.end(), r.begin(), r.end(),
+            [](const auto lc, const auto rc) {
+                return std::tolower(lc) < std::tolower(rc);
+            });
+    }
+}
+
+// -----------------------------------------------------------------------------
+//
+// request_builder
+//
+// -----------------------------------------------------------------------------
+
+namespace curly_hpp
+{
+    request_builder::request_builder(methods m) noexcept
+    : method_(m) {}
+
+    request_builder::request_builder(std::string u) noexcept
+    : url_(std::move(u)) {}
+
+    request_builder::request_builder(methods m, std::string u) noexcept
+    : url_(std::move(u))
+    , method_(m) {}
+
+    request_builder& request_builder::url(std::string u) noexcept {
+        url_ = std::move(u);
+        return *this;
+    }
+
+    request_builder& request_builder::method(methods m) noexcept {
+        method_ = m;
+        return *this;
+    }
+
+    request_builder& request_builder::header(std::string key, std::string value) {
+        headers_.insert_or_assign(std::move(key), std::move(value));
+        return *this;
+    }
+
+    request_builder& request_builder::verbose(bool v) noexcept {
+        verbose_ = v;
+        return *this;
+    }
+
+    request_builder& request_builder::verification(bool v) noexcept {
+        verification_ = v;
+        return *this;
+    }
+
+    request_builder& request_builder::response_timeout(sec_t t) noexcept {
+        response_timeout_ = t;
+        return *this;
+    }
+
+    request_builder& request_builder::connection_timeout(sec_t t) noexcept {
+        connection_timeout_ = t;
+        return *this;
+    }
+
+    request_builder& request_builder::redirections(std::uint32_t r) noexcept {
+        redirections_ = r;
+        return *this;
+    }
+
+    request_builder& request_builder::body(body_t b) noexcept {
+        body_ = std::move(b);
+        return *this;
+    }
+
+    request_builder& request_builder::body(std::string_view b) {
+        body_.assign(b.begin(), b.end());
+        return *this;
+    }
+
+    request_builder& request_builder::uploader(uploader_uptr u) noexcept {
+        uploader_ = std::move(u);
+        return *this;
+    }
+
+    request_builder& request_builder::downloader(downloader_uptr d) noexcept {
+        downloader_ = std::move(d);
+        return *this;
+    }
+
+    const std::string& request_builder::url() const noexcept {
+        return url_;
+    }
+
+    methods request_builder::method() const noexcept {
+        return method_;
+    }
+
+    const headers_t& request_builder::headers() const noexcept {
+        return headers_;
+    }
+
+    bool request_builder::verbose() const noexcept {
+        return verbose_;
+    }
+
+    bool request_builder::verification() const noexcept {
+        return verification_;
+    }
+
+    sec_t request_builder::response_timeout() const noexcept {
+        return response_timeout_;
+    }
+
+    sec_t request_builder::connection_timeout() const noexcept {
+        return connection_timeout_;
+    }
+
+    std::uint32_t request_builder::redirections() const noexcept {
+        return redirections_;
+    }
+
+    body_t& request_builder::body() noexcept {
+        return body_;
+    }
+
+    const body_t& request_builder::body() const noexcept {
+        return body_;
+    }
+
+    uploader_uptr& request_builder::uploader() noexcept {
+        return uploader_;
+    }
+
+    const uploader_uptr& request_builder::uploader() const noexcept {
+        return uploader_;
+    }
+
+    downloader_uptr& request_builder::downloader() noexcept {
+        return downloader_;
+    }
+
+    const downloader_uptr& request_builder::downloader() const noexcept {
+        return downloader_;
+    }
+}
+
+// -----------------------------------------------------------------------------
+//
+// response
+//
+// -----------------------------------------------------------------------------
+
+response::response(response_code_t c, body_t b, headers_t h)
+: code_(c)
+, body_(std::move(b))
+, headers_(std::move(h)) {}
+
+response_code_t response::code() const noexcept {
+    return code_;
+}
+
+const body_t& response::body() const noexcept {
+    return body_;
+}
+
+const headers_t& response::headers() const noexcept {
+    return headers_;
+}
+
+std::string_view response::body_as_string() const noexcept {
+    return {body_.data(), body_.size()};
+}
+
+// -----------------------------------------------------------------------------
+//
+// request
+//
+// -----------------------------------------------------------------------------
+
+namespace curly_hpp
+{
+    class request::internal_state final {
+    public:
+        internal_state(handle_t handle, request_builder&& rb)
+        : hlist_(make_header_slist(rb.headers()))
+        , handle_(std::move(handle))
+        , body_(std::move(rb.body()))
+        , uploader_(std::move(rb.uploader()))
+        , downloader_(std::move(rb.downloader()))
+        {
+            if ( const auto* vi = curl_version_info(CURLVERSION_NOW); vi && vi->version ) {
+                std::string user_agent("cURL/");
+                user_agent.append(vi->version);
+                curl_easy_setopt(handle_.get(), CURLOPT_USERAGENT, user_agent.c_str());
+            }
+
+            curl_easy_setopt(handle_.get(), CURLOPT_NOSIGNAL, 1L);
+            curl_easy_setopt(handle_.get(), CURLOPT_TCP_KEEPALIVE, 1L);
+            curl_easy_setopt(handle_.get(), CURLOPT_BUFFERSIZE, 65536L);
+            curl_easy_setopt(handle_.get(), CURLOPT_USE_SSL, CURLUSESSL_ALL);
+
+            curl_easy_setopt(handle_.get(), CURLOPT_READDATA, this);
+            curl_easy_setopt(handle_.get(), CURLOPT_READFUNCTION, &s_upload_callback_);
+
+            curl_easy_setopt(handle_.get(), CURLOPT_WRITEDATA, this);
+            curl_easy_setopt(handle_.get(), CURLOPT_WRITEFUNCTION, &s_download_callback_);
+
+            curl_easy_setopt(handle_.get(), CURLOPT_HEADERDATA, this);
+            curl_easy_setopt(handle_.get(), CURLOPT_HEADERFUNCTION, &s_header_callback_);
+
+            curl_easy_setopt(handle_.get(), CURLOPT_URL, rb.url().c_str());
+            curl_easy_setopt(handle_.get(), CURLOPT_HTTPHEADER, hlist_.get());
+            curl_easy_setopt(handle_.get(), CURLOPT_VERBOSE, rb.verbose() ? 1L : 0L);
+
+            switch ( rb.method() ) {
+            case methods::put:
+                curl_easy_setopt(handle_.get(), CURLOPT_UPLOAD, 1L);
+                curl_easy_setopt(handle_.get(), CURLOPT_INFILESIZE_LARGE, uploader_
+                    ? static_cast<curl_off_t>(uploader_->size())
+                    : static_cast<curl_off_t>(body_.size()));
+                break;
+            case methods::get:
+                curl_easy_setopt(handle_.get(), CURLOPT_HTTPGET, 1L);
+                break;
+            case methods::head:
+                curl_easy_setopt(handle_.get(), CURLOPT_NOBODY, 1L);
+                break;
+            case methods::post:
+                curl_easy_setopt(handle_.get(), CURLOPT_POST, 1L);
+                curl_easy_setopt(handle_.get(), CURLOPT_POSTFIELDSIZE_LARGE, uploader_
+                    ? static_cast<curl_off_t>(uploader_->size())
+                    : static_cast<curl_off_t>(body_.size()));
+                break;
+            default:
+                throw exception("curly_hpp: unexpected request method");
+            }
+
+            if ( rb.verification() ) {
+                curl_easy_setopt(handle.get(), CURLOPT_SSL_VERIFYPEER, 1L);
+                curl_easy_setopt(handle.get(), CURLOPT_SSL_VERIFYHOST, 2L);
+            } else {
+                curl_easy_setopt(handle.get(), CURLOPT_SSL_VERIFYPEER, 0L);
+                curl_easy_setopt(handle.get(), CURLOPT_SSL_VERIFYHOST, 0L);
+            }
+
+            if ( rb.redirections() ) {
+                curl_easy_setopt(handle_.get(), CURLOPT_FOLLOWLOCATION, 1L);
+                curl_easy_setopt(handle_.get(), CURLOPT_MAXREDIRS, rb.redirections());
+            } else {
+                curl_easy_setopt(handle_.get(), CURLOPT_FOLLOWLOCATION, 0L);
+            }
+
+            curl_easy_setopt(handle_.get(), CURLOPT_CONNECTTIMEOUT,
+                std::max(sec_t(1), rb.connection_timeout()).count());
+
+            last_response_ = time_point_t::clock::now();
+            response_timeout_ = std::max(sec_t(1), rb.response_timeout());
+        }
+
+        bool done() noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            if ( status_ != statuses::pending ) {
+                return false;
+            }
+
+            long response_code = 0;
+            curl_easy_getinfo(
+                handle_.get(),
+                CURLINFO_RESPONSE_CODE,
+                &response_code);
+
+            response_ = response(
+                static_cast<response_code_t>(response_code),
+                std::move(response_body_),
+                std::move(response_headers_));
+
+            status_ = statuses::done;
+            error_.clear();
+
+            cond_var_.notify_all();
+            return true;
+        }
+
+        bool fail(CURLcode err) noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            if ( status_ != statuses::pending ) {
+                return false;
+            }
+
+            status_ = (err == CURLE_OPERATION_TIMEDOUT)
+                ? statuses::timeout
+                : statuses::failed;
+
+            try {
+                error_ = curl_easy_strerror(err);
+            } catch (...) {
+                // nothing
+            }
+
+            cond_var_.notify_all();
+            return true;
+        }
+
+        bool cancel() noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            if ( status_ != statuses::pending ) {
+                return false;
+            }
+
+            status_ = statuses::canceled;
+            error_.clear();
+
+            cond_var_.notify_all();
+            return true;
+        }
+
+        statuses wait() const noexcept {
+            std::unique_lock<std::mutex> lock(mutex_);
+            cond_var_.wait(lock, [this](){
+                return status_ != statuses::pending;
+            });
+            return status_;
+        }
+
+        statuses status() const noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            return status_;
+        }
+
+        const response& get() const {
+            std::unique_lock<std::mutex> lock(mutex_);
+            cond_var_.wait(lock, [this](){
+                return status_ != statuses::pending;
+            });
+            if ( status_ != statuses::done ) {
+                throw exception("curly_hpp: response is unavailable");
+            }
+            return response_;
+        }
+
+        const std::string& error() const noexcept {
+            std::unique_lock<std::mutex> lock(mutex_);
+            cond_var_.wait(lock, [this](){
+                return status_ != statuses::pending;
+            });
+            return error_;
+        }
+
+        const handle_t& handle() const noexcept {
+            return handle_;
+        }
+
+        bool check_response_timeout(time_point_t now) const noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            return now - last_response_ >= response_timeout_;
+        }
+    private:
+        static std::size_t s_upload_callback_(
+            char* buffer, std::size_t size, std::size_t nitems, void* userdata) noexcept
+        {
+            auto* self = static_cast<internal_state*>(userdata);
+            return self->upload_callback_(buffer, size * nitems);
+        }
+
+        static std::size_t s_download_callback_(
+            char* ptr, std::size_t size, std::size_t nmemb, void* userdata) noexcept
+        {
+            auto* self = static_cast<internal_state*>(userdata);
+            return self->download_callback_(ptr, size * nmemb);
+        }
+
+        static std::size_t s_header_callback_(
+            char* buffer, std::size_t size, std::size_t nitems, void* userdata) noexcept
+        {
+            auto* self = static_cast<internal_state*>(userdata);
+            return self->header_callback_(buffer, size * nitems);
+        }
+    private:
+        void response_callback_() noexcept {
+            std::lock_guard<std::mutex> guard(mutex_);
+            last_response_ = time_point_t::clock::now();
+        }
+
+        std::size_t upload_callback_(char* dst, std::size_t size) noexcept {
+            try {
+                if ( uploader_ ) {
+                    std::size_t bytes = uploader_->upload(dst, size);
+                    uploaded_.fetch_add(bytes);
+                    return bytes;
+                }
+                std::lock_guard<std::mutex> guard(mutex_);
+                size = std::min(size, body_.size() - uploaded_.load());
+                std::memcpy(dst, body_.data() + uploaded_.load(), size);
+                uploaded_.fetch_add(size);
+                return size;
+            } catch (...) {
+                return CURL_READFUNC_ABORT;
+            }
+        }
+
+        std::size_t download_callback_(const char* src, std::size_t size) noexcept {
+            try {
+                if ( downloader_ ) {
+                    std::size_t bytes = downloader_->download(src, size);
+                    downloaded_.fetch_add(bytes);
+                    return bytes;
+                }
+                response_body_.insert(response_body_.end(), src, src + size);
+                downloaded_.fetch_add(size);
+                return size;
+            } catch (...) {
+                return 0u;
+            }
+        }
+
+        std::size_t header_callback_(const char* src, std::size_t size) noexcept {
+            try {
+                const std::string_view header(src, size);
+                if ( !header.compare(0u, 5u, "HTTP/") ) {
+                    std::lock_guard<std::mutex> guard(mutex_);
+                    response_headers_.clear();
+                } else if ( const auto sep_idx = header.find(':'); sep_idx != std::string_view::npos ) {
+                    if ( const auto key = header.substr(0, sep_idx); !key.empty() ) {
+                        auto val = header.substr(sep_idx + 1);
+                        const auto val_f = val.find_first_not_of("\t ");
+                        const auto val_l = val.find_last_not_of("\r\n\t ");
+                        val = (val_f != std::string_view::npos && val_l != std::string_view::npos)
+                            ? val.substr(val_f, val_l)
+                            : std::string_view();
+                        std::lock_guard<std::mutex> guard(mutex_);
+                        response_headers_.emplace(key, val);
+                    }
+                }
+                return header.size();
+            } catch (...) {
+                return 0;
+            }
+        }
+    private:
+        slist_t hlist_;
+        handle_t handle_;
+        body_t body_;
+        uploader_uptr uploader_;
+        downloader_uptr downloader_;
+    private:
+        time_point_t last_response_;
+        time_point_t::duration response_timeout_;
+    private:
+        mutable std::mutex mutex_;
+        mutable std::condition_variable cond_var_;
+        response response_;
+        body_t response_body_;
+        headers_t response_headers_;
+        std::atomic_size_t uploaded_{0u};
+        std::atomic_size_t downloaded_{0u};
+        statuses status_{statuses::pending};
+        std::string error_{"Unknown error"};
+    };
+}
+
+namespace curly_hpp
+{
+    request::request(internal_state_ptr state)
+    : state_(state) {}
+
+    bool request::cancel() noexcept {
+        return state_->cancel();
+    }
+
+    request::statuses request::wait() const noexcept {
+        return state_->wait();
+    }
+
+    request::statuses request::status() const noexcept {
+        return state_->status();
+    }
+
+    const response& request::get() const {
+        return state_->get();
+    }
+
+    const std::string& request::error() const noexcept {
+        return state_->error();
+    }
+}
+
+// -----------------------------------------------------------------------------
+//
+// auto_updater
+//
+// -----------------------------------------------------------------------------
+
+namespace curly_hpp
+{
+    auto_updater::auto_updater() {
+        thread_ = std::thread([this](){
+            while ( !done_ ) {
+                ::update();
+                ::wait_activity(wait_activity());
+            }
+        });
+    }
+
+    auto_updater::~auto_updater() noexcept {
+        done_.store(true);
+        if ( thread_.joinable() ) {
+            thread_.join();
+        }
+    }
+
+    ms_t auto_updater::wait_activity() const noexcept {
+        return wait_activity_;
+    }
+
+    void auto_updater::wait_activity(ms_t ms) noexcept {
+        wait_activity_ = ms;
+    }
+}
+
+// -----------------------------------------------------------------------------
+//
+// perform
+//
+// -----------------------------------------------------------------------------
+
+namespace curly_hpp
+{
+    void update() {
+        curl_state::with([](CURLM* curlm){
+            int running_handles = 0;
+            curl_multi_perform(curlm, &running_handles);
+            if ( !running_handles || static_cast<std::size_t>(running_handles) != handles.size() ) {
+                while ( true ) {
+                    int msgs_in_queue = 0;
+                    CURLMsg* msg = curl_multi_info_read(curlm, &msgs_in_queue);
+                    if ( !msg ) {
+                        break;
+                    }
+                    if ( msg->msg == CURLMSG_DONE ) {
+                        const auto iter = handles.find(msg->easy_handle);
+                        if ( iter != handles.end() ) {
+                            if ( msg->data.result == CURLE_OK ) {
+                                iter->second->done();
+                            } else {
+                                iter->second->fail(msg->data.result);
+                            }
+                        }
+                    }
+                }
+            }
+            const auto now = time_point_t::clock::now();
+            for ( const auto& [curl, sreq] : handles ) {
+                if ( sreq->check_response_timeout(now) ) {
+                    sreq->fail(CURLE_OPERATION_TIMEDOUT);
+                }
+            }
+            for ( auto iter = handles.begin(); iter != handles.end(); ) {
+                if ( iter->second->status() != request::statuses::pending ) {
+                    curl_multi_remove_handle(curlm, iter->first);
+                    iter = handles.erase(iter);
+                } else {
+                    ++iter;
+                }
+            }
+        });
+    }
+
+    void wait_activity(ms_t ms) {
+        curl_state::with([ms](CURLM* curlm){
+            curl_multi_wait(curlm, nullptr, 0, static_cast<int>(ms.count()), nullptr);
+        });
+    }
+
+    request perform(request_builder& rb) {
+        return perform(std::move(rb));
+    }
+
+    request perform(request_builder&& rb) {
+        return curl_state::with([&rb](CURLM* curlm){
+            handle_t handle{curl_easy_init(), &curl_easy_cleanup};
+            if ( !handle ) {
+                throw exception("curly_hpp: failed to curl_easy_init");
+            }
+            auto sreq = std::make_shared<request::internal_state>(std::move(handle), std::move(rb));
+            curl_multi_add_handle(curlm, sreq->handle().get());
+            try {
+                handles.emplace(sreq->handle().get(), sreq);
+            } catch (...) {
+                curl_multi_remove_handle(curlm, sreq->handle().get());
+                throw;
+            }
+            return request(sreq);
+        });
+    }
+}

untests/CMakeLists.txt

@@ -3,19 +3,44 @@ cmake_minimum_required(VERSION 3.11 FATAL_ERROR)
 
 project(curly.hpp.untests)
 
+include(FetchContent)
+
+#
+# nlohmann/json
+#
+
+set(JSON_BuildTests OFF CACHE BOOL "" FORCE)
+
+FetchContent_Declare(
+    nlohmann_json
+    GIT_REPOSITORY https://github.com/nlohmann/json)
+
+FetchContent_GetProperties(nlohmann_json)
+if(NOT nlohmann_json_POPULATED)
+    FetchContent_Populate(nlohmann_json)
+    add_subdirectory(${nlohmann_json_SOURCE_DIR} ${nlohmann_json_BINARY_DIR})
+endif()
+
+#
+# catchorg/catch2
+#
+
 set(CATCH_BUILD_TESTING OFF CACHE BOOL "" FORCE)
 
-include(FetchContent)
 FetchContent_Declare(
-    catch2
+    catchorg_catch2
     GIT_REPOSITORY https://github.com/catchorg/catch2)
 
-FetchContent_GetProperties(catch2)
-if(NOT catch2_POPULATED)
-    FetchContent_Populate(catch2)
-    add_subdirectory(${catch2_SOURCE_DIR} ${catch2_BINARY_DIR})
+FetchContent_GetProperties(catchorg_catch2)
+if(NOT catchorg_catch2_POPULATED)
+    FetchContent_Populate(catchorg_catch2)
+    add_subdirectory(${catchorg_catch2_SOURCE_DIR} ${catchorg_catch2_BINARY_DIR})
 endif()
 
+#
+# coverage
+#
+
 option(BUILD_WITH_COVERAGE "Build with coverage" OFF)
 if(BUILD_WITH_COVERAGE AND (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang"))
     set(COVERAGE_FLAGS "--coverage")
@@ -24,10 +49,15 @@ if(BUILD_WITH_COVERAGE AND (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang"))
     set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} ${COVERAGE_FLAGS}")
 endif()
 
+#
+# executable
+#
+
 file(GLOB UNTESTS_SOURCES "*.cpp" "*.hpp")
 add_executable(${PROJECT_NAME} ${UNTESTS_SOURCES})
 target_link_libraries(${PROJECT_NAME}
     Catch2
+    nlohmann_json
     curly.hpp)
 target_compile_options(${PROJECT_NAME}
     PRIVATE

untests/curly_tests.cpp

@@ -7,13 +7,336 @@
 #define CATCH_CONFIG_FAST_COMPILE
 #include <catch2/catch.hpp>
 
+#include <iostream>
+
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;
+
 #include <curly.hpp/curly.hpp>
-namespace cur = curly_hpp;
+namespace net = curly_hpp;
+
+#include "png_data.h"
+#include "jpeg_data.h"
 
 namespace
 {
+    class verbose_uploader : public net::upload_handler {
+    public:
+        verbose_uploader() = default;
+
+        std::size_t size() const override {
+            return 0;
+        }
+
+        std::size_t upload(void* dst, std::size_t size) override {
+            (void)dst;
+            std::cout << "---------- ** UPLOAD (" << size << ") ** ---------- " << std::endl;
+            return size;
+        }
+    };
+
+    class verbose_downloader : public net::download_handler {
+    public:
+        verbose_downloader() = default;
+
+        std::size_t download(const void* src, std::size_t size) override {
+            (void)src;
+            std::cout << "---------- ** DOWNLOAD (" << size << ") ** ---------- " << std::endl;
+            return size;
+        }
+    };
 }
 
 TEST_CASE("curly"){
-    REQUIRE(true);
+    net::auto_updater updater;
+
+    SECTION("wait") {
+        auto req = net::perform(net::request_builder("https://httpbin.org/status/200"));
+        REQUIRE(req.status() == net::request::statuses::pending);
+        REQUIRE(req.wait() == net::request::statuses::done);
+        REQUIRE(req.status() == net::request::statuses::done);
+        REQUIRE(req.get().code() == 200u);
+        REQUIRE(req.error().empty());
+    }
+
+    SECTION("error") {
+        auto req = net::perform(net::request_builder("|||"));
+        REQUIRE(req.wait() == net::request::statuses::failed);
+        REQUIRE(req.status() == net::request::statuses::failed);
+        REQUIRE_FALSE(req.error().empty());
+    }
+
+    SECTION("cancel") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/delay/2"));
+            REQUIRE(req.cancel());
+            REQUIRE(req.status() == net::request::statuses::canceled);
+            REQUIRE(req.error().empty());
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/status/200"));
+            REQUIRE(req.wait() == net::request::statuses::done);
+            REQUIRE_FALSE(req.cancel());
+            REQUIRE(req.status() == net::request::statuses::done);
+            REQUIRE(req.error().empty());
+        }
+    }
+
+    SECTION("get") {
+        {
+            auto req = net::perform(net::request_builder("https://httpbin.org/status/204"));
+            auto resp = req.get();
+            REQUIRE(req.status() == net::request::statuses::done);
+            REQUIRE(resp.code() == 204u);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/delay/2"));
+            REQUIRE(req.cancel());
+            REQUIRE_THROWS_AS(req.get(), net::exception);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/delay/2")
+                .response_timeout(net::sec_t(0)));
+            REQUIRE(req.wait() == net::request::statuses::timeout);
+            REQUIRE_THROWS_AS(req.get(), net::exception);
+        }
+    }
+
+    SECTION("http_methods") {
+        {
+            auto req0 = net::perform(net::request_builder()
+                .url("https://httpbin.org/put")
+                .method(net::methods::put));
+            REQUIRE(req0.get().code() == 200u);
+
+            auto req1 = net::perform(net::request_builder()
+                .url("https://httpbin.org/put")
+                .method(net::methods::get));
+            REQUIRE(req1.get().code() == 405u);
+
+            auto req2 = net::perform(net::request_builder()
+                .url("https://httpbin.org/put")
+                .method(net::methods::head));
+            REQUIRE(req2.get().code() == 405u);
+
+            auto req3 = net::perform(net::request_builder()
+                .url("https://httpbin.org/put")
+                .method(net::methods::post));
+            REQUIRE(req3.get().code() == 405u);
+        }
+        {
+            auto req0 = net::perform(net::request_builder()
+                .url("https://httpbin.org/get")
+                .method(net::methods::put));
+            REQUIRE(req0.get().code() == 405u);
+
+            auto req1 = net::perform(net::request_builder()
+                .url("https://httpbin.org/get")
+                .method(net::methods::get));
+            REQUIRE(req1.get().code() == 200u);
+
+            auto req2 = net::perform(net::request_builder()
+                .url("https://httpbin.org/get")
+                .method(net::methods::head));
+            REQUIRE(req2.get().code() == 200u);
+
+            auto req3 = net::perform(net::request_builder()
+                .url("https://httpbin.org/get")
+                .method(net::methods::post));
+            REQUIRE(req3.get().code() == 405u);
+        }
+        {
+            auto req0 = net::perform(net::request_builder()
+                .url("https://httpbin.org/post")
+                .method(net::methods::put));
+            REQUIRE(req0.get().code() == 405u);
+
+            auto req1 = net::perform(net::request_builder()
+                .url("https://httpbin.org/post")
+                .method(net::methods::get));
+            REQUIRE(req1.get().code() == 405u);
+
+            auto req2 = net::perform(net::request_builder()
+                .url("https://httpbin.org/post")
+                .method(net::methods::head));
+            REQUIRE(req2.get().code() == 405u);
+
+            auto req3 = net::perform(net::request_builder()
+                .url("https://httpbin.org/post")
+                .method(net::methods::post));
+            REQUIRE(req3.get().code() == 200u);
+        }
+    }
+
+    SECTION("status_codes") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/status/200")
+                .method(net::methods::put));
+            REQUIRE(req.get().code() == 200u);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/status/201")
+                .method(net::methods::get));
+            REQUIRE(req.get().code() == 201u);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/status/202")
+                .method(net::methods::head));
+            REQUIRE(req.get().code() == 202u);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/status/203")
+                .method(net::methods::post));
+            REQUIRE(req.get().code() == 203u);
+        }
+    }
+
+    SECTION("request_inspection") {
+        auto req = net::perform(net::request_builder()
+            .url("https://httpbin.org/headers")
+            .header("Custom-Header-1", "custom_header_value_1")
+            .header("Custom-Header-2", "custom header value 2"));
+        const auto resp = req.get();
+        const auto body_j = json::parse(resp.body_as_string());
+        REQUIRE(body_j["headers"]["Custom-Header-1"] == "custom_header_value_1");
+        REQUIRE(body_j["headers"]["Custom-Header-2"] == "custom header value 2");
+    }
+
+    SECTION("response_inspection") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/response-headers?hello=world&world=hello"));
+            const auto resp = req.get();
+            const auto body_j = json::parse(resp.body_as_string());
+            REQUIRE(body_j["hello"] == "world");
+            REQUIRE(body_j["world"] == "hello");
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/response-headers?hello=world&world=hello")
+                .method(net::methods::post));
+            const auto resp = req.get();
+            const auto body_j = json::parse(resp.body_as_string());
+            REQUIRE(body_j["hello"] == "world");
+            REQUIRE(body_j["world"] == "hello");
+        }
+    }
+
+    SECTION("dynamic_data") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/base64/SFRUUEJJTiBpcyBhd2Vzb21l"));
+            const auto resp = req.get();
+            REQUIRE(resp.body_as_string() == "HTTPBIN is awesome");
+            REQUIRE(req.error().empty());
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/delay/10")
+                .response_timeout(net::sec_t(0)));
+            REQUIRE(req.wait() == net::request::statuses::timeout);
+            REQUIRE_FALSE(req.error().empty());
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/delay/10")
+                .response_timeout(net::sec_t(1)));
+            REQUIRE(req.wait() == net::request::statuses::timeout);
+            REQUIRE_FALSE(req.error().empty());
+        }
+    }
+
+    SECTION("binary") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/image/png")
+                .method(net::methods::get));
+            const auto resp = req.get();
+            REQUIRE(resp.code() == 200u);
+            REQUIRE(resp.headers().count("Content-Type"));
+            REQUIRE(resp.headers().at("Content-Type") == "image/png");
+            REQUIRE(untests::png_data_length == resp.body().size());
+            REQUIRE(!std::memcmp(
+                resp.body().data(),
+                untests::png_data,
+                untests::png_data_length));
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/image/jpeg")
+                .method(net::methods::get));
+            const auto resp = req.get();
+            REQUIRE(resp.code() == 200u);
+            REQUIRE(resp.headers().count("Content-Type"));
+            REQUIRE(resp.headers().at("Content-Type") == "image/jpeg");
+            REQUIRE(untests::jpeg_data_length == resp.body().size());
+            REQUIRE(!std::memcmp(
+                resp.body().data(),
+                untests::jpeg_data,
+                untests::jpeg_data_length));
+        }
+    }
+
+    SECTION("redirects") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/redirect/2")
+                .method(net::methods::get));
+            REQUIRE(req.get().code() == 200u);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/absolute-redirect/2")
+                .method(net::methods::get));
+            REQUIRE(req.get().code() == 200u);
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/relative-redirect/2")
+                .method(net::methods::get));
+            REQUIRE(req.get().code() == 200u);
+        }
+    }
+
+    SECTION("request_body") {
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/anything")
+                .method(net::methods::put)
+                .header("Content-Type", "application/json")
+                .body(R"({"hello":"world"})"));
+            const auto resp = req.get();
+            const auto body_j = json::parse(resp.body_as_string());
+            REQUIRE(body_j["data"] == R"({"hello":"world"})");
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/anything")
+                .method(net::methods::post)
+                .header("Content-Type", "application/json")
+                .body(R"({"hello":"world"})"));
+            const auto resp = req.get();
+            const auto body_j = json::parse(resp.body_as_string());
+            REQUIRE(body_j["data"] == R"({"hello":"world"})");
+        }
+        {
+            auto req = net::perform(net::request_builder()
+                .url("https://httpbin.org/anything")
+                .method(net::methods::post)
+                .header("Content-Type", "application/x-www-form-urlencoded")
+                .body("hello=world&world=hello"));
+            const auto resp = req.get();
+            const auto body_j = json::parse(resp.body_as_string());
+            REQUIRE(body_j["form"]["hello"] == "world");
+            REQUIRE(body_j["form"]["world"] == "hello");
+        }
+    }
 }

untests/png_data.h

@@ -0,0 +1,748 @@
+#pragma once
+
+#include <cstdint>
+#include <cstddef>
+
+namespace untests
+{
+    static constexpr std::uint8_t png_data[8090] = {
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00,
+        0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00,
+        0x00, 0x64, 0x08, 0x02, 0x00, 0x00, 0x00, 0xff, 0x80, 0x02, 0x03,
+        0x00, 0x00, 0x1f, 0x61, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0xdd,
+        0x7d, 0x77, 0x58, 0x53, 0xd9, 0xd6, 0xfe, 0x4a, 0x23, 0xa1, 0x17,
+        0xc1, 0x20, 0x02, 0xa1, 0x08, 0xc1, 0x4a, 0x19, 0x11, 0x45, 0x10,
+        0x1c, 0x11, 0x14, 0x10, 0xf8, 0x74, 0x6c, 0x28, 0xea, 0xd8, 0x46,
+        0x47, 0x47, 0x54, 0xac, 0x9f, 0x5c, 0xeb, 0x8c, 0x0e, 0x56, 0xd4,
+        0xb1, 0xdc, 0x61, 0xe4, 0x0a, 0xb6, 0x11, 0x1b, 0x45, 0x41, 0x14,
+        0x51, 0x41, 0x94, 0x26, 0x82, 0xa2, 0x42, 0x00, 0x45, 0x7a, 0x6f,
+        0x49, 0x20, 0x10, 0x92, 0xf3, 0xfb, 0x63, 0x87, 0x10, 0x21, 0xc4,
+        0x24, 0x44, 0x7f, 0x77, 0xbe, 0xf7, 0xe1, 0xe1, 0x39, 0x39, 0x67,
+        0x67, 0xad, 0x75, 0xde, 0xb3, 0xf7, 0x3e, 0x7b, 0xaf, 0xbd, 0xd6,
+        0x0e, 0x0e, 0xc3, 0x30, 0x00, 0x60, 0xb3, 0xd9, 0xc7, 0x8e, 0x1d,
+        0x4b, 0x4a, 0x4a, 0xca, 0xc9, 0xc9, 0xe9, 0xec, 0xec, 0x24, 0x93,
+        0xc9, 0x14, 0x0a, 0x85, 0xdc, 0x03, 0x55, 0x55, 0x55, 0x1a, 0x8d,
+        0x66, 0x6a, 0x6a, 0x6a, 0x62, 0x62, 0x62, 0x6a, 0x6a, 0x8a, 0x0e,
+        0x54, 0x54, 0x54, 0x60, 0x10, 0xc0, 0x30, 0xac, 0xbc, 0xbc, 0xbc,
+        0xb0, 0xb0, 0x90, 0xc1, 0x60, 0x30, 0x18, 0x8c, 0xf2, 0xf2, 0x72,
+        0x26, 0x93, 0xc9, 0x62, 0xb1, 0x98, 0x4c, 0x26, 0x93, 0xc9, 0xe4,
+        0xf3, 0xf9, 0xea, 0x22, 0x30, 0x30, 0x30, 0xb0, 0xec, 0x81, 0x89,
+        0x89, 0x09, 0x81, 0x40, 0x18, 0x8c, 0xea, 0xf6, 0xf6, 0xf6, 0xd2,
+        0xd2, 0xd2, 0x8f, 0x1f, 0x3f, 0x7e, 0xfc, 0xf8, 0x11, 0x1d, 0x7c,
+        0xfa, 0xf4, 0x89, 0xcd, 0x66, 0x77, 0x8a, 0x80, 0xc3, 0xe1, 0x90,
+        0xc9, 0x64, 0x3b, 0x3b, 0x3b, 0x37, 0x37, 0xb7, 0xa0, 0xa0, 0x20,
+        0x55, 0x55, 0x55, 0x81, 0xd1, 0xa9, 0xa9, 0xa9, 0x26, 0x26, 0x26,
+        0x32, 0xe9, 0xc3, 0xe3, 0xf1, 0x76, 0x76, 0x76, 0x41, 0x41, 0x41,
+        0x77, 0xef, 0xde, 0x6d, 0x6d, 0x6d, 0xc5, 0xa4, 0x46, 0x79, 0x79,
+        0xf9, 0x99, 0x33, 0x67, 0xa6, 0x4f, 0x9f, 0xae, 0xac, 0xac, 0x2c,
+        0xdf, 0xad, 0x2a, 0x29, 0x29, 0x39, 0x3b, 0x3b, 0x1f, 0x3b, 0x76,
+        0xac, 0xa4, 0xa4, 0x44, 0x7a, 0xbd, 0xad, 0xad, 0xad, 0x77, 0xef,
+        0xde, 0x0d, 0x0a, 0x0a, 0xb2, 0xb3, 0xb3, 0xc3, 0xe3, 0xf1, 0x32,
+        0x69, 0x34, 0x31, 0x31, 0x49, 0x4d, 0x4d, 0xc5, 0x30, 0x0c, 0xc7,
+        0x66, 0xb3, 0xad, 0xac, 0xac, 0xca, 0xcb, 0xcb, 0x01, 0xc0, 0xd6,
+        0xd4, 0x74, 0x32, 0x9d, 0xae, 0xa9, 0xa2, 0xc2, 0xe1, 0x72, 0x3b,
+        0xb9, 0xdc, 0x4e, 0x2e, 0x17, 0x1d, 0xb4, 0x77, 0x75, 0x95, 0x37,
+        0x34, 0x7c, 0xac, 0xab, 0x6b, 0xeb, 0xe8, 0xe8, 0x2f, 0x8b, 0x40,
+        0x20, 0xd8, 0xd9, 0xd9, 0x79, 0x79, 0x79, 0x2d, 0x5f, 0xbe, 0xdc,
+        0xc8, 0xc8, 0x48, 0xac, 0xbe, 0xfc, 0xfc, 0xfc, 0xe8, 0xe8, 0xe8,
+        0x98, 0x98, 0x98, 0xec, 0xec, 0xec, 0xfe, 0x57, 0x55, 0xc9, 0x64,
+        0x9a, 0x9e, 0x9e, 0x86, 0xb2, 0xb2, 0x86, 0x8a, 0x8a, 0x3a, 0x85,
+        0xa2, 0xa1, 0xa2, 0x82, 0x03, 0x60, 0x72, 0x38, 0x6d, 0xed, 0xed,
+        0xe8, 0x7f, 0x59, 0x43, 0x83, 0x58, 0xd5, 0x63, 0xc6, 0x8c, 0xf1,
+        0xf3, 0xf3, 0xf3, 0xf5, 0xf5, 0x1d, 0x3f, 0x7e, 0xbc, 0x58, 0xbd,
+        0xe5, 0xe5, 0xe5, 0xe1, 0xe1, 0xe1, 0xf7, 0xee, 0xdd, 0xcb, 0xc9,
+        0xc9, 0xe1, 0xf1, 0x78, 0xfd, 0x0b, 0x68, 0x28, 0x2b, 0x9b, 0x0e,
+        0x1d, 0x6a, 0xa4, 0xab, 0xab, 0xa2, 0xa4, 0x44, 0x26, 0x91, 0x28,
+        0x24, 0x12, 0x99, 0x44, 0x42, 0x07, 0xad, 0xed, 0xed, 0x69, 0x85,
+        0x85, 0xaf, 0x3e, 0x7e, 0x04, 0x00, 0x23, 0x23, 0xa3, 0x82, 0x82,
+        0x02, 0xdc, 0xbe, 0x7d, 0xfb, 0xf6, 0xec, 0xd9, 0x03, 0x00, 0x21,
+        0x8b, 0x16, 0x6d, 0xf3, 0xf5, 0x1d, 0x90, 0x5e, 0x00, 0x00, 0x68,
+        0x62, 0xb1, 0x4a, 0xeb, 0xeb, 0x3f, 0xd6, 0xd5, 0xbd, 0x29, 0x2b,
+        0x7b, 0xf2, 0xf6, 0x6d, 0x7a, 0x51, 0x51, 0x27, 0x97, 0x2b, 0xbc,
+        0x8a, 0xc7, 0xe3, 0x67, 0xce, 0x9c, 0xb9, 0x7a, 0xf5, 0x6a, 0x2f,
+        0x2f, 0x2f, 0x02, 0x81, 0xc0, 0xe3, 0xf1, 0xd2, 0xd2, 0xd2, 0x62,
+        0x62, 0x62, 0x62, 0x62, 0x62, 0x4a, 0x4a, 0x4a, 0x44, 0xe5, 0x18,
+        0xeb, 0xea, 0xce, 0xb0, 0xb1, 0x19, 0x63, 0x64, 0x64, 0x35, 0x7c,
+        0xb8, 0xd5, 0xf0, 0xe1, 0x86, 0x3a, 0x3a, 0x38, 0x1c, 0x4e, 0xb2,
+        0xea, 0xea, 0xe6, 0xe6, 0x82, 0xaa, 0xaa, 0xc2, 0xaa, 0xaa, 0x77,
+        0x15, 0x15, 0x0f, 0xf2, 0xf2, 0x0a, 0xab, 0xaa, 0x44, 0xaf, 0x1a,
+        0x1a, 0x1a, 0xfa, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xb9, 0xba, 0xba,
+        0x92, 0x48, 0x24, 0x1e, 0x8f, 0x77, 0xef, 0xde, 0xbd, 0x3f, 0xff,
+        0xfc, 0x33, 0x21, 0x21, 0x81, 0xcf, 0xe7, 0x0b, 0x8b, 0x91, 0x49,
+        0xa4, 0x89, 0x16, 0x16, 0xae, 0xa3, 0x47, 0x8f, 0x35, 0x36, 0x36,
+        0x1d, 0x3a, 0xd4, 0x44, 0x4f, 0x4f, 0x47, 0x4d, 0x4d, 0xb2, 0xde,
+        0xc3, 0x31, 0x31, 0xdb, 0xaf, 0x5c, 0x01, 0x80, 0x7d, 0xfb, 0xf6,
+        0xe1, 0xa6, 0x4c, 0x99, 0x92, 0x92, 0x92, 0x32, 0x8e, 0x46, 0xcb,
+        0x3d, 0x7c, 0x18, 0x59, 0x5c, 0xd1, 0xd8, 0xf8, 0x57, 0x72, 0xf2,
+        0xd3, 0x77, 0xef, 0xf0, 0x38, 0x1c, 0x1e, 0x87, 0xc3, 0xe3, 0xf1,
+        0x64, 0x22, 0xd1, 0xd6, 0xd4, 0x74, 0x92, 0xa5, 0xa5, 0x83, 0x85,
+        0x85, 0x36, 0x6a, 0xbd, 0x00, 0x00, 0xc0, 0xe1, 0x72, 0x9f, 0x17,
+        0x16, 0x3e, 0x7e, 0xfb, 0x36, 0x31, 0x37, 0x37, 0x4b, 0x84, 0x0e,
+        0x03, 0x03, 0x03, 0x7b, 0x7b, 0xfb, 0x97, 0x2f, 0x5f, 0x56, 0x54,
+        0x54, 0x88, 0x2a, 0xb6, 0xa6, 0xd1, 0x7c, 0xed, 0xed, 0xfd, 0xec,
+        0xed, 0x6d, 0x4d, 0x4d, 0x25, 0x9b, 0xf8, 0x45, 0x14, 0x54, 0x56,
+        0xc6, 0x64, 0x67, 0x47, 0x67, 0x66, 0x66, 0x14, 0x17, 0xa3, 0x6e,
+        0x17, 0x41, 0x57, 0x57, 0xd7, 0xde, 0xde, 0x3e, 0x37, 0x37, 0xb7,
+        0xba, 0xba, 0x5a, 0x78, 0xd2, 0xde, 0xdc, 0xdc, 0xc3, 0xc6, 0x66,
+        0xea, 0xe8, 0xd1, 0x8e, 0x74, 0x3a, 0x85, 0x44, 0x02, 0x80, 0x66,
+        0x36, 0x3b, 0x9d, 0xc1, 0x48, 0x2f, 0x2a, 0x7a, 0xc1, 0x60, 0x64,
+        0x16, 0x17, 0xb7, 0xb6, 0xb7, 0x0b, 0x0b, 0x9b, 0x51, 0xa9, 0xcb,
+        0xa7, 0x4e, 0xdd, 0x30, 0x73, 0xa6, 0xba, 0xb2, 0x32, 0x00, 0x60,
+        0x18, 0x66, 0xb3, 0x6d, 0xdb, 0xeb, 0x4f, 0x9f, 0xa6, 0x4c, 0x99,
+        0x82, 0xb3, 0xb0, 0xb0, 0x28, 0x2a, 0x2a, 0x0a, 0x98, 0x32, 0x25,
+        0x72, 0xfd, 0x7a, 0x00, 0xc8, 0xfb, 0xf4, 0x69, 0xfc, 0x8e, 0x1d,
+        0xdd, 0xe2, 0x6a, 0x2c, 0x00, 0xe0, 0x70, 0x38, 0xba, 0x81, 0xc1,
+        0xb4, 0x31, 0x63, 0xd6, 0xcd, 0x98, 0x31, 0x72, 0xf8, 0x70, 0xd1,
+        0x4b, 0x6f, 0xca, 0xca, 0xfe, 0x4c, 0x4a, 0xba, 0x9c, 0x9a, 0xda,
+        0xc2, 0x66, 0x8b, 0x9e, 0x27, 0x12, 0x08, 0xce, 0x56, 0x56, 0x7e,
+        0x13, 0x26, 0xf8, 0x8c, 0x1f, 0x6f, 0xa2, 0xa7, 0x37, 0x48, 0x8e,
+        0xfa, 0xa3, 0xa6, 0xa5, 0x25, 0x36, 0x3b, 0x3b, 0x3a, 0x2b, 0x2b,
+        0x39, 0x3f, 0x5f, 0xb4, 0x9a, 0x03, 0x80, 0x96, 0xaa, 0xea, 0x62,
+        0x67, 0xe7, 0xd5, 0x6e, 0x6e, 0x63, 0x8d, 0x8d, 0xd1, 0x19, 0x3e,
+        0x86, 0xdd, 0xcb, 0xc9, 0x39, 0x9d, 0x90, 0x90, 0xf4, 0xe6, 0x8d,
+        0x28, 0xc5, 0xfd, 0xb1, 0x72, 0xda, 0xb4, 0xb0, 0x9f, 0x7e, 0x42,
+        0xc7, 0x4b, 0xfe, 0xf8, 0xe3, 0x52, 0x4a, 0x8a, 0x85, 0x85, 0x05,
+        0x11, 0x3d, 0x01, 0x7d, 0x2d, 0x2d, 0x74, 0x61, 0x4f, 0x54, 0x14,
+        0x62, 0x6a, 0x8c, 0x91, 0x91, 0x8e, 0x9a, 0x1a, 0x8f, 0xcf, 0xe7,
+        0x63, 0x58, 0x0b, 0x9b, 0x5d, 0x58, 0x55, 0xc5, 0xc7, 0x30, 0x0c,
+        0xc3, 0x0a, 0x2a, 0x2b, 0x0b, 0x2a, 0x2b, 0xcf, 0x3e, 0x78, 0xe0,
+        0x3e, 0x6e, 0xdc, 0x66, 0x6f, 0x6f, 0x77, 0x6b, 0x6b, 0xf4, 0xc5,
+        0xb1, 0xc6, 0xc6, 0x5e, 0x76, 0x76, 0xe1, 0x8f, 0x1f, 0x0b, 0xf5,
+        0x19, 0x0e, 0x19, 0xf2, 0xaf, 0x39, 0x73, 0xe6, 0x4e, 0x9a, 0x24,
+        0x5a, 0x19, 0x15, 0x0e, 0x7d, 0x2d, 0xad, 0xd5, 0x6e, 0x6e, 0xab,
+        0xdd, 0xdc, 0x98, 0x1d, 0x1d, 0x31, 0xd9, 0xd9, 0x07, 0x6e, 0xde,
+        0x64, 0xf4, 0xd4, 0x29, 0x0e, 0x97, 0x8b, 0x5a, 0x1c, 0xfa, 0x78,
+        0x39, 0x35, 0x75, 0xf7, 0xf5, 0xeb, 0x1f, 0xeb, 0xea, 0x84, 0xdf,
+        0x45, 0xcf, 0xde, 0xd1, 0xd2, 0xd2, 0x48, 0x57, 0x17, 0x9d, 0xe1,
+        0xf1, 0xf9, 0x37, 0xd3, 0xd3, 0x0b, 0x2a, 0x2b, 0x2f, 0x24, 0x27,
+        0xff, 0xba, 0x60, 0x01, 0x55, 0x53, 0x53, 0x48, 0x4e, 0x75, 0x75,
+        0x35, 0xb1, 0xbb, 0xbb, 0x1b, 0x00, 0x08, 0x3d, 0x2f, 0x08, 0x1e,
+        0x9f, 0x0f, 0x00, 0x3b, 0xff, 0xe7, 0x7f, 0x0e, 0x2e, 0x5c, 0x28,
+        0x6a, 0x53, 0x5b, 0x47, 0x47, 0x56, 0x71, 0x71, 0x7a, 0x51, 0xd1,
+        0xe3, 0xb7, 0x6f, 0x93, 0xf3, 0xf3, 0x31, 0x0c, 0x4b, 0xcc, 0xcb,
+        0x4b, 0xcc, 0xcb, 0x7b, 0x10, 0x1c, 0x3c, 0x7d, 0xdc, 0xb8, 0xa2,
+        0xea, 0xea, 0xa0, 0xc8, 0xc8, 0xb8, 0x97, 0x2f, 0x51, 0x61, 0x4d,
+        0x15, 0x95, 0x1d, 0x7e, 0x7e, 0x81, 0x9e, 0x9e, 0xca, 0x4a, 0x4a,
+        0x5f, 0x8b, 0xa4, 0x7e, 0x50, 0x57, 0x56, 0x5e, 0xec, 0xec, 0xbc,
+        0xc0, 0xd1, 0x31, 0xec, 0xd1, 0xa3, 0x7d, 0x37, 0x6e, 0xd4, 0xb6,
+        0xb6, 0x72, 0xba, 0xba, 0x7e, 0x38, 0x76, 0x6c, 0xea, 0xe8, 0xd1,
+        0x27, 0x96, 0x2d, 0xa3, 0x6a, 0x6a, 0x2e, 0xfd, 0xe3, 0x0f, 0x3e,
+        0x86, 0x21, 0xf3, 0x96, 0xba, 0xb8, 0x4c, 0x1f, 0x37, 0x6e, 0x92,
+        0xa5, 0xe5, 0x10, 0x75, 0xf5, 0x3e, 0x72, 0x56, 0xbb, 0xb9, 0x79,
+        0xff, 0xfe, 0xbb, 0x8e, 0x9a, 0xda, 0x50, 0x0d, 0x0d, 0x74, 0x06,
+        0x91, 0xd3, 0xdd, 0xdd, 0x8d, 0xa3, 0x52, 0xa9, 0xb5, 0xb5, 0xb5,
+        0x6b, 0xdd, 0xdd, 0xcf, 0xae, 0x5c, 0x09, 0x00, 0x2c, 0x0e, 0xe7,
+        0x53, 0x7d, 0xfd, 0x28, 0x43, 0x43, 0x09, 0x3d, 0x6e, 0x51, 0x75,
+        0xf5, 0x99, 0xc4, 0xc4, 0x8b, 0x4f, 0x9e, 0xb0, 0x38, 0x9c, 0x87,
+        0xff, 0xfa, 0xd7, 0xcd, 0xf4, 0xf4, 0x3f, 0x1f, 0x3e, 0xec, 0xe6,
+        0xf3, 0x01, 0x40, 0x89, 0x48, 0x5c, 0xeb, 0xee, 0xfe, 0xaf, 0x39,
+        0x73, 0xfa, 0x1b, 0xf1, 0x2d, 0xc1, 0xe2, 0x70, 0x8e, 0xc5, 0xc5,
+        0x1d, 0x8d, 0x8b, 0x63, 0x71, 0x38, 0x00, 0x80, 0xc3, 0xe1, 0xfc,
+        0x9d, 0x9c, 0xda, 0xda, 0xdb, 0x4b, 0xeb, 0xeb, 0x57, 0xbb, 0xb9,
+        0x2d, 0x73, 0x75, 0x55, 0xa3, 0x50, 0xa4, 0x97, 0xf6, 0xf3, 0x5f,
+        0x7f, 0x9d, 0x7b, 0xf0, 0x80, 0x4a, 0xa5, 0xe2, 0xe8, 0x74, 0x7a,
+        0x61, 0x61, 0xa1, 0xbf, 0x93, 0xd3, 0x95, 0x0d, 0x1b, 0x64, 0x32,
+        0x88, 0xc3, 0xe5, 0x96, 0xd6, 0xd7, 0x2f, 0x3a, 0x79, 0x32, 0xe7,
+        0xe3, 0x47, 0x64, 0xd0, 0x7c, 0x47, 0xc7, 0xdf, 0x16, 0x2c, 0x30,
+        0xa3, 0x52, 0x65, 0x92, 0xf3, 0xf5, 0x50, 0xd7, 0xda, 0xba, 0xef,
+        0xe6, 0xcd, 0xb0, 0xa4, 0x24, 0x2e, 0x8f, 0x07, 0x00, 0x16, 0xc3,
+        0x86, 0xc5, 0x6e, 0xdb, 0x66, 0xf5, 0x79, 0x57, 0x2b, 0x0d, 0x16,
+        0x9f, 0x3e, 0x7d, 0x25, 0x35, 0x95, 0x4e, 0xa7, 0xe3, 0x35, 0x35,
+        0x35, 0x01, 0x40, 0xec, 0x28, 0x46, 0x32, 0x72, 0x3e, 0x7c, 0x70,
+        0xdd, 0xb3, 0x07, 0x31, 0xe5, 0x3c, 0x72, 0x64, 0xe6, 0xc1, 0x83,
+        0xd7, 0x02, 0x03, 0xff, 0x7b, 0x98, 0x02, 0x80, 0xa1, 0x9a, 0x9a,
+        0x67, 0x56, 0xac, 0x78, 0x7b, 0xfc, 0xb8, 0x9f, 0xbd, 0x3d, 0x00,
+        0x14, 0x55, 0x57, 0x4f, 0xdc, 0xb5, 0x2b, 0xe1, 0xd5, 0x2b, 0x59,
+        0xe5, 0xa0, 0x77, 0xa5, 0xa6, 0xa6, 0xa6, 0x80, 0x2c, 0xd1, 0x77,
+        0xa7, 0x34, 0xb8, 0xf8, 0xe4, 0xc9, 0xd4, 0x7d, 0xfb, 0x6a, 0x5b,
+        0x5b, 0x01, 0x60, 0xb3, 0xb7, 0xf7, 0xe3, 0x3d, 0x7b, 0xc6, 0x9b,
+        0x9b, 0xcb, 0x6a, 0xc4, 0xb7, 0x81, 0xc5, 0xb0, 0x61, 0x77, 0xb6,
+        0x6e, 0x3d, 0x12, 0x10, 0x80, 0xc7, 0xe1, 0x5a, 0xdb, 0xdb, 0xbd,
+        0x7f, 0xff, 0xfd, 0x68, 0x5c, 0x9c, 0x4c, 0x12, 0x7a, 0xc9, 0xd2,
+        0xd2, 0xd2, 0x02, 0x80, 0x26, 0x16, 0x4b, 0xca, 0x6f, 0xf2, 0xf8,
+        0xfc, 0xa0, 0xc8, 0xc8, 0x1f, 0xcf, 0x9e, 0xed, 0xea, 0xee, 0x56,
+        0x22, 0x12, 0xc3, 0xd7, 0xae, 0x3d, 0xb6, 0x64, 0x09, 0x41, 0xc6,
+        0x09, 0xc4, 0xb7, 0xc7, 0x96, 0x59, 0xb3, 0xe2, 0x76, 0xec, 0xd0,
+        0x50, 0x56, 0xe6, 0x63, 0xd8, 0xd6, 0x4b, 0x97, 0x96, 0x9e, 0x39,
+        0xd3, 0x67, 0x9c, 0x21, 0x01, 0x88, 0x1c, 0x2d, 0x2d, 0x2d, 0x3c,
+        0x9a, 0xa0, 0x7c, 0xa8, 0xad, 0x95, 0x3c, 0xee, 0x40, 0x68, 0x6d,
+        0x6f, 0xf7, 0x3a, 0x74, 0xe8, 0xf8, 0xdd, 0xbb, 0x00, 0x40, 0xd5,
+        0xd4, 0x7c, 0xbc, 0x67, 0xcf, 0x8f, 0x53, 0xa7, 0x0e, 0xe2, 0x16,
+        0xbe, 0x29, 0x3c, 0x6d, 0x6d, 0x5f, 0xfc, 0xf6, 0x1b, 0xea, 0x28,
+        0x22, 0x9f, 0x3e, 0x75, 0xdd, 0xbb, 0xb7, 0xa6, 0xa5, 0xe5, 0x8b,
+        0xdf, 0xc2, 0x30, 0xec, 0x43, 0x6d, 0x2d, 0x00, 0x18, 0x1b, 0x1b,
+        0xe3, 0xad, 0xac, 0xac, 0x00, 0xa0, 0xa3, 0xab, 0xab, 0xb2, 0xa9,
+        0x49, 0xf2, 0xd7, 0x4a, 0x6a, 0x6b, 0x1d, 0xfe, 0xf7, 0x7f, 0x13,
+        0xf3, 0xf2, 0x00, 0xc0, 0xc6, 0xc4, 0x24, 0xeb, 0xf7, 0xdf, 0x1d,
+        0xe9, 0xf4, 0xc1, 0xdf, 0xc3, 0xb7, 0xc4, 0x28, 0x43, 0xc3, 0xcc,
+        0x83, 0x07, 0x5d, 0x47, 0x8f, 0x06, 0x80, 0xf4, 0xa2, 0x22, 0xfb,
+        0x9d, 0x3b, 0x73, 0x4b, 0x4b, 0x25, 0x7f, 0xa5, 0xb2, 0xa9, 0xa9,
+        0xa3, 0xab, 0x0b, 0x00, 0xe8, 0x74, 0x3a, 0x9e, 0xde, 0x73, 0xc3,
+        0x45, 0x35, 0x35, 0x12, 0xbe, 0x83, 0xea, 0x14, 0x9a, 0x91, 0xfd,
+        0x30, 0x71, 0x62, 0xda, 0x81, 0x03, 0x46, 0x43, 0x86, 0x28, 0xe4,
+        0x06, 0xbe, 0x31, 0x86, 0xa8, 0xab, 0x3f, 0x08, 0x0e, 0xfe, 0x69,
+        0xfa, 0x74, 0x00, 0xa8, 0x68, 0x6c, 0xf4, 0x3c, 0x74, 0x48, 0x72,
+        0x2d, 0x11, 0xd2, 0xf2, 0x19, 0x59, 0x8c, 0xcf, 0xa7, 0xa6, 0xa2,
+        0xe0, 0xf1, 0xf9, 0xf3, 0x4f, 0x9c, 0x40, 0x4c, 0x6d, 0x99, 0x35,
+        0x2b, 0x6a, 0xd3, 0x26, 0x15, 0x32, 0x59, 0x61, 0xe6, 0x7f, 0x73,
+        0x90, 0x08, 0x84, 0xf3, 0xab, 0x56, 0x1d, 0x09, 0x08, 0x00, 0x80,
+        0xea, 0xe6, 0x66, 0xbf, 0x23, 0x47, 0x50, 0xdd, 0x11, 0x0b, 0x21,
+        0x2d, 0x74, 0x3a, 0x1d, 0x4f, 0xa5, 0x52, 0x51, 0x1f, 0x2f, 0xa1,
+        0x66, 0x6d, 0xbb, 0x7c, 0x19, 0xb5, 0xbe, 0x1f, 0x26, 0x4e, 0x3c,
+        0xbc, 0x78, 0xf1, 0x17, 0x3d, 0x04, 0xff, 0x08, 0x6c, 0x99, 0x35,
+        0x6b, 0x9d, 0x87, 0x07, 0x00, 0x64, 0x97, 0x94, 0xfc, 0x78, 0xf6,
+        0xec, 0x40, 0xc5, 0x10, 0x2d, 0x5a, 0x5a, 0x5a, 0x54, 0x2a, 0x15,
+        0x0f, 0x00, 0xa8, 0xdb, 0x7a, 0xc1, 0x60, 0x88, 0x2d, 0x7d, 0xf1,
+        0xc9, 0x13, 0xd4, 0xa3, 0xdb, 0x98, 0x98, 0x44, 0xac, 0x5b, 0xf7,
+        0x7f, 0x83, 0x29, 0x84, 0xd0, 0x65, 0xcb, 0xa6, 0x8d, 0x1d, 0x0b,
+        0x00, 0xd7, 0x9f, 0x3f, 0xff, 0xf5, 0xd6, 0x2d, 0xb1, 0x65, 0x10,
+        0x2d, 0x88, 0x22, 0x3c, 0x00, 0xb8, 0xb8, 0xb8, 0x00, 0x40, 0x66,
+        0x71, 0x31, 0xb3, 0xdf, 0xd0, 0xf4, 0x79, 0x61, 0xe1, 0x4f, 0x7f,
+        0xfe, 0x09, 0x00, 0x54, 0x4d, 0xcd, 0xd8, 0xed, 0xdb, 0xff, 0xd1,
+        0xad, 0xaf, 0x3f, 0x88, 0x04, 0xc2, 0x8d, 0xcd, 0x9b, 0x47, 0xe8,
+        0xeb, 0x03, 0xc0, 0xee, 0xa8, 0xa8, 0x3b, 0x99, 0x99, 0x7d, 0x0a,
+        0x30, 0x3b, 0x3a, 0x32, 0x8b, 0x8b, 0xa1, 0x87, 0x22, 0x3c, 0x00,
+        0x4c, 0x9b, 0x36, 0x0d, 0x00, 0xba, 0x79, 0xbc, 0xa7, 0xef, 0xde,
+        0x89, 0x16, 0x2d, 0x6f, 0x6c, 0x9c, 0x7d, 0xf4, 0x28, 0x1a, 0x4f,
+        0xdd, 0xde, 0xb2, 0xe5, 0x1f, 0xda, 0xa3, 0x4b, 0x86, 0xb6, 0xaa,
+        0x6a, 0xdc, 0xf6, 0xed, 0x9a, 0x2a, 0x2a, 0x18, 0x86, 0x05, 0x9c,
+        0x3e, 0x9d, 0xf7, 0xe9, 0x93, 0xe8, 0xd5, 0xa7, 0xef, 0xde, 0x21,
+        0x1f, 0x0c, 0xa2, 0x08, 0x0f, 0x00, 0x4e, 0x4e, 0x4e, 0x64, 0x32,
+        0x19, 0x00, 0x92, 0xde, 0xbc, 0x11, 0x96, 0x6b, 0xef, 0xec, 0xf4,
+        0x3b, 0x7c, 0x18, 0x8d, 0xd1, 0xcf, 0xaf, 0x5a, 0xf5, 0x8f, 0x1b,
+        0x25, 0x48, 0x0f, 0xab, 0xe1, 0xc3, 0xff, 0xde, 0xb8, 0x91, 0x80,
+        0xc7, 0xb3, 0x3b, 0x3b, 0x7d, 0x42, 0x42, 0xea, 0x5a, 0x5b, 0x85,
+        0x97, 0x10, 0x21, 0x64, 0x32, 0xd9, 0xc9, 0xc9, 0x09, 0x10, 0x59,
+        0xca, 0xca, 0xca, 0x8e, 0x8e, 0x8e, 0x00, 0xf0, 0x48, 0x84, 0xac,
+        0xad, 0x97, 0x2f, 0xa3, 0x79, 0xdf, 0x66, 0x6f, 0xef, 0x7f, 0xd0,
+        0xc8, 0x53, 0x3e, 0xcc, 0xb0, 0xb1, 0x39, 0xbc, 0x78, 0x31, 0x00,
+        0x94, 0x35, 0x34, 0xac, 0x09, 0x0b, 0x13, 0x9e, 0x47, 0x84, 0x38,
+        0x3a, 0x3a, 0xa2, 0xe5, 0x15, 0xc1, 0x34, 0x05, 0x55, 0xb3, 0xfc,
+        0xf2, 0x72, 0x34, 0x5a, 0x2d, 0xaa, 0xae, 0xfe, 0x33, 0x29, 0x09,
+        0x00, 0x9c, 0x47, 0x8e, 0x44, 0x52, 0xfe, 0xcf, 0x63, 0xb3, 0xb7,
+        0xb7, 0xbf, 0x93, 0x13, 0x00, 0xdc, 0xc9, 0xcc, 0x7c, 0x5e, 0x58,
+        0x08, 0x00, 0x1f, 0x6a, 0x6b, 0xf3, 0xcb, 0xcb, 0xa1, 0x87, 0x1c,
+        0x10, 0x92, 0x35, 0x77, 0xee, 0x5c, 0x74, 0x70, 0xf1, 0xc9, 0x13,
+        0x00, 0xd8, 0x71, 0xf5, 0x6a, 0x37, 0x8f, 0x87, 0xc3, 0xe1, 0x8e,
+        0xff, 0x13, 0xe6, 0x7d, 0x8a, 0xc2, 0xd1, 0x80, 0x00, 0xf4, 0x06,
+        0xdb, 0x7a, 0xf9, 0x32, 0xf4, 0x50, 0x01, 0x22, 0xe4, 0x08, 0x88,
+        0xb0, 0xb4, 0xb4, 0x44, 0xcd, 0x32, 0xe2, 0xe9, 0xd3, 0x67, 0x05,
+        0x05, 0xb7, 0x33, 0x32, 0x00, 0x60, 0xbe, 0xa3, 0xe3, 0x7f, 0xad,
+        0x2f, 0xe1, 0x6b, 0x60, 0x98, 0xb6, 0xf6, 0x46, 0x4f, 0x4f, 0x00,
+        0x78, 0x5e, 0x58, 0x78, 0xe3, 0xc5, 0x8b, 0x88, 0xa7, 0x4f, 0x01,
+        0xc0, 0xc9, 0xc9, 0xc9, 0xd2, 0xd2, 0x12, 0x15, 0xc0, 0x09, 0xe7,
+        0xcf, 0xe1, 0xe1, 0xe1, 0x2b, 0x56, 0xac, 0x00, 0x00, 0x35, 0x0a,
+        0x85, 0xc5, 0xe1, 0x28, 0x11, 0x89, 0xef, 0x4f, 0x9c, 0xf8, 0xaf,
+        0xf2, 0x4f, 0x7d, 0x03, 0xb4, 0x75, 0x74, 0x98, 0xad, 0x5f, 0xdf,
+        0xc8, 0x64, 0x52, 0x48, 0x24, 0x0e, 0x97, 0x0b, 0x00, 0x17, 0x2e,
+        0x5c, 0x58, 0xbe, 0x7c, 0x39, 0xba, 0xda, 0x4b, 0x16, 0x8b, 0xc5,
+        0x1a, 0x36, 0x6c, 0x18, 0xab, 0xc7, 0x57, 0xb3, 0xd1, 0xcb, 0xeb,
+        0xc4, 0xd2, 0xa5, 0x83, 0x57, 0xcf, 0xe3, 0xf3, 0xdf, 0x55, 0x54,
+        0xa0, 0x85, 0x32, 0x7b, 0x73, 0xf3, 0x51, 0x86, 0x86, 0x0a, 0x6c,
+        0xd7, 0xf5, 0x6d, 0x6d, 0x42, 0xc9, 0x7a, 0x3d, 0x2e, 0xf3, 0x41,
+        0x22, 0xf4, 0xde, 0xbd, 0x4d, 0x11, 0x11, 0xe8, 0x58, 0x4d, 0x4d,
+        0xad, 0xba, 0xba, 0x5a, 0xad, 0x67, 0x6d, 0x11, 0x27, 0xea, 0x99,
+        0xf9, 0xf1, 0xc7, 0x1f, 0x2f, 0x5e, 0xbc, 0x08, 0x00, 0x9a, 0x2a,
+        0x2a, 0x25, 0xa7, 0x4f, 0x0f, 0xd2, 0x8f, 0xce, 0xe5, 0xf1, 0x7e,
+        0xbd, 0x7d, 0xfb, 0x44, 0x7c, 0xbc, 0x81, 0xbe, 0xbe, 0x8d, 0x8d,
+        0x0d, 0x00, 0xe4, 0xe6, 0xe6, 0x56, 0xd5, 0xd4, 0x6c, 0xf2, 0xf4,
+        0x0c, 0x9e, 0x3d, 0x9b, 0x34, 0x88, 0x78, 0x05, 0x0c, 0xc3, 0xce,
+        0x27, 0x25, 0x85, 0xc4, 0xc5, 0xb1, 0x38, 0x9c, 0xef, 0x6c, 0x6d,
+        0x01, 0xe0, 0xe5, 0xab, 0x57, 0x6a, 0x14, 0xca, 0xf6, 0x59, 0xb3,
+        0xd6, 0xb8, 0xb9, 0x0d, 0x72, 0x8e, 0xd1, 0xd5, 0xdd, 0x4d, 0x0f,
+        0x0c, 0x2c, 0xad, 0xaf, 0x07, 0x80, 0x80, 0x80, 0x80, 0xc8, 0xc8,
+        0x48, 0xe1, 0x25, 0xa2, 0x68, 0x39, 0x43, 0x43, 0x43, 0x74, 0xb0,
+        0xc3, 0xcf, 0x6f, 0x90, 0x4c, 0x15, 0x55, 0x57, 0xcf, 0x3b, 0x75,
+        0xca, 0xd0, 0xc2, 0xa2, 0x80, 0xc1, 0x30, 0x30, 0x30, 0x10, 0x9e,
+        0xaf, 0xaa, 0xaa, 0xfa, 0x69, 0xc5, 0x8a, 0x09, 0xc1, 0xc1, 0x51,
+        0x1b, 0x36, 0x58, 0x0c, 0x1b, 0x26, 0x87, 0xe4, 0xaa, 0xe6, 0xe6,
+        0xa5, 0xe7, 0xcf, 0xb7, 0xe1, 0x70, 0x31, 0xf7, 0xef, 0x5b, 0xf7,
+        0x2c, 0xc4, 0x01, 0x40, 0x5e, 0x5e, 0xde, 0xea, 0xe5, 0xcb, 0x6f,
+        0x67, 0x67, 0x47, 0xac, 0x59, 0x63, 0xa0, 0xad, 0x2d, 0xb7, 0xe5,
+        0x4a, 0x44, 0xe2, 0x81, 0x05, 0x0b, 0x02, 0x4e, 0x9f, 0x06, 0x00,
+        0xf2, 0xe7, 0x33, 0x96, 0xde, 0x16, 0xc1, 0xe3, 0xf1, 0x2e, 0x5d,
+        0xba, 0x04, 0x00, 0x86, 0x43, 0x86, 0x04, 0x7a, 0x7a, 0xca, 0xad,
+        0x0c, 0x00, 0xb8, 0x3c, 0xde, 0xdc, 0x53, 0xa7, 0x96, 0xae, 0x5b,
+        0x17, 0x97, 0x90, 0x50, 0x55, 0x55, 0xb5, 0x70, 0xe1, 0x42, 0x73,
+        0x73, 0x73, 0x73, 0x73, 0xf3, 0x85, 0x0b, 0x17, 0x56, 0x55, 0x55,
+        0xc5, 0x25, 0x24, 0x2c, 0x5d, 0xb7, 0x6e, 0xee, 0xa9, 0x53, 0xdc,
+        0x01, 0x96, 0x72, 0x25, 0x80, 0x8f, 0x61, 0xf3, 0x4e, 0x9d, 0xb2,
+        0xf7, 0xf0, 0x78, 0x9e, 0x99, 0xc9, 0xe5, 0x72, 0x45, 0x25, 0x73,
+        0xb9, 0xdc, 0xe7, 0x99, 0x99, 0xf6, 0x1e, 0x1e, 0xf3, 0x4e, 0x9d,
+        0xe2, 0x4b, 0xe1, 0xc8, 0x94, 0x00, 0x7f, 0x27, 0x27, 0x6b, 0x1a,
+        0x0d, 0x00, 0xae, 0x5f, 0xbf, 0xde, 0x22, 0xe2, 0x20, 0xec, 0x6d,
+        0x86, 0x29, 0x29, 0x29, 0x68, 0x06, 0xf4, 0xef, 0xd5, 0xab, 0x57,
+        0xbb, 0xb9, 0x0d, 0x46, 0x59, 0xf0, 0xf5, 0xeb, 0x6f, 0x3a, 0x3a,
+        0x62, 0xee, 0xdd, 0x3b, 0x71, 0xe2, 0xc4, 0xb6, 0x6d, 0xdb, 0xd0,
+        0xd2, 0x24, 0x02, 0x91, 0x48, 0x3c, 0x7c, 0xf8, 0xf0, 0xa6, 0x4d,
+        0x9b, 0x7c, 0xbd, 0xbc, 0xc6, 0x2a, 0x2b, 0xff, 0x3a, 0x7f, 0xbe,
+        0x4c, 0x92, 0x8f, 0xdd, 0xbd, 0x1b, 0x5f, 0x5a, 0x9a, 0xf4, 0xe4,
+        0x49, 0x68, 0x68, 0xa8, 0x58, 0xc9, 0x1b, 0x37, 0x6e, 0x74, 0x73,
+        0x75, 0xf5, 0x34, 0x31, 0x09, 0xf2, 0xf6, 0x1e, 0xcc, 0x2d, 0xc4,
+        0x66, 0x67, 0xfb, 0x1e, 0x3e, 0x0c, 0x00, 0x11, 0x11, 0x11, 0x4b,
+        0x96, 0x2c, 0x41, 0x27, 0x7b, 0xc9, 0x0a, 0x0a, 0x0a, 0x3a, 0x7e,
+        0xfc, 0x38, 0x91, 0x40, 0xa8, 0xfb, 0xeb, 0xaf, 0xc1, 0xac, 0x21,
+        0x77, 0x75, 0x77, 0xeb, 0xae, 0x5a, 0xc5, 0x28, 0x2e, 0x2e, 0x2b,
+        0x2b, 0x73, 0x74, 0x74, 0xec, 0x1f, 0xbb, 0x42, 0x20, 0x10, 0x9e,
+        0x3f, 0x7f, 0x6e, 0x6c, 0x6c, 0x6c, 0x39, 0x62, 0x44, 0x43, 0x58,
+        0x98, 0x12, 0x91, 0x28, 0x56, 0x4e, 0x7f, 0xf0, 0xf8, 0xfc, 0x21,
+        0x2b, 0x57, 0xbe, 0x7a, 0xfd, 0xba, 0xbe, 0xbe, 0x5e, 0x82, 0x64,
+        0x3d, 0x3d, 0x3d, 0xdb, 0x71, 0xe3, 0x1a, 0xff, 0xfa, 0x6b, 0x30,
+        0x6f, 0x12, 0x2e, 0x8f, 0x37, 0x74, 0xe5, 0xca, 0x16, 0x36, 0x7b,
+        0xf6, 0xec, 0xd9, 0xb7, 0x7a, 0x1c, 0x12, 0xbd, 0xe2, 0x62, 0x62,
+        0x62, 0x00, 0xc0, 0xd9, 0xca, 0x6a, 0x90, 0xab, 0xed, 0x6f, 0xca,
+        0xca, 0x4c, 0x8d, 0x8d, 0xf5, 0xf5, 0xf5, 0x43, 0x42, 0x42, 0xc4,
+        0x46, 0xf9, 0xf0, 0x78, 0xbc, 0x90, 0x90, 0x10, 0x7d, 0x7d, 0x7d,
+        0x53, 0x63, 0xe3, 0x37, 0x65, 0x65, 0xd2, 0x4b, 0x7e, 0x5b, 0x5e,
+        0x6e, 0xa0, 0xaf, 0x6f, 0x6a, 0x6a, 0x2a, 0x59, 0xb2, 0xa9, 0xa9,
+        0xa9, 0x81, 0xbe, 0xfe, 0xdb, 0xf2, 0x72, 0xf9, 0xef, 0x01, 0x80,
+        0x44, 0x20, 0x78, 0xda, 0xda, 0x02, 0x40, 0x62, 0x62, 0x22, 0x87,
+        0xc3, 0x41, 0x27, 0x05, 0x64, 0xe5, 0xe7, 0xe7, 0xa3, 0xa8, 0x20,
+        0xbf, 0x09, 0x13, 0x06, 0xa3, 0x03, 0x00, 0xb2, 0x4a, 0x4a, 0x6c,
+        0xec, 0xec, 0x00, 0x20, 0xb3, 0x9f, 0xc7, 0x43, 0x08, 0x74, 0xc9,
+        0xc6, 0xce, 0x2e, 0xeb, 0xf3, 0x50, 0xa4, 0x2f, 0x4b, 0xb6, 0xb5,
+        0x95, 0x4a, 0xb2, 0xad, 0xad, 0x4c, 0x92, 0xc5, 0x02, 0xad, 0x36,
+        0xb2, 0xd9, 0xec, 0xa4, 0xa4, 0x24, 0x74, 0x46, 0x40, 0x56, 0x74,
+        0x74, 0x34, 0x3a, 0xf0, 0x19, 0x20, 0x2a, 0x4c, 0x7a, 0xf0, 0xf8,
+        0x7c, 0x14, 0xc6, 0x28, 0xf6, 0xe1, 0x0b, 0xca, 0xf0, 0x78, 0x00,
+        0x40, 0x20, 0x10, 0x78, 0x22, 0xc1, 0x53, 0x5f, 0x04, 0x8b, 0xc3,
+        0x51, 0x53, 0x57, 0x97, 0x46, 0xb2, 0x9a, 0xba, 0x3a, 0xab, 0xa7,
+        0x3a, 0xc8, 0x8d, 0x19, 0x36, 0x36, 0x64, 0x12, 0x09, 0x44, 0xc8,
+        0x11, 0x90, 0x85, 0xda, 0xa0, 0x35, 0x8d, 0x36, 0xf8, 0xa8, 0xa0,
+        0xf1, 0x66, 0x66, 0xb9, 0x39, 0x39, 0x00, 0x60, 0x6f, 0x6f, 0x3f,
+        0x50, 0x19, 0x74, 0x29, 0x37, 0x27, 0xe7, 0x3b, 0x33, 0x33, 0xe9,
+        0x25, 0x7f, 0xf7, 0xd5, 0x24, 0x8b, 0x85, 0xba, 0xb2, 0xf2, 0xf7,
+        0x63, 0xc6, 0x00, 0x40, 0x5c, 0x5c, 0x1c, 0x8a, 0x88, 0xc3, 0x03,
+        0x40, 0x45, 0x45, 0x05, 0x8a, 0x5e, 0xf4, 0x1d, 0xd8, 0x08, 0xe9,
+        0x61, 0x6d, 0x62, 0xc2, 0x28, 0x29, 0x69, 0x6a, 0x6a, 0xda, 0xbc,
+        0x79, 0xb3, 0xd8, 0xf1, 0x21, 0x0e, 0x87, 0xdb, 0xbc, 0x79, 0x73,
+        0x53, 0x53, 0x13, 0xa3, 0xa4, 0xc4, 0x46, 0x96, 0x58, 0x56, 0x3b,
+        0x53, 0xd3, 0xf7, 0x0c, 0x06, 0x9b, 0xcd, 0x96, 0x2c, 0x99, 0xcd,
+        0x66, 0xbf, 0x67, 0x30, 0xec, 0x06, 0x1d, 0x2f, 0x07, 0x3d, 0x2d,
+        0xb1, 0xae, 0xae, 0xee, 0xc5, 0x8b, 0x17, 0x80, 0xc8, 0x8a, 0x8d,
+        0x8d, 0x15, 0xbd, 0x36, 0x48, 0x50, 0x48, 0xa4, 0x55, 0x6e, 0x6e,
+        0x1b, 0x7e, 0xfe, 0xd9, 0xc5, 0xc5, 0x65, 0xf7, 0xee, 0xdd, 0xfd,
+        0x0b, 0xec, 0xde, 0xbd, 0xdb, 0xc5, 0xc5, 0x65, 0xc3, 0xcf, 0x3f,
+        0xaf, 0x72, 0x73, 0x43, 0x71, 0x78, 0x52, 0x42, 0x85, 0x4c, 0x9e,
+        0x3b, 0x69, 0xd2, 0xf6, 0x2d, 0x5b, 0x24, 0x4b, 0xde, 0xbe, 0x65,
+        0xcb, 0xdc, 0x49, 0x93, 0x14, 0xe2, 0x01, 0xf7, 0x19, 0x3f, 0x1e,
+        0x3d, 0x15, 0xd4, 0xf2, 0xf0, 0xd0, 0xd3, 0x26, 0x8d, 0x75, 0x75,
+        0x07, 0x1f, 0xbd, 0x88, 0xf0, 0xdb, 0xbc, 0x79, 0x19, 0xcf, 0x9e,
+        0x45, 0x44, 0x44, 0xec, 0xdd, 0xbb, 0x37, 0x31, 0x31, 0xf1, 0xfb,
+        0xef, 0xbf, 0xd7, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0xfe, 0xfb,
+        0xef, 0x13, 0x13, 0x13, 0xf7, 0xee, 0xdd, 0x1b, 0x11, 0x11, 0x91,
+        0xf1, 0xec, 0xd9, 0x6f, 0xf3, 0xe6, 0xc9, 0x2a, 0xf9, 0x44, 0x40,
+        0x40, 0xdc, 0x9d, 0x3b, 0xf1, 0xf1, 0xf1, 0x03, 0x49, 0x8e, 0x8f,
+        0x8f, 0x8f, 0xbb, 0x73, 0xe7, 0x44, 0x40, 0x80, 0x42, 0x6e, 0x44,
+        0x5f, 0x4b, 0xcb, 0x61, 0xc4, 0x08, 0xe8, 0x21, 0x0b, 0xc7, 0xe7,
+        0xf3, 0x55, 0x55, 0x55, 0x3b, 0x3a, 0x3a, 0x56, 0xbb, 0xb9, 0xfd,
+        0x7b, 0xf5, 0x6a, 0x85, 0xe8, 0x00, 0x80, 0xbc, 0x4f, 0x9f, 0xe6,
+        0x9e, 0x3c, 0x69, 0x3f, 0x79, 0xf2, 0x1f, 0xe7, 0xce, 0x69, 0x8b,
+        0x4c, 0x3e, 0x9a, 0x9b, 0x9b, 0xd7, 0xaf, 0x5d, 0x9b, 0x95, 0x96,
+        0x76, 0x23, 0x30, 0x10, 0x8d, 0x92, 0x65, 0x45, 0x5a, 0x61, 0xe1,
+        0xdc, 0x93, 0x27, 0x17, 0x2e, 0x5e, 0xfc, 0xdb, 0xa1, 0x43, 0x14,
+        0x91, 0x30, 0x2b, 0x0e, 0x87, 0xb3, 0x6b, 0xe7, 0xce, 0x6b, 0x97,
+        0x2f, 0xdf, 0x08, 0x0c, 0x9c, 0xac, 0x38, 0x27, 0xf8, 0x6f, 0xb7,
+        0x6f, 0x07, 0xff, 0xfd, 0x37, 0x00, 0x34, 0x35, 0x35, 0x11, 0xcb,
+        0xcb, 0xcb, 0x3b, 0x3a, 0x3a, 0x00, 0x60, 0xcc, 0x00, 0x51, 0xd9,
+        0x7d, 0xd1, 0xdd, 0x0d, 0x2d, 0x2d, 0xc0, 0x62, 0x01, 0x87, 0x03,
+        0x3c, 0x1e, 0x10, 0x08, 0x40, 0xa1, 0x80, 0x9a, 0x1a, 0x68, 0x6b,
+        0x83, 0xc8, 0xdc, 0xd8, 0x9a, 0x46, 0xcb, 0x3d, 0x74, 0x68, 0xe7,
+        0xf5, 0xeb, 0x34, 0x23, 0xa3, 0x71, 0xa3, 0x47, 0x7f, 0x37, 0x61,
+        0x02, 0x00, 0xbc, 0xcc, 0xcc, 0x7c, 0xfd, 0xf6, 0xed, 0x8f, 0x53,
+        0xa7, 0xe6, 0x1e, 0x3a, 0x24, 0x77, 0x33, 0x99, 0x4c, 0xa7, 0xbf,
+        0x09, 0x09, 0xf9, 0xf9, 0xe2, 0x45, 0x33, 0x1a, 0xcd, 0x71, 0xe2,
+        0xc4, 0xef, 0x1c, 0x1c, 0x00, 0xe0, 0x65, 0x46, 0xc6, 0xf3, 0xf4,
+        0x74, 0x67, 0x3a, 0xfd, 0x4d, 0x48, 0x88, 0x98, 0x59, 0xad, 0x74,
+        0x36, 0x8b, 0x85, 0x30, 0xca, 0xb2, 0xa0, 0xa0, 0x00, 0xf7, 0xe0,
+        0xc1, 0x03, 0x77, 0x77, 0x77, 0x00, 0x40, 0x01, 0x8f, 0x5f, 0xb0,
+        0xb4, 0xa6, 0x06, 0x1a, 0x1b, 0x01, 0xbd, 0xef, 0x31, 0x0c, 0x30,
+        0x0c, 0x70, 0x38, 0x40, 0x7d, 0x2d, 0x1e, 0x0f, 0xba, 0xba, 0xd0,
+        0xcf, 0xff, 0xc5, 0xee, 0xec, 0xcc, 0xf9, 0xf0, 0x41, 0xe8, 0x48,
+        0xb1, 0x33, 0x33, 0x53, 0x55, 0xd0, 0x7a, 0x5a, 0x69, 0x7d, 0x7d,
+        0x56, 0x71, 0x71, 0xd6, 0xc7, 0x8f, 0x00, 0x60, 0x6f, 0x6a, 0x6a,
+        0x3f, 0x62, 0x84, 0xf8, 0x57, 0xb9, 0xec, 0x36, 0x8b, 0xa2, 0xa0,
+        0xb2, 0x72, 0xe4, 0xa6, 0x4d, 0x00, 0x10, 0x1e, 0x1e, 0x4e, 0x64,
+        0xf4, 0xac, 0xad, 0x7e, 0x21, 0x24, 0x8e, 0xc7, 0x83, 0xb2, 0x32,
+        0x60, 0xb3, 0x81, 0xcf, 0x07, 0x3e, 0x1f, 0x78, 0x3c, 0x81, 0x56,
+        0xf4, 0x9f, 0x40, 0x00, 0x0c, 0x83, 0xfa, 0x7a, 0x68, 0x6f, 0x07,
+        0x1a, 0x0d, 0x44, 0xe6, 0x19, 0xaa, 0x64, 0xb2, 0xf3, 0xc8, 0x91,
+        0xce, 0x23, 0x47, 0xca, 0x44, 0x84, 0x34, 0x30, 0xd1, 0xd3, 0x33,
+        0xd1, 0xd3, 0x9b, 0x3b, 0x69, 0x92, 0xc2, 0x6d, 0x16, 0x85, 0x19,
+        0x95, 0x4a, 0xc0, 0xe3, 0x79, 0x7c, 0x7e, 0x41, 0x41, 0x01, 0xb1,
+        0xb0, 0xb0, 0x10, 0xdd, 0x92, 0xa1, 0x8e, 0x8e, 0x24, 0xd3, 0x90,
+        0xd6, 0xee, 0xee, 0x5e, 0xad, 0x7c, 0xbe, 0x40, 0x2b, 0x1e, 0x0f,
+        0x7c, 0x3e, 0x10, 0x08, 0x80, 0xc7, 0x03, 0x9b, 0x0d, 0xe5, 0xe5,
+        0x20, 0x63, 0x67, 0xd4, 0xd6, 0xd1, 0xf1, 0x82, 0xc1, 0x28, 0xa9,
+        0xa9, 0xa9, 0x6f, 0x6b, 0x6b, 0x60, 0x32, 0x1b, 0x98, 0x4c, 0x00,
+        0xd0, 0x55, 0x57, 0xd7, 0x55, 0x57, 0xd7, 0xd3, 0xd0, 0x30, 0xd7,
+        0xd7, 0x9f, 0x64, 0x69, 0xa9, 0x21, 0x47, 0xfa, 0x8a, 0x22, 0x6c,
+        0x56, 0x22, 0x12, 0x4d, 0xf4, 0xf4, 0x4a, 0x6a, 0x6b, 0x0b, 0x0b,
+        0x0b, 0x89, 0x28, 0xae, 0x9f, 0xa6, 0xa7, 0x27, 0xc9, 0x67, 0x56,
+        0x53, 0x23, 0xd0, 0xda, 0xdd, 0x0d, 0x3c, 0x9e, 0x40, 0x37, 0x80,
+        0x40, 0x31, 0x00, 0x10, 0x08, 0x02, 0xdd, 0x00, 0xc0, 0x64, 0x42,
+        0x63, 0x23, 0x7c, 0x69, 0x45, 0x16, 0xc3, 0xb0, 0xe4, 0xfc, 0xfc,
+        0x5b, 0x19, 0x19, 0x69, 0x85, 0x85, 0xf9, 0x65, 0x65, 0x92, 0x9d,
+        0x2a, 0x78, 0x1c, 0x6e, 0x8c, 0xb1, 0xf1, 0x64, 0x3a, 0x7d, 0x8e,
+        0x83, 0xc3, 0xf7, 0x63, 0xc6, 0x48, 0xe5, 0xde, 0x53, 0x9c, 0xcd,
+        0x34, 0x3d, 0xbd, 0x92, 0xda, 0xda, 0xba, 0xba, 0x3a, 0x22, 0x93,
+        0xc9, 0x04, 0x00, 0x49, 0xcf, 0x8d, 0xcb, 0x85, 0xa6, 0x26, 0x41,
+        0x4d, 0x46, 0x2a, 0x85, 0xba, 0x51, 0x95, 0x46, 0xf5, 0x99, 0x40,
+        0x00, 0x1c, 0x4e, 0x50, 0xa6, 0xb6, 0x16, 0x74, 0x74, 0x60, 0x80,
+        0x5b, 0xaa, 0x6f, 0x6b, 0xfb, 0xcf, 0xe3, 0xc7, 0x61, 0x8f, 0x1e,
+        0x15, 0xf7, 0x0b, 0x45, 0xc1, 0xe3, 0xf1, 0xda, 0x1a, 0x1a, 0xba,
+        0xda, 0xda, 0x00, 0xd0, 0xd0, 0xdc, 0xdc, 0xdc, 0xd6, 0x86, 0x86,
+        0xce, 0x7c, 0x0c, 0x7b, 0xfd, 0xe9, 0xd3, 0xeb, 0x4f, 0x9f, 0xce,
+        0x3d, 0x78, 0x30, 0x42, 0x5f, 0x7f, 0xd5, 0xb4, 0x69, 0x3f, 0x4e,
+        0x9d, 0x2a, 0xc9, 0x8f, 0xac, 0x50, 0x9b, 0x11, 0x39, 0x4c, 0x26,
+        0xb3, 0x87, 0x2c, 0x09, 0xf9, 0x70, 0x2d, 0x2d, 0x02, 0x65, 0x3c,
+        0x9e, 0xe0, 0x29, 0x09, 0x75, 0xf3, 0xf9, 0x80, 0xc7, 0x0b, 0xb4,
+        0x22, 0xa0, 0xbe, 0x13, 0x87, 0x83, 0x8e, 0x0e, 0xe8, 0x27, 0x93,
+        0xc7, 0xe7, 0x9f, 0x4e, 0x48, 0xd8, 0x1d, 0x15, 0x25, 0x0c, 0xaa,
+        0x50, 0xa1, 0x50, 0x1c, 0x6d, 0x6d, 0x27, 0xdb, 0xda, 0x3a, 0xda,
+        0xda, 0xda, 0x58, 0x59, 0xe9, 0x6a, 0x69, 0x89, 0xa6, 0x6c, 0xf1,
+        0xf9, 0xfc, 0x86, 0x96, 0x96, 0xdc, 0x82, 0x82, 0xe7, 0xaf, 0x5e,
+        0xa5, 0xbd, 0x7a, 0xf5, 0xfc, 0xd5, 0xab, 0x76, 0x0e, 0xa7, 0xb8,
+        0xa6, 0x66, 0xfb, 0x95, 0x2b, 0xbf, 0xde, 0xbe, 0xbd, 0x7f, 0xde,
+        0xbc, 0x5f, 0x66, 0xce, 0x14, 0xef, 0x87, 0x51, 0x9c, 0xcd, 0x42,
+        0x72, 0x58, 0x2c, 0x16, 0x11, 0xad, 0x50, 0xa8, 0x4b, 0x88, 0x0b,
+        0x67, 0x32, 0x05, 0xad, 0x5d, 0xf4, 0x41, 0x71, 0xb9, 0xbd, 0x8a,
+        0x91, 0xb9, 0x48, 0x1f, 0x3a, 0x89, 0x61, 0xd0, 0xd6, 0xd6, 0x47,
+        0x71, 0x76, 0x49, 0xc9, 0xaa, 0x7f, 0xff, 0x5b, 0x18, 0x69, 0x37,
+        0x7a, 0xc4, 0x88, 0x35, 0xf3, 0xe7, 0x2f, 0xf1, 0xf1, 0xd1, 0x18,
+        0x38, 0xd5, 0x08, 0x8f, 0xc7, 0x0f, 0xd5, 0xd1, 0x71, 0x77, 0x74,
+        0x74, 0x77, 0x74, 0x04, 0x80, 0x36, 0x16, 0x2b, 0x32, 0x36, 0xf6,
+        0xfc, 0xf5, 0xeb, 0x6f, 0x8b, 0x8b, 0x99, 0x1d, 0x1d, 0x9b, 0x22,
+        0x22, 0x22, 0x9e, 0x3e, 0x0d, 0xfb, 0xe9, 0x27, 0x31, 0xeb, 0x75,
+        0x0a, 0xb2, 0x19, 0x01, 0x91, 0xc3, 0x64, 0x32, 0xf1, 0x5f, 0xae,
+        0x59, 0x9d, 0x9d, 0x00, 0x3d, 0x2f, 0x5d, 0x80, 0xcf, 0x9e, 0x98,
+        0xb0, 0x47, 0x40, 0x7f, 0xa2, 0xc5, 0x98, 0x4c, 0x51, 0x19, 0xb7,
+        0x33, 0x32, 0x9c, 0x77, 0xef, 0x46, 0x4c, 0x59, 0xd0, 0x68, 0xf1,
+        0xe7, 0xcf, 0xe7, 0xc7, 0xc4, 0xac, 0xf7, 0xf7, 0x97, 0xc0, 0x54,
+        0x7f, 0x68, 0xa8, 0xa9, 0xad, 0xf7, 0xf7, 0xcf, 0x8f, 0x89, 0x89,
+        0x3f, 0x7f, 0xde, 0x82, 0x46, 0x03, 0x80, 0xdc, 0xd2, 0x52, 0xe7,
+        0xdd, 0xbb, 0xd1, 0x2a, 0xa7, 0xc2, 0x6d, 0xee, 0xd5, 0xab, 0xa2,
+        0x22, 0x20, 0x0b, 0x75, 0x0a, 0x92, 0x3a, 0x4c, 0xc4, 0xba, 0xf0,
+        0x18, 0x01, 0x3d, 0x37, 0xf4, 0xa2, 0x11, 0x7b, 0x55, 0xa4, 0xc3,
+        0x3e, 0x9b, 0x98, 0x38, 0xf7, 0xf8, 0x71, 0x0e, 0x97, 0x4b, 0x22,
+        0x12, 0x0f, 0xfc, 0xf2, 0xcb, 0x9b, 0xe8, 0xe8, 0x99, 0xce, 0xce,
+        0x5f, 0xe6, 0x66, 0x60, 0xcc, 0x74, 0x76, 0x7e, 0x13, 0x1d, 0x7d,
+        0xe0, 0x97, 0x5f, 0x48, 0x44, 0x22, 0x87, 0xcb, 0x9d, 0x7b, 0xfc,
+        0xf8, 0xd9, 0xc4, 0x44, 0xc5, 0xda, 0x2c, 0x0a, 0x9c, 0xa0, 0x20,
+        0x1f, 0xaf, 0xae, 0xae, 0x0e, 0x00, 0xcc, 0x2f, 0x7a, 0x7f, 0x50,
+        0xbf, 0x28, 0xec, 0x20, 0x50, 0x05, 0x46, 0x1d, 0xa4, 0xb0, 0x53,
+        0x44, 0x7d, 0x01, 0xfa, 0xd8, 0xd3, 0xae, 0x2f, 0xa7, 0xa6, 0xae,
+        0xbb, 0x70, 0x81, 0x8f, 0x61, 0xea, 0xaa, 0xaa, 0xf7, 0xce, 0x9d,
+        0x0b, 0x5e, 0xb3, 0x86, 0xac, 0x88, 0x84, 0x1e, 0xb2, 0x92, 0x52,
+        0xf0, 0x9a, 0x35, 0xf7, 0xce, 0x9d, 0x53, 0x57, 0x55, 0xe5, 0x63,
+        0xd8, 0xba, 0x0b, 0x17, 0x2e, 0xa7, 0xa6, 0x2a, 0xca, 0xe6, 0x3e,
+        0x40, 0xe4, 0xa8, 0xab, 0xab, 0x0b, 0xc8, 0x6a, 0x93, 0x90, 0x34,
+        0x40, 0x26, 0x0b, 0xa4, 0xe3, 0xf1, 0x82, 0xff, 0x78, 0x3c, 0x10,
+        0x89, 0x40, 0x22, 0x81, 0x92, 0x12, 0x90, 0x48, 0x40, 0x24, 0x0a,
+        0x4e, 0x0a, 0xcb, 0xe0, 0x70, 0xa0, 0xa6, 0x06, 0x00, 0x45, 0xd5,
+        0xd5, 0x6b, 0xc3, 0xc2, 0x00, 0x60, 0x88, 0x96, 0x56, 0x4a, 0x64,
+        0xe4, 0x74, 0x47, 0x47, 0xf9, 0xe9, 0x11, 0x87, 0xe9, 0x8e, 0x8e,
+        0x29, 0x91, 0x91, 0x43, 0xb4, 0xb4, 0x00, 0x60, 0x6d, 0x58, 0x58,
+        0x91, 0x30, 0xc7, 0x70, 0x10, 0x36, 0xf7, 0x07, 0x22, 0xa7, 0x97,
+        0x2c, 0x49, 0x35, 0x4b, 0x4d, 0xad, 0x57, 0x1c, 0x12, 0x4d, 0x20,
+        0x08, 0xfe, 0x88, 0xc4, 0xde, 0xe3, 0x3e, 0x65, 0x54, 0x55, 0x79,
+        0x7c, 0xfe, 0x82, 0xd0, 0x50, 0x16, 0x87, 0x83, 0xc3, 0xe1, 0x22,
+        0x0e, 0x1e, 0xb4, 0xb1, 0xb2, 0x52, 0x2c, 0x53, 0x08, 0x36, 0x56,
+        0x56, 0x11, 0x07, 0x0f, 0xe2, 0x70, 0x38, 0x16, 0x87, 0xb3, 0x20,
+        0x34, 0x54, 0xe0, 0x7a, 0x95, 0xd7, 0x66, 0xb1, 0x2a, 0x64, 0xa9,
+        0x59, 0x3a, 0x3a, 0x82, 0x87, 0x20, 0xaa, 0x89, 0x48, 0x04, 0x25,
+        0xa5, 0xde, 0xff, 0xa2, 0x76, 0xe0, 0xf1, 0xa0, 0xa2, 0x02, 0x64,
+        0xf2, 0xed, 0x8c, 0x0c, 0x14, 0xe1, 0xb5, 0x31, 0x20, 0xc0, 0xcb,
+        0xc5, 0xe5, 0x2b, 0x10, 0x25, 0x80, 0x97, 0x8b, 0xcb, 0xc6, 0x80,
+        0x00, 0x00, 0xc8, 0xf9, 0xf8, 0x51, 0xd0, 0xd9, 0xcb, 0x6b, 0xb3,
+        0x58, 0xf9, 0xbd, 0x35, 0x0b, 0x2d, 0x17, 0x97, 0x35, 0x34, 0x0c,
+        0x68, 0x8b, 0x92, 0x12, 0x68, 0x6b, 0xf7, 0x3e, 0x1c, 0x54, 0x99,
+        0x51, 0x4d, 0x46, 0x5a, 0x85, 0x1f, 0x85, 0x4f, 0xcc, 0xc8, 0x08,
+        0x00, 0x4e, 0xdf, 0xbf, 0x0f, 0x00, 0x3a, 0x9a, 0x9a, 0xbf, 0x06,
+        0x06, 0x2a, 0x9c, 0xa0, 0x3e, 0xf8, 0x35, 0x30, 0x50, 0x47, 0x53,
+        0x53, 0xa8, 0x54, 0x6e, 0x9b, 0xc5, 0xa2, 0xbc, 0xb1, 0x11, 0x00,
+        0x74, 0x75, 0x75, 0xf1, 0x28, 0x9e, 0xa6, 0xad, 0xa3, 0xa3, 0xba,
+        0xb9, 0x79, 0x40, 0x5b, 0xf4, 0xf5, 0x41, 0x59, 0x59, 0xf0, 0x04,
+        0x44, 0x9f, 0x89, 0xa8, 0x3e, 0xd4, 0x0b, 0x10, 0x08, 0x30, 0x7c,
+        0x38, 0x90, 0x48, 0x6f, 0xca, 0xca, 0x52, 0xdf, 0xbf, 0x07, 0x80,
+        0x55, 0x3f, 0xfc, 0xa0, 0x22, 0x4b, 0x72, 0x9f, 0x7c, 0x50, 0xa1,
+        0x50, 0x56, 0xfd, 0xf0, 0x03, 0x00, 0xa4, 0xbe, 0x7f, 0x2f, 0x58,
+        0x5e, 0x93, 0xdd, 0x66, 0xb1, 0x92, 0xbb, 0x79, 0x3c, 0x14, 0xe0,
+        0x67, 0x69, 0x69, 0x89, 0x17, 0x06, 0x1f, 0x15, 0x0c, 0x9c, 0x34,
+        0x00, 0x38, 0x1c, 0x98, 0x9a, 0x82, 0x8a, 0x0a, 0x10, 0x89, 0x82,
+        0x3f, 0x25, 0xa5, 0xde, 0x2a, 0x8d, 0x0e, 0xd0, 0xf1, 0xf0, 0xe1,
+        0xa0, 0xad, 0x0d, 0x00, 0xc2, 0x95, 0xa8, 0x15, 0x73, 0xe6, 0x28,
+        0x90, 0x14, 0x09, 0x10, 0x2a, 0x12, 0xa8, 0x96, 0xdd, 0x66, 0xb1,
+        0x28, 0xad, 0xaf, 0x47, 0x61, 0x06, 0x56, 0x56, 0x56, 0xbd, 0x64,
+        0x15, 0x4a, 0x20, 0x0b, 0x00, 0x08, 0x04, 0x30, 0x33, 0x83, 0xa1,
+        0x43, 0x05, 0x0a, 0xd0, 0x63, 0x41, 0x7f, 0x04, 0x02, 0x28, 0x29,
+        0x81, 0x8a, 0x0a, 0x58, 0x5a, 0x42, 0x8f, 0xeb, 0x02, 0xcd, 0xfb,
+        0x94, 0x48, 0x24, 0x73, 0x29, 0x7d, 0x8a, 0x83, 0x86, 0xb9, 0x91,
+        0x91, 0x12, 0x89, 0x24, 0x54, 0x2d, 0x87, 0xcd, 0x62, 0x21, 0xcc,
+        0xb8, 0xb6, 0xb2, 0xb2, 0x22, 0x9a, 0x98, 0x98, 0x28, 0x29, 0x29,
+        0x75, 0x75, 0x75, 0xbd, 0xfb, 0x7c, 0x5b, 0x01, 0x31, 0xc0, 0xe1,
+        0x80, 0x4a, 0x85, 0x21, 0x43, 0xa0, 0xbd, 0x1d, 0x5a, 0x5b, 0x81,
+        0xc5, 0x02, 0x1c, 0x0e, 0xc8, 0x64, 0x50, 0x53, 0x03, 0x35, 0x35,
+        0xa0, 0x50, 0x44, 0x67, 0xa1, 0x25, 0x35, 0x35, 0x00, 0x40, 0x33,
+        0x30, 0x90, 0x75, 0x7b, 0x0e, 0xb9, 0x81, 0xc7, 0xe3, 0x69, 0x06,
+        0x06, 0x45, 0x9f, 0x3e, 0x95, 0x88, 0xce, 0xcf, 0x65, 0xb1, 0x59,
+        0x2c, 0x84, 0xb4, 0xd0, 0xe9, 0x74, 0x22, 0x81, 0x40, 0x70, 0x70,
+        0x70, 0x48, 0x4d, 0x4d, 0x7d, 0x90, 0x97, 0x27, 0x95, 0x51, 0x44,
+        0x22, 0x68, 0x68, 0xc0, 0x97, 0x22, 0xc7, 0x50, 0xd5, 0x25, 0xf6,
+        0x73, 0xda, 0x36, 0xb6, 0xb4, 0x9c, 0x88, 0x8c, 0xbc, 0x93, 0x94,
+        0xf4, 0x3f, 0x6e, 0x6e, 0x9b, 0x96, 0x2c, 0x19, 0xd2, 0x93, 0xf5,
+        0x2f, 0x25, 0x1a, 0x5b, 0x5a, 0x42, 0x2e, 0x5c, 0xb8, 0xfd, 0xf0,
+        0xe1, 0xec, 0xe9, 0xd3, 0xb7, 0x2d, 0x5f, 0xae, 0xfb, 0x79, 0xf3,
+        0x41, 0xea, 0xc4, 0x04, 0xe7, 0x48, 0x67, 0xb3, 0x58, 0xa0, 0xcc,
+        0x57, 0x1a, 0x8d, 0x36, 0x74, 0xe8, 0x50, 0x22, 0x00, 0xf8, 0xf9,
+        0xf9, 0xa5, 0xa6, 0xa6, 0x16, 0x56, 0x55, 0x15, 0x54, 0x56, 0xca,
+        0x91, 0x42, 0x2c, 0x16, 0x28, 0x6d, 0xa1, 0xb4, 0xaa, 0x0a, 0xc3,
+        0x30, 0x51, 0xf7, 0xd3, 0x81, 0xf3, 0xe7, 0x4f, 0x5e, 0xba, 0x04,
+        0x00, 0xef, 0x4a, 0x4a, 0x58, 0xed, 0xed, 0xa1, 0x3b, 0x76, 0xc8,
+        0x24, 0x36, 0xe4, 0xc2, 0x85, 0x23, 0xe1, 0xe1, 0x00, 0x70, 0x24,
+        0x3c, 0x9c, 0xc7, 0xe3, 0x1d, 0xdb, 0xb6, 0x4d, 0x78, 0x09, 0xc3,
+        0xb0, 0xd2, 0xaa, 0x2a, 0xa1, 0x6a, 0x85, 0xa0, 0x99, 0xcd, 0x4e,
+        0x79, 0xff, 0x1e, 0x00, 0x7c, 0x7c, 0x7c, 0x00, 0x2d, 0x85, 0xf9,
+        0xf9, 0xf9, 0xa1, 0x6b, 0x31, 0xe2, 0x36, 0x8a, 0x91, 0x0f, 0xe6,
+        0x54, 0x2a, 0x00, 0x74, 0x70, 0x38, 0x15, 0xb5, 0xb5, 0xa2, 0xe7,
+        0x6f, 0x88, 0x4c, 0xe2, 0x6e, 0xf4, 0x99, 0xd0, 0x49, 0x81, 0x5b,
+        0x0f, 0x1e, 0x08, 0x8f, 0xaf, 0xa3, 0x51, 0x42, 0x0f, 0x2a, 0x6a,
+        0x6b, 0x3b, 0x38, 0x1c, 0xa1, 0x6a, 0x85, 0xe0, 0xee, 0xcb, 0x97,
+        0x28, 0xc3, 0x02, 0x51, 0x84, 0x07, 0x00, 0x33, 0x33, 0xb3, 0x31,
+        0x63, 0xc6, 0x00, 0x40, 0xf4, 0xc0, 0x01, 0x17, 0xb2, 0x42, 0xb8,
+        0xd4, 0x7c, 0xa9, 0x67, 0x05, 0x17, 0xc1, 0x5d, 0x64, 0xc6, 0xe3,
+        0x2e, 0xfb, 0xec, 0xc7, 0x7d, 0xf2, 0x64, 0xe1, 0xb1, 0xe7, 0xe7,
+        0xb3, 0x71, 0xa1, 0x22, 0x99, 0x56, 0xb9, 0x25, 0x23, 0x3a, 0x2b,
+        0x0b, 0x00, 0xb4, 0xb5, 0xb5, 0xa7, 0x4c, 0x99, 0x02, 0xc2, 0x58,
+        0x07, 0xc4, 0x5c, 0x46, 0x71, 0xb1, 0x34, 0x99, 0xb0, 0xd2, 0xc0,
+        0xc1, 0xc2, 0x02, 0x19, 0x7d, 0xe6, 0xda, 0x35, 0xae, 0x48, 0xc8,
+        0x59, 0xf0, 0x9a, 0x35, 0x73, 0xa6, 0x4f, 0xa7, 0x90, 0xc9, 0x73,
+        0xa6, 0x4f, 0x0f, 0x5e, 0xb3, 0x46, 0x56, 0xb1, 0x3b, 0x56, 0xae,
+        0x5c, 0xe8, 0xe9, 0xa9, 0xa6, 0xa2, 0xb2, 0xd0, 0xd3, 0x73, 0x57,
+        0xcf, 0xf6, 0x27, 0x00, 0xc0, 0xed, 0xee, 0x3e, 0x73, 0xed, 0x1a,
+        0x00, 0xd8, 0x98, 0x98, 0x38, 0x58, 0x58, 0x28, 0xe0, 0x06, 0x00,
+        0x38, 0x5c, 0x6e, 0x62, 0x6e, 0x2e, 0x00, 0x78, 0x79, 0x79, 0x11,
+        0x89, 0x44, 0x10, 0x92, 0xe5, 0xeb, 0xeb, 0x0b, 0x00, 0x18, 0x86,
+        0xc5, 0x2a, 0xae, 0x25, 0xfe, 0x32, 0x73, 0x26, 0x00, 0x54, 0xd5,
+        0xd5, 0x1d, 0xef, 0x09, 0xfe, 0x05, 0x00, 0x73, 0x23, 0xa3, 0x9b,
+        0xa1, 0xa1, 0x6d, 0x99, 0x99, 0x37, 0x43, 0x43, 0xe5, 0x18, 0x55,
+        0xd0, 0x0c, 0x0c, 0xae, 0x1e, 0x39, 0xd2, 0x9a, 0x91, 0x71, 0xf5,
+        0xc8, 0x11, 0x9a, 0x48, 0xa8, 0xea, 0xf1, 0x88, 0x88, 0xaa, 0xba,
+        0x3a, 0xa1, 0x52, 0x85, 0xe0, 0xe1, 0xeb, 0xd7, 0xec, 0xce, 0x4e,
+        0xe8, 0x21, 0x07, 0x84, 0x64, 0x8d, 0x1f, 0x3f, 0x1e, 0x45, 0xdf,
+        0xa2, 0x8a, 0xa7, 0x10, 0xf8, 0x3b, 0x39, 0xa1, 0x30, 0xfa, 0xe0,
+        0x93, 0x27, 0xd3, 0x3f, 0x7f, 0xd5, 0x92, 0xa4, 0x8e, 0xf6, 0x13,
+        0x8b, 0x3e, 0xc3, 0x91, 0xf4, 0xbc, 0xbc, 0xe0, 0x93, 0x27, 0x01,
+        0xc0, 0x8c, 0x4a, 0x45, 0x29, 0x25, 0x0a, 0x01, 0xea, 0x94, 0xc8,
+        0x64, 0xf2, 0x8c, 0x19, 0x33, 0x04, 0x7a, 0x85, 0xd7, 0x50, 0x87,
+        0x9f, 0x9c, 0x9f, 0xdf, 0x3f, 0xeb, 0x50, 0x3e, 0x50, 0x48, 0xa4,
+        0xbf, 0x37, 0x6e, 0x24, 0x11, 0x08, 0xdd, 0x3c, 0xde, 0xc2, 0xad,
+        0x5b, 0xcb, 0x25, 0xe6, 0x60, 0xcb, 0x8d, 0xf2, 0x9a, 0x9a, 0x85,
+        0x5b, 0xb7, 0x76, 0xf3, 0x78, 0x24, 0x02, 0xe1, 0xef, 0x8d, 0x1b,
+        0x65, 0x8a, 0x34, 0x91, 0x00, 0x3e, 0x86, 0xa1, 0xad, 0x75, 0xa6,
+        0x4d, 0x9b, 0x26, 0x8c, 0x83, 0xef, 0x25, 0x0b, 0x75, 0x5b, 0x9d,
+        0x5c, 0xae, 0x02, 0xdf, 0x89, 0xf6, 0xe6, 0xe6, 0x07, 0xfd, 0xfd,
+        0x01, 0xa0, 0xb4, 0xb2, 0x72, 0x92, 0xbf, 0xff, 0xeb, 0x01, 0x92,
+        0x65, 0xe5, 0xc6, 0x6b, 0x06, 0x63, 0x92, 0xbf, 0x7f, 0x69, 0x65,
+        0x25, 0x00, 0x1c, 0xf4, 0xf7, 0xb7, 0x57, 0x5c, 0xf2, 0xcc, 0xe3,
+        0xfc, 0xfc, 0xfa, 0xb6, 0x36, 0x10, 0x19, 0x2a, 0x80, 0x28, 0x59,
+        0xae, 0xae, 0xae, 0x54, 0x2a, 0x15, 0x00, 0x0e, 0xdc, 0xbc, 0x39,
+        0xd0, 0xfe, 0x59, 0x72, 0x20, 0xc8, 0xdb, 0x7b, 0xab, 0x8f, 0x0f,
+        0x00, 0x54, 0xd6, 0xd6, 0x3a, 0x07, 0x04, 0x5c, 0x96, 0x71, 0xb7,
+        0x0e, 0x09, 0xb8, 0x1c, 0x17, 0xe7, 0x1c, 0x10, 0x50, 0x59, 0x5b,
+        0x0b, 0x00, 0x5b, 0x7d, 0x7c, 0x06, 0x19, 0x9e, 0xdc, 0x07, 0xbb,
+        0xa3, 0xa2, 0x00, 0x80, 0x42, 0xa1, 0xf8, 0x8a, 0xec, 0x56, 0xd7,
+        0x4b, 0x16, 0x89, 0x44, 0x42, 0x41, 0x4f, 0x8c, 0xea, 0xea, 0xb0,
+        0x47, 0x8f, 0x14, 0xa5, 0x15, 0x87, 0xc3, 0x1d, 0x5e, 0xbc, 0xf8,
+        0xc4, 0xd2, 0xa5, 0x38, 0x1c, 0xae, 0x8d, 0xc5, 0x0a, 0xd8, 0xb1,
+        0xc3, 0x75, 0xd9, 0xb2, 0xfc, 0xa2, 0xa2, 0xc1, 0xc8, 0xcc, 0x2f,
+        0x2a, 0x72, 0x5d, 0xb6, 0x2c, 0x60, 0xc7, 0x8e, 0x36, 0x16, 0x0b,
+        0x87, 0xc3, 0x9d, 0x58, 0xba, 0x54, 0xb1, 0x69, 0xee, 0x31, 0x59,
+        0x59, 0x28, 0x8b, 0x6e, 0xc3, 0x86, 0x0d, 0x43, 0x87, 0x0e, 0x15,
+        0x9e, 0xff, 0x2c, 0x1d, 0x85, 0xcb, 0xe5, 0x8e, 0x1a, 0x35, 0xaa,
+        0xb8, 0xb8, 0x98, 0xaa, 0xa9, 0x59, 0x7c, 0xfa, 0xb4, 0x4c, 0xfb,
+        0x26, 0x7d, 0x11, 0xb1, 0xd9, 0xd9, 0x6b, 0xc3, 0xc2, 0xaa, 0x9a,
+        0x9b, 0x01, 0xed, 0x0e, 0xe8, 0xec, 0xbc, 0x66, 0xfe, 0x7c, 0x4f,
+        0x67, 0x67, 0xe9, 0x27, 0x8f, 0x7c, 0x3e, 0x3f, 0x3e, 0x35, 0xf5,
+        0xfc, 0xf5, 0xeb, 0x09, 0xa9, 0xa9, 0x68, 0x9d, 0xc5, 0x40, 0x5b,
+        0xfb, 0xdc, 0xaa, 0x55, 0x83, 0x8f, 0x83, 0x15, 0x05, 0x8f, 0xcf,
+        0x1f, 0x1b, 0x14, 0xf4, 0xbe, 0xb2, 0x52, 0x5b, 0x5b, 0xfb, 0xc3,
+        0x87, 0x0f, 0x5a, 0x22, 0x13, 0x32, 0x5c, 0x9f, 0x5d, 0x55, 0xa2,
+        0xa2, 0xa2, 0xe6, 0xcf, 0x9f, 0x0f, 0x00, 0x7b, 0xe7, 0xce, 0xdd,
+        0xd3, 0x93, 0x67, 0xa7, 0x28, 0x30, 0x3b, 0x3a, 0x76, 0x47, 0x45,
+        0x9d, 0x4e, 0x48, 0x10, 0xc6, 0xdd, 0x1a, 0xe9, 0xeb, 0x7b, 0x38,
+        0x39, 0x4d, 0xb6, 0xb5, 0x75, 0xb4, 0xb1, 0xb1, 0x1c, 0x60, 0x30,
+        0xc9, 0x28, 0x2d, 0x7d, 0x9e, 0x9b, 0x9b, 0xf6, 0xea, 0x55, 0xe2,
+        0xb3, 0x67, 0xc2, 0xb7, 0x04, 0x01, 0x8f, 0xff, 0x65, 0xe6, 0xcc,
+        0xfd, 0xf3, 0xe6, 0xa9, 0xcb, 0xbb, 0x85, 0xe7, 0x40, 0xb8, 0x90,
+        0x9c, 0xbc, 0xf2, 0xfc, 0x79, 0x00, 0x38, 0x7a, 0xf4, 0x68, 0x50,
+        0x50, 0x90, 0xe8, 0xa5, 0xbe, 0x64, 0x61, 0x18, 0x36, 0x61, 0xc2,
+        0x84, 0xec, 0xec, 0x6c, 0x35, 0x0a, 0xa5, 0xe4, 0xf4, 0xe9, 0xa1,
+        0x9a, 0x9a, 0x8a, 0x35, 0x05, 0x00, 0xde, 0x55, 0x54, 0xfc, 0x71,
+        0xff, 0xfe, 0x95, 0xd4, 0xd4, 0x3e, 0xfb, 0x50, 0x29, 0x53, 0x28,
+        0x43, 0x75, 0x74, 0x74, 0xb5, 0xb5, 0x75, 0xb5, 0xb4, 0x00, 0xa0,
+        0xa1, 0xa5, 0xa5, 0xa1, 0xb9, 0xb9, 0xae, 0xa9, 0xa9, 0xe3, 0xf3,
+        0xf5, 0x01, 0x0d, 0x65, 0xe5, 0x45, 0xce, 0xce, 0xeb, 0x67, 0xcc,
+        0x18, 0xd5, 0x93, 0x69, 0xa4, 0x40, 0x74, 0x74, 0x75, 0x59, 0x6c,
+        0xd8, 0x50, 0xd9, 0xd4, 0x44, 0xa3, 0xd1, 0x0a, 0x0b, 0x0b, 0xfb,
+        0xe4, 0xee, 0xf4, 0x25, 0x0b, 0x00, 0x92, 0x93, 0x93, 0x51, 0xa2,
+        0xeb, 0xcf, 0x1e, 0x1e, 0x67, 0x56, 0xac, 0x50, 0xb8, 0x41, 0x08,
+        0xec, 0xce, 0xce, 0xbf, 0xd3, 0xd2, 0x6e, 0x65, 0x64, 0xbc, 0x60,
+        0x30, 0xfa, 0xec, 0xa9, 0x28, 0x16, 0x5a, 0xaa, 0xaa, 0x93, 0x2c,
+        0x2d, 0xe7, 0x38, 0x38, 0x2c, 0x98, 0x3c, 0x59, 0x51, 0x11, 0x5e,
+        0xfd, 0xf1, 0x7b, 0x74, 0xf4, 0xce, 0xab, 0x57, 0x01, 0x20, 0x32,
+        0x32, 0x32, 0xa0, 0x5f, 0xac, 0xa5, 0x18, 0xb2, 0x00, 0x60, 0xc6,
+        0x8c, 0x19, 0x89, 0x89, 0x89, 0x24, 0x02, 0xe1, 0xed, 0xf1, 0xe3,
+        0xf2, 0xe5, 0x6e, 0x01, 0xc0, 0xce, 0xab, 0x57, 0x9f, 0x15, 0x14,
+        0x04, 0xcf, 0x99, 0xe3, 0x21, 0x92, 0xbb, 0xd5, 0x1f, 0x18, 0x86,
+        0xbd, 0xad, 0xa8, 0x48, 0x2b, 0x28, 0x28, 0xa9, 0xad, 0x15, 0x84,
+        0x1c, 0xb5, 0xb5, 0x01, 0x80, 0xae, 0x86, 0x86, 0x20, 0xe4, 0x88,
+        0x4a, 0x9d, 0x6c, 0x65, 0x35, 0x5a, 0xe2, 0xce, 0x7a, 0x00, 0x70,
+        0x2f, 0x27, 0x67, 0xfb, 0x95, 0x2b, 0x3e, 0xe3, 0xc7, 0xf7, 0xd9,
+        0xad, 0x50, 0x7a, 0x34, 0xb1, 0x58, 0xe6, 0xbf, 0xfc, 0xd2, 0xc2,
+        0x66, 0x5b, 0x5b, 0x5b, 0xe7, 0xe4, 0xe4, 0xf4, 0xef, 0x4c, 0xc5,
+        0x93, 0x95, 0x97, 0x97, 0x67, 0x6b, 0x6b, 0x8b, 0x61, 0x98, 0x9f,
+        0xbd, 0xfd, 0x9d, 0xad, 0x5b, 0xe5, 0xd3, 0x6d, 0x19, 0x18, 0x88,
+        0x16, 0xf2, 0x96, 0xb9, 0xba, 0x1e, 0x5f, 0xba, 0xf4, 0xeb, 0xed,
+        0x29, 0xd9, 0xcc, 0x66, 0x07, 0xfe, 0xe7, 0x3f, 0x97, 0x52, 0x52,
+        0x00, 0xc0, 0xd6, 0xd4, 0x34, 0x27, 0x24, 0x44, 0x3e, 0x39, 0x6b,
+        0xc3, 0xc2, 0xce, 0x3f, 0x7c, 0x08, 0x00, 0xf7, 0xef, 0xdf, 0xf7,
+        0xf0, 0xf0, 0xe8, 0x5f, 0x40, 0xfc, 0x9b, 0xc8, 0xda, 0xda, 0x7a,
+        0xd1, 0xa2, 0x45, 0x00, 0x10, 0x9d, 0x95, 0x25, 0xeb, 0x3e, 0x66,
+        0x42, 0xdc, 0x0a, 0x0a, 0x42, 0xe1, 0xcf, 0x17, 0x9f, 0x3c, 0x19,
+        0xb5, 0x69, 0x93, 0x02, 0x27, 0x52, 0xa2, 0x88, 0xc9, 0xca, 0x1a,
+        0xb5, 0x69, 0x13, 0x62, 0xca, 0xc1, 0xc2, 0xe2, 0x9a, 0xbc, 0x2b,
+        0x49, 0xe1, 0x8f, 0x1f, 0x23, 0xa6, 0xdc, 0xdc, 0xdc, 0xc4, 0x32,
+        0x05, 0x03, 0xd5, 0x2c, 0x00, 0x68, 0x6e, 0x6e, 0x76, 0x70, 0x70,
+        0x28, 0x2a, 0x2a, 0xc2, 0xe3, 0x70, 0x71, 0x3b, 0x76, 0xa0, 0xac,
+        0x1f, 0x59, 0xd1, 0xcd, 0xe3, 0x1d, 0x89, 0x8d, 0xdd, 0x77, 0xf3,
+        0x26, 0xda, 0x06, 0xcd, 0xfb, 0xbb, 0xef, 0x42, 0x16, 0x2d, 0x52,
+        0x54, 0xc7, 0x5c, 0x50, 0x59, 0xb9, 0xe3, 0xea, 0xd5, 0x98, 0xac,
+        0x2c, 0x00, 0xa0, 0x90, 0x48, 0xfb, 0xe7, 0xcf, 0xdf, 0xec, 0xed,
+        0x2d, 0x5f, 0x26, 0xd8, 0xb3, 0x82, 0x82, 0x69, 0xfb, 0xf7, 0x77,
+        0x75, 0x77, 0xeb, 0xe9, 0xe9, 0x65, 0x66, 0x66, 0x0e, 0xb4, 0x2d,
+        0xf7, 0x80, 0x64, 0x01, 0x40, 0x41, 0x41, 0xc1, 0xc4, 0x89, 0x13,
+        0x5b, 0x5b, 0x5b, 0x35, 0x94, 0x95, 0x5f, 0xfc, 0xf6, 0x9b, 0xdc,
+        0x37, 0xf9, 0xbe, 0xb2, 0x72, 0xc5, 0xb9, 0x73, 0x68, 0x07, 0x1c,
+        0x02, 0x1e, 0xbf, 0x7c, 0xea, 0xd4, 0x7d, 0xf3, 0xe6, 0x0d, 0x1b,
+        0x44, 0xb2, 0x69, 0x4d, 0x4b, 0xcb, 0x9e, 0xa8, 0xa8, 0x0b, 0xc9,
+        0xc9, 0x68, 0x08, 0xe2, 0x48, 0xa7, 0x87, 0xaf, 0x5d, 0x4b, 0x17,
+        0x71, 0x42, 0xc8, 0x84, 0xb2, 0x86, 0x06, 0xfb, 0x9d, 0x3b, 0xeb,
+        0x5a, 0x5b, 0x49, 0x24, 0xd2, 0xa3, 0x47, 0x8f, 0x9c, 0x07, 0x0e,
+        0x5a, 0x91, 0x44, 0x16, 0x00, 0x24, 0x24, 0x24, 0x78, 0x7b, 0x7b,
+        0xf3, 0xf9, 0x7c, 0x33, 0x2a, 0x35, 0xf3, 0xe0, 0x41, 0xb9, 0x73,
+        0x81, 0xf9, 0x18, 0x76, 0x21, 0x39, 0x79, 0x6f, 0x54, 0x14, 0x1a,
+        0x94, 0xaa, 0x92, 0xc9, 0x6b, 0xdc, 0xdd, 0x97, 0x4c, 0x99, 0x32,
+        0x4e, 0xc6, 0xe8, 0xd3, 0xf7, 0x95, 0x95, 0xe1, 0xc9, 0xc9, 0xe7,
+        0x1e, 0x3c, 0x40, 0xce, 0x93, 0xe1, 0x3a, 0x3a, 0xfb, 0xe7, 0xcf,
+        0x5f, 0xe6, 0xea, 0x8a, 0x97, 0x77, 0xf8, 0xce, 0xee, 0xec, 0x9c,
+        0x1c, 0x1c, 0x8c, 0xb6, 0xa0, 0x09, 0x0b, 0x0b, 0x5b, 0xb9, 0x72,
+        0xa5, 0x84, 0xc2, 0x5f, 0x20, 0x0b, 0x00, 0x8e, 0x1e, 0x3d, 0xba,
+        0x75, 0xeb, 0x56, 0x00, 0x70, 0x1d, 0x3d, 0xfa, 0x41, 0x70, 0xf0,
+        0x60, 0x12, 0xc1, 0x3b, 0xba, 0xba, 0x42, 0xef, 0xdd, 0x0b, 0x89,
+        0x89, 0x11, 0x6e, 0x5e, 0x39, 0xca, 0xd0, 0xd0, 0xdf, 0xc9, 0x69,
+        0xc1, 0xe4, 0xc9, 0x92, 0x7d, 0xc1, 0x8d, 0x4c, 0xe6, 0xb5, 0xb4,
+        0xb4, 0xc8, 0xa7, 0x4f, 0x85, 0xcb, 0x91, 0x1a, 0xca, 0xca, 0x3b,
+        0xfc, 0xfc, 0x36, 0x7a, 0x79, 0x0d, 0x66, 0x93, 0x5d, 0x0c, 0xc3,
+        0x7e, 0x38, 0x7e, 0x1c, 0xad, 0xf8, 0x07, 0x06, 0x06, 0x86, 0x86,
+        0x86, 0x4a, 0x2e, 0xff, 0x65, 0xb2, 0x00, 0x60, 0xe9, 0xd2, 0xa5,
+        0x28, 0x09, 0xfd, 0xa7, 0xe9, 0xd3, 0xcf, 0xaf, 0x5a, 0x25, 0xb7,
+        0x71, 0x08, 0x4d, 0x2c, 0xd6, 0xb1, 0xb8, 0xb8, 0xc8, 0x94, 0x94,
+        0x8a, 0xc6, 0x46, 0xe1, 0x49, 0x73, 0x2a, 0x75, 0x84, 0xbe, 0xbe,
+        0x19, 0x95, 0x6a, 0x4e, 0xa5, 0x9a, 0xeb, 0xeb, 0xab, 0x53, 0x28,
+        0xc5, 0x35, 0x35, 0x8c, 0xea, 0x6a, 0x46, 0x75, 0x35, 0xa3, 0xaa,
+        0xea, 0x43, 0x5d, 0x9d, 0x70, 0x6e, 0x6f, 0xa0, 0xad, 0xbd, 0xc4,
+        0xc5, 0x25, 0x68, 0xd6, 0x2c, 0xdd, 0x41, 0x6f, 0xb2, 0xbb, 0x27,
+        0x2a, 0x6a, 0xff, 0xcd, 0x9b, 0x00, 0xe0, 0xee, 0xee, 0x1e, 0x1f,
+        0x1f, 0xff, 0xc5, 0x1f, 0x30, 0x90, 0x8a, 0xac, 0xce, 0xce, 0x4e,
+        0x57, 0x57, 0xd7, 0xf4, 0xf4, 0x74, 0x00, 0x38, 0x12, 0x10, 0xb0,
+        0x65, 0xd6, 0xac, 0x41, 0x5a, 0x09, 0x00, 0x7c, 0x0c, 0x7b, 0xfa,
+        0xee, 0xdd, 0x95, 0xd4, 0xd4, 0x9b, 0xe9, 0xe9, 0xd2, 0xec, 0x92,
+        0xaa, 0x42, 0x26, 0xcf, 0x9e, 0x30, 0x61, 0x89, 0x8b, 0xcb, 0xb4,
+        0xb1, 0x63, 0xe5, 0x6e, 0x74, 0xa2, 0xb8, 0x94, 0x92, 0xb2, 0xf4,
+        0xcc, 0x19, 0x0c, 0xc3, 0xe8, 0x74, 0x7a, 0x7a, 0x7a, 0xba, 0x96,
+        0x14, 0x8b, 0x72, 0x52, 0x91, 0x05, 0x00, 0x35, 0x35, 0x35, 0xf6,
+        0xf6, 0xf6, 0x28, 0x0e, 0x7c, 0x9d, 0x87, 0x47, 0xe8, 0xb2, 0x65,
+        0xfd, 0xd7, 0x04, 0xe5, 0x43, 0x27, 0x97, 0xfb, 0xf0, 0xf5, 0xeb,
+        0xb7, 0x15, 0x15, 0x1f, 0x6a, 0x6b, 0x4b, 0x6a, 0x6b, 0x3f, 0xd4,
+        0xd6, 0x96, 0x35, 0x34, 0xf0, 0x31, 0x6c, 0x98, 0x96, 0xd6, 0x08,
+        0x7d, 0x7d, 0x73, 0x7d, 0x7d, 0x73, 0x2a, 0xd5, 0x6a, 0xf8, 0x70,
+        0x0f, 0x6b, 0x6b, 0x45, 0x4d, 0xec, 0x31, 0x0c, 0xdb, 0x7b, 0xe3,
+        0xc6, 0x81, 0x5b, 0xb7, 0x30, 0x0c, 0xd3, 0xd2, 0xd2, 0xca, 0xc8,
+        0xc8, 0x10, 0x2e, 0xcb, 0x4b, 0x86, 0xb4, 0x64, 0x01, 0x40, 0x6e,
+        0x6e, 0xae, 0xa7, 0xa7, 0x27, 0xda, 0x12, 0x7d, 0xda, 0xd8, 0xb1,
+        0x37, 0x36, 0x6f, 0xfe, 0x4a, 0xe3, 0xcc, 0x6e, 0x1e, 0x8f, 0xcb,
+        0xe3, 0x7d, 0xa5, 0x1d, 0xbf, 0xd9, 0x9d, 0x9d, 0x4b, 0xfe, 0xf8,
+        0x03, 0xf5, 0x53, 0x5a, 0x5a, 0x5a, 0xd1, 0xd1, 0xd1, 0x2e, 0x52,
+        0x87, 0x43, 0xc9, 0x40, 0x16, 0x00, 0x54, 0x56, 0x56, 0xfa, 0xf9,
+        0xf9, 0xa1, 0x4c, 0xce, 0x11, 0xfa, 0xfa, 0x71, 0xdb, 0xb7, 0x2b,
+        0x6a, 0x51, 0xf6, 0xdb, 0xa0, 0xac, 0xa1, 0xc1, 0x27, 0x24, 0x04,
+        0xbd, 0xfb, 0xe8, 0x74, 0x7a, 0x6c, 0x6c, 0xac, 0x94, 0x75, 0x0a,
+        0x41, 0xb6, 0x21, 0xdc, 0xf0, 0xe1, 0xc3, 0x53, 0x52, 0x52, 0x90,
+        0x0f, 0xa7, 0xb8, 0xa6, 0x66, 0xe2, 0xae, 0x5d, 0xf7, 0x73, 0x73,
+        0x65, 0x92, 0xf0, 0xff, 0x11, 0xcf, 0x0a, 0x0a, 0xec, 0x77, 0xee,
+        0x44, 0x4c, 0xb9, 0xbb, 0xbb, 0xa7, 0xa7, 0xa7, 0xcb, 0xc4, 0x14,
+        0xc8, 0x4a, 0x16, 0x00, 0x28, 0x2b, 0x2b, 0xff, 0xfd, 0xf7, 0xdf,
+        0x07, 0x0e, 0x1c, 0xc0, 0xf5, 0xec, 0xeb, 0x8c, 0xf6, 0x9a, 0xfc,
+        0x2f, 0x47, 0xf8, 0xe3, 0xc7, 0xd3, 0xf6, 0xef, 0x47, 0x5b, 0xd4,
+        0x05, 0x06, 0x06, 0xc6, 0xc7, 0xc7, 0x4b, 0xd3, 0xa3, 0xf7, 0x81,
+        0x6c, 0xcd, 0x50, 0x14, 0x77, 0xee, 0xdc, 0x09, 0x08, 0x08, 0x60,
+        0xb3, 0xd9, 0x00, 0xe0, 0xef, 0xe4, 0x74, 0x34, 0x20, 0x60, 0x30,
+        0x83, 0xf2, 0xaf, 0x87, 0x26, 0x16, 0x6b, 0xd7, 0xb5, 0x6b, 0x68,
+        0xde, 0x47, 0x22, 0x91, 0xce, 0x9e, 0x3d, 0x2b, 0x79, 0xe4, 0x29,
+        0x01, 0xf2, 0x93, 0x05, 0x00, 0x79, 0x79, 0x79, 0x3e, 0x3e, 0x3e,
+        0x65, 0x65, 0x65, 0x00, 0xa0, 0x42, 0x26, 0x6f, 0xf4, 0xf4, 0xdc,
+        0xee, 0xe7, 0x27, 0x4f, 0xfa, 0xd6, 0xd7, 0x41, 0x47, 0x57, 0xd7,
+        0xc9, 0xf8, 0xf8, 0x90, 0x98, 0x18, 0xe4, 0x2f, 0xd3, 0xd3, 0xd3,
+        0xbb, 0x75, 0xeb, 0x96, 0x84, 0xd9, 0xcc, 0x17, 0x31, 0x28, 0xb2,
+        0x00, 0xa0, 0xae, 0xae, 0x6e, 0xcd, 0x9a, 0x35, 0x77, 0xee, 0xdc,
+        0x41, 0x1f, 0x87, 0xa8, 0xab, 0x07, 0xcf, 0x9e, 0xfd, 0xb3, 0x87,
+        0x87, 0xf4, 0x9b, 0xa6, 0x7c, 0x0d, 0xf0, 0xf8, 0xfc, 0xff, 0x3c,
+        0x7e, 0xbc, 0xf7, 0xc6, 0x0d, 0xe1, 0xbe, 0xc9, 0x6e, 0x6e, 0x6e,
+        0x61, 0x61, 0x61, 0xb2, 0xfe, 0x70, 0x55, 0x1f, 0x0c, 0x96, 0x2c,
+        0x84, 0xe7, 0xcf, 0x9f, 0x6f, 0xdb, 0xb6, 0x2d, 0x2d, 0x2d, 0x0d,
+        0x7d, 0x34, 0xd1, 0xd3, 0x3b, 0xb0, 0x60, 0x81, 0xbf, 0x93, 0x93,
+        0x42, 0x46, 0x8f, 0xb2, 0x22, 0x26, 0x2b, 0x6b, 0xe7, 0xd5, 0xab,
+        0xef, 0x2b, 0x2b, 0xd1, 0x47, 0x6b, 0x6b, 0xeb, 0x90, 0x90, 0x90,
+        0x81, 0xbc, 0x2e, 0x32, 0x41, 0x31, 0x64, 0x21, 0x44, 0x47, 0x47,
+        0xef, 0xdc, 0xb9, 0xb3, 0xa0, 0xa0, 0x00, 0x7d, 0xb4, 0xa6, 0xd1,
+        0xf6, 0xcf, 0x9f, 0x3f, 0xd3, 0xd6, 0x76, 0x30, 0xd3, 0x49, 0xe9,
+        0xc1, 0xc7, 0xb0, 0xc7, 0xf9, 0xf9, 0xbb, 0xa3, 0xa2, 0xd0, 0x2a,
+        0x16, 0x00, 0xd0, 0x68, 0xb4, 0x03, 0x07, 0x0e, 0x2c, 0x5a, 0xb4,
+        0x48, 0x51, 0xd1, 0x87, 0x8a, 0x24, 0x0b, 0x00, 0x78, 0x3c, 0xde,
+        0x85, 0x0b, 0x17, 0xf6, 0xee, 0xdd, 0x2b, 0xfc, 0x41, 0x25, 0x2d,
+        0x55, 0x55, 0x4f, 0x5b, 0x5b, 0x3f, 0x7b, 0xfb, 0x19, 0x36, 0x36,
+        0x0a, 0x5f, 0x89, 0x01, 0x00, 0x0e, 0x97, 0xfb, 0xf0, 0xf5, 0xeb,
+        0xe8, 0xcc, 0xcc, 0xb8, 0x97, 0x2f, 0xd1, 0x1a, 0x32, 0x00, 0x68,
+        0x6b, 0x6b, 0xef, 0xda, 0xb5, 0x6b, 0xfd, 0xfa, 0xf5, 0x64, 0x85,
+        0x7a, 0xeb, 0x15, 0x4c, 0x16, 0x02, 0x9b, 0xcd, 0x3e, 0x71, 0xe2,
+        0xc4, 0xe1, 0xc3, 0x87, 0x99, 0x22, 0x79, 0x56, 0x64, 0x12, 0xe9,
+        0xfb, 0x31, 0x63, 0xfc, 0xec, 0xed, 0x7d, 0xc6, 0x8f, 0xd7, 0x97,
+        0xfd, 0xb5, 0xdd, 0x07, 0xcd, 0x6c, 0xf6, 0xdd, 0x97, 0x2f, 0xa3,
+        0xb3, 0xb2, 0x12, 0x73, 0x73, 0x91, 0xbb, 0x06, 0x81, 0x42, 0xa1,
+        0x6c, 0xd8, 0xb0, 0x61, 0xe7, 0xce, 0x9d, 0x72, 0x8c, 0x0c, 0xbe,
+        0x88, 0xaf, 0x42, 0x16, 0x42, 0x4b, 0x4b, 0x4b, 0x5c, 0x5c, 0x5c,
+        0x4c, 0x4c, 0x4c, 0x62, 0x62, 0x22, 0x4b, 0xe4, 0x37, 0x32, 0x70,
+        0x38, 0x9c, 0xc3, 0x88, 0x11, 0xde, 0xdf, 0x7d, 0x37, 0xd6, 0xd8,
+        0xd8, 0x72, 0xd8, 0x30, 0x33, 0x2a, 0x55, 0x9a, 0xb7, 0x41, 0x37,
+        0x8f, 0x57, 0x5a, 0x5f, 0xcf, 0xa8, 0xae, 0x7e, 0x57, 0x51, 0x91,
+        0xf0, 0xea, 0x55, 0xca, 0xfb, 0xf7, 0xa2, 0x31, 0x06, 0x14, 0x0a,
+        0xc5, 0xcd, 0xcd, 0xcd, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0x57, 0xef,
+        0x2b, 0xfc, 0xc8, 0x96, 0xc0, 0xf2, 0xaf, 0x47, 0x96, 0x10, 0x9d,
+        0x9d, 0x9d, 0xc9, 0xc9, 0xc9, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
+        0x55, 0xfd, 0x02, 0xc8, 0x09, 0x78, 0xbc, 0x89, 0x9e, 0x9e, 0xe4,
+        0x9f, 0xec, 0x2b, 0x6f, 0x6c, 0xfc, 0x50, 0x5b, 0xdb, 0x3f, 0xb2,
+        0x56, 0x57, 0x57, 0xd7, 0xdb, 0xdb, 0xdb, 0xd7, 0xd7, 0xd7, 0xdd,
+        0xdd, 0x7d, 0x90, 0x3f, 0x4e, 0x29, 0x0d, 0xbe, 0x05, 0x59, 0x42,
+        0x60, 0x18, 0x96, 0x9d, 0x9d, 0x1d, 0x1b, 0x1b, 0x1b, 0x13, 0x13,
+        0xf3, 0x46, 0x64, 0x1f, 0x67, 0x59, 0x61, 0x61, 0x61, 0x81, 0x2a,
+        0x91, 0xa3, 0xa3, 0xe3, 0x37, 0x0b, 0x1d, 0x87, 0x6f, 0x4c, 0x96,
+        0x28, 0x5a, 0x5a, 0x5a, 0x18, 0x0c, 0x06, 0xfa, 0x99, 0xd1, 0xc2,
+        0xc2, 0xc2, 0x8a, 0x8a, 0x0a, 0x29, 0x7f, 0x66, 0xd4, 0xd2, 0xd2,
+        0xf2, 0xeb, 0x35, 0x34, 0xc9, 0xf8, 0x7f, 0xba, 0xe7, 0x77, 0xc2,
+        0x98, 0x53, 0x6c, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
+        0x44, 0xae, 0x42, 0x60, 0x82
+    };
+
+    static constexpr std::size_t png_data_length = 8090;
+}