Upstream
/
esphome
mirror of https://github.com/esphome/esphome.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'i8080' of https://github.com/clydebarrow/esphome into i8080

This commit is contained in:
clydebarrow 2024-05-01 11:35:25 +10:00
parent f8050d1107 d6af7a6e31
commit e9b3073898
113 changed files with 6972 additions and 1166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
esphome/__main__.py
View File

@ -343,9 +343,10 @@ def upload_program(config, args, host):
password = ota_conf.get(CONF_PASSWORD, "")
if (
not is_ip_address(CORE.address)
not is_ip_address(CORE.address) # pylint: disable=too-many-boolean-expressions
and (get_port_type(host) == "MQTT" or config[CONF_MDNS][CONF_DISABLED])
and CONF_MQTT in config
and (not args.device or args.device == "MQTT")
):
from esphome import mqtt
@ -768,7 +769,9 @@ def parse_args(argv):
)
parser_upload = subparsers.add_parser(
"upload", help="Validate the configuration and upload the latest binary."
"upload",
help="Validate the configuration and upload the latest binary.",
parents=[mqtt_options],
)
parser_upload.add_argument(
"configuration", help="Your YAML configuration file(s).", nargs="+"

10
esphome/automation.py
View File

@ -18,10 +18,20 @@ from esphome.util import Registry
def maybe_simple_id(*validators):
"""Allow a raw ID to be specified in place of a config block.
If the value that's being validated is a dictionary, it's passed as-is to the specified validators. Otherwise, it's
wrapped in a dict that looks like ``{"id": <value>}``, and that dict is then handed off to the specified validators.
"""
return maybe_conf(CONF_ID, *validators)
def maybe_conf(conf, *validators):
"""Allow a raw value to be specified in place of a config block.
If the value that's being validated is a dictionary, it's passed as-is to the specified validators. Otherwise, it's
wrapped in a dict that looks like ``{<conf>: <value>}``, and that dict is then handed off to the specified
validators.
(This is a general case of ``maybe_simple_id`` that allows the wrapping key to be something other than ``id``.)
"""
validator = cv.All(*validators)
@schema_extractor("maybe")

8
esphome/components/alpha3/alpha3.cpp
View File

@ -97,9 +97,11 @@ void Alpha3::handle_geni_response_(const uint8_t *response, uint16_t length) {
void Alpha3::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {
switch (event) {
case ESP_GATTC_OPEN_EVT: {
this->response_offset_ = 0;
this->response_length_ = 0;
ESP_LOGI(TAG, "[%s] connection open", this->parent_->address_str().c_str());
if (param->open.status == ESP_GATT_OK) {
this->response_offset_ = 0;
this->response_length_ = 0;
ESP_LOGI(TAG, "[%s] connection open", this->parent_->address_str().c_str());
}
break;
}
case ESP_GATTC_CONNECT_EVT: {

4
esphome/components/am43/sensor/am43_sensor.cpp
View File

@ -26,7 +26,9 @@ void Am43::setup() {
void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {
switch (event) {
case ESP_GATTC_OPEN_EVT: {
this->logged_in_ = false;
if (param->open.status == ESP_GATT_OK) {
this->logged_in_ = false;
}
break;
}
case ESP_GATTC_DISCONNECT_EVT: {

38
esphome/components/api/api.proto
View File

@ -47,6 +47,7 @@ service APIConnection {
rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
rpc date_command (DateCommandRequest) returns (void) {}
rpc time_command (TimeCommandRequest) returns (void) {}
rpc datetime_command (DateTimeCommandRequest) returns (void) {}
rpc subscribe_bluetooth_le_advertisements(SubscribeBluetoothLEAdvertisementsRequest) returns (void) {}
rpc bluetooth_device_request(BluetoothDeviceRequest) returns (void) {}
@ -1777,3 +1778,40 @@ message ValveCommandRequest {
float position = 3;
bool stop = 4;
}
// ==================== DATETIME DATETIME ====================
message ListEntitiesDateTimeResponse {
option (id) = 112;
option (source) = SOURCE_SERVER;
option (ifdef) = "USE_DATETIME_DATETIME";
string object_id = 1;
fixed32 key = 2;
string name = 3;
string unique_id = 4;
string icon = 5;
bool disabled_by_default = 6;
EntityCategory entity_category = 7;
}
message DateTimeStateResponse {
option (id) = 113;
option (source) = SOURCE_SERVER;
option (ifdef) = "USE_DATETIME_DATETIME";
option (no_delay) = true;
fixed32 key = 1;
// If the datetime does not have a valid state yet.
// Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
bool missing_state = 2;
fixed32 epoch_seconds = 3;
}
message DateTimeCommandRequest {
option (id) = 114;
option (source) = SOURCE_CLIENT;
option (ifdef) = "USE_DATETIME_DATETIME";
option (no_delay) = true;
fixed32 key = 1;
fixed32 epoch_seconds = 2;
}

38
esphome/components/api/api_connection.cpp
View File

@ -772,6 +772,44 @@ void APIConnection::time_command(const TimeCommandRequest &msg) {
}
#endif
#ifdef USE_DATETIME_DATETIME
bool APIConnection::send_datetime_state(datetime::DateTimeEntity *datetime) {
if (!this->state_subscription_)
return false;
DateTimeStateResponse resp{};
resp.key = datetime->get_object_id_hash();
resp.missing_state = !datetime->has_state();
if (datetime->has_state()) {
ESPTime state = datetime->state_as_esptime();
resp.epoch_seconds = state.timestamp;
}
return this->send_date_time_state_response(resp);
}
bool APIConnection::send_datetime_info(datetime::DateTimeEntity *datetime) {
ListEntitiesDateTimeResponse msg;
msg.key = datetime->get_object_id_hash();
msg.object_id = datetime->get_object_id();
if (datetime->has_own_name())
msg.name = datetime->get_name();
msg.unique_id = get_default_unique_id("datetime", datetime);
msg.icon = datetime->get_icon();
msg.disabled_by_default = datetime->is_disabled_by_default();
msg.entity_category = static_cast<enums::EntityCategory>(datetime->get_entity_category());
return this->send_list_entities_date_time_response(msg);
}
void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
datetime::DateTimeEntity *datetime = App.get_datetime_by_key(msg.key);
if (datetime == nullptr)
return;
auto call = datetime->make_call();
call.set_datetime(msg.epoch_seconds);
call.perform();
}
#endif
#ifdef USE_TEXT
bool APIConnection::send_text_state(text::Text *text, std::string state) {
if (!this->state_subscription_)

5
esphome/components/api/api_connection.h
View File

@ -82,6 +82,11 @@ class APIConnection : public APIServerConnection {
bool send_time_info(datetime::TimeEntity *time);
void time_command(const TimeCommandRequest &msg) override;
#endif
#ifdef USE_DATETIME_DATETIME
bool send_datetime_state(datetime::DateTimeEntity *datetime);
bool send_datetime_info(datetime::DateTimeEntity *datetime);
void datetime_command(const DateTimeCommandRequest &msg) override;
#endif
#ifdef USE_TEXT
bool send_text_state(text::Text *text, std::string state);
bool send_text_info(text::Text *text);

173
esphome/components/api/api_pb2.cpp
View File

@ -8093,6 +8093,179 @@ void ValveCommandRequest::dump_to(std::string &out) const {
out.append("}");
}
#endif
bool ListEntitiesDateTimeResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
switch (field_id) {
case 6: {
this->disabled_by_default = value.as_bool();
return true;
}
case 7: {
this->entity_category = value.as_enum<enums::EntityCategory>();
return true;
}
default:
return false;
}
}
bool ListEntitiesDateTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
switch (field_id) {
case 1: {
this->object_id = value.as_string();
return true;
}
case 3: {
this->name = value.as_string();
return true;
}
case 4: {
this->unique_id = value.as_string();
return true;
}
case 5: {
this->icon = value.as_string();
return true;
}
default:
return false;
}
}
bool ListEntitiesDateTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
switch (field_id) {
case 2: {
this->key = value.as_fixed32();
return true;
}
default:
return false;
}
}
void ListEntitiesDateTimeResponse::encode(ProtoWriteBuffer buffer) const {
buffer.encode_string(1, this->object_id);
buffer.encode_fixed32(2, this->key);
buffer.encode_string(3, this->name);
buffer.encode_string(4, this->unique_id);
buffer.encode_string(5, this->icon);
buffer.encode_bool(6, this->disabled_by_default);
buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
}
#ifdef HAS_PROTO_MESSAGE_DUMP
void ListEntitiesDateTimeResponse::dump_to(std::string &out) const {
__attribute__((unused)) char buffer[64];
out.append("ListEntitiesDateTimeResponse {\n");
out.append(" object_id: ");
out.append("'").append(this->object_id).append("'");
out.append("\n");
out.append(" key: ");
sprintf(buffer, "%" PRIu32, this->key);
out.append(buffer);
out.append("\n");
out.append(" name: ");
out.append("'").append(this->name).append("'");
out.append("\n");
out.append(" unique_id: ");
out.append("'").append(this->unique_id).append("'");
out.append("\n");
out.append(" icon: ");
out.append("'").append(this->icon).append("'");
out.append("\n");
out.append(" disabled_by_default: ");
out.append(YESNO(this->disabled_by_default));
out.append("\n");
out.append(" entity_category: ");
out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
out.append("\n");
out.append("}");
}
#endif
bool DateTimeStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
switch (field_id) {
case 2: {
this->missing_state = value.as_bool();
return true;
}
default:
return false;
}
}
bool DateTimeStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
switch (field_id) {
case 1: {
this->key = value.as_fixed32();
return true;
}
case 3: {
this->epoch_seconds = value.as_fixed32();
return true;
}
default:
return false;
}
}
void DateTimeStateResponse::encode(ProtoWriteBuffer buffer) const {
buffer.encode_fixed32(1, this->key);
buffer.encode_bool(2, this->missing_state);
buffer.encode_fixed32(3, this->epoch_seconds);
}
#ifdef HAS_PROTO_MESSAGE_DUMP
void DateTimeStateResponse::dump_to(std::string &out) const {
__attribute__((unused)) char buffer[64];
out.append("DateTimeStateResponse {\n");
out.append(" key: ");
sprintf(buffer, "%" PRIu32, this->key);
out.append(buffer);
out.append("\n");
out.append(" missing_state: ");
out.append(YESNO(this->missing_state));
out.append("\n");
out.append(" epoch_seconds: ");
sprintf(buffer, "%" PRIu32, this->epoch_seconds);
out.append(buffer);
out.append("\n");
out.append("}");
}
#endif
bool DateTimeCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
switch (field_id) {
case 1: {
this->key = value.as_fixed32();
return true;
}
case 2: {
this->epoch_seconds = value.as_fixed32();
return true;
}
default:
return false;
}
}
void DateTimeCommandRequest::encode(ProtoWriteBuffer buffer) const {
buffer.encode_fixed32(1, this->key);
buffer.encode_fixed32(2, this->epoch_seconds);
}
#ifdef HAS_PROTO_MESSAGE_DUMP
void DateTimeCommandRequest::dump_to(std::string &out) const {
__attribute__((unused)) char buffer[64];
out.append("DateTimeCommandRequest {\n");
out.append(" key: ");
sprintf(buffer, "%" PRIu32, this->key);
out.append(buffer);
out.append("\n");
out.append(" epoch_seconds: ");
sprintf(buffer, "%" PRIu32, this->epoch_seconds);
out.append(buffer);
out.append("\n");
out.append("}");
}
#endif
} // namespace api
} // namespace esphome

45
esphome/components/api/api_pb2.h
View File

@ -2060,6 +2060,51 @@ class ValveCommandRequest : public ProtoMessage {
bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
};
class ListEntitiesDateTimeResponse : public ProtoMessage {
public:
std::string object_id{};
uint32_t key{0};
std::string name{};
std::string unique_id{};
std::string icon{};
bool disabled_by_default{false};
enums::EntityCategory entity_category{};
void encode(ProtoWriteBuffer buffer) const override;
#ifdef HAS_PROTO_MESSAGE_DUMP
void dump_to(std::string &out) const override;
#endif
protected:
bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
};
class DateTimeStateResponse : public ProtoMessage {
public:
uint32_t key{0};
bool missing_state{false};
uint32_t epoch_seconds{0};
void encode(ProtoWriteBuffer buffer) const override;
#ifdef HAS_PROTO_MESSAGE_DUMP
void dump_to(std::string &out) const override;
#endif
protected:
bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
};
class DateTimeCommandRequest : public ProtoMessage {
public:
uint32_t key{0};
uint32_t epoch_seconds{0};
void encode(ProtoWriteBuffer buffer) const override;
#ifdef HAS_PROTO_MESSAGE_DUMP
void dump_to(std::string &out) const override;
#endif
protected:
bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
};
} // namespace api
} // namespace esphome

42
esphome/components/api/api_pb2_service.cpp
View File

@ -591,6 +591,24 @@ bool APIServerConnectionBase::send_valve_state_response(const ValveStateResponse
#endif
#ifdef USE_VALVE
#endif
#ifdef USE_DATETIME_DATETIME
bool APIServerConnectionBase::send_list_entities_date_time_response(const ListEntitiesDateTimeResponse &msg) {
#ifdef HAS_PROTO_MESSAGE_DUMP
ESP_LOGVV(TAG, "send_list_entities_date_time_response: %s", msg.dump().c_str());
#endif
return this->send_message_<ListEntitiesDateTimeResponse>(msg, 112);
}
#endif
#ifdef USE_DATETIME_DATETIME
bool APIServerConnectionBase::send_date_time_state_response(const DateTimeStateResponse &msg) {
#ifdef HAS_PROTO_MESSAGE_DUMP
ESP_LOGVV(TAG, "send_date_time_state_response: %s", msg.dump().c_str());
#endif
return this->send_message_<DateTimeStateResponse>(msg, 113);
}
#endif
#ifdef USE_DATETIME_DATETIME
#endif
bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
switch (msg_type) {
case 1: {
@ -1064,6 +1082,17 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
ESP_LOGVV(TAG, "on_valve_command_request: %s", msg.dump().c_str());
#endif
this->on_valve_command_request(msg);
#endif
break;
}
case 114: {
#ifdef USE_DATETIME_DATETIME
DateTimeCommandRequest msg;
msg.decode(msg_data, msg_size);
#ifdef HAS_PROTO_MESSAGE_DUMP
ESP_LOGVV(TAG, "on_date_time_command_request: %s", msg.dump().c_str());
#endif
this->on_date_time_command_request(msg);
#endif
break;
}
@ -1379,6 +1408,19 @@ void APIServerConnection::on_time_command_request(const TimeCommandRequest &msg)
this->time_command(msg);
}
#endif
#ifdef USE_DATETIME_DATETIME
void APIServerConnection::on_date_time_command_request(const DateTimeCommandRequest &msg) {
if (!this->is_connection_setup()) {
this->on_no_setup_connection();
return;
}
if (!this->is_authenticated()) {
this->on_unauthenticated_access();
return;
}
this->datetime_command(msg);
}
#endif
#ifdef USE_BLUETOOTH_PROXY
void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
const SubscribeBluetoothLEAdvertisementsRequest &msg) {

15
esphome/components/api/api_pb2_service.h
View File

@ -294,6 +294,15 @@ class APIServerConnectionBase : public ProtoService {
#endif
#ifdef USE_VALVE
virtual void on_valve_command_request(const ValveCommandRequest &value){};
#endif
#ifdef USE_DATETIME_DATETIME
bool send_list_entities_date_time_response(const ListEntitiesDateTimeResponse &msg);
#endif
#ifdef USE_DATETIME_DATETIME
bool send_date_time_state_response(const DateTimeStateResponse &msg);
#endif
#ifdef USE_DATETIME_DATETIME
virtual void on_date_time_command_request(const DateTimeCommandRequest &value){};
#endif
protected:
bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@ -358,6 +367,9 @@ class APIServerConnection : public APIServerConnectionBase {
#ifdef USE_DATETIME_TIME
virtual void time_command(const TimeCommandRequest &msg) = 0;
#endif
#ifdef USE_DATETIME_DATETIME
virtual void datetime_command(const DateTimeCommandRequest &msg) = 0;
#endif
#ifdef USE_BLUETOOTH_PROXY
virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
#endif
@ -453,6 +465,9 @@ class APIServerConnection : public APIServerConnectionBase {
#ifdef USE_DATETIME_TIME
void on_time_command_request(const TimeCommandRequest &msg) override;
#endif
#ifdef USE_DATETIME_DATETIME
void on_date_time_command_request(const DateTimeCommandRequest &msg) override;
#endif
#ifdef USE_BLUETOOTH_PROXY
void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
#endif

9
esphome/components/api/api_server.cpp
View File

@ -273,6 +273,15 @@ void APIServer::on_time_update(datetime::TimeEntity *obj) {
}
#endif
#ifdef USE_DATETIME_DATETIME
void APIServer::on_datetime_update(datetime::DateTimeEntity *obj) {
if (obj->is_internal())
return;
for (auto &c : this->clients_)
c->send_datetime_state(obj);
}
#endif
#ifdef USE_TEXT
void APIServer::on_text_update(text::Text *obj, const std::string &state) {
if (obj->is_internal())

3
esphome/components/api/api_server.h
View File

@ -72,6 +72,9 @@ class APIServer : public Component, public Controller {
#ifdef USE_DATETIME_TIME
void on_time_update(datetime::TimeEntity *obj) override;
#endif
#ifdef USE_DATETIME_DATETIME
void on_datetime_update(datetime::DateTimeEntity *obj) override;
#endif
#ifdef USE_TEXT
void on_text_update(text::Text *obj, const std::string &state) override;
#endif

6
esphome/components/api/list_entities.cpp
View File

@ -71,6 +71,12 @@ bool ListEntitiesIterator::on_date(datetime::DateEntity *date) { return this->cl
bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) { return this->client_->send_time_info(time); }
#endif
#ifdef USE_DATETIME_DATETIME
bool ListEntitiesIterator::on_datetime(datetime::DateTimeEntity *datetime) {
return this->client_->send_datetime_info(datetime);
}
#endif
#ifdef USE_TEXT
bool ListEntitiesIterator::on_text(text::Text *text) { return this->client_->send_text_info(text); }
#endif

3
esphome/components/api/list_entities.h
View File

@ -52,6 +52,9 @@ class ListEntitiesIterator : public ComponentIterator {
#ifdef USE_DATETIME_TIME
bool on_time(datetime::TimeEntity *time) override;
#endif
#ifdef USE_DATETIME_DATETIME
bool on_datetime(datetime::DateTimeEntity *datetime) override;
#endif
#ifdef USE_TEXT
bool on_text(text::Text *text) override;
#endif

5
esphome/components/api/subscribe_state.cpp
View File

@ -48,6 +48,11 @@ bool InitialStateIterator::on_date(datetime::DateEntity *date) { return this->cl
#ifdef USE_DATETIME_TIME
bool InitialStateIterator::on_time(datetime::TimeEntity *time) { return this->client_->send_time_state(time); }
#endif
#ifdef USE_DATETIME_DATETIME
bool InitialStateIterator::on_datetime(datetime::DateTimeEntity *datetime) {
return this->client_->send_datetime_state(datetime);
}
#endif
#ifdef USE_TEXT
bool InitialStateIterator::on_text(text::Text *text) { return this->client_->send_text_state(text, text->state); }
#endif

3
esphome/components/api/subscribe_state.h
View File

@ -49,6 +49,9 @@ class InitialStateIterator : public ComponentIterator {
#ifdef USE_DATETIME_TIME
bool on_time(datetime::TimeEntity *time) override;
#endif
#ifdef USE_DATETIME_DATETIME
bool on_datetime(datetime::DateTimeEntity *datetime) override;
#endif
#ifdef USE_TEXT
bool on_text(text::Text *text) override;
#endif

6
esphome/components/binary_sensor/automation.cpp
View File

@ -51,15 +51,15 @@ void binary_sensor::MultiClickTrigger::on_state_(bool state) {
MultiClickTriggerEvent evt = this->timing_[*this->at_index_];
if (evt.max_length != 4294967294UL) {
ESP_LOGV(TAG, "A i=%u min=%" PRIu32 " max=%" PRIu32, *this->at_index_, evt.min_length, evt.max_length); // NOLINT
ESP_LOGV(TAG, "A i=%zu min=%" PRIu32 " max=%" PRIu32, *this->at_index_, evt.min_length, evt.max_length); // NOLINT
this->schedule_is_valid_(evt.min_length);
this->schedule_is_not_valid_(evt.max_length);
} else if (*this->at_index_ + 1 != this->timing_.size()) {
ESP_LOGV(TAG, "B i=%u min=%" PRIu32, *this->at_index_, evt.min_length); // NOLINT
ESP_LOGV(TAG, "B i=%zu min=%" PRIu32, *this->at_index_, evt.min_length); // NOLINT
this->cancel_timeout("is_not_valid");
this->schedule_is_valid_(evt.min_length);
} else {
ESP_LOGV(TAG, "C i=%u min=%" PRIu32, *this->at_index_, evt.min_length); // NOLINT
ESP_LOGV(TAG, "C i=%zu min=%" PRIu32, *this->at_index_, evt.min_length); // NOLINT
this->is_valid_ = false;
this->cancel_timeout("is_not_valid");
this->set_timeout("trigger", evt.min_length, [this]() { this->trigger_(); });

33
esphome/components/bluetooth_proxy/bluetooth_connection.cpp
View File

@ -25,9 +25,13 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
this->proxy_->send_connections_free();
break;
}
case ESP_GATTC_CLOSE_EVT: {
this->proxy_->send_device_connection(this->address_, false, 0, param->close.reason);
this->set_address(0);
this->proxy_->send_connections_free();
break;
}
case ESP_GATTC_OPEN_EVT: {
if (param->open.conn_id != this->conn_id_)
break;
if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
this->proxy_->send_device_connection(this->address_, false, 0, param->open.status);
this->set_address(0);
@ -39,9 +43,8 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
this->seen_mtu_or_services_ = false;
break;
}
case ESP_GATTC_CFG_MTU_EVT: {
if (param->cfg_mtu.conn_id != this->conn_id_)
break;
case ESP_GATTC_CFG_MTU_EVT:
case ESP_GATTC_SEARCH_CMPL_EVT: {
if (!this->seen_mtu_or_services_) {
// We don't know if we will get the MTU or the services first, so
// only send the device connection true if we have already received
@ -53,24 +56,8 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
this->proxy_->send_connections_free();
break;
}
case ESP_GATTC_SEARCH_CMPL_EVT: {
if (param->search_cmpl.conn_id != this->conn_id_)
break;
if (!this->seen_mtu_or_services_) {
// We don't know if we will get the MTU or the services first, so
// only send the device connection true if we have already received
// the mtu.
this->seen_mtu_or_services_ = true;
break;
}
this->proxy_->send_device_connection(this->address_, true, this->mtu_);
this->proxy_->send_connections_free();
break;
}
case ESP_GATTC_READ_DESCR_EVT:
case ESP_GATTC_READ_CHAR_EVT: {
if (param->read.conn_id != this->conn_id_)
break;
if (param->read.status != ESP_GATT_OK) {
ESP_LOGW(TAG, "[%d] [%s] Error reading char/descriptor at handle 0x%2X, status=%d", this->connection_index_,
this->address_str_.c_str(), param->read.handle, param->read.status);
@ -89,8 +76,6 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
}
case ESP_GATTC_WRITE_CHAR_EVT:
case ESP_GATTC_WRITE_DESCR_EVT: {
if (param->write.conn_id != this->conn_id_)
break;
if (param->write.status != ESP_GATT_OK) {
ESP_LOGW(TAG, "[%d] [%s] Error writing char/descriptor at handle 0x%2X, status=%d", this->connection_index_,
this->address_str_.c_str(), param->write.handle, param->write.status);
@ -131,8 +116,6 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
break;
}
case ESP_GATTC_NOTIFY_EVT: {
if (param->notify.conn_id != this->conn_id_)
break;
ESP_LOGV(TAG, "[%d] [%s] ESP_GATTC_NOTIFY_EVT: handle=0x%2X", this->connection_index_, this->address_str_.c_str(),
param->notify.handle);
api::BluetoothGATTNotifyDataResponse resp;

196
esphome/components/captive_portal/captive_index.h
View File

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

1
esphome/components/daly_bms/__init__.py
View File

@ -4,6 +4,7 @@ from esphome.components import uart
from esphome.const import CONF_ID, CONF_ADDRESS
CODEOWNERS = ["@s1lvi0"]
MULTI_CONF = True
DEPENDENCIES = ["uart"]
CONF_BMS_DALY_ID = "bms_daly_id"

129
esphome/components/datetime/__init__.py
View File

@ -1,6 +1,5 @@
import esphome.codegen as cg
# import cpp_generator as cpp
import esphome.config_validation as cv
from esphome import automation
from esphome.components import mqtt, time
@ -13,6 +12,7 @@ from esphome.const import (
CONF_TYPE,
CONF_MQTT_ID,
CONF_DATE,
CONF_DATETIME,
CONF_TIME,
CONF_YEAR,
CONF_MONTH,
@ -27,6 +27,7 @@ from esphome.cpp_helpers import setup_entity
CODEOWNERS = ["@rfdarter", "@jesserockz"]
DEPENDENCIES = ["time"]
IS_PLATFORM_COMPONENT = True
@ -34,10 +35,12 @@ datetime_ns = cg.esphome_ns.namespace("datetime")
DateTimeBase = datetime_ns.class_("DateTimeBase", cg.EntityBase)
DateEntity = datetime_ns.class_("DateEntity", DateTimeBase)
TimeEntity = datetime_ns.class_("TimeEntity", DateTimeBase)
DateTimeEntity = datetime_ns.class_("DateTimeEntity", DateTimeBase)
# Actions
DateSetAction = datetime_ns.class_("DateSetAction", automation.Action)
TimeSetAction = datetime_ns.class_("TimeSetAction", automation.Action)
DateTimeSetAction = datetime_ns.class_("DateTimeSetAction", automation.Action)
DateTimeStateTrigger = datetime_ns.class_(
"DateTimeStateTrigger", automation.Trigger.template(cg.ESPTime)
@ -46,6 +49,12 @@ DateTimeStateTrigger = datetime_ns.class_(
OnTimeTrigger = datetime_ns.class_(
"OnTimeTrigger", automation.Trigger, cg.Component, cg.Parented.template(TimeEntity)
)
OnDateTimeTrigger = datetime_ns.class_(
"OnDateTimeTrigger",
automation.Trigger,
cg.Component,
cg.Parented.template(DateTimeEntity),
)
DATETIME_MODES = [
"DATE",
@ -61,45 +70,55 @@ _DATETIME_SCHEMA = cv.Schema(
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DateTimeStateTrigger),
}
),
cv.GenerateID(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
}
).extend(cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA))
def date_schema(class_: MockObjClass) -> cv.Schema:
schema = {
cv.GenerateID(): cv.declare_id(class_),
cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTDateComponent),
cv.Optional(CONF_TYPE, default="DATE"): cv.one_of("DATE", upper=True),
}
schema = cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTDateComponent),
cv.Optional(CONF_TYPE, default="DATE"): cv.one_of("DATE", upper=True),
}
)
return _DATETIME_SCHEMA.extend(schema)
def time_schema(class_: MockObjClass) -> cv.Schema:
schema = {
cv.GenerateID(): cv.declare_id(class_),
cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTTimeComponent),
cv.Optional(CONF_TYPE, default="TIME"): cv.one_of("TIME", upper=True),
cv.Inclusive(
CONF_ON_TIME,
group_of_inclusion=CONF_ON_TIME,
msg="`on_time` and `time_id` must both be specified",
): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnTimeTrigger),
}
),
cv.Inclusive(CONF_TIME_ID, group_of_inclusion=CONF_ON_TIME): cv.use_id(
time.RealTimeClock
),
}
schema = cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTTimeComponent),
cv.Optional(CONF_TYPE, default="TIME"): cv.one_of("TIME", upper=True),
cv.Optional(CONF_ON_TIME): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnTimeTrigger),
}
),
}
)
return _DATETIME_SCHEMA.extend(schema)
def datetime_schema(class_: MockObjClass) -> cv.Schema:
schema = {
cv.GenerateID(): cv.declare_id(class_),
cv.Optional(CONF_TYPE, default="DATETIME"): cv.one_of("DATETIME", upper=True),
}
schema = cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
mqtt.MQTTDateTimeComponent
),
cv.Optional(CONF_TYPE, default="DATETIME"): cv.one_of(
"DATETIME", upper=True
),
cv.Optional(CONF_ON_TIME): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnDateTimeTrigger),
}
),
}
)
return _DATETIME_SCHEMA.extend(schema)
@ -113,13 +132,11 @@ async def setup_datetime_core_(var, config):
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
await automation.build_automation(trigger, [(cg.ESPTime, "x")], conf)
rtc_id = config.get(CONF_TIME_ID)
rtc = None
if rtc_id is not None:
rtc = await cg.get_variable(rtc_id)
rtc = await cg.get_variable(config[CONF_TIME_ID])
cg.add(var.set_rtc(rtc))
for conf in config.get(CONF_ON_TIME, []):
assert rtc is not None
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], rtc)
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
await automation.build_automation(trigger, [], conf)
await cg.register_component(trigger, conf)
await cg.register_parented(trigger, var)
@ -161,16 +178,16 @@ async def datetime_date_set_to_code(config, action_id, template_arg, args):
action_var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(action_var, config[CONF_ID])
date = config[CONF_DATE]
if cg.is_template(date):
template_ = await cg.templatable(config[CONF_DATE], [], cg.ESPTime)
date_config = config[CONF_DATE]
if cg.is_template(date_config):
template_ = await cg.templatable(date_config, [], cg.ESPTime)
cg.add(action_var.set_date(template_))
else:
date_struct = cg.StructInitializer(
cg.ESPTime,
("day_of_month", date[CONF_DAY]),
("month", date[CONF_MONTH]),
("year", date[CONF_YEAR]),
("day_of_month", date_config[CONF_DAY]),
("month", date_config[CONF_MONTH]),
("year", date_config[CONF_YEAR]),
)
cg.add(action_var.set_date(date_struct))
return action_var
@ -194,7 +211,7 @@ async def datetime_time_set_to_code(config, action_id, template_arg, args):
time_config = config[CONF_TIME]
if cg.is_template(time_config):
template_ = await cg.templatable(config[CONF_TIME], [], cg.ESPTime)
template_ = await cg.templatable(time_config, [], cg.ESPTime)
cg.add(action_var.set_time(template_))
else:
time_struct = cg.StructInitializer(
@ -205,3 +222,35 @@ async def datetime_time_set_to_code(config, action_id, template_arg, args):
)
cg.add(action_var.set_time(time_struct))
return action_var
@automation.register_action(
"datetime.datetime.set",
DateTimeSetAction,
cv.Schema(
{
cv.Required(CONF_ID): cv.use_id(DateTimeEntity),
cv.Required(CONF_DATETIME): cv.Any(cv.returning_lambda, cv.date_time()),
},
),
)
async def datetime_datetime_set_to_code(config, action_id, template_arg, args):
action_var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(action_var, config[CONF_ID])
datetime_config = config[CONF_DATETIME]
if cg.is_template(datetime_config):
template_ = await cg.templatable(datetime_config, [], cg.ESPTime)
cg.add(action_var.set_datetime(template_))
else:
datetime_struct = cg.StructInitializer(
cg.ESPTime,
("second", datetime_config[CONF_SECOND]),
("minute", datetime_config[CONF_MINUTE]),
("hour", datetime_config[CONF_HOUR]),
("day_of_month", datetime_config[CONF_DAY]),
("month", datetime_config[CONF_MONTH]),
("year", datetime_config[CONF_YEAR]),
)
cg.add(action_var.set_datetime(datetime_struct))
return action_var

