Merge branch 'dev' into webserver-v3-entity-grouping

CODEOWNERS

@@ -171,6 +171,7 @@ esphome/components/host/* @clydebarrow @esphome/core
 esphome/components/host/time/* @clydebarrow
 esphome/components/hrxl_maxsonar_wr/* @netmikey
 esphome/components/hte501/* @Stock-M
+esphome/components/http_request/ota/* @oarcher
 esphome/components/htu31d/* @betterengineering
 esphome/components/hydreon_rgxx/* @functionpointer
 esphome/components/hyt271/* @Philippe12

docker/Dockerfile

@@ -101,7 +101,7 @@ RUN --mount=type=tmpfs,target=/root/.cargo if [ "$TARGETARCH$TARGETVARIANT" = "a
     && /platformio_install_deps.py /platformio.ini --libraries
 
 # Avoid unsafe git error when container user and file config volume permissions don't match
-RUN git config --system --add safe.directory '/config/*'
+RUN git config --system --add safe.directory '*'
 
 
 # ======================= docker-type image =======================

esphome/components/datetime/date_entity.cpp

@@ -80,6 +80,17 @@ void DateCall::validate_() {
 
 void DateCall::perform() {
   this->validate_();
+  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+
+  if (this->year_.has_value()) {
+    ESP_LOGD(TAG, " Year: %d", *this->year_);
+  }
+  if (this->month_.has_value()) {
+    ESP_LOGD(TAG, " Month: %d", *this->month_);
+  }
+  if (this->day_.has_value()) {
+    ESP_LOGD(TAG, " Day: %d", *this->day_);
+  }
   this->parent_->control(*this);
 }
 

esphome/components/http_request/ota/__init__.py

@@ -0,0 +1,189 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.const import (
+    CONF_ESP8266_DISABLE_SSL_SUPPORT,
+    CONF_ID,
+    CONF_PASSWORD,
+    CONF_TIMEOUT,
+    CONF_URL,
+    CONF_USERNAME,
+)
+from esphome.components import esp32
+from esphome.components.ota import BASE_OTA_SCHEMA, ota_to_code, OTAComponent
+from esphome.core import CORE, coroutine_with_priority
+from .. import http_request_ns
+
+CODEOWNERS = ["@oarcher"]
+
+AUTO_LOAD = ["md5"]
+DEPENDENCIES = ["network"]
+
+CONF_MD5 = "md5"
+CONF_MD5_URL = "md5_url"
+CONF_VERIFY_SSL = "verify_ssl"
+CONF_WATCHDOG_TIMEOUT = "watchdog_timeout"
+
+OtaHttpRequestComponent = http_request_ns.class_(
+    "OtaHttpRequestComponent", OTAComponent
+)
+OtaHttpRequestComponentArduino = http_request_ns.class_(
+    "OtaHttpRequestComponentArduino", OtaHttpRequestComponent
+)
+OtaHttpRequestComponentIDF = http_request_ns.class_(
+    "OtaHttpRequestComponentIDF", OtaHttpRequestComponent
+)
+OtaHttpRequestComponentFlashAction = http_request_ns.class_(
+    "OtaHttpRequestComponentFlashAction", automation.Action
+)
+
+
+def validate_ssl_verification(config):
+    error_message = ""
+
+    if CORE.is_esp32:
+        if not CORE.using_esp_idf and config[CONF_VERIFY_SSL]:
+            error_message = "ESPHome supports certificate verification only via ESP-IDF"
+
+    if CORE.is_rp2040 and config[CONF_VERIFY_SSL]:
+        error_message = "ESPHome does not support certificate verification in Arduino"
+
+    if (
+        CORE.is_esp8266
+        and not config[CONF_ESP8266_DISABLE_SSL_SUPPORT]
+        and config[CONF_VERIFY_SSL]
+    ):
+        error_message = "ESPHome does not support certificate verification in Arduino"
+
+    if len(error_message) > 0:
+        raise cv.Invalid(
+            f"{error_message}. Set '{CONF_VERIFY_SSL}: false' to skip certificate validation and allow less secure HTTPS connections."
+        )
+
+    return config
+
+
+def _declare_request_class(value):
+    if CORE.using_esp_idf:
+        return cv.declare_id(OtaHttpRequestComponentIDF)(value)
+
+    if CORE.is_esp8266 or CORE.is_esp32 or CORE.is_rp2040:
+        return cv.declare_id(OtaHttpRequestComponentArduino)(value)
+    return NotImplementedError
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): _declare_request_class,
+            cv.SplitDefault(CONF_ESP8266_DISABLE_SSL_SUPPORT, esp8266=False): cv.All(
+                cv.only_on_esp8266, cv.boolean
+            ),
+            cv.Optional(CONF_VERIFY_SSL, default=True): cv.boolean,
+            cv.Optional(
+                CONF_TIMEOUT, default="5min"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_WATCHDOG_TIMEOUT): cv.All(
+                cv.Any(cv.only_on_esp32, cv.only_on_rp2040),
+                cv.positive_not_null_time_period,
+                cv.positive_time_period_milliseconds,
+            ),
+        }
+    )
+    .extend(BASE_OTA_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.require_framework_version(
+        esp8266_arduino=cv.Version(2, 5, 1),
+        esp32_arduino=cv.Version(0, 0, 0),
+        esp_idf=cv.Version(0, 0, 0),
+        rp2040_arduino=cv.Version(0, 0, 0),
+    ),
+    validate_ssl_verification,
+)
+
+
+@coroutine_with_priority(52.0)
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await ota_to_code(var, config)
+
+    cg.add(var.set_timeout(config[CONF_TIMEOUT]))
+
+    if timeout_ms := config.get(CONF_WATCHDOG_TIMEOUT):
+        cg.add_define(
+            "USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT",
+            timeout_ms,
+        )
+
+    if CORE.is_esp8266 and not config[CONF_ESP8266_DISABLE_SSL_SUPPORT]:
+        cg.add_define("USE_HTTP_REQUEST_ESP8266_HTTPS")
+
+    if CORE.is_esp32:
+        if CORE.using_esp_idf:
+            esp32.add_idf_sdkconfig_option(
+                "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE",
+                config.get(CONF_VERIFY_SSL),
+            )
+            esp32.add_idf_sdkconfig_option(
+                "CONFIG_ESP_TLS_INSECURE",
+                not config.get(CONF_VERIFY_SSL),
+            )
+            esp32.add_idf_sdkconfig_option(
+                "CONFIG_ESP_TLS_SKIP_SERVER_CERT_VERIFY",
+                not config.get(CONF_VERIFY_SSL),
+            )
+        else:
+            cg.add_library("WiFiClientSecure", None)
+            cg.add_library("HTTPClient", None)
+    if CORE.is_esp8266:
+        cg.add_library("ESP8266HTTPClient", None)
+    if CORE.is_rp2040 and CORE.using_arduino:
+        cg.add_library("HTTPClient", None)
+
+    await cg.register_component(var, config)
+
+
+OTA_HTTP_REQUEST_FLASH_ACTION_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(OtaHttpRequestComponent),
+            cv.Optional(CONF_MD5_URL): cv.templatable(cv.url),
+            cv.Optional(CONF_MD5): cv.templatable(cv.string),
+            cv.Optional(CONF_PASSWORD): cv.templatable(cv.string),
+            cv.Optional(CONF_USERNAME): cv.templatable(cv.string),
+            cv.Required(CONF_URL): cv.templatable(cv.url),
+        }
+    ),
+    cv.has_exactly_one_key(CONF_MD5, CONF_MD5_URL),
+)
+
+
+@automation.register_action(
+    "ota_http_request.flash",
+    OtaHttpRequestComponentFlashAction,
+    OTA_HTTP_REQUEST_FLASH_ACTION_SCHEMA,
+)
+async def ota_http_request_action_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    if md5_url := config.get(CONF_MD5_URL):
+        template_ = await cg.templatable(md5_url, args, cg.std_string)
+        cg.add(var.set_md5_url(template_))
+
+    if md5_str := config.get(CONF_MD5):
+        template_ = await cg.templatable(md5_str, args, cg.std_string)
+        cg.add(var.set_md5(template_))
+
+    if password_str := config.get(CONF_PASSWORD):
+        template_ = await cg.templatable(password_str, args, cg.std_string)
+        cg.add(var.set_password(template_))
+
+    if username_str := config.get(CONF_USERNAME):
+        template_ = await cg.templatable(username_str, args, cg.std_string)
+        cg.add(var.set_username(template_))
+
+    template_ = await cg.templatable(config[CONF_URL], args, cg.std_string)
+    cg.add(var.set_url(template_))
+
+    return var

esphome/components/http_request/ota/automation.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "ota_http_request.h"
+
+#include "esphome/core/automation.h"
+
+namespace esphome {
+namespace http_request {
+
+template<typename... Ts> class OtaHttpRequestComponentFlashAction : public Action<Ts...> {
+ public:
+  OtaHttpRequestComponentFlashAction(OtaHttpRequestComponent *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(std::string, md5_url)
+  TEMPLATABLE_VALUE(std::string, md5)
+  TEMPLATABLE_VALUE(std::string, password)
+  TEMPLATABLE_VALUE(std::string, url)
+  TEMPLATABLE_VALUE(std::string, username)
+
+  void play(Ts... x) override {
+    if (this->md5_url_.has_value()) {
+      this->parent_->set_md5_url(this->md5_url_.value(x...));
+    }
+    if (this->md5_.has_value()) {
+      this->parent_->set_md5(this->md5_.value(x...));
+    }
+    if (this->password_.has_value()) {
+      this->parent_->set_password(this->password_.value(x...));
+    }
+    if (this->username_.has_value()) {
+      this->parent_->set_username(this->username_.value(x...));
+    }
+    this->parent_->set_url(this->url_.value(x...));
+
+    this->parent_->flash();
+    // Normally never reached due to reboot
+  }
+
+ protected:
+  OtaHttpRequestComponent *parent_;
+};
+
+}  // namespace http_request
+}  // namespace esphome

esphome/components/http_request/ota/ota_http_request.cpp

@@ -0,0 +1,293 @@
+#include "ota_http_request.h"
+#include "watchdog.h"
+
+#include "esphome/core/application.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+
+#include "esphome/components/md5/md5.h"
+#include "esphome/components/ota/ota_backend_arduino_esp32.h"
+#include "esphome/components/ota/ota_backend_arduino_esp8266.h"
+#include "esphome/components/ota/ota_backend_arduino_rp2040.h"
+#include "esphome/components/ota/ota_backend_esp_idf.h"
+#include "esphome/components/ota/ota_backend.h"
+
+namespace esphome {
+namespace http_request {
+
+void OtaHttpRequestComponent::setup() {
+#ifdef USE_OTA_STATE_CALLBACK
+  ota::register_ota_platform(this);
+#endif
+}
+
+void OtaHttpRequestComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "Over-The-Air updates via HTTP request:");
+  ESP_LOGCONFIG(TAG, "  Timeout: %llus", this->timeout_ / 1000);
+#ifdef USE_ESP8266
+#ifdef USE_HTTP_REQUEST_ESP8266_HTTPS
+  ESP_LOGCONFIG(TAG, "  ESP8266 SSL support: No");
+#else
+  ESP_LOGCONFIG(TAG, "  ESP8266 SSL support: Yes");
+#endif
+#endif
+#ifdef CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
+  ESP_LOGCONFIG(TAG, "  TLS server verification: Yes");
+#else
+  ESP_LOGCONFIG(TAG, "  TLS server verification: No");
+#endif
+#ifdef USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT
+  ESP_LOGCONFIG(TAG, "  Watchdog timeout: %ds", USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT / 1000);
+#endif
+};
+
+void OtaHttpRequestComponent::set_md5_url(const std::string &url) {
+  if (!this->validate_url_(url)) {
+    this->md5_url_.clear();  // URL was not valid; prevent flashing until it is
+    return;
+  }
+  this->md5_url_ = url;
+  this->md5_expected_.clear();  // to be retrieved later
+}
+
+void OtaHttpRequestComponent::set_url(const std::string &url) {
+  if (!this->validate_url_(url)) {
+    this->url_.clear();  // URL was not valid; prevent flashing until it is
+    return;
+  }
+  this->url_ = url;
+}
+
+bool OtaHttpRequestComponent::check_status() {
+  // status can be -1, or HTTP status code
+  if (this->status_ < 100) {
+    ESP_LOGE(TAG, "HTTP server did not respond (error %d)", this->status_);
+    return false;
+  }
+  if (this->status_ >= 310) {
+    ESP_LOGE(TAG, "HTTP error %d", this->status_);
+    return false;
+  }
+  ESP_LOGV(TAG, "HTTP status %d", this->status_);
+  return true;
+}
+
+void OtaHttpRequestComponent::flash() {
+  if (this->url_.empty()) {
+    ESP_LOGE(TAG, "URL not set; cannot start update");
+    return;
+  }
+
+  ESP_LOGI(TAG, "Starting update...");
+#ifdef USE_OTA_STATE_CALLBACK
+  this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);
+#endif
+
+  auto ota_status = this->do_ota_();
+
+  switch (ota_status) {
+    case ota::OTA_RESPONSE_OK:
+#ifdef USE_OTA_STATE_CALLBACK
+      this->state_callback_.call(ota::OTA_COMPLETED, 100.0f, ota_status);
+#endif
+      delay(10);
+      App.safe_reboot();
+      break;
+
+    default:
+#ifdef USE_OTA_STATE_CALLBACK
+      this->state_callback_.call(ota::OTA_ERROR, 0.0f, ota_status);
+#endif
+      this->md5_computed_.clear();  // will be reset at next attempt
+      this->md5_expected_.clear();  // will be reset at next attempt
+      break;
+  }
+}
+
+void OtaHttpRequestComponent::cleanup_(std::unique_ptr<ota::OTABackend> backend) {
+  if (this->update_started_) {
+    ESP_LOGV(TAG, "Aborting OTA backend");
+    backend->abort();
+  }
+  ESP_LOGV(TAG, "Aborting HTTP connection");
+  this->http_end();
+};
+
+uint8_t OtaHttpRequestComponent::do_ota_() {
+  uint8_t buf[this->http_recv_buffer_ + 1];
+  uint32_t last_progress = 0;
+  uint32_t update_start_time = millis();
+  md5::MD5Digest md5_receive;
+  std::unique_ptr<char[]> md5_receive_str(new char[33]);
+
+  if (this->md5_expected_.empty() && !this->http_get_md5_()) {
+    return OTA_MD5_INVALID;
+  }
+
+  ESP_LOGD(TAG, "MD5 expected: %s", this->md5_expected_.c_str());
+
+  auto url_with_auth = this->get_url_with_auth_(this->url_);
+  if (url_with_auth.empty()) {
+    return OTA_BAD_URL;
+  }
+  ESP_LOGVV(TAG, "url_with_auth: %s", url_with_auth.c_str());
+  ESP_LOGI(TAG, "Connecting to: %s", this->url_.c_str());
+  this->http_init(url_with_auth);
+  if (!this->check_status()) {
+    this->http_end();
+    return OTA_CONNECTION_ERROR;
+  }
+
+  // we will compute MD5 on the fly for verification -- Arduino OTA seems to ignore it
+  md5_receive.init();
+  ESP_LOGV(TAG, "MD5Digest initialized");
+
+  ESP_LOGV(TAG, "OTA backend begin");
+  auto backend = ota::make_ota_backend();
+  auto error_code = backend->begin(this->body_length_);
+  if (error_code != ota::OTA_RESPONSE_OK) {
+    ESP_LOGW(TAG, "backend->begin error: %d", error_code);
+    this->cleanup_(std::move(backend));
+    return error_code;
+  }
+
+  this->bytes_read_ = 0;
+  while (this->bytes_read_ < this->body_length_) {
+    // read a maximum of chunk_size bytes into buf. (real read size returned)
+    int bufsize = this->http_read(buf, this->http_recv_buffer_);
+    ESP_LOGVV(TAG, "bytes_read_ = %u, body_length_ = %u, bufsize = %i", this->bytes_read_, this->body_length_, bufsize);
+
+    // feed watchdog and give other tasks a chance to run
+    App.feed_wdt();
+    yield();
+
+    if (bufsize < 0) {
+      ESP_LOGE(TAG, "Stream closed");
+      this->cleanup_(std::move(backend));
+      return OTA_CONNECTION_ERROR;
+    } else if (bufsize > 0 && bufsize <= this->http_recv_buffer_) {
+      // add read bytes to MD5
+      md5_receive.add(buf, bufsize);
+
+      // write bytes to OTA backend
+      this->update_started_ = true;
+      error_code = backend->write(buf, bufsize);
+      if (error_code != ota::OTA_RESPONSE_OK) {
+        // error code explanation available at
+        // https://github.com/esphome/esphome/blob/dev/esphome/components/ota/ota_backend.h
+        ESP_LOGE(TAG, "Error code (%02X) writing binary data to flash at offset %d and size %d", error_code,
+                 this->bytes_read_ - bufsize, this->body_length_);
+        this->cleanup_(std::move(backend));
+        return error_code;
+      }
+    }
+
+    uint32_t now = millis();
+    if ((now - last_progress > 1000) or (this->bytes_read_ == this->body_length_)) {
+      last_progress = now;
+      float percentage = this->bytes_read_ * 100.0f / this->body_length_;
+      ESP_LOGD(TAG, "Progress: %0.1f%%", percentage);
+#ifdef USE_OTA_STATE_CALLBACK
+      this->state_callback_.call(ota::OTA_IN_PROGRESS, percentage, 0);
+#endif
+    }
+  }  // while
+
+  ESP_LOGI(TAG, "Done in %.0f seconds", float(millis() - update_start_time) / 1000);
+
+  // verify MD5 is as expected and act accordingly
+  md5_receive.calculate();
+  md5_receive.get_hex(md5_receive_str.get());
+  this->md5_computed_ = md5_receive_str.get();
+  if (strncmp(this->md5_computed_.c_str(), this->md5_expected_.c_str(), MD5_SIZE) != 0) {
+    ESP_LOGE(TAG, "MD5 computed: %s - Aborting due to MD5 mismatch", this->md5_computed_.c_str());
+    this->cleanup_(std::move(backend));
+    return ota::OTA_RESPONSE_ERROR_MD5_MISMATCH;
+  } else {
+    backend->set_update_md5(md5_receive_str.get());
+  }
+
+  this->http_end();
+
+  // feed watchdog and give other tasks a chance to run
+  App.feed_wdt();
+  yield();
+  delay(100);  // NOLINT
+
+  error_code = backend->end();
+  if (error_code != ota::OTA_RESPONSE_OK) {
+    ESP_LOGW(TAG, "Error ending update! error_code: %d", error_code);
+    this->cleanup_(std::move(backend));
+    return error_code;
+  }
+
+  ESP_LOGI(TAG, "Update complete");
+  return ota::OTA_RESPONSE_OK;
+}
+
+std::string OtaHttpRequestComponent::get_url_with_auth_(const std::string &url) {
+  if (this->username_.empty() || this->password_.empty()) {
+    return url;
+  }
+
+  auto start_char = url.find("://");
+  if ((start_char == std::string::npos) || (start_char < 4)) {
+    ESP_LOGE(TAG, "Incorrect URL prefix");
+    return {};
+  }
+
+  ESP_LOGD(TAG, "Using basic HTTP authentication");
+
+  start_char += 3;  // skip '://' characters
+  auto url_with_auth =
+      url.substr(0, start_char) + this->username_ + ":" + this->password_ + "@" + url.substr(start_char);
+  return url_with_auth;
+}
+
+bool OtaHttpRequestComponent::http_get_md5_() {
+  if (this->md5_url_.empty()) {
+    return false;
+  }
+
+  auto url_with_auth = this->get_url_with_auth_(this->md5_url_);
+  if (url_with_auth.empty()) {
+    return false;
+  }
+
+  ESP_LOGVV(TAG, "url_with_auth: %s", url_with_auth.c_str());
+  ESP_LOGI(TAG, "Connecting to: %s", this->md5_url_.c_str());
+  this->http_init(url_with_auth);
+  if (!this->check_status()) {
+    this->http_end();
+    return false;
+  }
+  int length = this->body_length_;
+  if (length < 0) {
+    this->http_end();
+    return false;
+  }
+  if (length < MD5_SIZE) {
+    ESP_LOGE(TAG, "MD5 file must be %u bytes; %u bytes reported by HTTP server. Aborting", MD5_SIZE,
+             this->body_length_);
+    this->http_end();
+    return false;
+  }
+
+  this->bytes_read_ = 0;
+  this->md5_expected_.resize(MD5_SIZE);
+  auto read_len = this->http_read((uint8_t *) this->md5_expected_.data(), MD5_SIZE);
+  this->http_end();
+
+  return read_len == MD5_SIZE;
+}
+
+bool OtaHttpRequestComponent::validate_url_(const std::string &url) {
+  if ((url.length() < 8) || (url.find("http") != 0) || (url.find("://") == std::string::npos)) {
+    ESP_LOGE(TAG, "URL is invalid and/or must be prefixed with 'http://' or 'https://'");
+    return false;
+  }
+  return true;
+}
+
+}  // namespace http_request
+}  // namespace esphome

esphome/components/http_request/ota/ota_http_request.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/components/ota/ota_backend.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace esphome {
+namespace http_request {
+
+static const char *const TAG = "http_request.ota";
+static const uint8_t MD5_SIZE = 32;
+
+enum OtaHttpRequestError : uint8_t {
+  OTA_MD5_INVALID = 0x10,
+  OTA_BAD_URL = 0x11,
+  OTA_CONNECTION_ERROR = 0x12,
+};
+
+class OtaHttpRequestComponent : public ota::OTAComponent {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+
+  void set_md5_url(const std::string &md5_url);
+  void set_md5(const std::string &md5) { this->md5_expected_ = md5; }
+  void set_password(const std::string &password) { this->password_ = password; }
+  void set_timeout(const uint64_t timeout) { this->timeout_ = timeout; }
+  void set_url(const std::string &url);
+  void set_username(const std::string &username) { this->username_ = username; }
+
+  std::string md5_computed() { return this->md5_computed_; }
+  std::string md5_expected() { return this->md5_expected_; }
+
+  bool check_status();
+
+  void flash();
+
+  virtual void http_init(const std::string &url){};
+  virtual int http_read(uint8_t *buf, size_t len) { return 0; };
+  virtual void http_end(){};
+
+ protected:
+  void cleanup_(std::unique_ptr<ota::OTABackend> backend);
+  uint8_t do_ota_();
+  std::string get_url_with_auth_(const std::string &url);
+  bool http_get_md5_();
+  bool secure_() { return this->url_.find("https:") != std::string::npos; };
+  bool validate_url_(const std::string &url);
+
+  std::string md5_computed_{};
+  std::string md5_expected_{};
+  std::string md5_url_{};
+  std::string password_{};
+  std::string username_{};
+  std::string url_{};
+  size_t body_length_ = 0;
+  size_t bytes_read_ = 0;
+  int status_ = -1;
+  uint64_t timeout_ = 0;
+  bool update_started_ = false;
+  const uint16_t http_recv_buffer_ = 256;      // the firmware GET chunk size
+  const uint16_t max_http_recv_buffer_ = 512;  // internal max http buffer size must be > HTTP_RECV_BUFFER_ (TLS
+                                               // overhead) and must be a power of two from 512 to 4096
+};
+
+}  // namespace http_request
+}  // namespace esphome

esphome/components/http_request/ota/ota_http_request_arduino.cpp

@@ -0,0 +1,134 @@
+#include "ota_http_request.h"
+#include "watchdog.h"
+
+#ifdef USE_ARDUINO
+#include "ota_http_request_arduino.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "esphome/components/network/util.h"
+#include "esphome/components/md5/md5.h"
+
+namespace esphome {
+namespace http_request {
+
+struct Header {
+  const char *name;
+  const char *value;
+};
+
+void OtaHttpRequestComponentArduino::http_init(const std::string &url) {
+  const char *header_keys[] = {"Content-Length", "Content-Type"};
+  const size_t header_count = sizeof(header_keys) / sizeof(header_keys[0]);
+  watchdog::WatchdogManager wdts;
+
+#ifdef USE_ESP8266
+  if (this->stream_ptr_ == nullptr && this->set_stream_ptr_()) {
+    ESP_LOGE(TAG, "Unable to set client");
+    return;
+  }
+#endif  // USE_ESP8266
+
+#ifdef USE_RP2040
+  this->client_.setInsecure();
+#endif
+
+  App.feed_wdt();
+
+#if defined(USE_ESP32) || defined(USE_RP2040)
+  this->status_ = this->client_.begin(url.c_str());
+#endif
+#ifdef USE_ESP8266
+  this->client_.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
+  this->status_ = this->client_.begin(*this->stream_ptr_, url.c_str());
+#endif
+
+  if (!this->status_) {
+    this->client_.end();
+    return;
+  }
+
+  this->client_.setReuse(true);
+
+  // returned needed headers must be collected before the requests
+  this->client_.collectHeaders(header_keys, header_count);
+
+  // HTTP GET
+  this->status_ = this->client_.GET();
+
+  this->body_length_ = (size_t) this->client_.getSize();
+
+#if defined(USE_ESP32) || defined(USE_RP2040)
+  if (this->stream_ptr_ == nullptr) {
+    this->set_stream_ptr_();
+  }
+#endif
+}
+
+int OtaHttpRequestComponentArduino::http_read(uint8_t *buf, const size_t max_len) {
+#ifdef USE_ESP8266
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 1, 0)  // && USE_ARDUINO_VERSION_CODE < VERSION_CODE(?, ?, ?)
+  if (!this->secure_()) {
+    ESP_LOGW(TAG, "Using HTTP on Arduino version >= 3.1 is **very** slow. Consider setting framework version to 3.0.2 "
+                  "in your YAML, or use HTTPS");
+  }
+#endif  // USE_ARDUINO_VERSION_CODE
+#endif  // USE_ESP8266
+
+  watchdog::WatchdogManager wdts;
+
+  // Since arduino8266 >= 3.1 using this->stream_ptr_ is broken (https://github.com/esp8266/Arduino/issues/9035)
+  WiFiClient *stream_ptr = this->client_.getStreamPtr();
+  if (stream_ptr == nullptr) {
+    ESP_LOGE(TAG, "Stream pointer vanished!");
+    return -1;
+  }
+
+  int available_data = stream_ptr->available();
+  int bufsize = std::min((int) max_len, available_data);
+  if (bufsize > 0) {
+    stream_ptr->readBytes(buf, bufsize);
+    this->bytes_read_ += bufsize;
+    buf[bufsize] = '\0';  // not fed to ota
+  }
+
+  return bufsize;
+}
+
+void OtaHttpRequestComponentArduino::http_end() {
+  watchdog::WatchdogManager wdts;
+  this->client_.end();
+}
+
+int OtaHttpRequestComponentArduino::set_stream_ptr_() {
+#ifdef USE_ESP8266
+#ifdef USE_HTTP_REQUEST_ESP8266_HTTPS
+  if (this->secure_()) {
+    ESP_LOGV(TAG, "ESP8266 HTTPS connection with WiFiClientSecure");
+    this->stream_ptr_ = std::make_unique<WiFiClientSecure>();
+    WiFiClientSecure *secure_client = static_cast<WiFiClientSecure *>(this->stream_ptr_.get());
+    secure_client->setBufferSizes(this->max_http_recv_buffer_, 512);
+    secure_client->setInsecure();
+  } else {
+    this->stream_ptr_ = std::make_unique<WiFiClient>();
+  }
+#else
+  ESP_LOGV(TAG, "ESP8266 HTTP connection with WiFiClient");
+  if (this->secure_()) {
+    ESP_LOGE(TAG, "Can't use HTTPS connection with esp8266_disable_ssl_support");
+    return -1;
+  }
+  this->stream_ptr_ = std::make_unique<WiFiClient>();
+#endif  // USE_HTTP_REQUEST_ESP8266_HTTPS
+#endif  // USE_ESP8266
+
+#if defined(USE_ESP32) || defined(USE_RP2040)
+  this->stream_ptr_ = std::unique_ptr<WiFiClient>(this->client_.getStreamPtr());
+#endif
+  return 0;
+}
+
+}  // namespace http_request
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/http_request/ota/ota_http_request_arduino.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ota_http_request.h"
+
+#ifdef USE_ARDUINO
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#if defined(USE_ESP32) || defined(USE_RP2040)
+#include <HTTPClient.h>
+#endif
+#ifdef USE_ESP8266
+#include <ESP8266HTTPClient.h>
+#ifdef USE_HTTP_REQUEST_ESP8266_HTTPS
+#include <WiFiClientSecure.h>
+#endif
+#endif
+
+namespace esphome {
+namespace http_request {
+
+class OtaHttpRequestComponentArduino : public OtaHttpRequestComponent {
+ public:
+  void http_init(const std::string &url) override;
+  int http_read(uint8_t *buf, size_t len) override;
+  void http_end() override;
+
+ protected:
+  int set_stream_ptr_();
+  HTTPClient client_{};
+  std::unique_ptr<WiFiClient> stream_ptr_;
+};
+
+}  // namespace http_request
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/http_request/ota/ota_http_request_idf.cpp

@@ -0,0 +1,86 @@
+#include "ota_http_request_idf.h"
+#include "watchdog.h"
+
+#ifdef USE_ESP_IDF
+#include "esphome/core/application.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+#include "esphome/components/md5/md5.h"
+#include "esphome/components/network/util.h"
+
+#include "esp_event.h"
+#include "esp_http_client.h"
+#include "esp_idf_version.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "esp_system.h"
+#include "esp_task_wdt.h"
+#include "esp_tls.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "nvs_flash.h"
+
+#include <cctype>
+#include <cinttypes>
+#include <cstdlib>
+#include <cstring>
+#include <sys/param.h>
+#if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
+#include "esp_crt_bundle.h"
+#endif
+
+namespace esphome {
+namespace http_request {
+
+void OtaHttpRequestComponentIDF::http_init(const std::string &url) {
+  App.feed_wdt();
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+  esp_http_client_config_t config = {nullptr};
+  config.url = url.c_str();
+  config.method = HTTP_METHOD_GET;
+  config.timeout_ms = (int) this->timeout_;
+  config.buffer_size = this->max_http_recv_buffer_;
+  config.auth_type = HTTP_AUTH_TYPE_BASIC;
+  config.max_authorization_retries = -1;
+#if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
+  if (this->secure_()) {
+    config.crt_bundle_attach = esp_crt_bundle_attach;
+  }
+#endif
+#pragma GCC diagnostic pop
+
+  watchdog::WatchdogManager wdts;
+  this->client_ = esp_http_client_init(&config);
+  if ((this->status_ = esp_http_client_open(this->client_, 0)) == ESP_OK) {
+    this->body_length_ = esp_http_client_fetch_headers(this->client_);
+    this->status_ = esp_http_client_get_status_code(this->client_);
+  }
+}
+
+int OtaHttpRequestComponentIDF::http_read(uint8_t *buf, const size_t max_len) {
+  watchdog::WatchdogManager wdts;
+  int bufsize = std::min(max_len, this->body_length_ - this->bytes_read_);
+
+  App.feed_wdt();
+  int read_len = esp_http_client_read(this->client_, (char *) buf, bufsize);
+  if (read_len > 0) {
+    this->bytes_read_ += bufsize;
+    buf[bufsize] = '\0';  // not fed to ota
+  }
+
+  return read_len;
+}
+
+void OtaHttpRequestComponentIDF::http_end() {
+  watchdog::WatchdogManager wdts;
+
+  esp_http_client_close(this->client_);
+  esp_http_client_cleanup(this->client_);
+}
+
+}  // namespace http_request
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/http_request/ota/ota_http_request_idf.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ota_http_request.h"
+
+#ifdef USE_ESP_IDF
+#include "esp_http_client.h"
+
+namespace esphome {
+namespace http_request {
+
+class OtaHttpRequestComponentIDF : public OtaHttpRequestComponent {
+ public:
+  void http_init(const std::string &url) override;
+  int http_read(uint8_t *buf, size_t len) override;
+  void http_end() override;
+
+ protected:
+  esp_http_client_handle_t client_{};
+};
+
+}  // namespace http_request
+}  // namespace esphome
+
+#endif  // USE_ESP_IDF

esphome/components/http_request/ota/watchdog.cpp

@@ -0,0 +1,71 @@
+#include "watchdog.h"
+
+#ifdef USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT
+
+#include "esphome/core/application.h"
+#include "esphome/core/log.h"
+
+#include <cinttypes>
+#include <cstdint>
+#ifdef USE_ESP32
+#include "esp_idf_version.h"
+#include "esp_task_wdt.h"
+#endif
+#ifdef USE_RP2040
+#include "hardware/watchdog.h"
+#include "pico/stdlib.h"
+#endif
+
+namespace esphome {
+namespace http_request {
+namespace watchdog {
+
+static const char *const TAG = "watchdog.http_request.ota";
+
+WatchdogManager::WatchdogManager() {
+  this->saved_timeout_ms_ = this->get_timeout_();
+  this->set_timeout_(USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT);
+}
+
+WatchdogManager::~WatchdogManager() { this->set_timeout_(this->saved_timeout_ms_); }
+
+void WatchdogManager::set_timeout_(uint32_t timeout_ms) {
+  ESP_LOGV(TAG, "Adjusting WDT to %" PRIu32 "ms", timeout_ms);
+#ifdef USE_ESP32
+#if ESP_IDF_VERSION_MAJOR >= 5
+  esp_task_wdt_config_t wdt_config = {
+      .timeout_ms = timeout_ms,
+      .idle_core_mask = 0x03,
+      .trigger_panic = true,
+  };
+  esp_task_wdt_reconfigure(&wdt_config);
+#else
+  esp_task_wdt_init(timeout_ms, true);
+#endif  // ESP_IDF_VERSION_MAJOR
+#endif  // USE_ESP32
+
+#ifdef USE_RP2040
+  watchdog_enable(timeout_ms, true);
+#endif
+}
+
+uint32_t WatchdogManager::get_timeout_() {
+  uint32_t timeout_ms = 0;
+
+#ifdef USE_ESP32
+  timeout_ms = (uint32_t) CONFIG_ESP_TASK_WDT_TIMEOUT_S * 1000;
+#endif  // USE_ESP32
+
+#ifdef USE_RP2040
+  timeout_ms = watchdog_get_count() / 1000;
+#endif
+
+  ESP_LOGVV(TAG, "get_timeout: %" PRIu32 "ms", timeout_ms);
+
+  return timeout_ms;
+}
+
+}  // namespace watchdog
+}  // namespace http_request
+}  // namespace esphome
+#endif

esphome/components/http_request/ota/watchdog.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#include <cstdint>
+
+namespace esphome {
+namespace http_request {
+namespace watchdog {
+
+class WatchdogManager {
+#ifdef USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT
+ public:
+  WatchdogManager();
+  ~WatchdogManager();
+
+ private:
+  uint32_t get_timeout_();
+  void set_timeout_(uint32_t timeout_ms);
+
+  uint32_t saved_timeout_ms_{0};
+#endif
+};
+
+}  // namespace watchdog
+}  // namespace http_request
+}  // namespace esphome

esphome/components/i2s_audio/media_player/i2s_audio_media_player.cpp

@@ -27,6 +27,11 @@ void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
       this->start();
     }
   }
+
+  if (play_state == media_player::MEDIA_PLAYER_STATE_ANNOUNCING) {
+    this->is_announcement_ = true;
+  }
+
   if (call.get_volume().has_value()) {
     this->volume = call.get_volume().value();
     this->set_volume_(volume);
@@ -171,9 +176,8 @@ void I2SAudioMediaPlayer::start_() {
   if (this->current_url_.has_value()) {
     this->audio_->connecttohost(this->current_url_.value().c_str());
     this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
-    if (this->is_announcement_.has_value()) {
-      this->state = this->is_announcement_.value() ? media_player::MEDIA_PLAYER_STATE_ANNOUNCING
-                                                   : media_player::MEDIA_PLAYER_STATE_PLAYING;
+    if (this->is_announcement_) {
+      this->state = media_player::MEDIA_PLAYER_STATE_ANNOUNCING;
     }
     this->publish_state();
   }
@@ -202,6 +206,7 @@ void I2SAudioMediaPlayer::stop_() {
   this->high_freq_.stop();
   this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
   this->publish_state();
+  this->is_announcement_ = false;
 }
 
 media_player::MediaPlayerTraits I2SAudioMediaPlayer::get_traits() {

esphome/components/i2s_audio/media_player/i2s_audio_media_player.h

@@ -78,7 +78,7 @@ class I2SAudioMediaPlayer : public Component, public media_player::MediaPlayer,
   HighFrequencyLoopRequester high_freq_;
 
   optional<std::string> current_url_{};
-  optional<bool> is_announcement_{};
+  bool is_announcement_{false};
 };
 
 }  // namespace i2s_audio

esphome/components/logger/__init__.py

@@ -112,11 +112,18 @@ HARDWARE_UART_TO_UART_SELECTION = {
 }
 
 HARDWARE_UART_TO_SERIAL = {
-    UART0: cg.global_ns.Serial,
-    UART0_SWAP: cg.global_ns.Serial,
-    UART1: cg.global_ns.Serial1,
-    UART2: cg.global_ns.Serial2,
-    DEFAULT: cg.global_ns.Serial,
+    PLATFORM_ESP8266: {
+        UART0: cg.global_ns.Serial,
+        UART0_SWAP: cg.global_ns.Serial,
+        UART1: cg.global_ns.Serial1,
+        UART2: cg.global_ns.Serial2,
+        DEFAULT: cg.global_ns.Serial,
+    },
+    PLATFORM_RP2040: {
+        UART0: cg.global_ns.Serial1,
+        UART1: cg.global_ns.Serial2,
+        USB_CDC: cg.global_ns.Serial,
+    },
 }
 
 is_log_level = cv.one_of(*LOG_LEVELS, upper=True)
@@ -244,8 +251,14 @@ async def to_code(config):
     is_at_least_very_verbose = this_severity >= very_verbose_severity
     has_serial_logging = baud_rate != 0
 
-    if CORE.is_esp8266 and has_serial_logging and is_at_least_verbose:
-        debug_serial_port = HARDWARE_UART_TO_SERIAL[config.get(CONF_HARDWARE_UART)]
+    if (
+        (CORE.is_esp8266 or CORE.is_rp2040)
+        and has_serial_logging
+        and is_at_least_verbose
+    ):
+        debug_serial_port = HARDWARE_UART_TO_SERIAL[CORE.target_platform][
+            config.get(CONF_HARDWARE_UART)
+        ]
         cg.add_build_flag(f"-DDEBUG_ESP_PORT={debug_serial_port}")
         cg.add_build_flag("-DLWIP_DEBUG")
         DEBUG_COMPONENTS = {

esphome/components/web_server/server_index_v3.h

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

esphome/core/defines.h

@@ -33,6 +33,7 @@
 #define USE_GRAPH
 #define USE_GRAPHICAL_DISPLAY_MENU
 #define USE_HOMEASSISTANT_TIME
+#define USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT 8000  // NOLINT
 #define USE_JSON
 #define USE_LIGHT
 #define USE_LOCK
@@ -100,6 +101,14 @@
 #ifdef USE_ESP_IDF
 #define USE_ESP_IDF_VERSION_CODE VERSION_CODE(4, 4, 2)
 #endif
+
+#if defined(USE_ESP32_VARIANT_ESP32S2)
+#define USE_LOGGER_USB_CDC
+#elif defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32C3) || \
+    defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H2)
+#define USE_LOGGER_USB_CDC
+#define USE_LOGGER_USB_SERIAL_JTAG
+#endif
 #endif
 
 // ESP8266-specific feature flags
@@ -122,6 +131,7 @@
 
 #ifdef USE_RP2040
 #define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 3, 0)
+#define USE_LOGGER_USB_CDC
 #define USE_SOCKET_IMPL_LWIP_TCP
 #define USE_SPI
 #endif

esphome/core/time.cpp

@@ -84,6 +84,16 @@ bool ESPTime::strptime(const std::string &time_to_parse, ESPTime &esp_time) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = second;
+  } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+                    &hour,                                                                               // NOLINT
+                    &minute, &num) == 5 &&                                                               // NOLINT
+             num == time_to_parse.size()) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = 0;
   } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
              num == time_to_parse.size()) {
     esp_time.hour = hour;

tests/components/http_request/common_http_request.yaml

@@ -28,10 +28,6 @@ esphome:
           body: "Some data"
           verify_ssl: false
 
-wifi:
-  ssid: MySSID
-  password: password1
-
 http_request:
   useragent: esphome/tagreader
   timeout: 10s

tests/components/http_request/common_ota.yaml

@@ -0,0 +1,36 @@
+wifi:
+  ssid: MySSID
+  password: password1
+
+ota:
+  - platform: http_request
+    verify_ssl: ${verify_ssl}
+    on_begin:
+      then:
+        - logger.log: "OTA start"
+    on_progress:
+      then:
+        - logger.log:
+            format: "OTA progress %0.1f%%"
+            args: ["x"]
+    on_end:
+      then:
+        - logger.log: "OTA end"
+    on_error:
+      then:
+        - logger.log:
+            format: "OTA update error %d"
+            args: ["x"]
+    on_state_change:
+      then:
+        lambda: 'ESP_LOGD("ota", "State %d", state);'
+
+button:
+  - platform: template
+    name: Firmware update
+    on_press:
+      then:
+        - ota_http_request.flash:
+            md5_url: http://my.ha.net:8123/local/esphome/firmware.md5
+            url: http://my.ha.net:8123/local/esphome/firmware.bin
+        - logger.log: "This message should be not displayed (reboot)"

tests/components/http_request/test-nossl.esp8266.yaml

@@ -0,0 +1,38 @@
+<<: !include common_http_request.yaml
+
+wifi:
+  ssid: MySSID
+  password: password1
+
+ota:
+  - platform: http_request
+    esp8266_disable_ssl_support: true
+    on_begin:
+      then:
+        - logger.log: "OTA start"
+    on_progress:
+      then:
+        - logger.log:
+            format: "OTA progress %0.1f%%"
+            args: ["x"]
+    on_end:
+      then:
+        - logger.log: "OTA end"
+    on_error:
+      then:
+        - logger.log:
+            format: "OTA update error %d"
+            args: ["x"]
+    on_state_change:
+      then:
+        lambda: 'ESP_LOGD("ota", "State %d", state);'
+
+button:
+  - platform: template
+    name: Firmware update
+    on_press:
+      then:
+        - ota_http_request.flash:
+            md5_url: http://my.ha.net:8123/local/esphome/firmware.md5
+            url: http://my.ha.net:8123/local/esphome/firmware.bin
+        - logger.log: "This message should be not displayed (reboot)"

tests/components/http_request/test.esp32-c3-idf.yaml

@@ -0,0 +1,4 @@
+substitutions:
+  verify_ssl: "true"
+
+<<: !include common_ota.yaml

tests/components/http_request/test.esp32-c3.yaml

@@ -1,2 +1,5 @@
-packages:
-  common: !include common.yaml
+substitutions:
+  verify_ssl: "false"
+
+<<: !include common_http_request.yaml
+<<: !include common_ota.yaml

tests/components/http_request/test.esp32-idf.yaml

@@ -0,0 +1,4 @@
+substitutions:
+  verify_ssl: "true"
+
+<<: !include common_ota.yaml

tests/components/http_request/test.esp32.yaml

@@ -1,2 +1,5 @@
-packages:
-  common: !include common.yaml
+substitutions:
+  verify_ssl: "false"
+
+<<: !include common_http_request.yaml
+<<: !include common_ota.yaml

tests/components/http_request/test.esp8266.yaml

@@ -1,2 +1,5 @@
-packages:
-  common: !include common.yaml
+substitutions:
+  verify_ssl: "false"
+
+<<: !include common_http_request.yaml
+<<: !include common_ota.yaml

tests/components/http_request/test.rp2040.yaml

@@ -0,0 +1,4 @@
+substitutions:
+  verify_ssl: "false"
+
+<<: !include common_ota.yaml