3
esphome/components/datetime/date_entity.cpp
View File

@ -40,10 +40,13 @@ void DateCall::validate_() {
if (this->year_.has_value() && (this->year_ < 1970 || this->year_ > 3000)) {
ESP_LOGE(TAG, "Year must be between 1970 and 3000");
this->year_.reset();
this->month_.reset();
this->day_.reset();
}
if (this->month_.has_value() && (this->month_ < 1 || this->month_ > 12)) {
ESP_LOGE(TAG, "Month must be between 1 and 12");
this->month_.reset();
this->day_.reset();
}
if (this->day_.has_value()) {
uint16_t year = 0;

7
esphome/components/datetime/datetime_base.h
View File

@ -5,6 +5,8 @@
#include "esphome/core/entity_base.h"
#include "esphome/core/time.h"
#include "esphome/components/time/real_time_clock.h"
namespace esphome {
namespace datetime {
@ -17,9 +19,14 @@ class DateTimeBase : public EntityBase {
void add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }
void set_rtc(time::RealTimeClock *rtc) { this->rtc_ = rtc; }
time::RealTimeClock *get_rtc() const { return this->rtc_; }
protected:
CallbackManager<void()> state_callback_;
time::RealTimeClock *rtc_;
bool has_state_{false};
};

252
esphome/components/datetime/datetime_entity.cpp Normal file
View File

@ -0,0 +1,252 @@
#include "datetime_entity.h"
#ifdef USE_DATETIME_DATETIME
#include "esphome/core/log.h"
namespace esphome {
namespace datetime {
static const char *const TAG = "datetime.datetime_entity";
void DateTimeEntity::publish_state() {
if (this->year_ == 0 || this->month_ == 0 || this->day_ == 0) {
this->has_state_ = false;
return;
}
if (this->year_ < 1970 || this->year_ > 3000) {
this->has_state_ = false;
ESP_LOGE(TAG, "Year must be between 1970 and 3000");
return;
}
if (this->month_ < 1 || this->month_ > 12) {
this->has_state_ = false;
ESP_LOGE(TAG, "Month must be between 1 and 12");
return;
}
if (this->day_ > days_in_month(this->month_, this->year_)) {
this->has_state_ = false;
ESP_LOGE(TAG, "Day must be between 1 and %d for month %d", days_in_month(this->month_, this->year_), this->month_);
return;
}
if (this->hour_ > 23) {
this->has_state_ = false;
ESP_LOGE(TAG, "Hour must be between 0 and 23");
return;
}
if (this->minute_ > 59) {
this->has_state_ = false;
ESP_LOGE(TAG, "Minute must be between 0 and 59");
return;
}
if (this->second_ > 59) {
this->has_state_ = false;
ESP_LOGE(TAG, "Second must be between 0 and 59");
return;
}
this->has_state_ = true;
ESP_LOGD(TAG, "'%s': Sending datetime %04u-%02u-%02u %02d:%02d:%02d", this->get_name().c_str(), this->year_,
this->month_, this->day_, this->hour_, this->minute_, this->second_);
this->state_callback_.call();
}
DateTimeCall DateTimeEntity::make_call() { return DateTimeCall(this); }
ESPTime DateTimeEntity::state_as_esptime() const {
ESPTime obj;
obj.year = this->year_;
obj.month = this->month_;
obj.day_of_month = this->day_;
obj.hour = this->hour_;
obj.minute = this->minute_;
obj.second = this->second_;
obj.day_of_week = 1; // Required to be valid for recalc_timestamp_local but not used.
obj.day_of_year = 1; // Required to be valid for recalc_timestamp_local but not used.
obj.recalc_timestamp_local(false);
return obj;
}
void DateTimeCall::validate_() {
if (this->year_.has_value() && (this->year_ < 1970 || this->year_ > 3000)) {
ESP_LOGE(TAG, "Year must be between 1970 and 3000");
this->year_.reset();
this->month_.reset();
this->day_.reset();
}
if (this->month_.has_value() && (this->month_ < 1 || this->month_ > 12)) {
ESP_LOGE(TAG, "Month must be between 1 and 12");
this->month_.reset();
this->day_.reset();
}
if (this->day_.has_value()) {
uint16_t year = 0;
uint8_t month = 0;
if (this->month_.has_value()) {
month = *this->month_;
} else {
if (this->parent_->month != 0) {
month = this->parent_->month;
} else {
ESP_LOGE(TAG, "Month must be set to validate day");
this->day_.reset();
}
}
if (this->year_.has_value()) {
year = *this->year_;
} else {
if (this->parent_->year != 0) {
year = this->parent_->year;
} else {
ESP_LOGE(TAG, "Year must be set to validate day");
this->day_.reset();
}
}
if (this->day_.has_value() && *this->day_ > days_in_month(month, year)) {
ESP_LOGE(TAG, "Day must be between 1 and %d for month %d", days_in_month(month, year), month);
this->day_.reset();
}
}
if (this->hour_.has_value() && this->hour_ > 23) {
ESP_LOGE(TAG, "Hour must be between 0 and 23");
this->hour_.reset();
}
if (this->minute_.has_value() && this->minute_ > 59) {
ESP_LOGE(TAG, "Minute must be between 0 and 59");
this->minute_.reset();
}
if (this->second_.has_value() && this->second_ > 59) {
ESP_LOGE(TAG, "Second must be between 0 and 59");
this->second_.reset();
}
}
void DateTimeCall::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_);
}
if (this->hour_.has_value()) {
ESP_LOGD(TAG, " Hour: %d", *this->hour_);
}
if (this->minute_.has_value()) {
ESP_LOGD(TAG, " Minute: %d", *this->minute_);
}
if (this->second_.has_value()) {
ESP_LOGD(TAG, " Second: %d", *this->second_);
}
this->parent_->control(*this);
}
DateTimeCall &DateTimeCall::set_datetime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
uint8_t second) {
this->year_ = year;
this->month_ = month;
this->day_ = day;
this->hour_ = hour;
this->minute_ = minute;
this->second_ = second;
return *this;
};
DateTimeCall &DateTimeCall::set_datetime(ESPTime datetime) {
return this->set_datetime(datetime.year, datetime.month, datetime.day_of_month, datetime.hour, datetime.minute,
datetime.second);
};
DateTimeCall &DateTimeCall::set_datetime(const std::string &datetime) {
ESPTime val{};
if (!ESPTime::strptime(datetime, val)) {
ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
return *this;
}
return this->set_datetime(val);
}
DateTimeCall &DateTimeCall::set_datetime(time_t epoch_seconds) {
ESPTime val = ESPTime::from_epoch_local(epoch_seconds);
return this->set_datetime(val);
}
DateTimeCall DateTimeEntityRestoreState::to_call(DateTimeEntity *datetime) {
DateTimeCall call = datetime->make_call();
call.set_datetime(this->year, this->month, this->day, this->hour, this->minute, this->second);
return call;
}
void DateTimeEntityRestoreState::apply(DateTimeEntity *time) {
time->year_ = this->year;
time->month_ = this->month;
time->day_ = this->day;
time->hour_ = this->hour;
time->minute_ = this->minute;
time->second_ = this->second;
time->publish_state();
}
static const int MAX_TIMESTAMP_DRIFT = 900; // how far can the clock drift before we consider
// there has been a drastic time synchronization
void OnDateTimeTrigger::loop() {
if (!this->parent_->has_state()) {
return;
}
ESPTime time = this->parent_->rtc_->now();
if (!time.is_valid()) {
return;
}
if (this->last_check_.has_value()) {
if (*this->last_check_ > time && this->last_check_->timestamp - time.timestamp > MAX_TIMESTAMP_DRIFT) {
// We went back in time (a lot), probably caused by time synchronization
ESP_LOGW(TAG, "Time has jumped back!");
} else if (*this->last_check_ >= time) {
// already handled this one
return;
} else if (time > *this->last_check_ && time.timestamp - this->last_check_->timestamp > MAX_TIMESTAMP_DRIFT) {
// We went ahead in time (a lot), probably caused by time synchronization
ESP_LOGW(TAG, "Time has jumped ahead!");
this->last_check_ = time;
return;
}
while (true) {
this->last_check_->increment_second();
if (*this->last_check_ >= time)
break;
if (this->matches_(*this->last_check_)) {
this->trigger();
break;
}
}
}
this->last_check_ = time;
if (!time.fields_in_range()) {
ESP_LOGW(TAG, "Time is out of range!");
ESP_LOGD(TAG, "Second=%02u Minute=%02u Hour=%02u Day=%02u Month=%02u Year=%04u", time.second, time.minute,
time.hour, time.day_of_month, time.month, time.year);
}
if (this->matches_(time))
this->trigger();
}
bool OnDateTimeTrigger::matches_(const ESPTime &time) const {
return time.is_valid() && time.year == this->parent_->year && time.month == this->parent_->month &&
time.day_of_month == this->parent_->day && time.hour == this->parent_->hour &&
time.minute == this->parent_->minute && time.second == this->parent_->second;
}
} // namespace datetime
} // namespace esphome
#endif // USE_DATETIME_TIME

150
esphome/components/datetime/datetime_entity.h Normal file
View File

@ -0,0 +1,150 @@
#pragma once
#include "esphome/core/defines.h"
#ifdef USE_DATETIME_DATETIME
#include "esphome/core/automation.h"
#include "esphome/core/helpers.h"
#include "esphome/core/time.h"
#include "datetime_base.h"
namespace esphome {
namespace datetime {
#define LOG_DATETIME_DATETIME(prefix, type, obj) \
if ((obj) != nullptr) { \
ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
if (!(obj)->get_icon().empty()) { \
ESP_LOGCONFIG(TAG, "%s Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
} \
}
class DateTimeCall;
class DateTimeEntity;
struct DateTimeEntityRestoreState {
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
DateTimeCall to_call(DateTimeEntity *datetime);
void apply(DateTimeEntity *datetime);
} __attribute__((packed));
class DateTimeEntity : public DateTimeBase {
protected:
uint16_t year_;
uint8_t month_;
uint8_t day_;
uint8_t hour_;
uint8_t minute_;
uint8_t second_;
public:
void publish_state();
DateTimeCall make_call();
ESPTime state_as_esptime() const override;
const uint16_t &year = year_;
const uint8_t &month = month_;
const uint8_t &day = day_;
const uint8_t &hour = hour_;
const uint8_t &minute = minute_;
const uint8_t &second = second_;
protected:
friend class DateTimeCall;
friend struct DateTimeEntityRestoreState;
friend class OnDateTimeTrigger;
virtual void control(const DateTimeCall &call) = 0;
};
class DateTimeCall {
public:
explicit DateTimeCall(DateTimeEntity *parent) : parent_(parent) {}
void perform();
DateTimeCall &set_datetime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
DateTimeCall &set_datetime(ESPTime datetime);
DateTimeCall &set_datetime(const std::string &datetime);
DateTimeCall &set_datetime(time_t epoch_seconds);
DateTimeCall &set_year(uint16_t year) {
this->year_ = year;
return *this;
}
DateTimeCall &set_month(uint8_t month) {
this->month_ = month;
return *this;
}
DateTimeCall &set_day(uint8_t day) {
this->day_ = day;
return *this;
}
DateTimeCall &set_hour(uint8_t hour) {
this->hour_ = hour;
return *this;
}
DateTimeCall &set_minute(uint8_t minute) {
this->minute_ = minute;
return *this;
}
DateTimeCall &set_second(uint8_t second) {
this->second_ = second;
return *this;
}
optional<uint16_t> get_year() const { return this->year_; }
optional<uint8_t> get_month() const { return this->month_; }
optional<uint8_t> get_day() const { return this->day_; }
optional<uint8_t> get_hour() const { return this->hour_; }
optional<uint8_t> get_minute() const { return this->minute_; }
optional<uint8_t> get_second() const { return this->second_; }
protected:
void validate_();
DateTimeEntity *parent_;
optional<uint16_t> year_;
optional<uint8_t> month_;
optional<uint8_t> day_;
optional<uint8_t> hour_;
optional<uint8_t> minute_;
optional<uint8_t> second_;
};
template<typename... Ts> class DateTimeSetAction : public Action<Ts...>, public Parented<DateTimeEntity> {
public:
TEMPLATABLE_VALUE(ESPTime, datetime)
void play(Ts... x) override {
auto call = this->parent_->make_call();
if (this->datetime_.has_value()) {
call.set_datetime(this->datetime_.value(x...));
}
call.perform();
}
};
class OnDateTimeTrigger : public Trigger<>, public Component, public Parented<DateTimeEntity> {
public:
void loop() override;
protected:
bool matches_(const ESPTime &time) const;
optional<ESPTime> last_check_;
};
} // namespace datetime
} // namespace esphome
#endif // USE_DATETIME_DATETIME

6
esphome/components/datetime/time_entity.cpp
View File

@ -94,8 +94,6 @@ void TimeEntityRestoreState::apply(TimeEntity *time) {
time->publish_state();
}
#ifdef USE_TIME
static const int MAX_TIMESTAMP_DRIFT = 900; // how far can the clock drift before we consider
// there has been a drastic time synchronization
@ -103,7 +101,7 @@ void OnTimeTrigger::loop() {
if (!this->parent_->has_state()) {
return;
}
ESPTime time = this->rtc_->now();
ESPTime time = this->parent_->rtc_->now();
if (!time.is_valid()) {
return;
}
@ -148,8 +146,6 @@ bool OnTimeTrigger::matches_(const ESPTime &time) const {
time.second == this->parent_->second;
}
#endif
} // namespace datetime
} // namespace esphome

12
esphome/components/datetime/time_entity.h
View File

@ -10,10 +10,6 @@
#include "datetime_base.h"
#ifdef USE_TIME
#include "esphome/components/time/real_time_clock.h"
#endif
namespace esphome {
namespace datetime {
@ -27,6 +23,7 @@ namespace datetime {
class TimeCall;
class TimeEntity;
class OnTimeTrigger;
struct TimeEntityRestoreState {
uint8_t hour;
@ -62,6 +59,7 @@ class TimeEntity : public DateTimeBase {
protected:
friend class TimeCall;
friend struct TimeEntityRestoreState;
friend class OnTimeTrigger;
virtual void control(const TimeCall &call) = 0;
};
@ -115,22 +113,16 @@ template<typename... Ts> class TimeSetAction : public Action<Ts...>, public Pare
}
};
#ifdef USE_TIME
class OnTimeTrigger : public Trigger<>, public Component, public Parented<TimeEntity> {
public:
explicit OnTimeTrigger(time::RealTimeClock *rtc) : rtc_(rtc) {}
void loop() override;
protected:
bool matches_(const ESPTime &time) const;
time::RealTimeClock *rtc_;
optional<ESPTime> last_check_;
};
#endif
} // namespace datetime
} // namespace esphome

4
esphome/components/display/__init__.py
View File

@ -38,6 +38,7 @@ DisplayOnPageChangeTrigger = display_ns.class_(
)
CONF_ON_PAGE_CHANGE = "on_page_change"
CONF_SHOW_TEST_CARD = "show_test_card"
DISPLAY_ROTATIONS = {
0: display_ns.DISPLAY_ROTATION_0_DEGREES,
@ -82,6 +83,7 @@ FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
}
),
cv.Optional(CONF_AUTO_CLEAR_ENABLED, default=True): cv.boolean,
cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
}
)
@ -113,6 +115,8 @@ async def setup_display_core_(var, config):
await automation.build_automation(
trigger, [(DisplayPagePtr, "from"), (DisplayPagePtr, "to")], conf
)
if config.get(CONF_SHOW_TEST_CARD):
cg.add(var.show_test_card())
async def register_display(var, config):

64
esphome/components/display/display.cpp
View File

@ -1,7 +1,7 @@
#include "display.h"
#include "display_color_utils.h"
#include <utility>
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
namespace esphome {
@ -507,7 +507,9 @@ void Display::do_update_() {
if (this->auto_clear_enabled_) {
this->clear();
}
if (this->page_ != nullptr) {
if (this->show_test_card_) {
this->test_card();
} else if (this->page_ != nullptr) {
this->page_->get_writer()(*this);
} else if (this->writer_.has_value()) {
(*this->writer_)(*this);
@ -608,6 +610,62 @@ bool Display::clamp_y_(int y, int h, int &min_y, int &max_y) {
return min_y < max_y;
}
const uint8_t TESTCARD_FONT[3][8] PROGMEM = {{0x41, 0x7F, 0x7F, 0x09, 0x19, 0x7F, 0x66, 0x00}, // 'R'
{0x1C, 0x3E, 0x63, 0x41, 0x51, 0x73, 0x72, 0x00}, // 'G'
{0x41, 0x7F, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00}}; // 'B'
void Display::test_card() {
int w = get_width(), h = get_height(), image_w, image_h;
this->clear();
this->show_test_card_ = false;
if (this->get_display_type() == DISPLAY_TYPE_COLOR) {
Color r(255, 0, 0), g(0, 255, 0), b(0, 0, 255);
image_w = std::min(w - 20, 310);
image_h = std::min(h - 20, 255);
int shift_x = (w - image_w) / 2;
int shift_y = (h - image_h) / 2;
int line_w = (image_w - 6) / 6;
int image_c = image_w / 2;
for (auto i = 0; i <= image_h; i++) {
int c = esp_scale(i, image_h);
this->horizontal_line(shift_x + 0, shift_y + i, line_w, r.fade_to_white(c));
this->horizontal_line(shift_x + line_w, shift_y + i, line_w, r.fade_to_black(c)); //
this->horizontal_line(shift_x + image_c - line_w, shift_y + i, line_w, g.fade_to_white(c));
this->horizontal_line(shift_x + image_c, shift_y + i, line_w, g.fade_to_black(c));
this->horizontal_line(shift_x + image_w - (line_w * 2), shift_y + i, line_w, b.fade_to_white(c));
this->horizontal_line(shift_x + image_w - line_w, shift_y + i, line_w, b.fade_to_black(c));
}
this->rectangle(shift_x, shift_y, image_w, image_h, Color(127, 127, 0));
uint16_t shift_r = shift_x + line_w - (8 * 3);
uint16_t shift_g = shift_x + image_c - (8 * 3);
uint16_t shift_b = shift_x + image_w - line_w - (8 * 3);
shift_y = h / 2 - (8 * 3);
for (auto i = 0; i < 8; i++) {
uint8_t ftr = progmem_read_byte(&TESTCARD_FONT[0][i]);
uint8_t ftg = progmem_read_byte(&TESTCARD_FONT[1][i]);
uint8_t ftb = progmem_read_byte(&TESTCARD_FONT[2][i]);
for (auto k = 0; k < 8; k++) {
if ((ftr & (1 << k)) != 0) {
this->filled_rectangle(shift_r + (i * 6), shift_y + (k * 6), 6, 6, COLOR_OFF);
}
if ((ftg & (1 << k)) != 0) {
this->filled_rectangle(shift_g + (i * 6), shift_y + (k * 6), 6, 6, COLOR_OFF);
}
if ((ftb & (1 << k)) != 0) {
this->filled_rectangle(shift_b + (i * 6), shift_y + (k * 6), 6, 6, COLOR_OFF);
}
}
}
}
this->rectangle(0, 0, w, h, Color(127, 0, 127));
this->filled_rectangle(0, 0, 10, 10, Color(255, 0, 255));
this->stop_poller();
}
DisplayPage::DisplayPage(display_writer_t writer) : writer_(std::move(writer)) {}
void DisplayPage::show() { this->parent_->show_page(this); }
void DisplayPage::show_next() { this->next_->show(); }

4
esphome/components/display/display.h
View File

@ -631,6 +631,9 @@ class Display : public PollingComponent {
*/
bool clip(int x, int y);
void test_card();
void show_test_card() { this->show_test_card_ = true; }
protected:
bool clamp_x_(int x, int w, int &min_x, int &max_x);
bool clamp_y_(int y, int h, int &min_y, int &max_y);
@ -659,6 +662,7 @@ class Display : public PollingComponent {
std::vector<DisplayOnPageChangeTrigger *> on_page_change_triggers_;
bool auto_clear_enabled_{true};
std::vector<Rect> clipping_rectangle_;
bool show_test_card_{false};
};
class DisplayPage {

3
esphome/components/esp32/__init__.py
View File

@ -32,6 +32,7 @@ from esphome.const import (
TYPE_GIT,
TYPE_LOCAL,
__version__,
CONF_PLATFORM_VERSION,
)
from esphome.core import CORE, HexInt, TimePeriod
import esphome.config_validation as cv
@ -365,8 +366,6 @@ def final_validate(config):
return config
CONF_PLATFORM_VERSION = "platform_version"
ARDUINO_FRAMEWORK_SCHEMA = cv.All(
cv.Schema(
{

2
esphome/components/esp32_ble_client/ble_client_base.cpp
View File

@ -142,7 +142,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
ESP_LOGW(TAG, "[%d] [%s] Connection failed, status=%d", this->connection_index_, this->address_str_.c_str(),
param->open.status);
this->set_state(espbt::ClientState::IDLE);
return false;
break;
}
auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if_, param->open.conn_id);
if (ret) {

2
esphome/components/esp8266/__init__.py
View File

@ -12,6 +12,7 @@ from esphome.const import (
KEY_TARGET_FRAMEWORK,
KEY_TARGET_PLATFORM,
PLATFORM_ESP8266,
CONF_PLATFORM_VERSION,
)
from esphome.core import CORE, coroutine_with_priority
import esphome.config_validation as cv
@ -146,7 +147,6 @@ def _parse_platform_version(value):
return value
CONF_PLATFORM_VERSION = "platform_version"
ARDUINO_FRAMEWORK_SCHEMA = cv.All(
cv.Schema(
{

2
esphome/components/event/__init__.py
View File

@ -25,8 +25,8 @@ IS_PLATFORM_COMPONENT = True
DEVICE_CLASSES = [
DEVICE_CLASS_BUTTON,
DEVICE_CLASS_EMPTY,
DEVICE_CLASS_DOORBELL,
DEVICE_CLASS_EMPTY,
DEVICE_CLASS_MOTION,
]

17
esphome/components/font/font.cpp
View File

@ -129,7 +129,13 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
uint8_t bitmask = 0;
uint8_t pixel_data = 0;
float bpp_max = (1 << this->bpp_) - 1;
uint8_t bpp_max = (1 << this->bpp_) - 1;
auto diff_r = (float) color.r - (float) background.r;
auto diff_g = (float) color.g - (float) background.g;
auto diff_b = (float) color.b - (float) background.b;
auto b_r = (float) background.r;
auto b_g = (float) background.g;
auto b_b = (float) background.g;
for (int glyph_y = y_start + scan_y1; glyph_y != max_y; glyph_y++) {
for (int glyph_x = x_at + scan_x1; glyph_x != max_x; glyph_x++) {
uint8_t pixel = 0;
@ -146,12 +152,9 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
if (pixel == bpp_max) {
display->draw_pixel_at(glyph_x, glyph_y, color);
} else if (pixel != 0) {
float on = (float) pixel / bpp_max;
float off = 1.0 - on;
Color blended;
blended.r = color.r * on + background.r * off;
blended.g = color.r * on + background.g * off;
blended.b = color.r * on + background.b * off;
auto on = (float) pixel / (float) bpp_max;
auto blended =
Color((uint8_t) (diff_r * on + b_r), (uint8_t) (diff_g * on + b_g), (uint8_t) (diff_b * on + b_b));
display->draw_pixel_at(glyph_x, glyph_y, blended);
}
}

26
esphome/components/graph/graph.cpp
View File

@ -164,7 +164,7 @@ void Graph::draw(Display *buff, uint16_t x_offset, uint16_t y_offset, Color colo
ESP_LOGV(TAG, "Updating graph. ymin %f, ymax %f", ymin, ymax);
for (auto *trace : traces_) {
Color c = trace->get_line_color();
uint16_t thick = trace->get_line_thickness();
int16_t thick = trace->get_line_thickness();
bool continuous = trace->get_continuous();
bool has_prev = false;
bool prev_b = false;
@ -177,22 +177,26 @@ void Graph::draw(Display *buff, uint16_t x_offset, uint16_t y_offset, Color colo
bool b = (trace->get_line_type() & bit) == bit;
if (b) {
int16_t y = (int16_t) roundf((this->height_ - 1) * (1.0 - v)) - thick / 2 + y_offset;
auto draw_pixel_at = [&buff, c, y_offset, this](int16_t x, int16_t y) {
if (y >= y_offset && y < y_offset + this->height_)
buff->draw_pixel_at(x, y, c);
};
if (!continuous || !has_prev || !prev_b || (abs(y - prev_y) <= thick)) {
for (uint16_t t = 0; t < thick; t++) {
buff->draw_pixel_at(x, y + t, c);
for (int16_t t = 0; t < thick; t++) {
draw_pixel_at(x, y + t);
}
} else {
int16_t mid_y = (y + prev_y + thick) / 2;
if (y > prev_y) {
for (uint16_t t = prev_y + thick; t <= mid_y; t++)
buff->draw_pixel_at(x + 1, t, c);
for (uint16_t t = mid_y + 1; t < y + thick; t++)
buff->draw_pixel_at(x, t, c);
for (int16_t t = prev_y + thick; t <= mid_y; t++)
draw_pixel_at(x + 1, t);
for (int16_t t = mid_y + 1; t < y + thick; t++)
draw_pixel_at(x, t);
} else {
for (uint16_t t = prev_y - 1; t >= mid_y; t--)
buff->draw_pixel_at(x + 1, t, c);
for (uint16_t t = mid_y - 1; t >= y; t--)
buff->draw_pixel_at(x, t, c);
for (int16_t t = prev_y - 1; t >= mid_y; t--)
draw_pixel_at(x + 1, t);
for (int16_t t = mid_y - 1; t >= y; t--)
draw_pixel_at(x, t);
}
}
prev_y = y;

15
esphome/components/graphical_display_menu/graphical_display_menu.cpp
View File

@ -104,7 +104,8 @@ void GraphicalDisplayMenu::draw(display::Display *display, const display::Rect *
}
void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const display::Rect *bounds) {
int total_height = 0;
int16_t total_height = 0;
int16_t max_width = 0;
int y_padding = 2;
bool scroll_menu_items = false;
std::vector<display::Rect> menu_dimensions;
@ -118,6 +119,7 @@ void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const
menu_dimensions.push_back(item_dimensions);
total_height += item_dimensions.h + (i == 0 ? 0 : y_padding);
max_width = std::max(max_width, item_dimensions.w);
if (total_height <= bounds->h) {
number_items_fit_to_screen++;
@ -166,7 +168,8 @@ void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const
// Render the items into the view port
display->start_clipping(*bounds);
int y_offset = bounds->y;
display->filled_rectangle(bounds->x, bounds->y, max_width, total_height, this->background_color_);
auto y_offset = bounds->y;
for (size_t i = first_item_index; i <= last_item_index; i++) {
const auto *item = this->displayed_item_->get_item(i);
const bool selected = i == this->cursor_index_;
@ -176,7 +179,7 @@ void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const
dimensions.x = bounds->x;
this->draw_item(display, item, &dimensions, selected);
y_offset = dimensions.y + dimensions.h + y_padding;
y_offset += dimensions.h + y_padding;
}
display->end_clipping();
@ -219,9 +222,7 @@ inline void GraphicalDisplayMenu::draw_item(display::Display *display, const dis
// int background_width = std::max(bounds->width, available_width);
int background_width = bounds->w;
if (selected) {
display->filled_rectangle(bounds->x, bounds->y, background_width, bounds->h, background_color);
}
display->filled_rectangle(bounds->x, bounds->y, background_width, bounds->h, background_color);
std::string label = item->get_text();
if (item->has_value()) {
@ -230,7 +231,7 @@ inline void GraphicalDisplayMenu::draw_item(display::Display *display, const dis
}
display->print(bounds->x, bounds->y, this->font_, foreground_color, display::TextAlign::TOP_LEFT, label.c_str(),
~foreground_color);
background_color);
}
void GraphicalDisplayMenu::draw_item(const display_menu_base::MenuItem *item, const uint8_t row, const bool selected) {

13
esphome/components/hm3301/aqi_calculator.h
View File

@ -1,6 +1,7 @@
#pragma once
#include "abstract_aqi_calculator.h"
// https://www.airnow.gov/sites/default/files/2020-05/aqi-technical-assistance-document-sept2018.pdf
namespace esphome {
namespace hm3301 {
@ -15,14 +16,16 @@ class AQICalculator : public AbstractAQICalculator {
}
protected:
static const int AMOUNT_OF_LEVELS = 6;
static const int AMOUNT_OF_LEVELS = 7;
int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 51}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200},
{201, 300}, {301, 400}, {401, 500}};
int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 12}, {13, 35}, {36, 55}, {56, 150}, {151, 250}, {251, 500}};
int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 12}, {13, 35}, {36, 55}, {56, 150},
{151, 250}, {251, 350}, {351, 500}};
int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 54}, {55, 154}, {155, 254},
{255, 354}, {355, 424}, {425, 604}};
int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 54}, {55, 154}, {155, 254}, {255, 354},
{355, 424}, {425, 504}, {505, 604}};
int calculate_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
int grid_index = get_grid_index_(value, array);

65
esphome/components/i2s_audio/microphone/i2s_audio_microphone.cpp
View File

@ -61,28 +61,57 @@ void I2SAudioMicrophone::start_() {
.bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
};
esp_err_t err;
#if SOC_I2S_SUPPORTS_ADC
if (this->adc_) {
config.mode = (i2s_mode_t) (config.mode | I2S_MODE_ADC_BUILT_IN);
i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
err = i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
err = i2s_set_adc_mode(ADC_UNIT_1, this->adc_channel_);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error setting ADC mode: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
err = i2s_adc_enable(this->parent_->get_port());
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error enabling ADC: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
i2s_set_adc_mode(ADC_UNIT_1, this->adc_channel_);
i2s_adc_enable(this->parent_->get_port());
} else
#endif
{
if (this->pdm_)
config.mode = (i2s_mode_t) (config.mode | I2S_MODE_PDM);
i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
err = i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
i2s_pin_config_t pin_config = this->parent_->get_pin_config();
pin_config.data_in_num = this->din_pin_;
i2s_set_pin(this->parent_->get_port(), &pin_config);
err = i2s_set_pin(this->parent_->get_port(), &pin_config);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error setting I2S pin: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
}
this->state_ = microphone::STATE_RUNNING;
this->high_freq_.start();
this->status_clear_error();
}
void I2SAudioMicrophone::stop() {
@ -96,11 +125,33 @@ void I2SAudioMicrophone::stop() {
}
void I2SAudioMicrophone::stop_() {
i2s_stop(this->parent_->get_port());
i2s_driver_uninstall(this->parent_->get_port());
esp_err_t err;
#if SOC_I2S_SUPPORTS_ADC
if (this->adc_) {
err = i2s_adc_disable(this->parent_->get_port());
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error disabling ADC: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
}
#endif
err = i2s_stop(this->parent_->get_port());
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error stopping I2S microphone: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
err = i2s_driver_uninstall(this->parent_->get_port());
if (err != ESP_OK) {
ESP_LOGW(TAG, "Error uninstalling I2S driver: %s", esp_err_to_name(err));
this->status_set_error();
return;
}
this->parent_->unlock();
this->state_ = microphone::STATE_STOPPED;
this->high_freq_.stop();
this->status_clear_error();
}
size_t I2SAudioMicrophone::read(int16_t *buf, size_t len) {

3
esphome/components/light/base_light_effects.h
View File

@ -150,6 +150,7 @@ class AutomationLightEffect : public LightEffect {
struct StrobeLightEffectColor {
LightColorValues color;
uint32_t duration;
uint32_t transition_length;
};
class StrobeLightEffect : public LightEffect {
@ -174,7 +175,7 @@ class StrobeLightEffect : public LightEffect {
}
call.set_publish(false);
call.set_save(false);
call.set_transition_length_if_supported(0);
call.set_transition_length_if_supported(this->colors_[this->at_color_].transition_length);
call.perform();
this->last_switch_ = now;
}

4
esphome/components/light/effects.py
View File

@ -266,6 +266,9 @@ async def random_effect_to_code(config, effect_id):
cv.Required(
CONF_DURATION
): cv.positive_time_period_milliseconds,
cv.Optional(
CONF_TRANSITION_LENGTH, default="0s"
): cv.positive_time_period_milliseconds,
}
),
cv.has_at_least_one_key(
@ -310,6 +313,7 @@ async def strobe_effect_to_code(config, effect_id):
),
),
("duration", color[CONF_DURATION]),
("transition_length", color[CONF_TRANSITION_LENGTH]),
)
)
cg.add(var.set_colors(colors))

1
esphome/components/mqtt/__init__.py
View File

@ -115,6 +115,7 @@ MQTTTextSensor = mqtt_ns.class_("MQTTTextSensor", MQTTComponent)
MQTTNumberComponent = mqtt_ns.class_("MQTTNumberComponent", MQTTComponent)
MQTTDateComponent = mqtt_ns.class_("MQTTDateComponent", MQTTComponent)
MQTTTimeComponent = mqtt_ns.class_("MQTTTimeComponent", MQTTComponent)
MQTTDateTimeComponent = mqtt_ns.class_("MQTTDateTimeComponent", MQTTComponent)
MQTTTextComponent = mqtt_ns.class_("MQTTTextComponent", MQTTComponent)
MQTTSelectComponent = mqtt_ns.class_("MQTTSelectComponent", MQTTComponent)
MQTTButtonComponent = mqtt_ns.class_("MQTTButtonComponent", MQTTComponent)

84
esphome/components/mqtt/mqtt_datetime.cpp Normal file
View File

@ -0,0 +1,84 @@
#include "mqtt_datetime.h"
#include <utility>
#include "esphome/core/log.h"
#include "mqtt_const.h"
#ifdef USE_MQTT
#ifdef USE_DATETIME_TIME
namespace esphome {
namespace mqtt {
static const char *const TAG = "mqtt.datetime.time";
using namespace esphome::datetime;
MQTTDateTimeComponent::MQTTDateTimeComponent(DateTimeEntity *datetime) : datetime_(datetime) {}
void MQTTDateTimeComponent::setup() {
this->subscribe_json(this->get_command_topic_(), [this](const std::string &topic, JsonObject root) {
auto call = this->datetime_->make_call();
if (root.containsKey("year")) {
call.set_year(root["year"]);
}
if (root.containsKey("month")) {
call.set_month(root["month"]);
}
if (root.containsKey("day")) {
call.set_day(root["day"]);
}
if (root.containsKey("hour")) {
call.set_hour(root["hour"]);
}
if (root.containsKey("minute")) {
call.set_minute(root["minute"]);
}
if (root.containsKey("second")) {
call.set_second(root["second"]);
}
call.perform();
});
this->datetime_->add_on_state_callback([this]() {
this->publish_state(this->datetime_->year, this->datetime_->month, this->datetime_->day, this->datetime_->hour,
this->datetime_->minute, this->datetime_->second);
});
}
void MQTTDateTimeComponent::dump_config() {
ESP_LOGCONFIG(TAG, "MQTT DateTime '%s':", this->datetime_->get_name().c_str());
LOG_MQTT_COMPONENT(true, true)
}
std::string MQTTDateTimeComponent::component_type() const { return "datetime"; }
const EntityBase *MQTTDateTimeComponent::get_entity() const { return this->datetime_; }
void MQTTDateTimeComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
// Nothing extra to add here
}
bool MQTTDateTimeComponent::send_initial_state() {
if (this->datetime_->has_state()) {
return this->publish_state(this->datetime_->year, this->datetime_->month, this->datetime_->day,
this->datetime_->hour, this->datetime_->minute, this->datetime_->second);
} else {
return true;
}
}
bool MQTTDateTimeComponent::publish_state(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
uint8_t second) {
return this->publish_json(this->get_state_topic_(), [year, month, day, hour, minute, second](JsonObject root) {
root["year"] = year;
root["month"] = month;
root["day"] = day;
root["hour"] = hour;
root["minute"] = minute;
root["second"] = second;
});
}
} // namespace mqtt
} // namespace esphome
#endif // USE_DATETIME_TIME
#endif // USE_MQTT

45
esphome/components/mqtt/mqtt_datetime.h Normal file
View File

@ -0,0 +1,45 @@
#pragma once
#include "esphome/core/defines.h"
#ifdef USE_MQTT
#ifdef USE_DATETIME_TIME
#include "esphome/components/datetime/datetime_entity.h"
#include "mqtt_component.h"
namespace esphome {
namespace mqtt {
class MQTTDateTimeComponent : public mqtt::MQTTComponent {
public:
/** Construct this MQTTDateTimeComponent instance with the provided friendly_name and time
*
* @param time The time entity.
*/
explicit MQTTDateTimeComponent(datetime::DateTimeEntity *time);
// ========== INTERNAL METHODS ==========
// (In most use cases you won't need these)
/// Override setup.
void setup() override;
void dump_config() override;
void send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) override;
bool send_initial_state() override;
bool publish_state(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
protected:
std::string component_type() const override;
const EntityBase *get_entity() const override;
datetime::DateTimeEntity *datetime_;
};
} // namespace mqtt
} // namespace esphome
#endif // USE_DATETIME_DATE
#endif // USE_MQTT

60
esphome/components/nextion/nextion.h
View File

@ -976,6 +976,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
* @return Whether the send was successful.
*/
bool send_command(const char *command);
/**
* Manually send a raw formatted command to the display.
* @param format The printf-style command format, like "vis %s,0"
@ -989,13 +990,30 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
* Set the tft file URL. https seems problematic with arduino..
*/
void set_tft_url(const std::string &tft_url) { this->tft_url_ = tft_url; }
#endif
/**
* Upload the tft file and soft reset Nextion
* @brief Uploads the TFT file to the Nextion display.
*
* This function initiates the upload of a TFT file to the Nextion display. Users can specify a target baud rate for
* the transfer. If the provided baud rate is not supported by Nextion, the function defaults to using the current
* baud rate set for the display. If no baud rate is specified (or if 0 is passed), the current baud rate is used.
*
* Supported baud rates are: 2400, 4800, 9600, 19200, 31250, 38400, 57600, 115200, 230400, 250000, 256000, 512000
* and 921600. Selecting a baud rate supported by both the Nextion display and the host hardware is essential for
* ensuring a successful upload process.
*
* @param baud_rate The desired baud rate for the TFT file transfer, specified as an unsigned 32-bit integer.
* If the specified baud rate is not supported, or if 0 is passed, the function will use the current baud rate.
* The default value is 0, which implies using the current baud rate.
* @param exit_reparse If true, the function exits reparse mode before uploading the TFT file. This parameter
* defaults to true, ensuring that the display is ready to receive and apply the new TFT file without needing
* to manually reset or reconfigure. Exiting reparse mode is recommended for most upload scenarios to ensure
* the display properly processes the uploaded file command.
* @return bool True: Transfer completed successfuly, False: Transfer failed.
*/
bool upload_tft();
bool upload_tft(uint32_t baud_rate = 0, bool exit_reparse = true);
#endif
void dump_config() override;
@ -1118,6 +1136,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
void all_components_send_state_(bool force_update = false);
uint64_t comok_sent_ = 0;
bool remove_from_q_(bool report_empty = true);
/**
* @brief
* Sends commands ignoring of the Nextion has been setup.
@ -1159,20 +1178,16 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
void check_pending_waveform_();
#ifdef USE_NEXTION_TFT_UPLOAD
uint32_t content_length_ = 0;
int tft_size_ = 0;
uint32_t original_baud_rate_ = 0;
bool upload_first_chunk_sent_ = false;
std::string tft_url_;
uint8_t *transfer_buffer_{nullptr};
size_t transfer_buffer_size_;
#ifdef USE_ESP8266
WiFiClient *wifi_client_{nullptr};
BearSSL::WiFiClientSecure *wifi_client_secure_{nullptr};
WiFiClient *get_wifi_client_();
#endif
std::string tft_url_;
uint32_t content_length_ = 0;
int tft_size_ = 0;
uint32_t original_baud_rate_ = 0;
bool upload_first_chunk_sent_ = false;
#ifdef ARDUINO
/**
@ -1182,18 +1197,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
* @param int range_start Position of next byte to transfer.
* @return position of last byte transferred, -1 for failure.
*/
int upload_by_chunks_(HTTPClient *http, int range_start);
int upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start);
bool upload_with_range_(uint32_t range_start, uint32_t range_end);
/**
* start update tft file to nextion.
*
* @param const uint8_t *file_buf
* @param size_t buf_size
* @return true if success, false for failure.
*/
bool upload_from_buffer_(const uint8_t *file_buf, size_t buf_size);
/**
* Ends the upload process, restart Nextion and, if successful,
* restarts ESP
@ -1201,6 +1206,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
* @return bool True: Transfer completed successfuly, False: Transfer failed.
*/
bool upload_end_(bool successful);
#elif defined(USE_ESP_IDF)
/**
* will request 4096 bytes chunks from the web server
@ -1210,6 +1216,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
* @return position of last byte transferred, -1 for failure.
*/
int upload_range(const std::string &url, int range_start);
/**
* Ends the upload process, restart Nextion and, if successful,
* restarts ESP
@ -1217,7 +1224,12 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
* @return bool True: Transfer completed successfuly, False: Transfer failed.
*/
bool upload_end(bool successful);
#endif // ARDUINO vs ESP-IDF
#endif // ARDUINO vs USE_ESP_IDF
/**
* Returns the ESP Free Heap memory. This is framework independent.
* @return Free Heap in bytes.
*/
uint32_t get_free_heap_();
#endif // USE_NEXTION_TFT_UPLOAD

433
esphome/components/nextion/nextion_upload_arduino.cpp
View File

@ -1,13 +1,14 @@
#include "nextion.h"
#ifdef ARDUINO
#ifdef USE_NEXTION_TFT_UPLOAD
#ifdef ARDUINO
#include "esphome/core/application.h"
#include "esphome/core/defines.h"
#include "esphome/core/util.h"
#include "esphome/core/log.h"
#include "esphome/components/network/util.h"
#include <cinttypes>
#ifdef USE_ESP32
#include <esp_heap_caps.h>
@ -20,180 +21,205 @@ static const char *const TAG = "nextion.upload.arduino";
// Followed guide
// https://unofficialnextion.com/t/nextion-upload-protocol-v1-2-the-fast-one/1044/2
int Nextion::upload_by_chunks_(HTTPClient *http, int range_start) {
int range_end = 0;
inline uint32_t Nextion::get_free_heap_() {
#if defined(USE_ESP32)
return heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
#elif defined(USE_ESP8266)
return EspClass::getFreeHeap();
#endif // USE_ESP32 vs USE_ESP8266
}
if (range_start == 0 && this->transfer_buffer_size_ > 16384) { // Start small at the first run in case of a big skip
range_end = 16384 - 1;
} else {
range_end = range_start + this->transfer_buffer_size_ - 1;
int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
uint32_t range_size = this->tft_size_ - range_start;
ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
uint32_t range_end = ((upload_first_chunk_sent_ or this->tft_size_ < 4096) ? this->tft_size_ : 4096) - 1;
ESP_LOGD(TAG, "Range start: %" PRIu32, range_start);
if (range_size <= 0 or range_end <= range_start) {
ESP_LOGD(TAG, "Range end: %" PRIu32, range_end);
ESP_LOGD(TAG, "Range size: %" PRIu32, range_size);
ESP_LOGE(TAG, "Invalid range");
return -1;
}
if (range_end > this->tft_size_)
range_end = this->tft_size_;
#ifdef USE_ESP8266
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
http->setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
#elif USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
http->setFollowRedirects(true);
#endif
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
http->setRedirectLimit(3);
#endif
#endif // USE_ESP8266
char range_header[64];
sprintf(range_header, "bytes=%d-%d", range_start, range_end);
ESP_LOGD(TAG, "Requesting range: %s", range_header);
int tries = 1;
int code = 0;
bool begin_status = false;
while (tries <= 5) {
#ifdef USE_ESP32
begin_status = http->begin(this->tft_url_.c_str());
#endif
#ifdef USE_ESP8266
begin_status = http->begin(*this->get_wifi_client_(), this->tft_url_.c_str());
#endif
++tries;
if (!begin_status) {
ESP_LOGD(TAG, "upload_by_chunks_: connection failed");
delay(500); // NOLINT
continue;
}
http->addHeader("Range", range_header);
code = http->GET();
if (code == 200 || code == 206) {
break;
}
ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s, retries(%d/5)", this->tft_url_.c_str(),
HTTPClient::errorToString(code).c_str(), tries);
http->end();
App.feed_wdt();
delay(500); // NOLINT
char range_header[32];
sprintf(range_header, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
ESP_LOGV(TAG, "Requesting range: %s", range_header);
http_client.addHeader("Range", range_header);
int code = http_client.GET();
if (code != HTTP_CODE_OK and code != HTTP_CODE_PARTIAL_CONTENT) {
ESP_LOGW(TAG, "HTTP Request failed; Error: %s", HTTPClient::errorToString(code).c_str());
return -1;
}
if (tries > 5) {
// Allocate the buffer dynamically
ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
uint8_t *buffer = allocator.allocate(4096);
if (!buffer) {
ESP_LOGE(TAG, "Failed to allocate upload buffer");
return -1;
}
std::string recv_string;
size_t size = 0;
int fetched = 0;
int range = range_end - range_start;
while (fetched < range) {
size = http->getStreamPtr()->available();
if (!size) {
App.feed_wdt();
delay(0);
continue;
}
int c = http->getStreamPtr()->readBytes(
&this->transfer_buffer_[fetched], ((size > this->transfer_buffer_size_) ? this->transfer_buffer_size_ : size));
fetched += c;
}
http->end();
ESP_LOGN(TAG, "Fetched %d of %d bytes", fetched, this->content_length_);
// upload fetched segments to the display in 4KB chunks
int write_len;
for (int i = 0; i < range; i += 4096) {
while (true) {
App.feed_wdt();
write_len = this->content_length_ < 4096 ? this->content_length_ : 4096;
this->write_array(&this->transfer_buffer_[i], write_len);
this->content_length_ -= write_len;
ESP_LOGD(TAG, "Uploaded %0.2f %%; %d bytes remaining",
100.0 * (this->tft_size_ - this->content_length_) / this->tft_size_, this->content_length_);
if (!this->upload_first_chunk_sent_) {
this->upload_first_chunk_sent_ = true;
delay(500); // NOLINT
}
this->recv_ret_string_(recv_string, 4096, true);
if (recv_string[0] != 0x05) { // 0x05 == "ok"
ESP_LOGD(TAG, "recv_string [%s]",
format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
}
// handle partial upload request
if (recv_string[0] == 0x08 && recv_string.size() == 5) {
uint32_t result = 0;
for (int j = 0; j < 4; ++j) {
result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
}
if (result > 0) {
ESP_LOGD(TAG, "Nextion reported new range %d", result);
this->content_length_ = this->tft_size_ - result;
return result;
const uint16_t buffer_size =
this->content_length_ < 4096 ? this->content_length_ : 4096; // Limits buffer to the remaining data
ESP_LOGV(TAG, "Fetching %" PRIu16 " bytes from HTTP", buffer_size);
uint16_t read_len = 0;
int partial_read_len = 0;
const uint32_t start_time = millis();
while (read_len < buffer_size && millis() - start_time < 5000) {
if (http_client.getStreamPtr()->available() > 0) {
partial_read_len =
http_client.getStreamPtr()->readBytes(reinterpret_cast<char *>(buffer) + read_len, buffer_size - read_len);
read_len += partial_read_len;
if (partial_read_len > 0) {
App.feed_wdt();
delay(2);
}
}
}
recv_string.clear();
if (read_len != buffer_size) {
// Did not receive the full package within the timeout period
ESP_LOGE(TAG, "Failed to read full package, received only %" PRIu16 " of %" PRIu16 " bytes", read_len,
buffer_size);
// Deallocate buffer
allocator.deallocate(buffer, 4096);
buffer = nullptr;
return -1;
}
ESP_LOGV(TAG, "%d bytes fetched, writing it to UART", read_len);
if (read_len > 0) {
recv_string.clear();
this->write_array(buffer, buffer_size);
App.feed_wdt();
this->recv_ret_string_(recv_string, upload_first_chunk_sent_ ? 500 : 5000, true);
this->content_length_ -= read_len;
const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
#if defined(USE_ESP32) && defined(USE_PSRAM)
ESP_LOGD(
TAG,
"Uploaded %0.2f%%, remaining %" PRIu32 " bytes, free heap: %" PRIu32 " (DRAM) + %" PRIu32 " (PSRAM) bytes",
upload_percentage, this->content_length_, static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)));
#else
ESP_LOGD(TAG, "Uploaded %0.2f%%, remaining %" PRIu32 " bytes, free heap: %" PRIu32 " bytes", upload_percentage,
this->content_length_, this->get_free_heap_());
#endif
upload_first_chunk_sent_ = true;
if (recv_string[0] == 0x08 && recv_string.size() == 5) { // handle partial upload request
ESP_LOGD(TAG, "recv_string [%s]",
format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
uint32_t result = 0;
for (int j = 0; j < 4; ++j) {
result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
}
if (result > 0) {
ESP_LOGI(TAG, "Nextion reported new range %" PRIu32, result);
this->content_length_ = this->tft_size_ - result;
range_start = result;
} else {
range_start = range_end + 1;
}
// Deallocate buffer
allocator.deallocate(buffer, 4096);
buffer = nullptr;
return range_end + 1;
} else if (recv_string[0] != 0x05 and recv_string[0] != 0x08) { // 0x05 == "ok"
ESP_LOGE(TAG, "Invalid response from Nextion: [%s]",
format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
// Deallocate buffer
allocator.deallocate(buffer, 4096);
buffer = nullptr;
return -1;
}
recv_string.clear();
} else if (read_len == 0) {
ESP_LOGV(TAG, "End of HTTP response reached");
break; // Exit the loop if there is no more data to read
} else {
ESP_LOGE(TAG, "Failed to read from HTTP client, error code: %d", read_len);
break; // Exit the loop on error
}
}
range_start = range_end + 1;
// Deallocate buffer
allocator.deallocate(buffer, 4096);
buffer = nullptr;
return range_end + 1;
}
bool Nextion::upload_tft() {
bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
ESP_LOGD(TAG, "Nextion TFT upload requested");
ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
if (this->is_updating_) {
ESP_LOGD(TAG, "Currently updating");
ESP_LOGW(TAG, "Currently uploading");
return false;
}
if (!network::is_connected()) {
ESP_LOGD(TAG, "network is not connected");
ESP_LOGE(TAG, "Network is not connected");
return false;
}
this->is_updating_ = true;
HTTPClient http;
http.setTimeout(15000); // Yes 15 seconds.... Helps 8266s along
if (exit_reparse) {
ESP_LOGD(TAG, "Exiting Nextion reparse mode");
if (!this->set_protocol_reparse_mode(false)) {
ESP_LOGW(TAG, "Failed to request Nextion to exit reparse mode");
return false;
}
}
// Check if baud rate is supported
this->original_baud_rate_ = this->parent_->get_baud_rate();
static const std::vector<uint32_t> SUPPORTED_BAUD_RATES = {2400, 4800, 9600, 19200, 31250, 38400, 57600,
115200, 230400, 250000, 256000, 512000, 921600};
if (std::find(SUPPORTED_BAUD_RATES.begin(), SUPPORTED_BAUD_RATES.end(), baud_rate) == SUPPORTED_BAUD_RATES.end()) {
baud_rate = this->original_baud_rate_;
}
ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
// Define the configuration for the HTTP client
ESP_LOGV(TAG, "Initializing HTTP client");
ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
HTTPClient http_client;
http_client.setTimeout(15000); // Yes 15 seconds.... Helps 8266s along
bool begin_status = false;
#ifdef USE_ESP32
begin_status = http.begin(this->tft_url_.c_str());
begin_status = http_client.begin(this->tft_url_.c_str());
#endif
#ifdef USE_ESP8266
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
http_client.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
#elif USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
http.setFollowRedirects(true);
http_client.setFollowRedirects(true);
#endif
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
http.setRedirectLimit(3);
http_client.setRedirectLimit(3);
#endif
begin_status = http.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
#endif
begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
#endif // USE_ESP8266
if (!begin_status) {
this->is_updating_ = false;
ESP_LOGD(TAG, "Connection failed");
ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
allocator.deallocate(this->transfer_buffer_, this->transfer_buffer_size_);
return false;
} else {
ESP_LOGD(TAG, "Connected");
}
http.addHeader("Range", "bytes=0-255");
http_client.addHeader("Range", "bytes=0-255");
const char *header_names[] = {"Content-Range"};
http.collectHeaders(header_names, 1);
http_client.collectHeaders(header_names, 1);
ESP_LOGD(TAG, "Requesting URL: %s", this->tft_url_.c_str());
http.setReuse(true);
http_client.setReuse(true);
// try up to 5 times. DNS sometimes needs a second try or so
int tries = 1;
int code = http.GET();
int code = http_client.GET();
delay(100); // NOLINT
App.feed_wdt();
@ -203,135 +229,133 @@ bool Nextion::upload_tft() {
delay(250); // NOLINT
App.feed_wdt();
code = http.GET();
code = http_client.GET();
++tries;
}
if ((code != 200 && code != 206) || tries > 5) {
if (code != 200 and code != 206) {
return this->upload_end_(false);
}
String content_range_string = http.header("Content-Range");
String content_range_string = http_client.header("Content-Range");
content_range_string.remove(0, 12);
this->content_length_ = content_range_string.toInt();
this->tft_size_ = content_length_;
http.end();
this->tft_size_ = content_range_string.toInt();
if (this->content_length_ < 4096) {
ESP_LOGE(TAG, "Failed to get file size");
ESP_LOGD(TAG, "TFT file size: %zu bytes", this->tft_size_);
if (this->tft_size_ < 4096) {
ESP_LOGE(TAG, "File size check failed.");
ESP_LOGD(TAG, "Close HTTP connection");
http_client.end();
ESP_LOGV(TAG, "Connection closed");
return this->upload_end_(false);
} else {
ESP_LOGV(TAG, "File size check passed. Proceeding...");
}
this->content_length_ = this->tft_size_;
ESP_LOGD(TAG, "Updating Nextion %s...", this->device_model_.c_str());
// The Nextion will ignore the update command if it is sleeping
ESP_LOGD(TAG, "Uploading Nextion");
// The Nextion will ignore the upload command if it is sleeping
ESP_LOGV(TAG, "Wake-up Nextion");
this->ignore_is_setup_ = true;
this->send_command_("sleep=0");
this->set_backlight_brightness(1.0);
this->send_command_("dim=100");
delay(250); // NOLINT
ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
App.feed_wdt();
char command[128];
// Tells the Nextion the content length of the tft file and baud rate it will be sent at
// Once the Nextion accepts the command it will wait until the file is successfully uploaded
// If it fails for any reason a power cycle of the display will be needed
sprintf(command, "whmi-wris %d,%d,1", this->content_length_, this->parent_->get_baud_rate());
sprintf(command, "whmi-wris %d,%d,1", this->content_length_, baud_rate);
// Clear serial receive buffer
uint8_t d;
while (this->available()) {
this->read_byte(&d);
};
ESP_LOGV(TAG, "Clear serial receive buffer");
this->reset_(false);
delay(250); // NOLINT
ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
ESP_LOGV(TAG, "Send upload instruction: %s", command);
this->send_command_(command);
if (baud_rate != this->original_baud_rate_) {
ESP_LOGD(TAG, "Changing baud rate from %" PRIu32 " to %" PRIu32 " bps", this->original_baud_rate_, baud_rate);
this->parent_->set_baud_rate(baud_rate);
this->parent_->load_settings();
}
App.feed_wdt();
std::string response;
ESP_LOGD(TAG, "Waiting for upgrade response");
this->recv_ret_string_(response, 2000, true); // This can take some time to return
ESP_LOGV(TAG, "Waiting for upgrade response");
this->recv_ret_string_(response, 5000, true); // This can take some time to return
// The Nextion display will, if it's ready to accept data, send a 0x05 byte.
ESP_LOGD(TAG, "Upgrade response is [%s] - %zu bytes",
ESP_LOGD(TAG, "Upgrade response is [%s] - %zu byte(s)",
format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str(),
response.length());
for (size_t i = 0; i < response.length(); i++) {
ESP_LOGD(TAG, "Available %d : 0x%02X", i, response[i]);
}
ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
if (response.find(0x05) != std::string::npos) {
ESP_LOGD(TAG, "preparation for tft update done");
ESP_LOGV(TAG, "Preparation for TFT upload done");
} else {
ESP_LOGD(TAG, "preparation for tft update failed %d \"%s\"", response[0], response.c_str());
ESP_LOGE(TAG, "Preparation for TFT upload failed %d \"%s\"", response[0], response.c_str());
ESP_LOGD(TAG, "Close HTTP connection");
http_client.end();
ESP_LOGV(TAG, "Connection closed");
return this->upload_end_(false);
}
// Nextion wants 4096 bytes at a time. Make chunk_size a multiple of 4096
#ifdef USE_ESP32
uint32_t chunk_size = 8192;
if (heap_caps_get_free_size(MALLOC_CAP_SPIRAM) > 0) {
chunk_size = this->content_length_;
} else {
if (ESP.getFreeHeap() > 81920) { // Ensure some FreeHeap to other things and limit chunk size
chunk_size = ESP.getFreeHeap() - 65536;
chunk_size = int(chunk_size / 4096) * 4096;
chunk_size = chunk_size > 65536 ? 65536 : chunk_size;
} else if (ESP.getFreeHeap() < 32768) {
chunk_size = 4096;
}
}
#else
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
uint32_t chunk_size = ESP.getFreeHeap() < 16384 ? 4096 : 8192;
#endif
ESP_LOGD(TAG, "Uploading TFT to Nextion:");
ESP_LOGD(TAG, " URL: %s", this->tft_url_.c_str());
ESP_LOGD(TAG, " File size: %d bytes", this->content_length_);
ESP_LOGD(TAG, " Free heap: %" PRIu32, this->get_free_heap_());
if (this->transfer_buffer_ == nullptr) {
ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
ESP_LOGD(TAG, "Allocating buffer size %d, Heap size is %u", chunk_size, ESP.getFreeHeap());
this->transfer_buffer_ = allocator.allocate(chunk_size);
if (this->transfer_buffer_ == nullptr) { // Try a smaller size
ESP_LOGD(TAG, "Could not allocate buffer size: %d trying 4096 instead", chunk_size);
chunk_size = 4096;
ESP_LOGD(TAG, "Allocating %d buffer", chunk_size);
this->transfer_buffer_ = allocator.allocate(chunk_size);
// Proceed with the content download as before
if (!this->transfer_buffer_)
return this->upload_end_(false);
}
ESP_LOGV(TAG, "Starting transfer by chunks loop");
this->transfer_buffer_size_ = chunk_size;
}
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
ESP_LOGD(TAG, "Updating tft from \"%s\" with a file size of %d using %zu chunksize, Heap Size %d",
this->tft_url_.c_str(), this->content_length_, this->transfer_buffer_size_, ESP.getFreeHeap());
int result = 0;
uint32_t position = 0;
while (this->content_length_ > 0) {
result = this->upload_by_chunks_(&http, result);
if (result < 0) {
ESP_LOGD(TAG, "Error updating Nextion!");
int upload_result = upload_by_chunks_(http_client, position);
if (upload_result < 0) {
ESP_LOGE(TAG, "Error uploading TFT to Nextion!");
ESP_LOGD(TAG, "Close HTTP connection");
http_client.end();
ESP_LOGV(TAG, "Connection closed");
return this->upload_end_(false);
}
App.feed_wdt();
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
ESP_LOGD(TAG, "Heap Size %d, Bytes left %d", ESP.getFreeHeap(), this->content_length_);
ESP_LOGV(TAG, "Free heap: %" PRIu32 ", Bytes left: %" PRIu32, this->get_free_heap_(), this->content_length_);
}
ESP_LOGD(TAG, "Successfully updated Nextion!");
return this->upload_end_(true);
ESP_LOGD(TAG, "Successfully uploaded TFT to Nextion!");
ESP_LOGD(TAG, "Close HTTP connection");
http_client.end();
ESP_LOGV(TAG, "Connection closed");
return upload_end_(true);
}
bool Nextion::upload_end_(bool successful) {
ESP_LOGD(TAG, "Nextion TFT upload finished: %s", YESNO(successful));
this->is_updating_ = false;
ESP_LOGD(TAG, "Restarting Nextion");
this->soft_reset();
this->ignore_is_setup_ = false;
uint32_t baud_rate = this->parent_->get_baud_rate();
if (baud_rate != this->original_baud_rate_) {
ESP_LOGD(TAG, "Changing baud rate back from %" PRIu32 " to %" PRIu32 " bps", baud_rate, this->original_baud_rate_);
this->parent_->set_baud_rate(this->original_baud_rate_);
this->parent_->load_settings();
}
if (successful) {
ESP_LOGD(TAG, "Restarting ESPHome");
delay(1500); // NOLINT
ESP_LOGD(TAG, "Restarting esphome");
ESP.restart(); // NOLINT(readability-static-accessed-through-instance)
arch_restart();
} else {
ESP_LOGE(TAG, "Nextion TFT upload failed");
}
return successful;
}
@ -354,9 +378,10 @@ WiFiClient *Nextion::get_wifi_client_() {
}
return this->wifi_client_;
}
#endif
#endif // USE_ESP8266
} // namespace nextion
} // namespace esphome
#endif // USE_NEXTION_TFT_UPLOAD
#endif // ARDUINO
#endif // USE_NEXTION_TFT_UPLOAD

36
esphome/components/nextion/nextion_upload_idf.cpp
View File

@ -160,8 +160,9 @@ int Nextion::upload_range(const std::string &url, int range_start) {
return range_end + 1;
}
bool Nextion::upload_tft() {
bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
ESP_LOGD(TAG, "Nextion TFT upload requested");
ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
ESP_LOGD(TAG, "url: %s", this->tft_url_.c_str());
if (this->is_updating_) {
@ -176,6 +177,23 @@ bool Nextion::upload_tft() {
this->is_updating_ = true;
if (exit_reparse) {
ESP_LOGD(TAG, "Exiting Nextion reparse mode");
if (!this->set_protocol_reparse_mode(false)) {
ESP_LOGW(TAG, "Failed to request Nextion to exit reparse mode");
return false;
}
}
// Check if baud rate is supported
this->original_baud_rate_ = this->parent_->get_baud_rate();
static const std::vector<uint32_t> SUPPORTED_BAUD_RATES = {2400, 4800, 9600, 19200, 31250, 38400, 57600,
115200, 230400, 250000, 256000, 512000, 921600};
if (std::find(SUPPORTED_BAUD_RATES.begin(), SUPPORTED_BAUD_RATES.end(), baud_rate) == SUPPORTED_BAUD_RATES.end()) {
baud_rate = this->original_baud_rate_;
}
ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
// Define the configuration for the HTTP client
ESP_LOGV(TAG, "Establishing connection to HTTP server");
ESP_LOGVV(TAG, "Available heap: %" PRIu32, esp_get_free_heap_size());
@ -245,7 +263,7 @@ bool Nextion::upload_tft() {
// Tells the Nextion the content length of the tft file and baud rate it will be sent at
// Once the Nextion accepts the command it will wait until the file is successfully uploaded
// If it fails for any reason a power cycle of the display will be needed
sprintf(command, "whmi-wris %d,%" PRIu32 ",1", this->content_length_, this->parent_->get_baud_rate());
sprintf(command, "whmi-wris %d,%" PRIu32 ",1", this->content_length_, baud_rate);
// Clear serial receive buffer
ESP_LOGV(TAG, "Clear serial receive buffer");
@ -259,6 +277,12 @@ bool Nextion::upload_tft() {
ESP_LOGVV(TAG, "Available heap: %" PRIu32, esp_get_free_heap_size());
this->send_command_(command);
if (baud_rate != this->original_baud_rate_) {
ESP_LOGD(TAG, "Changing baud rate from %" PRIu32 " to %" PRIu32 " bps", this->original_baud_rate_, baud_rate);
this->parent_->set_baud_rate(baud_rate);
this->parent_->load_settings();
}
std::string response;
ESP_LOGV(TAG, "Waiting for upgrade response");
this->recv_ret_string_(response, 5000, true); // This can take some time to return
@ -299,6 +323,14 @@ bool Nextion::upload_tft() {
bool Nextion::upload_end(bool successful) {
this->is_updating_ = false;
uint32_t baud_rate = this->parent_->get_baud_rate();
if (baud_rate != this->original_baud_rate_) {
ESP_LOGD(TAG, "Changing baud rate back from %" PRIu32 " to %" PRIu32 " bps", baud_rate, this->original_baud_rate_);
this->parent_->set_baud_rate(this->original_baud_rate_);
this->parent_->load_settings();
}
ESP_LOGD(TAG, "Restarting Nextion");
this->soft_reset();
vTaskDelay(pdMS_TO_TICKS(1500)); // NOLINT

6
esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
View File

@ -24,8 +24,10 @@ void PVVXDisplay::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t
esp_ble_gattc_cb_param_t *param) {
switch (event) {
case ESP_GATTC_OPEN_EVT:
ESP_LOGV(TAG, "[%s] Connected successfully!", this->parent_->address_str().c_str());
this->delayed_disconnect_();
if (param->open.status == ESP_GATT_OK) {
ESP_LOGV(TAG, "[%s] Connected successfully!", this->parent_->address_str().c_str());
this->delayed_disconnect_();
}
break;
case ESP_GATTC_DISCONNECT_EVT:
ESP_LOGV(TAG, "[%s] Disconnected", this->parent_->address_str().c_str());

46
esphome/components/qmc5883l/qmc5883l.cpp
View File

@ -77,8 +77,17 @@ void QMC5883LComponent::dump_config() {
float QMC5883LComponent::get_setup_priority() const { return setup_priority::DATA; }
void QMC5883LComponent::update() {
uint8_t status = false;
if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG)
this->read_byte(QMC5883L_REGISTER_STATUS, &status);
this->read_byte(QMC5883L_REGISTER_STATUS, &status);
// Always request X,Y,Z regardless if there are sensors for them
// to avoid https://github.com/esphome/issues/issues/5731
uint16_t raw_x, raw_y, raw_z;
if (!this->read_byte_16_(QMC5883L_REGISTER_DATA_X_LSB, &raw_x) ||
!this->read_byte_16_(QMC5883L_REGISTER_DATA_Y_LSB, &raw_y) ||
!this->read_byte_16_(QMC5883L_REGISTER_DATA_Z_LSB, &raw_z)) {
this->status_set_warning();
return;
}
float mg_per_bit;
switch (this->range_) {
@ -93,36 +102,11 @@ void QMC5883LComponent::update() {
}
// in µT
float x = NAN, y = NAN, z = NAN;
if (this->x_sensor_ != nullptr || this->heading_sensor_ != nullptr) {
uint16_t raw_x;
if (!this->read_byte_16_(QMC5883L_REGISTER_DATA_X_LSB, &raw_x)) {
this->status_set_warning();
return;
}
x = int16_t(raw_x) * mg_per_bit * 0.1f;
}
if (this->y_sensor_ != nullptr || this->heading_sensor_ != nullptr) {
uint16_t raw_y;
if (!this->read_byte_16_(QMC5883L_REGISTER_DATA_Y_LSB, &raw_y)) {
this->status_set_warning();
return;
}
y = int16_t(raw_y) * mg_per_bit * 0.1f;
}
if (this->z_sensor_ != nullptr) {
uint16_t raw_z;
if (!this->read_byte_16_(QMC5883L_REGISTER_DATA_Z_LSB, &raw_z)) {
this->status_set_warning();
return;
}
z = int16_t(raw_z) * mg_per_bit * 0.1f;
}
const float x = int16_t(raw_x) * mg_per_bit * 0.1f;
const float y = int16_t(raw_y) * mg_per_bit * 0.1f;
const float z = int16_t(raw_z) * mg_per_bit * 0.1f;
float heading = NAN;
if (this->heading_sensor_ != nullptr) {
heading = atan2f(0.0f - x, y) * 180.0f / M_PI;
}
float heading = atan2f(0.0f - x, y) * 180.0f / M_PI;
float temp = NAN;
if (this->temperature_sensor_ != nullptr) {

3
esphome/components/rp2040/__init__.py
View File

@ -15,6 +15,7 @@ from esphome.const import (
KEY_TARGET_FRAMEWORK,
KEY_TARGET_PLATFORM,
PLATFORM_RP2040,
CONF_PLATFORM_VERSION,
)
from esphome.core import CORE, coroutine_with_priority, EsphomeError
from esphome.helpers import mkdir_p, write_file, copy_file_if_changed
@ -125,8 +126,6 @@ def _parse_platform_version(value):
return value
CONF_PLATFORM_VERSION = "platform_version"
ARDUINO_FRAMEWORK_SCHEMA = cv.All(
cv.Schema(
{

2
esphome/components/substitutions/__init__.py
View File

@ -116,7 +116,7 @@ def do_substitution_pass(config, command_line_substitutions, ignore_missing=Fals
if CONF_SUBSTITUTIONS not in config and not command_line_substitutions:
return
substitutions = config[CONF_SUBSTITUTIONS]
substitutions = config.get(CONF_SUBSTITUTIONS)
if substitutions is None:
substitutions = command_line_substitutions
elif command_line_substitutions:

22
esphome/components/template/datetime/__init__.py
View File

@ -31,6 +31,10 @@ TemplateTime = template_ns.class_(
"TemplateTime", datetime.TimeEntity, cg.PollingComponent
)
TemplateDateTime = template_ns.class_(
"TemplateDateTime", datetime.DateTimeEntity, cg.PollingComponent
)
def validate(config):
config = config.copy()
@ -78,6 +82,13 @@ CONFIG_SCHEMA = cv.All(
cv.Optional(CONF_INITIAL_VALUE): cv.date_time(allowed_date=False),
}
),
"DATETIME": datetime.datetime_schema(TemplateDateTime)
.extend(_BASE_SCHEMA)
.extend(
{
cv.Optional(CONF_INITIAL_VALUE): cv.date_time(),
}
),
},
upper=True,
),
@ -116,6 +127,17 @@ async def to_code(config):
("hour", initial_value[CONF_HOUR]),
)
cg.add(var.set_initial_value(time_struct))
elif config[CONF_TYPE] == "DATETIME":
datetime_struct = cg.StructInitializer(
cg.ESPTime,
("second", initial_value[CONF_SECOND]),
("minute", initial_value[CONF_MINUTE]),
("hour", initial_value[CONF_HOUR]),
("day_of_month", initial_value[CONF_DAY]),
("month", initial_value[CONF_MONTH]),
("year", initial_value[CONF_YEAR]),
)
cg.add(var.set_initial_value(datetime_struct))
if CONF_SET_ACTION in config:
await automation.build_automation(

150
esphome/components/template/datetime/template_datetime.cpp Normal file
View File

@ -0,0 +1,150 @@
#include "template_datetime.h"
#ifdef USE_DATETIME_DATETIME
#include "esphome/core/log.h"
namespace esphome {
namespace template_ {
static const char *const TAG = "template.datetime";
void TemplateDateTime::setup() {
if (this->f_.has_value())
return;
ESPTime state{};
if (!this->restore_value_) {
state = this->initial_value_;
} else {
datetime::DateTimeEntityRestoreState temp;
this->pref_ = global_preferences->make_preference<datetime::DateTimeEntityRestoreState>(194434090U ^
this->get_object_id_hash());
if (this->pref_.load(&temp)) {
temp.apply(this);
return;
} else {
// set to inital value if loading from pref failed
state = this->initial_value_;
}
}
this->year_ = state.year;
this->month_ = state.month;
this->day_ = state.day_of_month;
this->hour_ = state.hour;
this->minute_ = state.minute;
this->second_ = state.second;
this->publish_state();
}
void TemplateDateTime::update() {
if (!this->f_.has_value())
return;
auto val = (*this->f_)();
if (!val.has_value())
return;
this->year_ = val->year;
this->month_ = val->month;
this->day_ = val->day_of_month;
this->hour_ = val->hour;
this->minute_ = val->minute;
this->second_ = val->second;
this->publish_state();
}
void TemplateDateTime::control(const datetime::DateTimeCall &call) {
bool has_year = call.get_year().has_value();
bool has_month = call.get_month().has_value();
bool has_day = call.get_day().has_value();
bool has_hour = call.get_hour().has_value();
bool has_minute = call.get_minute().has_value();
bool has_second = call.get_second().has_value();
ESPTime value = {};
if (has_year)
value.year = *call.get_year();
if (has_month)
value.month = *call.get_month();
if (has_day)
value.day_of_month = *call.get_day();
if (has_hour)
value.hour = *call.get_hour();
if (has_minute)
value.minute = *call.get_minute();
if (has_second)
value.second = *call.get_second();
this->set_trigger_->trigger(value);
if (this->optimistic_) {
if (has_year)
this->year_ = *call.get_year();
if (has_month)
this->month_ = *call.get_month();
if (has_day)
this->day_ = *call.get_day();
if (has_hour)
this->hour_ = *call.get_hour();
if (has_minute)
this->minute_ = *call.get_minute();
if (has_second)
this->second_ = *call.get_second();
this->publish_state();
}
if (this->restore_value_) {
datetime::DateTimeEntityRestoreState temp = {};
if (has_year) {
temp.year = *call.get_year();
} else {
temp.year = this->year_;
}
if (has_month) {
temp.month = *call.get_month();
} else {
temp.month = this->month_;
}
if (has_day) {
temp.day = *call.get_day();
} else {
temp.day = this->day_;
}
if (has_hour) {
temp.hour = *call.get_hour();
} else {
temp.hour = this->hour_;
}
if (has_minute) {
temp.minute = *call.get_minute();
} else {
temp.minute = this->minute_;
}
if (has_second) {
temp.second = *call.get_second();
} else {
temp.second = this->second_;
}
this->pref_.save(&temp);
}
}
void TemplateDateTime::dump_config() {
LOG_DATETIME_DATETIME("", "Template DateTime", this);
ESP_LOGCONFIG(TAG, " Optimistic: %s", YESNO(this->optimistic_));
LOG_UPDATE_INTERVAL(this);
}
} // namespace template_
} // namespace esphome
#endif // USE_DATETIME_DATETIME

46
esphome/components/template/datetime/template_datetime.h Normal file
View File

@ -0,0 +1,46 @@
#pragma once
#include "esphome/core/defines.h"
#ifdef USE_DATETIME_TIME
#include "esphome/components/datetime/datetime_entity.h"
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/preferences.h"
#include "esphome/core/time.h"
namespace esphome {
namespace template_ {
class TemplateDateTime : public datetime::DateTimeEntity, public PollingComponent {
public:
void set_template(std::function<optional<ESPTime>()> &&f) { this->f_ = f; }
void setup() override;
void update() override;
void dump_config() override;
float get_setup_priority() const override { return setup_priority::HARDWARE; }
Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
protected:
void control(const datetime::DateTimeCall &call) override;
bool optimistic_{false};
ESPTime initial_value_{};
bool restore_value_{false};
Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
optional<std::function<optional<ESPTime>()>> f_;
ESPPreferenceObject pref_;
};
} // namespace template_
} // namespace esphome
#endif // USE_DATETIME_TIME

2
esphome/components/template/text/__init__.py
View File

@ -28,7 +28,7 @@ def validate(config):
raise cv.Invalid("optimistic cannot be used with lambda")
if CONF_INITIAL_VALUE in config:
raise cv.Invalid("initial_value cannot be used with lambda")
if CONF_RESTORE_VALUE in config:
if config[CONF_RESTORE_VALUE]:
raise cv.Invalid("restore_value cannot be used with lambda")
elif CONF_INITIAL_VALUE not in config:
config[CONF_INITIAL_VALUE] = ""

2
esphome/components/time/real_time_clock.cpp
View File

@ -13,6 +13,8 @@
#endif
#include <cerrno>
#include <cinttypes>
namespace esphome {
namespace time {

1
esphome/components/time_based/time_based_cover.h
View File

@ -23,6 +23,7 @@ class TimeBasedCover : public cover::Cover, public Component {
void set_has_built_in_endstop(bool value) { this->has_built_in_endstop_ = value; }
void set_manual_control(bool value) { this->manual_control_ = value; }
void set_assumed_state(bool value) { this->assumed_state_ = value; }
cover::CoverOperation get_last_operation() const { return this->last_operation_; }
protected:
void control(const cover::CoverCall &call) override;

2
esphome/components/tm1637/tm1637.cpp
View File

@ -225,7 +225,7 @@ void TM1637Display::display() {
// Write display CTRL CMND + brightness
this->start_();
this->send_byte_(TM1637_CMD_CTRL + ((this->intensity_ & 0x7) | 0x08));
this->send_byte_(TM1637_CMD_CTRL + ((this->intensity_ & 0x7) | (this->on_ ? 0x08 : 0x00)));
this->stop_();
}
bool TM1637Display::send_byte_(uint8_t b) {

2
esphome/components/tm1637/tm1637.h
View File

@ -49,6 +49,7 @@ class TM1637Display : public PollingComponent {
void set_intensity(uint8_t intensity) { this->intensity_ = intensity; }
void set_inverted(bool inverted) { this->inverted_ = inverted; }
void set_length(uint8_t length) { this->length_ = length; }
void set_on(bool on) { this->on_ = on; }
void display();
@ -76,6 +77,7 @@ class TM1637Display : public PollingComponent {
uint8_t intensity_;
uint8_t length_;
bool inverted_;
bool on_{true};
optional<tm1637_writer_t> writer_{};
uint8_t buffer_[6] = {0};
#ifdef USE_BINARY_SENSOR

4
esphome/components/waveshare_epaper/display.py
View File

@ -49,6 +49,9 @@ WaveshareEPaper2P9InV2R2 = waveshare_epaper_ns.class_(
"WaveshareEPaper2P9InV2R2", WaveshareEPaper
)
GDEY029T94 = waveshare_epaper_ns.class_("GDEY029T94", WaveshareEPaper)
WaveshareEPaper2P9InDKE = waveshare_epaper_ns.class_(
"WaveshareEPaper2P9InDKE", WaveshareEPaper
)
WaveshareEPaper4P2In = waveshare_epaper_ns.class_(
"WaveshareEPaper4P2In", WaveshareEPaper
)
@ -115,6 +118,7 @@ MODELS = {
"2.90in-b": ("b", WaveshareEPaper2P9InB),
"2.90in-bv3": ("b", WaveshareEPaper2P9InBV3),
"2.90inv2-r2": ("c", WaveshareEPaper2P9InV2R2),
"2.90in-dke": ("c", WaveshareEPaper2P9InDKE),
"4.20in": ("b", WaveshareEPaper4P2In),
"4.20in-bv2": ("b", WaveshareEPaper4P2InBV2),
"5.83in": ("b", WaveshareEPaper5P8In),

125
esphome/components/waveshare_epaper/waveshare_epaper.cpp
View File

@ -1127,6 +1127,131 @@ void WaveshareEPaper2P9InB::dump_config() {
LOG_UPDATE_INTERVAL(this);
}
// DKE 2.9
// https://www.badge.team/docs/badges/sha2017/hardware/#e-ink-display-the-dke-group-depg0290b1
// https://www.badge.team/docs/badges/sha2017/hardware/DEPG0290B01V3.0.pdf
static const uint8_t LUT_SIZE_DKE = 70;
static const uint8_t UPDATE_LUT_DKE[LUT_SIZE_DKE] = {
0xA0, 0x90, 0x50, 0x0, 0x0, 0x0, 0x0, 0x50, 0x90, 0xA0, 0x0, 0x0, 0x0, 0x0, 0xA0, 0x90, 0x50, 0x0,
0x0, 0x0, 0x0, 0x50, 0x90, 0xA0, 0x0, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00, 0x0, 0x0, 0x0, 0x0, 0xF,
0xF, 0x0, 0x0, 0x0, 0xF, 0xF, 0x0, 0x0, 0x02, 0xF, 0xF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};
static const uint8_t PART_UPDATE_LUT_DKE[LUT_SIZE_DKE] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xa0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x50, 0x10, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
0x05, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
static const uint8_t FULL_UPDATE_LUT_DKE[LUT_SIZE_DKE] = {
0x90, 0x50, 0xa0, 0x50, 0x50, 0x00, 0x00, 0x00, 0x00, 0x10, 0xa0, 0xa0, 0x80, 0x00, 0x90, 0x50, 0xa0, 0x50,
0x50, 0x00, 0x00, 0x00, 0x00, 0x10, 0xa0, 0xa0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17,
0x04, 0x00, 0x00, 0x00, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x06, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x00, 0x00,
0x00, 0x01, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
void WaveshareEPaper2P9InDKE::initialize() {
// Hardware reset
delay(10);
this->reset_pin_->digital_write(false);
delayMicroseconds(200);
this->reset_pin_->digital_write(true);
delayMicroseconds(200);
// Wait for busy low
this->wait_until_idle_();
// Software reset
this->command(0x12);
// Wait for busy low
this->wait_until_idle_();
// Set Analog Block Control
this->command(0x74);
this->data(0x54);
// Set Digital Block Control
this->command(0x7E);
this->data(0x3B);
// Set display size and driver output control
this->command(0x01);
// this->data(0x27);
// this->data(0x01);
// this->data(0x00);
this->data(this->get_height_internal() - 1);
this->data((this->get_height_internal() - 1) >> 8);
this->data(0x00); // ? GD = 0, SM = 0, TB = 0
// Ram data entry mode
this->command(0x11);
this->data(0x03);
// Set Ram X address
this->command(0x44);
this->data(0x00);
this->data(0x0F);
// Set Ram Y address
this->command(0x45);
this->data(0x00);
this->data(0x00);
this->data(0x27);
this->data(0x01);
// Set border
this->command(0x3C);
// this->data(0x80);
this->data(0x01);
// Set VCOM value
this->command(0x2C);
this->data(0x26);
// Gate voltage setting
this->command(0x03);
this->data(0x17);
// Source voltage setting
this->command(0x04);
this->data(0x41);
this->data(0x00);
this->data(0x32);
// Frame setting 50hz
this->command(0x3A);
this->data(0x30);
this->command(0x3B);
this->data(0x0A);
// Load LUT
this->command(0x32);
for (uint8_t v : FULL_UPDATE_LUT_DKE)
this->data(v);
}
void HOT WaveshareEPaper2P9InDKE::display() {
ESP_LOGI(TAG, "Performing e-paper update.");
// Set Ram X address counter
this->command(0x4e);
this->data(0);
// Set Ram Y address counter
this->command(0x4f);
this->data(0);
this->data(0);
// Load image (128/8*296)
this->command(0x24);
this->start_data_();
this->write_array(this->buffer_, this->get_buffer_length_());
this->end_data_();
// Image update
this->command(0x22);
this->data(0xC7);
this->command(0x20);
// Wait for busy low
this->wait_until_idle_();
// Enter deep sleep mode
this->command(0x10);
this->data(0x01);
}
int WaveshareEPaper2P9InDKE::get_width_internal() { return 128; }
int WaveshareEPaper2P9InDKE::get_height_internal() { return 296; }
void WaveshareEPaper2P9InDKE::dump_config() {
LOG_DISPLAY("", "Waveshare E-Paper", this);
ESP_LOGCONFIG(TAG, " Model: 2.9in DKE");
LOG_PIN(" Reset Pin: ", this->reset_pin_);
LOG_PIN(" DC Pin: ", this->dc_pin_);
LOG_PIN(" Busy Pin: ", this->busy_pin_);
LOG_UPDATE_INTERVAL(this);
}
void WaveshareEPaper2P9InDKE::set_full_update_every(uint32_t full_update_every) {
this->full_update_every_ = full_update_every;
}
// ========================================================
// 2.90in Type B (LUT from OTP)
// Datasheet:

24
esphome/components/waveshare_epaper/waveshare_epaper.h
View File

@ -373,6 +373,30 @@ class WaveshareEPaper2P9InV2R2 : public WaveshareEPaper {
void reset_();
};
class WaveshareEPaper2P9InDKE : public WaveshareEPaper {
public:
void initialize() override;
void display() override;
void dump_config() override;
void deep_sleep() override {
// COMMAND DEEP SLEEP
this->command(0x10);
this->data(0x01);
}
void set_full_update_every(uint32_t full_update_every);
protected:
uint32_t full_update_every_{30};
uint32_t at_update_{0};
int get_width_internal() override;
int get_height_internal() override;
};
class WaveshareEPaper4P2In : public WaveshareEPaper {
public:
void initialize() override;

9
esphome/components/web_server/list_entities.cpp
View File

@ -129,6 +129,15 @@ bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) {
}
#endif
#ifdef USE_DATETIME_DATETIME
bool ListEntitiesIterator::on_datetime(datetime::DateTimeEntity *datetime) {
if (this->web_server_->events_.count() == 0)
return true;
this->web_server_->events_.send(this->web_server_->datetime_json(datetime, DETAIL_ALL).c_str(), "state");
return true;
}
#endif
#ifdef USE_TEXT
bool ListEntitiesIterator::on_text(text::Text *text) {
if (this->web_server_->events_.count() == 0)

3
esphome/components/web_server/list_entities.h
View File

@ -47,6 +47,9 @@ class ListEntitiesIterator : public ComponentIterator {
#ifdef USE_DATETIME_TIME
bool on_time(datetime::TimeEntity *time) override;
#endif
#ifdef USE_DATETIME_DATETIME
bool on_datetime(datetime::DateTimeEntity *datetime) override;
#endif
#ifdef USE_TEXT
bool on_text(text::Text *text) override;
#endif

605
esphome/components/web_server/server_index.h
View File

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

636
esphome/components/web_server/server_index_v2.h Normal file
View File

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

3998
esphome/components/web_server/server_index_v3.h Normal file
View File

File diff suppressed because it is too large Load Diff

69
esphome/components/web_server/web_server.cpp
View File

@ -27,7 +27,11 @@
#endif
#ifdef USE_WEBSERVER_LOCAL
#include "server_index.h"
#if USE_WEBSERVER_VERSION == 2
#include "server_index_v2.h"
#elif USE_WEBSERVER_VERSION == 3
#include "server_index_v3.h"
#endif
#endif
namespace esphome {
@ -926,6 +930,8 @@ std::string WebServer::date_json(datetime::DateEntity *obj, JsonDetail start_con
#ifdef USE_DATETIME_TIME
void WebServer::on_time_update(datetime::TimeEntity *obj) {
if (this->events_.count() == 0)
return;
this->events_.send(this->time_json(obj, DETAIL_STATE).c_str(), "state");
}
void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match) {
@ -970,6 +976,55 @@ std::string WebServer::time_json(datetime::TimeEntity *obj, JsonDetail start_con
}
#endif // USE_DATETIME_TIME
#ifdef USE_DATETIME_DATETIME
void WebServer::on_datetime_update(datetime::DateTimeEntity *obj) {
if (this->events_.count() == 0)
return;
this->events_.send(this->datetime_json(obj, DETAIL_STATE).c_str(), "state");
}
void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match) {
for (auto *obj : App.get_datetimes()) {
if (obj->get_object_id() != match.id)
continue;
if (request->method() == HTTP_GET && match.method.empty()) {
std::string data = this->datetime_json(obj, DETAIL_STATE);
request->send(200, "application/json", data.c_str());
return;
}
if (match.method != "set") {
request->send(404);
return;
}
auto call = obj->make_call();
if (!request->hasParam("value")) {
request->send(409);
return;
}
if (request->hasParam("value")) {
std::string value = request->getParam("value")->value().c_str();
call.set_datetime(value);
}
this->schedule_([call]() mutable { call.perform(); });
request->send(200);
return;
}
request->send(404);
}
std::string WebServer::datetime_json(datetime::DateTimeEntity *obj, JsonDetail start_config) {
return json::build_json([obj, start_config](JsonObject root) {
set_json_id(root, obj, "datetime-" + obj->get_object_id(), start_config);
std::string value = str_sprintf("%d-%02d-%02d %02d:%02d:%02d", obj->year, obj->month, obj->day, obj->hour,
obj->minute, obj->second);
root["value"] = value;
root["state"] = value;
});
}
#endif // USE_DATETIME_DATETIME
#ifdef USE_TEXT
void WebServer::on_text_update(text::Text *obj, const std::string &state) {
if (this->events_.count() == 0)
@ -1458,6 +1513,11 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) {
return true;
#endif
#ifdef USE_DATETIME_DATETIME
if ((request->method() == HTTP_POST || request->method() == HTTP_GET) && match.domain == "datetime")
return true;
#endif
#ifdef USE_TEXT
if ((request->method() == HTTP_POST || request->method() == HTTP_GET) && match.domain == "text")
return true;
@ -1595,6 +1655,13 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
}
#endif
#ifdef USE_DATETIME_DATETIME
if (match.domain == "datetime") {
this->handle_datetime_request(request, match);
return;
}
#endif
#ifdef USE_TEXT
if (match.domain == "text") {
this->handle_text_request(request, match);

9
esphome/components/web_server/web_server.h
View File

@ -239,6 +239,15 @@ class WebServer : public Controller, public Component, public AsyncWebHandler {
std::string time_json(datetime::TimeEntity *obj, JsonDetail start_config);
#endif
#ifdef USE_DATETIME_DATETIME
void on_datetime_update(datetime::DateTimeEntity *obj) override;
/// Handle a datetime request under '/datetime/<id>'.
void handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match);
/// Dump the datetime state with its value as a JSON string.
std::string datetime_json(datetime::DateTimeEntity *obj, JsonDetail start_config);
#endif
#ifdef USE_TEXT
void on_text_update(text::Text *obj, const std::string &state) override;
/// Handle a text input request under '/text/<id>'.

32
esphome/config.py
View File

@ -374,7 +374,10 @@ class LoadValidationStep(ConfigValidationStep):
path + [CONF_ID],
)
continue
result.add_str_error("No platform specified! See 'platform' key.", path)
result.add_str_error(
f"'{self.domain}' requires a 'platform' key but it was not specified.",
path,
)
continue
# Remove temp output path and construct new one
result.remove_output_path(path, p_domain)
@ -449,9 +452,28 @@ class MetadataValidationStep(ConfigValidationStep):
success = True
for dependency in self.comp.dependencies:
if dependency not in result:
dependency_parts = dependency.split(".")
if len(dependency_parts) > 2:
result.add_str_error(
f"Component {self.domain} requires component {dependency}",
"Dependencies must be specified as a single component or in component.platform format only",
self.path,
)
return
component_dep = dependency_parts[0]
platform_dep = dependency_parts[-1]
if component_dep not in result:
result.add_str_error(
f"Component {self.domain} requires component {component_dep}",
self.path,
)
success = False
elif component_dep != platform_dep and (
not isinstance(platform_list := result.get(component_dep), list)
or not any(CONF_PLATFORM in p for p in platform_list)
or not any(p[CONF_PLATFORM] == platform_dep for p in platform_list)
):
result.add_str_error(
f"Component {self.domain} requires 'platform: {platform_dep}' in component '{component_dep}'",
self.path,
)
success = False
@ -756,11 +778,11 @@ def validate_config(
CORE.raw_config = config
# 1. Load substitutions
if CONF_SUBSTITUTIONS in config:
if CONF_SUBSTITUTIONS in config or command_line_substitutions:
from esphome.components import substitutions
result[CONF_SUBSTITUTIONS] = {
**config[CONF_SUBSTITUTIONS],
**config.get(CONF_SUBSTITUTIONS, {}),
**command_line_substitutions,
}
result.add_output_path([CONF_SUBSTITUTIONS], CONF_SUBSTITUTIONS)

2
esphome/config_validation.py
View File

@ -304,7 +304,7 @@ def string(value):
"""Validate that a configuration value is a string. If not, automatically converts to a string.
Note that this can be lossy, for example the input value 60.00 (float) will be turned into
"60.0" (string). For values where this could be a problem `string_string` has to be used.
"60.0" (string). For values where this could be a problem `string_strict` has to be used.
"""
check_not_templatable(value)
if isinstance(value, (dict, list)):

2
esphome/const.py
View File

@ -179,6 +179,7 @@ CONF_DATA_PINS = "data_pins"
CONF_DATA_RATE = "data_rate"
CONF_DATA_TEMPLATE = "data_template"
CONF_DATE = "date"
CONF_DATETIME = "datetime"
CONF_DAY = "day"
CONF_DAYS_OF_MONTH = "days_of_month"
CONF_DAYS_OF_WEEK = "days_of_week"
@ -597,6 +598,7 @@ CONF_PIN_D = "pin_d"
CONF_PINS = "pins"
CONF_PIXEL_MAPPER = "pixel_mapper"
CONF_PLATFORM = "platform"
CONF_PLATFORM_VERSION = "platform_version"
CONF_PLATFORMIO_OPTIONS = "platformio_options"
CONF_PM_0_3UM = "pm_0_3um"
CONF_PM_0_5UM = "pm_0_5um"

19
esphome/core/application.h
View File

@ -45,6 +45,9 @@
#ifdef USE_DATETIME_TIME
#include "esphome/components/datetime/time_entity.h"
#endif
#ifdef USE_DATETIME_DATETIME
#include "esphome/components/datetime/datetime_entity.h"
#endif
#ifdef USE_TEXT
#include "esphome/components/text/text.h"
#endif
@ -141,6 +144,10 @@ class Application {
void register_time(datetime::TimeEntity *time) { this->times_.push_back(time); }
#endif
#ifdef USE_DATETIME_DATETIME
void register_datetime(datetime::DateTimeEntity *datetime) { this->datetimes_.push_back(datetime); }
#endif
#ifdef USE_TEXT
void register_text(text::Text *text) { this->texts_.push_back(text); }
#endif
@ -335,6 +342,15 @@ class Application {
return nullptr;
}
#endif
#ifdef USE_DATETIME_DATETIME
const std::vector<datetime::DateTimeEntity *> &get_datetimes() { return this->datetimes_; }
datetime::DateTimeEntity *get_datetime_by_key(uint32_t key, bool include_internal = false) {
for (auto *obj : this->datetimes_)
if (obj->get_object_id_hash() == key && (include_internal || !obj->is_internal()))
return obj;
return nullptr;
}
#endif
#ifdef USE_TEXT
const std::vector<text::Text *> &get_texts() { return this->texts_; }
text::Text *get_text_by_key(uint32_t key, bool include_internal = false) {
@ -456,6 +472,9 @@ class Application {
#ifdef USE_DATETIME_TIME
std::vector<datetime::TimeEntity *> times_{};
#endif
#ifdef USE_DATETIME_DATETIME
std::vector<datetime::DateTimeEntity *> datetimes_{};
#endif
#ifdef USE_SELECT
std::vector<select::Select *> selects_{};
#endif

2
esphome/core/component.h
View File

@ -85,7 +85,7 @@ class Component {
/** priority of setup(). higher -> executed earlier
*
* Defaults to 0.
* Defaults to setup_priority::DATA, i.e. 600.
*
* @return The setup priority of this component
*/

15
esphome/core/component_iterator.cpp
View File

@ -232,6 +232,21 @@ void ComponentIterator::advance() {
}
break;
#endif
#ifdef USE_DATETIME_DATETIME
case IteratorState::DATETIME_DATETIME:
if (this->at_ >= App.get_datetimes().size()) {
advance_platform = true;
} else {
auto *datetime = App.get_datetimes()[this->at_];
if (datetime->is_internal() && !this->include_internal_) {
success = true;
break;
} else {
success = this->on_datetime(datetime);
}
}
break;
#endif
#ifdef USE_TEXT
case IteratorState::TEXT:
if (this->at_ >= App.get_texts().size()) {

6
esphome/core/component_iterator.h
View File

@ -63,6 +63,9 @@ class ComponentIterator {
#ifdef USE_DATETIME_TIME
virtual bool on_time(datetime::TimeEntity *time) = 0;
#endif
#ifdef USE_DATETIME_DATETIME
virtual bool on_datetime(datetime::DateTimeEntity *datetime) = 0;
#endif
#ifdef USE_TEXT
virtual bool on_text(text::Text *text) = 0;
#endif
@ -132,6 +135,9 @@ class ComponentIterator {
#ifdef USE_DATETIME_TIME
DATETIME_TIME,
#endif
#ifdef USE_DATETIME_DATETIME
DATETIME_DATETIME,
#endif
#ifdef USE_TEXT
TEXT,
#endif

6
esphome/core/controller.cpp
View File

@ -71,6 +71,12 @@ void Controller::setup_controller(bool include_internal) {
obj->add_on_state_callback([this, obj]() { this->on_time_update(obj); });
}
#endif
#ifdef USE_DATETIME_DATETIME
for (auto *obj : App.get_datetimes()) {
if (include_internal || !obj->is_internal())
obj->add_on_state_callback([this, obj]() { this->on_datetime_update(obj); });
}
#endif
#ifdef USE_TEXT
for (auto *obj : App.get_texts()) {
if (include_internal || !obj->is_internal())

6
esphome/core/controller.h
View File

@ -37,6 +37,9 @@
#ifdef USE_DATETIME_TIME
#include "esphome/components/datetime/time_entity.h"
#endif
#ifdef USE_DATETIME_DATETIME
#include "esphome/components/datetime/datetime_entity.h"
#endif
#ifdef USE_TEXT
#include "esphome/components/text/text.h"
#endif
@ -97,6 +100,9 @@ class Controller {
#ifdef USE_DATETIME_TIME
virtual void on_time_update(datetime::TimeEntity *obj){};
#endif
#ifdef USE_DATETIME_DATETIME
virtual void on_datetime_update(datetime::DateTimeEntity *obj){};
#endif
#ifdef USE_TEXT
virtual void on_text_update(text::Text *obj, const std::string &state){};
#endif

1
esphome/core/defines.h
View File

@ -39,6 +39,7 @@
#define USE_DATETIME
#define USE_DATETIME_DATE
#define USE_DATETIME_TIME
#define USE_DATETIME_DATETIME
#define USE_OTA
#define USE_OTA_PASSWORD
#define USE_OTA_STATE_CALLBACK

2
esphome/core/helpers.cpp
View File

@ -437,7 +437,7 @@ static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c ==
std::string base64_encode(const std::vector<uint8_t> &buf) { return base64_encode(buf.data(), buf.size()); }
std::string base64_encode(const char *buf, unsigned int buf_len) {
std::string base64_encode(const uint8_t *buf, size_t buf_len) {
std::string ret;
int i = 0;
int j = 0;

9
esphome/core/time.cpp
View File

@ -178,6 +178,15 @@ void ESPTime::recalc_timestamp_utc(bool use_day_of_year) {
this->timestamp = res;
}
void ESPTime::recalc_timestamp_local(bool use_day_of_year) {
this->recalc_timestamp_utc(use_day_of_year);
this->timestamp -= ESPTime::timezone_offset();
ESPTime temp = ESPTime::from_epoch_local(this->timestamp);
if (temp.is_dst) {
this->timestamp -= 3600;
}
}
int32_t ESPTime::timezone_offset() {
int32_t offset = 0;
time_t now = ::time(nullptr);

3
esphome/core/time.h
View File

@ -99,6 +99,9 @@ struct ESPTime {
/// Recalculate the timestamp field from the other fields of this ESPTime instance (must be UTC).
void recalc_timestamp_utc(bool use_day_of_year = true);
/// Recalculate the timestamp field from the other fields of this ESPTime instance assuming local fields.
void recalc_timestamp_local(bool use_day_of_year = true);
/// Convert this ESPTime instance back to a tm struct.
struct tm to_c_tm();

1
script/ci-custom.py
View File

@ -623,6 +623,7 @@ def lint_trailing_whitespace(fname, match):
"esphome/components/cover/cover.h",
"esphome/components/datetime/date_entity.h",
"esphome/components/datetime/time_entity.h",
"esphome/components/datetime/datetime_entity.h",
"esphome/components/display/display.h",
"esphome/components/event/event.h",
"esphome/components/fan/fan.h",

8
script/list-components.py
View File

@ -69,7 +69,9 @@ def create_components_graph():
sys.exit(1)
for dependency in comp.dependencies:
add_item_to_components_graph(components_graph, dependency, name)
add_item_to_components_graph(
components_graph, dependency.split(".")[0], name
)
for target_config in TARGET_CONFIGURATIONS:
CORE.data[KEY_CORE] = target_config
@ -87,7 +89,9 @@ def create_components_graph():
add_item_to_components_graph(components_graph, platform_name, name)
for dependency in platform.dependencies:
add_item_to_components_graph(components_graph, dependency, name)
add_item_to_components_graph(
components_graph, dependency.split(".")[0], name
)
for target_config in TARGET_CONFIGURATIONS:
CORE.data[KEY_CORE] = target_config

4
script/sync-device_class.py
View File

@ -6,9 +6,11 @@ import re
from homeassistant.components.binary_sensor import BinarySensorDeviceClass
from homeassistant.components.button import ButtonDeviceClass
from homeassistant.components.cover import CoverDeviceClass
from homeassistant.components.event import EventDeviceClass
from homeassistant.components.number import NumberDeviceClass
from homeassistant.components.sensor import SensorDeviceClass
from homeassistant.components.switch import SwitchDeviceClass
from homeassistant.components.valve import ValveDeviceClass
# pylint: enable=import-error
@ -21,9 +23,11 @@ DOMAINS = {
"binary_sensor": BinarySensorDeviceClass,
"button": ButtonDeviceClass,
"cover": CoverDeviceClass,
"event": EventDeviceClass,
"number": NumberDeviceClass,
"sensor": SensorDeviceClass,
"switch": SwitchDeviceClass,
"valve": ValveDeviceClass,
}

4
script/test_build_components
View File

@ -37,9 +37,9 @@ start_esphome() {
# Start esphome process
echo "> [$target_component] [$test_name] [$target_platform]"
echo "esphome -s component_name $target_component -s test_name $test_name -s target_platform $target_platform $esphome_command $component_test_file"
echo "esphome -s component_name $target_component -s component_dir ../../components/$target_component -s test_name $test_name -s target_platform $target_platform $esphome_command $component_test_file"
# TODO: Validate escape of Command line substitution value
esphome -s component_name $target_component -s test_name $test_name -s target_platform $target_platform $esphome_command $component_test_file
esphome -s component_name $target_component -s component_dir ../../components/$target_component -s test_name $test_name -s target_platform $target_platform $esphome_command $component_test_file
}
# Find all test yaml files.

14
tests/component_tests/text/test_text.py
View File

@ -54,3 +54,17 @@ def test_text_config_value_mode_set(generate_main):
# Then
assert "it_1->traits.set_mode(text::TEXT_MODE_TEXT);" in main_cpp
assert "it_3->traits.set_mode(text::TEXT_MODE_PASSWORD);" in main_cpp
def test_text_config_lamda_is_set(generate_main):
"""
Test if lambda is set for lambda mode
"""
# Given
# When
main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
# Then
assert "it_4->set_template([=]() -> optional<std::string> {" in main_cpp
assert 'return std::string{"Hello"};' in main_cpp

12
tests/component_tests/text/test_text.yaml
View File

@ -31,3 +31,15 @@ text:
optimistic: true
internal: true
max_length: 255
- platform: template
name: "test 4 key"
id: "it_4"
mode: text
set_action:
- then:
- logger.log:
format: Template text set to %s
args: ["x.c_str()"]
lambda: |
return std::string{"Hello"};

2
tests/components/datetime/test.all.yaml
View File

@ -1 +1,3 @@
datetime:
time:

15
tests/components/host/test.host.yaml Normal file
View File

@ -0,0 +1,15 @@
time:
- platform: sntp
id: esptime
timezone: Australia/Sydney
logger:
level: VERBOSE
logs:
lvgl: INFO
display: DEBUG
sensor: INFO
vnc: DEBUG
host:
mac_address: "62:23:45:AF:B3:DD"

33
tests/components/template/test.all.yaml → tests/components/template/common.yaml
View File

@ -149,6 +149,17 @@ text:
min_length: 0
max_length: 100
mode: text
- platform: template
name: "Template text lambda"
mode: text
update_interval: 1s
lambda: |
return std::string{"Hello!"};
set_action:
then:
- logger.log:
format: Template Text set to %s
args: ["x.c_str()"]
alarm_control_panel:
- platform: template
@ -183,3 +194,25 @@ datetime:
- x.hour
- x.minute
- x.second
- platform: template
name: DateTime
id: test_datetime
type: datetime
set_action:
- logger.log: "set_value"
on_value:
- logger.log:
format: "DateTime: %04d-%02d-%02d %02d:%02d:%02d"
args:
- x.year
- x.month
- x.day_of_month
- x.hour
- x.minute
- x.second
time:
- platform: sntp # Required for datetime
wifi: # Required for sntp time
ap:

2
tests/components/template/test.bk72xx.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.esp32-c3-idf.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.esp32-c3.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.esp32-idf.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.esp32-s3-idf.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.esp32.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.esp8266.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

2
tests/components/template/test.rp2040.yaml Normal file
View File

@ -0,0 +1,2 @@
packages:
common: !include common.yaml

Some files were not shown because too many files have changed in this diff Show More