fdo-mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2026-05-21 07:38:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

validity: externalize proprietary blob data to runtime-loaded files

Browse source 
Remove ~400KB of compiled-in .inc blob files and replace with a runtime
data loader that reads HMAC-SHA256 verified .bin files from disk at
device open time.

New components:
- validity_data.h/c: Runtime data file loader with HMAC-SHA256 integrity
  verification. Searches /usr/share/libfprint/validity/ and
  /usr/local/share/libfprint/validity/ for per-device and common data
  files. Skipped entirely in emulation mode.

Changes to existing code:
- validity.c: New OPEN_LOAD_DATA SSM state loads device and common data
  files between firmware info reception and init sequence. Populates TLS
  key pointers from loaded data. Frees data stores on close.
- validity_hal.h/c: Simplified device_table to vid/pid/flash_layout only
  (all blob pointers and partition_sig removed from structs).
- validity_pair.c/h: Updated make_cert, build_partition_flash_cmd,
  build_tls_flash to take data parameters instead of using compiled-in
  arrays. Reset/DBE blob accessors use data store.
- validity_tls.c/h: Removed 4 static key arrays, added pointer fields
  to ValidityTlsState populated from loaded data.
- validity_db.c/h, validity_fwext.c/h: Updated get_write_enable_blob
  to take FpiDeviceValidity* and access data store.
- validity_enroll.c: Updated all 5 callers for new signatures.

Deleted files:
- validity_blobs_0090.inc, validity_blobs_0097.inc,
  validity_blobs_009a.inc, validity_blobs_009d.inc (~400KB)
- validity_pair_constants.inc (~6KB)

Tests (171 total, all passing):
- 15 data loader tests covering: empty store, double-free safety,
  valid/corrupt/too-small/nonexistent file loading, tag enum,
  load_device with missing dir/missing mandatory file/valid files/
  corrupt HMAC, load_common with missing/valid files, enroll
  db_write_enable accessor with empty and populated stores.
- All existing unit and integration tests updated and passing.

The data files are distributed separately via the
libfprint-validity-data package.
This commit is contained in:
Leonardo Francisco 2026-04-12 00:17:09 -04:00 • committed by lewohart
parent ef4beee574
commit f35dd0322a
22 changed files with 1358 additions and 4497 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
libfprint/drivers/validity/validity.c
View file

@ -23,6 +23,7 @@
#include "drivers_api.h"
#include "fpi-byte-reader.h"
#include "validity.h"
#include "validity_data.h"
#include "validity_fwext.h"
#include "validity_pair.h"
#include "validity_tls.h"
@ -178,6 +179,7 @@ typedef enum {
OPEN_RECV_CMD19,
OPEN_SEND_GET_FW_INFO,
OPEN_RECV_GET_FW_INFO,
OPEN_LOAD_DATA,
OPEN_SEND_INIT_HARDCODED,
OPEN_RECV_INIT_HARDCODED,
OPEN_SEND_INIT_CLEAN_SLATE,
@ -481,22 +483,74 @@ open_recv_get_fw_info (FpiSsm *ssm,
fw_info_recv_cb, NULL);
}
static void
open_load_data (FpiSsm *ssm,
FpiDeviceValidity *self)
{
const ValidityDeviceDesc *desc;
GError *error = NULL;
/* In emulation mode, skip loading external data files —
* the emulated device uses in-memory store, not real blobs */
if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
{
fp_dbg ("Emulation mode — skipping data file loading");
fpi_ssm_next_state (ssm);
return;
}
desc = validity_hal_device_lookup (self->dev_type);
if (!desc)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED));
return;
}
validity_data_store_init (&self->device_data);
validity_data_store_init (&self->common_data);
/* Load per-device blobs */
if (!validity_data_load_device (&self->device_data,
desc->vid, desc->pid, &error))
{
fpi_ssm_mark_failed (ssm, error);
return;
}
/* Load common data (partition sigs, CA cert, TLS keys, etc.) */
if (!validity_data_load_common (&self->common_data, &error))
{
fpi_ssm_mark_failed (ssm, error);
return;
}
/* Populate TLS state key pointers from common data store */
self->tls.password = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_TLS_PASSWORD,
&self->tls.password_len);
self->tls.gwk_sign = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_GWK_SIGN,
&self->tls.gwk_sign_len);
self->tls.fw_pubkey_x = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_FW_PUBKEY_X,
&self->tls.fw_pubkey_x_len);
self->tls.fw_pubkey_y = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_FW_PUBKEY_Y,
&self->tls.fw_pubkey_y_len);
fp_info ("Loaded external data files for %04x:%04x", desc->vid, desc->pid);
fpi_ssm_next_state (ssm);
}
static void
open_send_init_hardcoded (FpiSsm *ssm,
FpiDeviceValidity *self)
{
FpDevice *dev = FP_DEVICE (self);
FpiUsbTransfer *transfer;
const ValidityDeviceDesc *desc =
validity_hal_device_lookup (self->dev_type);
if (!desc || !desc->init_hardcoded)
{
fp_warn ("No init_hardcoded blob for dev_type %u — skipping",
self->dev_type);
fpi_ssm_jump_to_state (ssm, OPEN_UPLOAD_FWEXT);
return;
}
gsize init_len;
const guint8 *init_data;
/* In emulation mode, skip raw USB blobs */
if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
@ -506,14 +560,22 @@ open_send_init_hardcoded (FpiSsm *ssm,
return;
}
fp_dbg ("Sending init_hardcoded (%zu bytes)", desc->init_hardcoded_len);
init_data = validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_INIT, &init_len);
if (!init_data || init_len == 0)
{
fp_warn ("No init_hardcoded data loaded — skipping");
fpi_ssm_jump_to_state (ssm, OPEN_UPLOAD_FWEXT);
return;
}
fp_dbg ("Sending init_hardcoded (%zu bytes)", init_len);
transfer = fpi_usb_transfer_new (dev);
transfer->short_is_error = TRUE;
transfer->ssm = ssm;
fpi_usb_transfer_fill_bulk (transfer, VALIDITY_EP_CMD_OUT,
desc->init_hardcoded_len);
memcpy (transfer->buffer, desc->init_hardcoded,
desc->init_hardcoded_len);
fpi_usb_transfer_fill_bulk (transfer, VALIDITY_EP_CMD_OUT, init_len);
memcpy (transfer->buffer, init_data, init_len);
fpi_usb_transfer_submit (transfer, VALIDITY_USB_TIMEOUT, NULL,
fpi_ssm_usb_transfer_cb, NULL);
}
@ -539,6 +601,8 @@ open_send_init_clean_slate (FpiSsm *ssm,
{
FpDevice *dev = FP_DEVICE (self);
FpiUsbTransfer *transfer;
gsize cs_len;
const guint8 *cs_data;
/* clean_slate is only sent when fwext is NOT loaded */
if (self->fwext_loaded)
@ -547,25 +611,23 @@ open_send_init_clean_slate (FpiSsm *ssm,
return;
}
const ValidityDeviceDesc *desc =
validity_hal_device_lookup (self->dev_type);
cs_data = validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_INIT_CLEAN_SLATE,
&cs_len);
if (!desc || !desc->init_clean_slate)
if (!cs_data || cs_len == 0)
{
fp_dbg ("No init_clean_slate blob — skipping");
fp_dbg ("No init_clean_slate data — skipping");
fpi_ssm_next_state (ssm);
return;
}
fp_info ("Fwext not loaded — sending init_clean_slate (%zu bytes)",
desc->init_clean_slate_len);
fp_info ("Fwext not loaded — sending init_clean_slate (%zu bytes)", cs_len);
transfer = fpi_usb_transfer_new (dev);
transfer->short_is_error = TRUE;
transfer->ssm = ssm;
fpi_usb_transfer_fill_bulk (transfer, VALIDITY_EP_CMD_OUT,
desc->init_clean_slate_len);
memcpy (transfer->buffer, desc->init_clean_slate,
desc->init_clean_slate_len);
fpi_usb_transfer_fill_bulk (transfer, VALIDITY_EP_CMD_OUT, cs_len);
memcpy (transfer->buffer, cs_data, cs_len);
fpi_usb_transfer_submit (transfer, VALIDITY_USB_TIMEOUT, NULL,
fpi_ssm_usb_transfer_cb, NULL);
}
@ -1100,6 +1162,10 @@ open_run_state (FpiSsm *ssm,
open_recv_get_fw_info (ssm, self);
break;
case OPEN_LOAD_DATA:
open_load_data (ssm, self);
break;
case OPEN_SEND_INIT_HARDCODED:
open_send_init_hardcoded (ssm, self);
break;
@ -1258,6 +1324,8 @@ dev_close (FpDevice *device)
validity_sensor_state_clear (&self->sensor);
validity_pair_state_free (&self->pair_state);
validity_tls_free (&self->tls);
validity_data_store_free (&self->device_data);
validity_data_store_free (&self->common_data);
g_clear_pointer (&self->emulation_prints, g_ptr_array_unref);

5
libfprint/drivers/validity/validity.h
View file

@ -23,6 +23,7 @@
#include "fpi-device.h"
#include "fpi-ssm.h"
#include "validity_capture.h"
#include "validity_data.h"
#include "validity_db.h"
#include "validity_pair.h"
#include "validity_sensor.h"
@ -249,6 +250,10 @@ struct _FpiDeviceValidity
ValidityVersionInfo version_info;
GCancellable *interrupt_cancellable;
/* Runtime data files loaded from libfprint-validity-data package */
ValidityDataStore device_data;
ValidityDataStore common_data;
/* TLS session state */
ValidityTlsState tls;

879
libfprint/drivers/validity/validity_blobs_0090.inc
View file

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

1084
libfprint/drivers/validity/validity_blobs_0097.inc
View file

File diff suppressed because it is too large Load diff

1084
libfprint/drivers/validity/validity_blobs_009a.inc
View file

File diff suppressed because it is too large Load diff

1084
libfprint/drivers/validity/validity_blobs_009d.inc
View file

File diff suppressed because it is too large Load diff

292
libfprint/drivers/validity/validity_data.c Normal file
View file

@ -0,0 +1,292 @@
/*
* Runtime data file loader for Validity/Synaptics VCSFW fingerprint sensors
*
* Copyright (C) 2024 libfprint contributors
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define FP_COMPONENT "validity"
#include "validity_data.h"
#include "fpi-log.h"
#include "fp-device.h"
#include <glib/gstdio.h>
#include <string.h>
/* Search paths for data files */
const gchar *validity_data_search_paths[] = {
"/usr/share/libfprint/validity",
"/usr/local/share/libfprint/validity",
NULL,
};
/* HMAC-SHA256 key for integrity verification.
* This is NOT secret — it is also compiled into the data package generator.
* Purpose: detect file corruption and casual tampering, not authentication.
* Plain text: "libfprint-validity-data-integrit" (32 bytes) */
static const guint8 hmac_key[32] = {
0x6c, 0x69, 0x62, 0x66, 0x70, 0x72, 0x69, 0x6e, /* "libfprin" */
0x74, 0x2d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69, /* "t-validi" */
0x74, 0x79, 0x2d, 0x64, 0x61, 0x74, 0x61, 0x2d, /* "ty-data-" */
0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x69, 0x74, /* "integrit" */
};
/* Per-device blob filename mapping (indexed by tag) */
static const gchar *device_blob_filenames[] = {
[VALIDITY_DATA_INIT] = "init.bin",
[VALIDITY_DATA_INIT_CLEAN_SLATE] = "init_clean_slate.bin",
[VALIDITY_DATA_RESET] = "reset.bin",
[VALIDITY_DATA_DB_WRITE_ENABLE] = "db_write_enable.bin",
};
/* Common data filename mapping (indexed by tag) */
static const struct {
ValidityDataTag tag;
const gchar *filename;
} common_file_map[] = {
{ VALIDITY_DATA_PARTITION_SIG_STANDARD, "partition_sig_standard.bin" },
{ VALIDITY_DATA_PARTITION_SIG_0090, "partition_sig_0090.bin" },
{ VALIDITY_DATA_CA_PUBKEY, "ca_pubkey.bin" },
{ VALIDITY_DATA_TLS_PASSWORD, "tls_password.bin" },
{ VALIDITY_DATA_GWK_SIGN, "gwk_sign.bin" },
{ VALIDITY_DATA_FW_PUBKEY_X, "fw_pubkey_x.bin" },
{ VALIDITY_DATA_FW_PUBKEY_Y, "fw_pubkey_y.bin" },
};
/* ================================================================
* HMAC-SHA256 verification
* ================================================================ */
static gboolean
verify_hmac (const guint8 *data,
gsize data_len,
const guint8 *expected_hmac)
{
guint8 computed[32];
GHmac *hmac = g_hmac_new (G_CHECKSUM_SHA256, hmac_key, sizeof (hmac_key));
g_hmac_update (hmac, data, data_len);
gsize digest_len = sizeof (computed);
g_hmac_get_digest (hmac, computed, &digest_len);
g_hmac_unref (hmac);
/* Constant-time comparison */
guint diff = 0;
for (gsize i = 0; i < 32; i++)
diff |= computed[i] ^ expected_hmac[i];
return diff == 0;
}
/* ================================================================
* Public API
* ================================================================ */
void
validity_data_store_init (ValidityDataStore *store)
{
memset (store, 0, sizeof (*store));
}
void
validity_data_store_free (ValidityDataStore *store)
{
for (gsize i = 0; i < VALIDITY_DATA_NUM_TAGS; i++)
g_clear_pointer (&store->entries[i], g_bytes_unref);
}
gboolean
validity_data_load_file (ValidityDataStore *store,
ValidityDataTag tag,
const gchar *filepath,
GError **error)
{
g_autofree guint8 *contents = NULL;
gsize length = 0;
g_return_val_if_fail (store != NULL, FALSE);
g_return_val_if_fail (tag < VALIDITY_DATA_NUM_TAGS, FALSE);
g_return_val_if_fail (filepath != NULL, FALSE);
if (!g_file_get_contents (filepath, (gchar **) &contents, &length, error))
return FALSE;
if (length < VALIDITY_DATA_MIN_FILE_SIZE)
{
g_set_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID,
"Data file '%s' too short (%zu bytes, minimum %d)",
filepath, length, VALIDITY_DATA_MIN_FILE_SIZE);
return FALSE;
}
gsize data_len = length - VALIDITY_DATA_HMAC_SIZE;
const guint8 *hmac_trailer = contents + data_len;
if (!verify_hmac (contents, data_len, hmac_trailer))
{
g_set_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID,
"Data file '%s' failed HMAC verification — "
"file may be corrupt or from an incompatible version",
filepath);
return FALSE;
}
/* Store only the data portion (without HMAC trailer) */
g_clear_pointer (&store->entries[tag], g_bytes_unref);
store->entries[tag] = g_bytes_new (contents, data_len);
fp_dbg ("Loaded data file: %s (%zu bytes)", filepath, data_len);
return TRUE;
}
gboolean
validity_data_load_device (ValidityDataStore *store,
guint16 vid,
guint16 pid,
GError **error)
{
g_autofree gchar *subdir = g_strdup_printf ("%04x_%04x", vid, pid);
gboolean found_any = FALSE;
g_return_val_if_fail (store != NULL, FALSE);
for (const gchar **base = validity_data_search_paths; *base != NULL; base++)
{
g_autofree gchar *dir_path = g_build_filename (*base, subdir, NULL);
if (!g_file_test (dir_path, G_FILE_TEST_IS_DIR))
continue;
found_any = TRUE;
fp_info ("Loading device data from %s", dir_path);
for (gsize i = 0; i < G_N_ELEMENTS (device_blob_filenames); i++)
{
if (device_blob_filenames[i] == NULL)
continue;
g_autofree gchar *fpath =
g_build_filename (dir_path, device_blob_filenames[i], NULL);
if (!g_file_test (fpath, G_FILE_TEST_IS_REGULAR))
{
fp_dbg ("Optional device blob not found: %s", fpath);
continue;
}
if (!validity_data_load_file (store, (ValidityDataTag) i,
fpath, error))
return FALSE;
}
break; /* Found directory — don't search further */
}
if (!found_any)
{
g_set_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_NOT_FOUND,
"Device data files not found for %04x:%04x. "
"Install the libfprint-validity-data package. "
"Search paths: /usr/share/libfprint/validity/, "
"/usr/local/share/libfprint/validity/",
vid, pid);
return FALSE;
}
/* Verify that init.bin was loaded (it is mandatory) */
if (!store->entries[VALIDITY_DATA_INIT])
{
g_set_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_NOT_FOUND,
"Required file init.bin not found for %04x:%04x",
vid, pid);
return FALSE;
}
return TRUE;
}
gboolean
validity_data_load_common (ValidityDataStore *store,
GError **error)
{
g_return_val_if_fail (store != NULL, FALSE);
for (gsize i = 0; i < G_N_ELEMENTS (common_file_map); i++)
{
ValidityDataTag tag = common_file_map[i].tag;
const gchar *filename = common_file_map[i].filename;
gboolean found = FALSE;
for (const gchar **base = validity_data_search_paths;
*base != NULL; base++)
{
g_autofree gchar *fpath =
g_build_filename (*base, filename, NULL);
if (!g_file_test (fpath, G_FILE_TEST_IS_REGULAR))
continue;
if (!validity_data_load_file (store, tag, fpath, error))
return FALSE;
found = TRUE;
break;
}
if (!found)
{
g_set_error (error, FP_DEVICE_ERROR,
FP_DEVICE_ERROR_DATA_NOT_FOUND,
"Common data file '%s' not found. "
"Install the libfprint-validity-data package. "
"Search paths: /usr/share/libfprint/validity/, "
"/usr/local/share/libfprint/validity/",
filename);
return FALSE;
}
}
return TRUE;
}
GBytes *
validity_data_get (const ValidityDataStore *store,
ValidityDataTag tag)
{
g_return_val_if_fail (store != NULL, NULL);
g_return_val_if_fail (tag < VALIDITY_DATA_NUM_TAGS, NULL);
return store->entries[tag];
}
const guint8 *
validity_data_get_bytes (const ValidityDataStore *store,
ValidityDataTag tag,
gsize *len)
{
g_return_val_if_fail (len != NULL, NULL);
GBytes *bytes = validity_data_get (store, tag);
if (!bytes)
{
*len = 0;
return NULL;
}
return g_bytes_get_data (bytes, len);
}

102
libfprint/drivers/validity/validity_data.h Normal file
View file

@ -0,0 +1,102 @@
/*
* Runtime data file loader for Validity/Synaptics VCSFW fingerprint sensors
*
* Loads per-device blob data and common pairing/TLS constants from
* external .bin files installed by the libfprint-validity-data package.
*
* File format: [raw_data: N bytes][HMAC-SHA256: 32 bytes]
* Install path: /usr/share/libfprint/validity/
*
* Copyright (C) 2024 libfprint contributors
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <glib.h>
/* HMAC-SHA256 trailer size appended to each .bin file */
#define VALIDITY_DATA_HMAC_SIZE 32
/* Minimum file size: at least 1 byte of data + 32 bytes HMAC */
#define VALIDITY_DATA_MIN_FILE_SIZE (1 + VALIDITY_DATA_HMAC_SIZE)
/* Data file tags — identifies which blob is being loaded */
typedef enum {
/* Per-device blobs (in <vid>_<pid>/ subdirectory) */
VALIDITY_DATA_INIT = 0,
VALIDITY_DATA_INIT_CLEAN_SLATE,
VALIDITY_DATA_RESET,
VALIDITY_DATA_DB_WRITE_ENABLE,
/* Common data files (in base directory) */
VALIDITY_DATA_PARTITION_SIG_STANDARD,
VALIDITY_DATA_PARTITION_SIG_0090,
VALIDITY_DATA_CA_PUBKEY,
VALIDITY_DATA_TLS_PASSWORD,
VALIDITY_DATA_GWK_SIGN,
VALIDITY_DATA_FW_PUBKEY_X,
VALIDITY_DATA_FW_PUBKEY_Y,
VALIDITY_DATA_NUM_TAGS,
} ValidityDataTag;
/* Container for loaded data files */
typedef struct
{
GBytes *entries[VALIDITY_DATA_NUM_TAGS];
} ValidityDataStore;
/* Search paths for data files (defined in validity_data.c) */
extern const gchar *validity_data_search_paths[];
/* Initialize a data store (all entries NULL) */
void validity_data_store_init (ValidityDataStore *store);
/* Free all loaded data in a store */
void validity_data_store_free (ValidityDataStore *store);
/* Load a single .bin file, verify its HMAC, and store in the given tag slot.
* Returns TRUE on success. On failure, sets error and returns FALSE. */
gboolean validity_data_load_file (ValidityDataStore *store,
ValidityDataTag tag,
const gchar *filepath,
GError **error);
/* Load all per-device blob files for the given VID/PID.
* Searches validity_data_search_paths for <vid>_<pid>/ subdirectory.
* Returns TRUE if all required blobs found, FALSE with error otherwise. */
gboolean validity_data_load_device (ValidityDataStore *store,
guint16 vid,
guint16 pid,
GError **error);
/* Load all common data files (partition sigs, CA cert, TLS keys, etc.).
* Returns TRUE if all files found, FALSE with error otherwise. */
gboolean validity_data_load_common (ValidityDataStore *store,
GError **error);
/* Get the raw data bytes for a given tag (without HMAC trailer).
* Returns NULL if the tag has not been loaded. The returned GBytes
* is owned by the store — do not unref. */
GBytes *validity_data_get (const ValidityDataStore *store,
ValidityDataTag tag);
/* Convenience: get raw data pointer and length for a tag.
* Returns NULL with *len=0 if not loaded. */
const guint8 *validity_data_get_bytes (const ValidityDataStore *store,
ValidityDataTag tag,
gsize *len);

16
libfprint/drivers/validity/validity_db.c
View file

@ -29,6 +29,7 @@
#include "fpi-byte-reader.h"
#include "fpi-byte-utils.h"
#include "validity_db.h"
#include "validity.h"
#include "validity_hal.h"
#include "vcsfw_protocol.h"
@ -777,16 +778,9 @@ validity_db_build_finger_data (guint16 subtype,
* ================================================================ */
const guint8 *
validity_db_get_write_enable_blob (guint dev_type, gsize *out_len)
validity_db_get_write_enable_blob (FpiDeviceValidity *self, gsize *out_len)
{
const ValidityDeviceDesc *desc = validity_hal_device_lookup (dev_type);
if (!desc || !desc->db_write_enable || desc->db_write_enable_len == 0)
{
*out_len = 0;
return NULL;
}
*out_len = desc->db_write_enable_len;
return desc->db_write_enable;
return validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_DB_WRITE_ENABLE,
out_len);
}

6
libfprint/drivers/validity/validity_db.h
View file

@ -300,5 +300,7 @@ guint8 *validity_db_build_cmd_match_cleanup (gsize *out_len);
* db_write_enable blob access
* ================================================================ */
const guint8 *validity_db_get_write_enable_blob (guint dev_type,
gsize *out_len);
typedef struct _FpiDeviceValidity FpiDeviceValidity;
const guint8 *validity_db_get_write_enable_blob (FpiDeviceValidity *self,
gsize *out_len);

10
libfprint/drivers/validity/validity_enroll.c
View file

@ -558,7 +558,7 @@ enroll_db_write_enable (FpiSsm *ssm,
{
/* PY: write_enable() before 1st enrollment_update */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self->dev_type, &blob_len);
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
@ -653,7 +653,7 @@ enroll_db_write_enable_read (FpiSsm *ssm,
{
/* PY: write_enable() before 2nd enrollment_update */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self->dev_type, &blob_len);
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
@ -885,7 +885,7 @@ enroll_init_storage_we (FpiSsm *ssm,
/* PY: db.new_user_storate() → new_record(1, 4, 3, 'StgWindsor\0')
* First: db_write_enable */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self->dev_type, &blob_len);
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
@ -949,7 +949,7 @@ enroll_db_write_enable2 (FpiSsm *ssm,
{
/* Enable DB writes for storing the finger record */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self->dev_type, &blob_len);
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
@ -1073,7 +1073,7 @@ enroll_db_write_enable3 (FpiSsm *ssm,
{
/* PY: new_record calls db_write_enable before each cmd 0x47 */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self->dev_type, &blob_len);
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}

27
libfprint/drivers/validity/validity_fwext.c
View file

@ -328,20 +328,12 @@ validity_fwext_build_reboot (guint8 *cmd,
* ================================================================ */
const guint8 *
validity_fwext_get_db_write_enable (guint16 vid,
guint16 pid,
gsize *len)
validity_fwext_get_db_write_enable (FpiDeviceValidity *self,
gsize *len)
{
const ValidityDeviceDesc *desc = validity_hal_device_lookup_by_pid (vid, pid);
if (!desc || !desc->db_write_enable || desc->db_write_enable_len == 0)
{
*len = 0;
return NULL;
}
*len = desc->db_write_enable_len;
return desc->db_write_enable;
return validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_DB_WRITE_ENABLE,
len);
}
/* ================================================================
@ -494,18 +486,15 @@ static void
fwext_send_db_write_enable (FpiSsm *ssm,
FpiDeviceValidity *self)
{
FwextUploadData *ud = fpi_ssm_get_data (ssm);
gsize dbe_len;
const guint8 *dbe = validity_fwext_get_db_write_enable (ud->vid,
ud->pid,
&dbe_len);
const guint8 *dbe = validity_fwext_get_db_write_enable (self, &dbe_len);
if (dbe == NULL || dbe_len == 0)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
"No db_write_enable blob for "
"%04x:%04x", ud->vid, ud->pid));
"No db_write_enable data for "
"this device"));
return;
}

7
libfprint/drivers/validity/validity_fwext.h
View file

@ -131,9 +131,10 @@ void validity_fwext_build_write_fw_sig (guint8 partition,
void validity_fwext_build_reboot (guint8 *cmd,
gsize *cmd_len);
const guint8 *validity_fwext_get_db_write_enable (guint16 vid,
guint16 pid,
gsize *len);
typedef struct _FpiDeviceValidity FpiDeviceValidity;
const guint8 *validity_fwext_get_db_write_enable (FpiDeviceValidity *self,
gsize *len);
/* SSM entry point for upload state machine */
void validity_fwext_upload_run_state (FpiSsm *ssm,

63
libfprint/drivers/validity/validity_hal.c
View file

@ -25,21 +25,6 @@
#include "validity_hal.h"
#include "fpi-log.h"
/* ================================================================
* Include auto-generated blob data for each PID
* ================================================================ */
#include "validity_blobs_0090.inc"
#include "validity_blobs_0097.inc"
#include "validity_blobs_009a.inc"
#include "validity_blobs_009d.inc"
/* ================================================================
* Include pairing constants (partition signatures, CA cert, keys)
* ================================================================ */
#include "validity_pair_constants.inc"
/* ================================================================
* Flash partition layouts
*
@ -72,76 +57,44 @@ static const ValidityPartition flash_partitions_0090[] = {
static const ValidityFlashLayout flash_layout_standard = {
.partitions = flash_partitions_standard,
.num_partitions = G_N_ELEMENTS (flash_partitions_standard),
.partition_sig = partition_sig_standard,
.partition_sig_len = sizeof (partition_sig_standard),
};
static const ValidityFlashLayout flash_layout_0090 = {
.partitions = flash_partitions_0090,
.num_partitions = G_N_ELEMENTS (flash_partitions_0090),
.partition_sig = partition_sig_0090,
.partition_sig_len = sizeof (partition_sig_0090),
};
/* ================================================================
* Per-device descriptors
*
* Blob data (init, reset, db_write_enable) has been moved to external
* .bin files loaded at runtime by validity_data.c. Only VID/PID and
* flash layout remain here.
* ================================================================ */
static const ValidityDeviceDesc device_table[] = {
[VALIDITY_HAL_DEV_90] = {
.vid = 0x138a,
.pid = 0x0090,
.init_hardcoded = init_hardcoded_0090,
.init_hardcoded_len = sizeof (init_hardcoded_0090),
.init_clean_slate = NULL, /* not available for this PID */
.init_clean_slate_len = 0,
.reset_blob = reset_blob_0090,
.reset_blob_len = sizeof (reset_blob_0090),
.db_write_enable = db_write_enable_0090,
.db_write_enable_len = sizeof (db_write_enable_0090),
.flash_layout = &flash_layout_0090,
.flash_layout = &flash_layout_0090,
},
[VALIDITY_HAL_DEV_97] = {
.vid = 0x138a,
.pid = 0x0097,
.init_hardcoded = init_hardcoded_0097,
.init_hardcoded_len = sizeof (init_hardcoded_0097),
.init_clean_slate = init_hardcoded_clean_slate_0097,
.init_clean_slate_len = sizeof (init_hardcoded_clean_slate_0097),
.reset_blob = reset_blob_0097,
.reset_blob_len = sizeof (reset_blob_0097),
.db_write_enable = db_write_enable_0097,
.db_write_enable_len = sizeof (db_write_enable_0097),
.flash_layout = &flash_layout_standard,
.flash_layout = &flash_layout_standard,
},
[VALIDITY_HAL_DEV_9A] = {
.vid = 0x06cb,
.pid = 0x009a,
.init_hardcoded = init_hardcoded_009a,
.init_hardcoded_len = sizeof (init_hardcoded_009a),
.init_clean_slate = init_hardcoded_clean_slate_009a,
.init_clean_slate_len = sizeof (init_hardcoded_clean_slate_009a),
.reset_blob = reset_blob_009a,
.reset_blob_len = sizeof (reset_blob_009a),
.db_write_enable = db_write_enable_009a,
.db_write_enable_len = sizeof (db_write_enable_009a),
.flash_layout = &flash_layout_standard,
.flash_layout = &flash_layout_standard,
},
[VALIDITY_HAL_DEV_9D] = {
.vid = 0x138a,
.pid = 0x009d,
.init_hardcoded = init_hardcoded_009d,
.init_hardcoded_len = sizeof (init_hardcoded_009d),
.init_clean_slate = init_hardcoded_clean_slate_009d,
.init_clean_slate_len = sizeof (init_hardcoded_clean_slate_009d),
.reset_blob = reset_blob_009d,
.reset_blob_len = sizeof (reset_blob_009d),
.db_write_enable = db_write_enable_009d,
.db_write_enable_len = sizeof (db_write_enable_009d),
.flash_layout = &flash_layout_standard,
.flash_layout = &flash_layout_standard,
},
};

28
libfprint/drivers/validity/validity_hal.h
View file

@ -43,38 +43,24 @@ typedef struct
guint32 size;
} ValidityPartition;
/* Per-device flash layout with partition table and RSA signature */
/* Per-device flash layout with partition table.
* The RSA partition signature is now loaded at runtime from external
* data files (validity_data.c) instead of being compiled in. */
typedef struct
{
const ValidityPartition *partitions;
gsize num_partitions;
const guint8 *partition_sig;
gsize partition_sig_len;
} ValidityFlashLayout;
/* Per-device encrypted blobs and flash layout.
* Some blobs may be NULL/0 if not available for the device. */
/* Per-device flash layout descriptor.
* Blob data has been moved to external .bin files loaded at runtime
* by validity_data.c. This struct retains only hardware identity
* and flash partition layout. */
typedef struct
{
guint16 vid;
guint16 pid;
/* init_hardcoded — sent during USB init (cmd prefix) */
const guint8 *init_hardcoded;
gsize init_hardcoded_len;
/* init_hardcoded_clean_slate — clean calibration variant */
const guint8 *init_clean_slate;
gsize init_clean_slate_len;
/* reset_blob — sent before pairing to reset device state */
const guint8 *reset_blob;
gsize reset_blob_len;
/* db_write_enable — sent before database writes */
const guint8 *db_write_enable;
gsize db_write_enable_len;
/* Flash partition layout for this device variant */
const ValidityFlashLayout *flash_layout;
} ValidityDeviceDesc;

132
libfprint/drivers/validity/validity_pair.c
View file

@ -26,6 +26,7 @@
#include "drivers_api.h"
#include "fpi-byte-utils.h"
#include "validity.h"
#include "validity_data.h"
#include "validity_pair.h"
#include "validity_tls.h"
#include "vcsfw_protocol.h"
@ -39,17 +40,9 @@
#include <openssl/param_build.h>
#include <string.h>
/* Include CA cert and other pairing constants */
#include "validity_pair_constants.inc"
/* Hardcoded password for HS_KEY_PAIR_GEN derivation.
* From python-validity tls.py: password_hardcoded */
static const guint8 password_hardcoded[] = {
0x71, 0x7c, 0xd7, 0x2d, 0x09, 0x62, 0xbc, 0x4a,
0x28, 0x46, 0x13, 0x8d, 0xbb, 0x2c, 0x24, 0x19,
0x25, 0x12, 0xa7, 0x64, 0x07, 0x06, 0x5f, 0x38,
0x38, 0x46, 0x13, 0x9d, 0x4b, 0xec, 0x20, 0x33,
};
/* CA cert, partition signatures, and TLS keys are now loaded at runtime
* from external .bin files via validity_data.c. See the
* libfprint-validity-data package. */
/* ================================================================
* Pairing state management
@ -204,15 +197,18 @@ serialize_flash_params (const ValidityFlashIcParams *ic, guint8 *out)
* ================================================================ */
static EVP_PKEY *
derive_hs_signing_key (void)
derive_hs_signing_key (const guint8 *password, gsize password_len)
{
const guint8 *key = password_hardcoded;
if (!password || password_len < 32)
return NULL;
const guint8 *key = password;
guint8 prf_seed[15 + 16 + 2]; /* "HS_KEY_PAIR_GEN" + password[16:32] + 0xaa*2 */
guint8 hs_key_bytes[32];
/* Build PRF seed: label + password_tail + 0xaa padding */
memcpy (prf_seed, "HS_KEY_PAIR_GEN", 15);
memcpy (prf_seed + 15, password_hardcoded + 16, 16);
memcpy (prf_seed + 15, password + 16, 16);
prf_seed[31] = 0xaa;
prf_seed[32] = 0xaa;
@ -291,6 +287,8 @@ derive_hs_signing_key (void)
guint8 *
validity_pair_make_cert (const guint8 *client_public_x,
const guint8 *client_public_y,
const guint8 *password,
gsize password_len,
gsize *out_len)
{
guint8 body[CERT_BODY_SIZE];
@ -304,7 +302,7 @@ validity_pair_make_cert (const guint8 *client_public_x,
/* 76 zero bytes at offset 108..183 */
/* Sign body with HS key (ECDSA + SHA-256) */
EVP_PKEY *hs_key = derive_hs_signing_key ();
EVP_PKEY *hs_key = derive_hs_signing_key (password, password_len);
if (!hs_key)
{
fp_warn ("Failed to derive HS signing key");
@ -441,8 +439,14 @@ validity_pair_encrypt_key (const guint8 *client_private,
guint8 *
validity_pair_build_partition_flash_cmd (const ValidityFlashIcParams *flash_ic,
const ValidityFlashLayout *layout,
const guint8 *partition_sig,
gsize partition_sig_len,
const guint8 *client_public_x,
const guint8 *client_public_y,
const guint8 *password,
gsize password_len,
const guint8 *ca_cert,
gsize ca_cert_len,
gsize *out_len)
{
/* Build flash IC params body (hdr 0) */
@ -458,14 +462,14 @@ validity_pair_build_partition_flash_cmd (const ValidityFlashIcParams *flash_ic,
/* Build partition table body (hdr 1):
* [partition entries (48 bytes each)] + [RSA signature (256 bytes)] */
gsize ptbl_body_len = (layout->num_partitions * VALIDITY_PARTITION_ENTRY_SIZE) +
layout->partition_sig_len;
partition_sig_len;
g_autofree guint8 *ptbl_body = g_malloc0 (ptbl_body_len);
for (gsize i = 0; i < layout->num_partitions; i++)
validity_pair_serialize_partition (&layout->partitions[i],
ptbl_body + (i * VALIDITY_PARTITION_ENTRY_SIZE));
memcpy (ptbl_body + (layout->num_partitions * VALIDITY_PARTITION_ENTRY_SIZE),
layout->partition_sig, layout->partition_sig_len);
partition_sig, partition_sig_len);
gsize hdr1_len;
g_autofree guint8 *hdr1 = build_header (VALIDITY_HDR_PARTITION_TABLE,
@ -476,6 +480,7 @@ validity_pair_build_partition_flash_cmd (const ValidityFlashIcParams *flash_ic,
gsize cert_len;
g_autofree guint8 *cert = validity_pair_make_cert (client_public_x,
client_public_y,
password, password_len,
&cert_len);
if (!cert)
return NULL;
@ -485,12 +490,10 @@ validity_pair_build_partition_flash_cmd (const ValidityFlashIcParams *flash_ic,
cert, cert_len,
&hdr5_len);
/* CA certificate (hdr 3) — from auto-generated constants */
gsize ca_cert_len = sizeof (ca_cert_hardcoded);
/* CA certificate (hdr 3) — from runtime data files */
gsize hdr3_len;
g_autofree guint8 *hdr3 = build_header (VALIDITY_HDR_CA_CERT,
ca_cert_hardcoded, ca_cert_len,
ca_cert, ca_cert_len,
&hdr3_len);
/* Assemble: [4f 00 00 00 00] + hdr0 + hdr1 + hdr5 + hdr3 */
@ -559,6 +562,8 @@ append_flash_block (guint8 *buf, gsize offset, guint16 id,
guint8 *
validity_pair_build_tls_flash (const ValidityPairState *state,
const guint8 *ca_cert,
gsize ca_cert_len,
gsize *out_len)
{
guint8 *buf = g_malloc (TLS_FLASH_IMAGE_SIZE);
@ -585,9 +590,8 @@ validity_pair_build_tls_flash (const ValidityPairState *state,
offset = append_flash_block (buf, offset, 3,
state->server_cert, state->server_cert_len);
/* Block 5: CA certificate (hardcoded) */
offset = append_flash_block (buf, offset, 5,
ca_cert_hardcoded, sizeof (ca_cert_hardcoded));
/* Block 5: CA certificate (from runtime data files) */
offset = append_flash_block (buf, offset, 5, ca_cert, ca_cert_len);
/* Block 1: empty placeholder (256 zeros) */
offset = append_flash_block (buf, offset, 1, empty_block, sizeof (empty_block));
@ -764,10 +768,13 @@ static void
pair_send_reset_blob (FpiSsm *ssm,
FpiDeviceValidity *self)
{
ValidityPairState *ps = &self->pair_state;
gsize reset_len;
const guint8 *reset_data;
/* Send reset_blob via raw USB (python-validity: usb.cmd(reset_blob)) */
if (!ps->dev_desc->reset_blob || ps->dev_desc->reset_blob_len == 0)
reset_data = validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_RESET, &reset_len);
if (!reset_data || reset_len == 0)
{
fp_warn ("No reset_blob available for this device");
fpi_ssm_mark_failed (ssm,
@ -775,9 +782,7 @@ pair_send_reset_blob (FpiSsm *ssm,
return;
}
vcsfw_cmd_send (self, ssm,
ps->dev_desc->reset_blob,
ps->dev_desc->reset_blob_len, NULL);
vcsfw_cmd_send (self, ssm, reset_data, reset_len, NULL);
}
static void
@ -848,12 +853,42 @@ pair_partition_flash_send (FpiSsm *ssm,
pub_y_le[i] = pub_y_be[31 - i];
}
/* Build CMD 0x4f */
/* Build CMD 0x4f — get data from runtime data store */
gsize partition_sig_len, password_len, ca_cert_len;
const guint8 *partition_sig_data;
const guint8 *password_data;
const guint8 *ca_cert_data;
/* Select partition signature based on PID */
ValidityDataTag sig_tag = (ps->dev_desc->pid == 0x0090)
? VALIDITY_DATA_PARTITION_SIG_0090
: VALIDITY_DATA_PARTITION_SIG_STANDARD;
partition_sig_data = validity_data_get_bytes (&self->common_data,
sig_tag, &partition_sig_len);
password_data = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_TLS_PASSWORD,
&password_len);
ca_cert_data = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_CA_PUBKEY,
&ca_cert_len);
if (!partition_sig_data || !password_data || !ca_cert_data)
{
fp_warn ("Missing runtime data for pairing");
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
return;
}
gsize cmd_len;
g_autofree guint8 *cmd = validity_pair_build_partition_flash_cmd (
&ps->flash_ic,
ps->dev_desc->flash_layout,
partition_sig_data, partition_sig_len,
pub_x_le, pub_y_le,
password_data, password_len,
ca_cert_data, ca_cert_len,
&cmd_len);
if (!cmd)
@ -1172,9 +1207,17 @@ pair_erase_dbe_send (FpiSsm *ssm,
ps->erase_step + 1,
(guint) VALIDITY_PAIR_NUM_ERASE_STEPS);
vcsfw_tls_cmd_send (self, ssm,
ps->dev_desc->db_write_enable,
ps->dev_desc->db_write_enable_len, NULL);
gsize dbe_len;
const guint8 *dbe_data = validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_DB_WRITE_ENABLE,
&dbe_len);
if (!dbe_data || dbe_len == 0)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
return;
}
vcsfw_tls_cmd_send (self, ssm, dbe_data, dbe_len, NULL);
}
static void
@ -1240,12 +1283,19 @@ static void
pair_write_dbe_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
ValidityPairState *ps = &self->pair_state;
/* db_write_enable before write_flash */
vcsfw_tls_cmd_send (self, ssm,
ps->dev_desc->db_write_enable,
ps->dev_desc->db_write_enable_len, NULL);
gsize dbe_len;
const guint8 *dbe_data = validity_data_get_bytes (&self->device_data,
VALIDITY_DATA_DB_WRITE_ENABLE,
&dbe_len);
if (!dbe_data || dbe_len == 0)
{
fp_warn ("No db_write_enable data for pairing");
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
return;
}
vcsfw_tls_cmd_send (self, ssm, dbe_data, dbe_len, NULL);
}
static void
@ -1255,9 +1305,13 @@ pair_write_flash_send (FpiSsm *ssm,
ValidityPairState *ps = &self->pair_state;
/* Build TLS flash image */
gsize ca_len;
const guint8 *ca_data = validity_data_get_bytes (&self->common_data,
VALIDITY_DATA_CA_PUBKEY,
&ca_len);
gsize flash_len;
g_autofree guint8 *flash_data =
validity_pair_build_tls_flash (ps, &flash_len);
validity_pair_build_tls_flash (ps, ca_data, ca_len, &flash_len);
/* CMD 0x41: WRITE_FLASH
* Format: [0x41][partition:1][flag:1][reserved:2][offset:4LE][size:4LE][data]

10
libfprint/drivers/validity/validity_pair.h
View file

@ -124,8 +124,14 @@ void validity_pair_serialize_partition (const ValidityPartition *part,
*/
guint8 *validity_pair_build_partition_flash_cmd (const ValidityFlashIcParams *flash_ic,
const ValidityFlashLayout *layout,
const guint8 *partition_sig,
gsize partition_sig_len,
const guint8 *client_public_x,
const guint8 *client_public_y,
const guint8 *password,
gsize password_len,
const guint8 *ca_cert,
gsize ca_cert_len,
gsize *out_len);
/**
@ -141,6 +147,8 @@ guint8 *validity_pair_build_partition_flash_cmd (const ValidityFlashIcParams *fl
*/
guint8 *validity_pair_make_cert (const guint8 *client_public_x,
const guint8 *client_public_y,
const guint8 *password,
gsize password_len,
gsize *out_len);
/**
@ -318,4 +326,6 @@ void validity_pair_run_state (FpiSsm *ssm,
* Returns: newly allocated 4096-byte buffer. Free with g_free().
*/
guint8 *validity_pair_build_tls_flash (const ValidityPairState *state,
const guint8 *ca_cert,
gsize ca_cert_len,
gsize *out_len);

75
libfprint/drivers/validity/validity_pair_constants.inc
View file

@ -1,75 +0,0 @@
/* Hardcoded pairing constants from python-validity
* Auto-generated from init_flash.py and tls.py
* DO NOT EDIT — regenerate with scripts/blob_extract/extract_constants.py
*/
/* partition_signature: 256 bytes */
static const guint8 partition_sig_standard[] = {
0x1d, 0xb0, 0x2a, 0x88, 0x6b, 0x00, 0x7e, 0x2b, 0x47, 0x26, 0x3b, 0xb8, 0xfe, 0x30, 0xbd, 0x64,
0xa1, 0xf5, 0x8b, 0xea, 0x7b, 0x25, 0xf1, 0xe1, 0xba, 0x9a, 0xe0, 0x9a, 0xdd, 0x7e, 0xcf, 0xf3,
0x63, 0x33, 0xf8, 0x19, 0x83, 0x39, 0xcd, 0xd7, 0x13, 0xf0, 0x43, 0x63, 0x37, 0x10, 0xa1, 0x7b,
0xc7, 0xb3, 0xf4, 0x18, 0xf1, 0xd8, 0xff, 0x43, 0x5a, 0x1b, 0xf4, 0x7f, 0x06, 0x5d, 0xff, 0xca,
0x72, 0x71, 0x09, 0x15, 0x22, 0x17, 0xfc, 0xe7, 0x3b, 0xf2, 0xbf, 0x8e, 0x01, 0xa1, 0x64, 0x1f,
0x6a, 0x24, 0xb0, 0xc4, 0x92, 0xa6, 0xa3, 0xf1, 0x01, 0x14, 0x05, 0x72, 0x75, 0x84, 0x68, 0x42,
0xb1, 0xc8, 0xb6, 0x6b, 0xd6, 0x70, 0x07, 0x38, 0x52, 0x4d, 0x44, 0x71, 0xbc, 0xa3, 0x31, 0x5b,
0xa2, 0x3b, 0xb8, 0x32, 0x74, 0x32, 0x20, 0xad, 0x19, 0x5b, 0x60, 0x55, 0x8a, 0xa7, 0x9a, 0x3e,
0xde, 0xb2, 0x60, 0x48, 0x34, 0xe2, 0xbb, 0x62, 0xe8, 0x90, 0xb0, 0xce, 0x40, 0x5b, 0x3b, 0x8e,
0xf2, 0xfe, 0xc2, 0xaa, 0xb3, 0xe2, 0x2b, 0xff, 0x23, 0xf8, 0x9a, 0x58, 0xff, 0x0d, 0xc0, 0x15,
0xfe, 0xce, 0x5d, 0x3e, 0xd3, 0xf5, 0x49, 0x6a, 0xce, 0x87, 0x9a, 0x92, 0x98, 0x0a, 0xec, 0x9d,
0x85, 0xeb, 0x7e, 0x9d, 0xf2, 0x45, 0xea, 0xe0, 0x3a, 0x41, 0xac, 0xfd, 0x4e, 0x7d, 0x1c, 0xb1,
0xdb, 0xd0, 0xdf, 0x42, 0xd5, 0x34, 0x90, 0x4d, 0xe0, 0x0b, 0x63, 0x89, 0xf6, 0x88, 0x67, 0x64,
0x6e, 0x9d, 0x7c, 0x3d, 0x0b, 0x1d, 0xff, 0xd7, 0x40, 0x70, 0xb2, 0xd0, 0xf2, 0x04, 0x9b, 0x9f,
0x1d, 0xc7, 0xb0, 0xc9, 0x65, 0x1c, 0x59, 0xbe, 0x3e, 0xa8, 0x91, 0x67, 0x47, 0x25, 0xe1, 0xf2,
0xf7, 0xa4, 0x84, 0xa9, 0x41, 0x61, 0x5b, 0x80, 0x21, 0x11, 0x05, 0x97, 0x83, 0x69, 0xcf, 0x71,
};
/* partition_signature_0090: 256 bytes */
static const guint8 partition_sig_0090[] = {
0xe4, 0x4f, 0x7a, 0x80, 0xd6, 0x13, 0x77, 0x94, 0xd3, 0x30, 0xb5, 0xd0, 0x26, 0xc3, 0x28, 0xa7,
0x3c, 0x90, 0x7f, 0x3f, 0x65, 0x3d, 0x41, 0x12, 0x55, 0xb7, 0xc2, 0xf8, 0xb4, 0x25, 0xd8, 0x70,
0xa8, 0xa5, 0x3c, 0x66, 0x30, 0xca, 0x86, 0x4b, 0x84, 0x59, 0x0e, 0x3c, 0x67, 0x86, 0xf0, 0xd6,
0x9b, 0xe4, 0xbb, 0xab, 0x57, 0x36, 0x38, 0x8f, 0x85, 0x27, 0x23, 0x7a, 0x0a, 0x86, 0xbb, 0xce,
0x7c, 0xed, 0x94, 0x50, 0xc4, 0x96, 0x47, 0x09, 0xe8, 0x9a, 0xc5, 0x35, 0xaa, 0x00, 0x78, 0x71,
0x58, 0xe0, 0xa8, 0xd9, 0xb1, 0xfb, 0x75, 0xf0, 0xf7, 0xae, 0x53, 0xd4, 0xbd, 0x11, 0xab, 0xfc,
0xf5, 0xee, 0x67, 0xa5, 0xa7, 0x1e, 0x24, 0x8a, 0x42, 0x6b, 0x3a, 0xff, 0x45, 0x67, 0x04, 0x8f,
0xa9, 0x3d, 0xe6, 0x59, 0x39, 0xcc, 0xfb, 0xe3, 0xf3, 0x11, 0x49, 0xa8, 0x2c, 0x64, 0xfb, 0xfd,
0x6a, 0x2a, 0x6c, 0xf7, 0x48, 0xe1, 0xd9, 0xbd, 0x85, 0x62, 0xcf, 0x39, 0xb1, 0xa4, 0xb3, 0x07,
0xb3, 0x7b, 0xe2, 0x23, 0x31, 0x7b, 0x1b, 0x81, 0x7e, 0x36, 0x4f, 0x28, 0x77, 0xd2, 0x9d, 0x12,
0x37, 0x31, 0x31, 0x4a, 0xa6, 0x27, 0xcb, 0xf2, 0x34, 0xe0, 0xea, 0x69, 0xa4, 0x06, 0xa4, 0x73,
0x5a, 0x03, 0xa4, 0x54, 0x95, 0x02, 0x3e, 0xf7, 0x06, 0xbd, 0xb5, 0x42, 0xc9, 0x49, 0xd2, 0x43,
0xac, 0x2c, 0x08, 0xc0, 0x0a, 0xbf, 0x43, 0xfa, 0xa5, 0x52, 0x8a, 0x0a, 0x8e, 0x49, 0xb0, 0x2c,
0x50, 0x7b, 0x01, 0xb6, 0xf1, 0xc9, 0xab, 0xff, 0xc6, 0x69, 0xd8, 0xc8, 0x4d, 0x7e, 0x4a, 0x71,
0x4d, 0xa3, 0x2a, 0xad, 0xe7, 0x92, 0x8e, 0xca, 0x96, 0x98, 0xb8, 0x2b, 0xee, 0x6b, 0x72, 0xc6,
0x42, 0xc9, 0xad, 0xd8, 0x0b, 0xbd, 0x7c, 0xcc, 0x41, 0x21, 0xb8, 0x02, 0x20, 0xd5, 0x2b, 0x8a,
};
/* CA certificate: 420 bytes */
static const guint8 ca_cert_hardcoded[] = {
0x17, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x4b, 0x60, 0xd2, 0x27, 0x3e, 0x3c, 0xce, 0x3b, 0xf6, 0xb0, 0x53, 0xcc, 0xb0, 0x06, 0x1d, 0x65,
0xbc, 0x86, 0x98, 0x76, 0x55, 0xbd, 0xeb, 0xb3, 0xe7, 0x93, 0x3a, 0xaa, 0xd8, 0x35, 0xc6, 0x5a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x96, 0xc2, 0x98, 0xd8, 0x45, 0x39, 0xa1, 0xf4, 0xa0, 0x33, 0xeb, 0x2d,
0x81, 0x7d, 0x03, 0x77, 0xf2, 0x40, 0xa4, 0x63, 0xe5, 0xe6, 0xbc, 0xf8, 0x47, 0x42, 0x2c, 0xe1,
0xf2, 0xd1, 0x17, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0x51, 0xbf, 0x37, 0x68, 0x40, 0xb6, 0xcb,
0xce, 0x5e, 0x31, 0x6b, 0x57, 0x33, 0xce, 0x2b, 0x16, 0x9e, 0x0f, 0x7c, 0x4a, 0xeb, 0xe7, 0x8e,
0x9b, 0x7f, 0x1a, 0xfe, 0xe2, 0x42, 0xe3, 0x4f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x25, 0x63, 0xfc,
0xc2, 0xca, 0xb9, 0xf3, 0x84, 0x9e, 0x17, 0xa7, 0xad, 0xfa, 0xe6, 0xbc, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};

43
libfprint/drivers/validity/validity_tls.c
View file

@ -34,39 +34,6 @@
#include <openssl/param_build.h>
#include <string.h>
/* ================================================================
* Hardcoded keys (from python-validity, MIT license)
* ================================================================ */
static const guint8 password_hardcoded[32] = {
0x71, 0x7c, 0xd7, 0x2d, 0x09, 0x62, 0xbc, 0x4a,
0x28, 0x46, 0x13, 0x8d, 0xbb, 0x2c, 0x24, 0x19,
0x25, 0x12, 0xa7, 0x64, 0x07, 0x06, 0x5f, 0x38,
0x38, 0x46, 0x13, 0x9d, 0x4b, 0xec, 0x20, 0x33
};
static const guint8 gwk_sign_hardcoded[32] = {
0x3a, 0x4c, 0x76, 0xb7, 0x6a, 0x97, 0x98, 0x1d,
0x12, 0x74, 0x24, 0x7e, 0x16, 0x66, 0x10, 0xe7,
0x7f, 0x4d, 0x9c, 0x9d, 0x07, 0xd3, 0xc7, 0x28,
0xe5, 0x32, 0x91, 0x6b, 0xdd, 0x28, 0xb4, 0x54
};
/* Hardcoded firmware ECDSA public key for ECDH blob verification */
static const guint8 fw_pubkey_x[32] = {
0xd3, 0xa8, 0xf6, 0x69, 0xdf, 0x1f, 0x67, 0x43,
0xa7, 0x92, 0x12, 0x0d, 0x31, 0xbe, 0xa0, 0xd0,
0xd7, 0x30, 0x3a, 0x7f, 0x4d, 0x89, 0xa6, 0x65,
0x06, 0xce, 0x16, 0x4e, 0x3b, 0x65, 0x27, 0xf7
};
static const guint8 fw_pubkey_y[32] = {
0x94, 0xca, 0xa6, 0x21, 0x47, 0xa8, 0x61, 0xf7,
0x8d, 0x94, 0x93, 0x23, 0x8b, 0xc5, 0x43, 0x62,
0x88, 0x7a, 0xd0, 0xf4, 0xd5, 0x8b, 0xef, 0x6e,
0x0d, 0xc5, 0xbe, 0xb6, 0xf8, 0x38, 0x55, 0xa8
};
/* ================================================================
* TLS PRF (P_SHA256) — Standard TLS 1.2 PRF with HMAC-SHA256
* ================================================================ */
@ -209,14 +176,14 @@ validity_tls_derive_psk (ValidityTlsState *tls)
g_autofree guint8 *seed = g_malloc (seed_len);
memcpy (seed, "GWK", 3);
memcpy (seed + 3, hw_key, hw_key_len);
validity_tls_prf (password_hardcoded, 32, seed, seed_len,
validity_tls_prf (tls->password, tls->password_len, seed, seed_len,
tls->psk_encryption_key, 32);
/* psk_validation_key = PRF(psk_encryption_key, "GWK_SIGN" || gwk_sign, 0x20) */
gsize seed2_len = 8 + 32;
gsize seed2_len = 8 + tls->gwk_sign_len;
g_autofree guint8 *seed2 = g_malloc (seed2_len);
memcpy (seed2, "GWK_SIGN", 8);
memcpy (seed2 + 8, gwk_sign_hardcoded, 32);
memcpy (seed2 + 8, tls->gwk_sign, tls->gwk_sign_len);
validity_tls_prf (tls->psk_encryption_key, 32, seed2, seed2_len,
tls->psk_validation_key, 32);
@ -820,7 +787,7 @@ handle_ecdh_block (ValidityTlsState *tls,
}
/* Create firmware verification public key */
EVP_PKEY *fw_pubkey = ec_pubkey_from_coords (fw_pubkey_x, fw_pubkey_y);
EVP_PKEY *fw_pubkey = ec_pubkey_from_coords (tls->fw_pubkey_x, tls->fw_pubkey_y);
if (!fw_pubkey)
{
EVP_PKEY_free (ecdh_pubkey);
@ -829,7 +796,7 @@ handle_ecdh_block (ValidityTlsState *tls,
return FALSE;
}
/* Note: fw_pubkey_x/y are stored as little-endian, like ECDH blob coords */
/* Note: fw_pubkey_x/y are loaded at runtime from data files (little-endian coords) */
/* Verify: fwpub.verify(signature, key_blob, ECDSA(SHA256)) */
EVP_MD_CTX *md_ctx = EVP_MD_CTX_new ();

10
libfprint/drivers/validity/validity_tls.h
View file

@ -123,6 +123,16 @@ typedef struct
gboolean secure_rx;
gboolean secure_tx;
gboolean keys_loaded;
/* Runtime data keys (populated from data store during open) */
const guint8 *password; /* TLS password (32 bytes) */
gsize password_len;
const guint8 *gwk_sign; /* GWK signing key (32 bytes) */
gsize gwk_sign_len;
const guint8 *fw_pubkey_x; /* firmware ECDSA public key X (32 bytes) */
gsize fw_pubkey_x_len;
const guint8 *fw_pubkey_y; /* firmware ECDSA public key Y (32 bytes) */
gsize fw_pubkey_y_len;
} ValidityTlsState;
/* TLS handshake SSM states */

3
libfprint/meson.build
View file

@ -164,7 +164,8 @@ driver_sources = {
'drivers/validity/validity_enroll.c',
'drivers/validity/validity_verify.c',
'drivers/validity/validity_hal.c',
'drivers/validity/validity_pair.c' ],
'drivers/validity/validity_pair.c',
'drivers/validity/validity_data.c' ],
}
helper_sources = {

777
tests/test-validity.c
View file

@ -11,6 +11,7 @@
#include <glib.h>
#include <string.h>
#include <unistd.h>
#include <glib/gstdio.h>
#include <openssl/evp.h>
@ -112,7 +113,7 @@ test_hal_lookup_by_pid_invalid (void)
}
/* ================================================================
* T7.5: All devices have non-empty blobs
* T7.5: All devices have flash layout (blobs loaded at runtime)
* ================================================================ */
static void
test_hal_blobs_present (void)
@ -125,22 +126,15 @@ test_hal_blobs_present (void)
const ValidityDeviceDesc *desc = validity_hal_device_lookup (types[i]);
g_assert_nonnull (desc);
/* init_hardcoded must be present for all */
g_assert_nonnull (desc->init_hardcoded);
g_assert_cmpuint (desc->init_hardcoded_len, >, 0);
/* reset_blob must be present for all */
g_assert_nonnull (desc->reset_blob);
g_assert_cmpuint (desc->reset_blob_len, >, 0);
/* db_write_enable must be present for all */
g_assert_nonnull (desc->db_write_enable);
g_assert_cmpuint (desc->db_write_enable_len, >, 0);
/* All devices must have vid, pid, and flash_layout */
g_assert_cmpuint (desc->vid, !=, 0);
g_assert_cmpuint (desc->pid, !=, 0);
g_assert_nonnull (desc->flash_layout);
}
}
/* ================================================================
* T7.6: PID 0090 has smaller db partition and no clean_slate blob
* T7.6: PID 0090 flash layout
* ================================================================ */
static void
test_hal_pid_0090_specifics (void)
@ -149,10 +143,6 @@ test_hal_pid_0090_specifics (void)
g_assert_nonnull (desc);
/* 0090 has no init_hardcoded_clean_slate */
g_assert_null (desc->init_clean_slate);
g_assert_cmpuint (desc->init_clean_slate_len, ==, 0);
/* Flash layout should exist */
g_assert_nonnull (desc->flash_layout);
g_assert_cmpuint (desc->flash_layout->num_partitions, ==,
@ -160,7 +150,7 @@ test_hal_pid_0090_specifics (void)
}
/* ================================================================
* T7.7: Non-0090 devices have init_hardcoded_clean_slate
* T7.7: Non-0090 devices also have flash layout
* ================================================================ */
static void
test_hal_clean_slate_present (void)
@ -171,8 +161,7 @@ test_hal_clean_slate_present (void)
{
const ValidityDeviceDesc *desc = validity_hal_device_lookup (types[i]);
g_assert_nonnull (desc);
g_assert_nonnull (desc->init_clean_slate);
g_assert_cmpuint (desc->init_clean_slate_len, >, 0);
g_assert_nonnull (desc->flash_layout);
}
}
@ -195,11 +184,6 @@ test_hal_flash_layout (void)
g_assert_cmpuint (layout->num_partitions, ==,
VALIDITY_FLASH_NUM_PARTITIONS);
/* Signature must be 256 bytes */
g_assert_nonnull (layout->partition_sig);
g_assert_cmpuint (layout->partition_sig_len, ==,
VALIDITY_PARTITION_SIG_SIZE);
/* Verify partitions are ordered and non-overlapping */
for (guint p = 0; p < layout->num_partitions; p++)
{
@ -217,7 +201,7 @@ test_hal_flash_layout (void)
}
/* ================================================================
* T7.9: Blob sizes match expected values from python-validity
* T7.9: Device descriptors have correct VID/PID
* ================================================================ */
static void
test_hal_blob_sizes (void)
@ -226,21 +210,14 @@ test_hal_blob_sizes (void)
validity_hal_device_lookup (VALIDITY_DEV_9A);
g_assert_nonnull (desc_9a);
/* 009a blobs: init=581, clean_slate=741, reset=12037, dbe=3621 */
g_assert_cmpuint (desc_9a->init_hardcoded_len, ==, 581);
g_assert_cmpuint (desc_9a->init_clean_slate_len, ==, 741);
g_assert_cmpuint (desc_9a->reset_blob_len, ==, 12037);
g_assert_cmpuint (desc_9a->db_write_enable_len, ==, 3621);
g_assert_cmpuint (desc_9a->vid, ==, 0x06cb);
g_assert_cmpuint (desc_9a->pid, ==, 0x009a);
const ValidityDeviceDesc *desc_90 =
validity_hal_device_lookup (VALIDITY_DEV_90);
g_assert_nonnull (desc_90);
/* 0090 blobs: init=485, no clean_slate, reset=11493, dbe=1765 */
g_assert_cmpuint (desc_90->init_hardcoded_len, ==, 485);
g_assert_cmpuint (desc_90->reset_blob_len, ==, 11493);
g_assert_cmpuint (desc_90->db_write_enable_len, ==, 1765);
g_assert_cmpuint (desc_90->vid, ==, 0x138a);
g_assert_cmpuint (desc_90->pid, ==, 0x0090);
}
/* ================================================================
@ -1361,22 +1338,22 @@ test_unsupported_pid_firmware (void)
/* ================================================================
* T3.10: test_fwext_db_write_enable_blob
*
* Verify that db_write_enable blob is returned for supported PID
* and NULL for unsupported PID.
* Since blobs are now loaded from external data files at runtime,
* this test verifies the function returns NULL when no data is loaded.
* ================================================================ */
static void
test_fwext_db_write_enable_blob (void)
{
/* Create a minimal FpiDeviceValidity with empty data stores.
* Since no data files are loaded, the accessor should return NULL. */
FpiDeviceValidity dev = { 0 };
validity_data_store_init (&dev.device_data);
gsize len;
const guint8 *blob;
blob = validity_fwext_get_db_write_enable (0x06cb, 0x009a, &len);
g_assert_nonnull (blob);
g_assert_cmpuint (len, ==, 3621);
blob = validity_fwext_get_db_write_enable (0x1234, 0x5678, &len);
const guint8 *blob = validity_fwext_get_db_write_enable (&dev, &len);
g_assert_null (blob);
g_assert_cmpuint (len, ==, 0);
validity_data_store_free (&dev.device_data);
}
/* ================================================================
@ -1967,30 +1944,20 @@ test_build_finger_data (void)
/* ================================================================
* T6.24: test_db_write_enable_blob
*
* Verify db_write_enable blob accessor returns a valid blob.
* Since blobs are now loaded from external data files at runtime,
* verify the function returns NULL when no data is loaded.
* ================================================================ */
static void
test_db_write_enable_blob (void)
{
FpiDeviceValidity dev = { 0 };
validity_data_store_init (&dev.device_data);
gsize len;
const guint8 *blob = validity_db_get_write_enable_blob (&dev, &len);
g_assert_null (blob);
/* Test with 009a device type (known to have a 3621-byte blob) */
const guint8 *blob = validity_db_get_write_enable_blob (VALIDITY_DEV_9A, &len);
g_assert_nonnull (blob);
g_assert_cmpuint (len, >, 0);
g_assert_cmpuint (len, ==, 3621);
/* Test all supported device types return valid blobs */
const guint dev_types[] = { VALIDITY_DEV_90, VALIDITY_DEV_97,
VALIDITY_DEV_9A, VALIDITY_DEV_9D };
for (guint i = 0; i < G_N_ELEMENTS (dev_types); i++)
{
gsize dbe_len;
const guint8 *dbe = validity_db_get_write_enable_blob (dev_types[i], &dbe_len);
g_assert_nonnull (dbe);
g_assert_cmpuint (dbe_len, >, 0);
}
validity_data_store_free (&dev.device_data);
}
/* ================================================================
@ -3462,7 +3429,11 @@ test_make_cert_size (void)
RAND_bytes (pub_y, 32);
gsize cert_len;
g_autofree guint8 *cert = validity_pair_make_cert (pub_x, pub_y, &cert_len);
guint8 password[32];
RAND_bytes (password, sizeof (password));
g_autofree guint8 *cert = validity_pair_make_cert (pub_x, pub_y,
password, sizeof (password),
&cert_len);
g_assert_nonnull (cert);
g_assert_cmpuint (cert_len, ==, VALIDITY_CLIENT_CERT_SIZE);
@ -3485,10 +3456,15 @@ test_make_cert_deterministic (void)
* without RFC 6979, so we can only verify structure matches. */
guint8 pub_x[32] = { 0x01 };
guint8 pub_y[32] = { 0x02 };
guint8 password[32] = { 0x03 };
gsize len1, len2;
g_autofree guint8 *cert1 = validity_pair_make_cert (pub_x, pub_y, &len1);
g_autofree guint8 *cert2 = validity_pair_make_cert (pub_x, pub_y, &len2);
g_autofree guint8 *cert1 = validity_pair_make_cert (pub_x, pub_y,
password, sizeof (password),
&len1);
g_autofree guint8 *cert2 = validity_pair_make_cert (pub_x, pub_y,
password, sizeof (password),
&len2);
g_assert_nonnull (cert1);
g_assert_nonnull (cert2);
@ -3584,10 +3560,22 @@ test_build_partition_flash_cmd (void)
RAND_bytes (pub_x, 32);
RAND_bytes (pub_y, 32);
/* Create dummy data for runtime parameters */
guint8 partition_sig[256];
guint8 password[32];
guint8 ca_cert[256];
RAND_bytes (partition_sig, sizeof (partition_sig));
RAND_bytes (password, sizeof (password));
RAND_bytes (ca_cert, sizeof (ca_cert));
gsize cmd_len;
g_autofree guint8 *cmd =
validity_pair_build_partition_flash_cmd (&flash_ic, desc->flash_layout,
pub_x, pub_y, &cmd_len);
partition_sig, sizeof (partition_sig),
pub_x, pub_y,
password, sizeof (password),
ca_cert, sizeof (ca_cert),
&cmd_len);
g_assert_nonnull (cmd);
g_assert_cmpuint (cmd_len, >, 5);
@ -3625,8 +3613,13 @@ test_build_tls_flash_size (void)
state.ecdh_blob = ecdh_blob;
state.ecdh_blob_len = sizeof (ecdh_blob);
guint8 ca_cert[256];
RAND_bytes (ca_cert, sizeof (ca_cert));
gsize flash_len;
g_autofree guint8 *flash = validity_pair_build_tls_flash (&state, &flash_len);
g_autofree guint8 *flash = validity_pair_build_tls_flash (&state,
ca_cert, sizeof (ca_cert),
&flash_len);
g_assert_nonnull (flash);
g_assert_cmpuint (flash_len, ==, 0x1000);
@ -3674,8 +3667,13 @@ test_build_tls_flash_blocks (void)
state.ecdh_blob = ecdh_blob;
state.ecdh_blob_len = sizeof (ecdh_blob);
guint8 ca_cert2[256];
memset (ca_cert2, 0xDD, sizeof (ca_cert2));
gsize flash_len;
g_autofree guint8 *flash = validity_pair_build_tls_flash (&state, &flash_len);
g_autofree guint8 *flash = validity_pair_build_tls_flash (&state,
ca_cert2, sizeof (ca_cert2),
&flash_len);
g_assert_nonnull (flash);
/* Block 0 should be first: id=0, size=1 */
@ -4692,9 +4690,612 @@ test_capture_split_real_prog (void)
}
/* ================================================================
* main
* Tests: Data Loader (validity_data.c)
* ================================================================ */
/* ================================================================
* T8.1: Store init/free — empty store returns NULL for all tags
* ================================================================ */
static void
test_data_store_empty (void)
{
ValidityDataStore store;
validity_data_store_init (&store);
/* All tags should return NULL */
for (int tag = 0; tag < VALIDITY_DATA_NUM_TAGS; tag++)
{
gsize len;
const guint8 *data = validity_data_get_bytes (&store, tag, &len);
g_assert_null (data);
g_assert_cmpuint (len, ==, 0);
GBytes *bytes = validity_data_get (&store, tag);
g_assert_null (bytes);
}
validity_data_store_free (&store);
}
/* ================================================================
* T8.2: Store double free — should not crash
* ================================================================ */
static void
test_data_store_double_free (void)
{
ValidityDataStore store;
validity_data_store_init (&store);
validity_data_store_free (&store);
validity_data_store_free (&store);
}
/* ================================================================
* T8.3: Load file with valid HMAC
* ================================================================ */
static void
test_data_load_valid_hmac (void)
{
/* Create a temp file with valid HMAC-SHA256 */
guint8 payload[] = { 0xDE, 0xAD, 0xBE, 0xEF };
gsize payload_len = sizeof (payload);
/* Compute HMAC-SHA256 with the known key */
const guint8 hmac_key[32] = {
0x6c, 0x69, 0x62, 0x66, 0x70, 0x72, 0x69, 0x6e,
0x74, 0x2d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69,
0x74, 0x79, 0x2d, 0x64, 0x61, 0x74, 0x61, 0x2d,
0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x69, 0x74,
};
GHmac *hmac = g_hmac_new (G_CHECKSUM_SHA256, hmac_key, sizeof (hmac_key));
g_hmac_update (hmac, payload, payload_len);
guint8 trailer[32];
gsize digest_len = sizeof (trailer);
g_hmac_get_digest (hmac, trailer, &digest_len);
g_hmac_unref (hmac);
/* Write payload + trailer to temp file */
g_autofree gchar *tmpfile = NULL;
gint fd = g_file_open_tmp ("validity-test-XXXXXX.bin", &tmpfile, NULL);
g_assert_cmpint (fd, >, 0);
g_assert_true (write (fd, payload, payload_len) == (ssize_t) payload_len);
g_assert_true (write (fd, trailer, sizeof (trailer)) == sizeof (trailer));
close (fd);
/* Load and verify */
ValidityDataStore store;
validity_data_store_init (&store);
GError *error = NULL;
gboolean ok = validity_data_load_file (&store, VALIDITY_DATA_INIT,
tmpfile, &error);
g_assert_no_error (error);
g_assert_true (ok);
/* Verify loaded data matches payload (without HMAC) */
gsize len;
const guint8 *data = validity_data_get_bytes (&store, VALIDITY_DATA_INIT, &len);
g_assert_nonnull (data);
g_assert_cmpuint (len, ==, payload_len);
g_assert_cmpmem (data, len, payload, payload_len);
validity_data_store_free (&store);
g_unlink (tmpfile);
}
/* ================================================================
* T8.4: Load file with corrupted HMAC — should fail
* ================================================================ */
static void
test_data_load_corrupt_hmac (void)
{
guint8 payload[] = { 0xCA, 0xFE };
guint8 bad_trailer[32];
memset (bad_trailer, 0xFF, sizeof (bad_trailer));
g_autofree gchar *tmpfile = NULL;
gint fd = g_file_open_tmp ("validity-test-XXXXXX.bin", &tmpfile, NULL);
g_assert_cmpint (fd, >, 0);
g_assert_true (write (fd, payload, sizeof (payload)) == sizeof (payload));
g_assert_true (write (fd, bad_trailer, sizeof (bad_trailer)) == sizeof (bad_trailer));
close (fd);
ValidityDataStore store;
validity_data_store_init (&store);
GError *error = NULL;
gboolean ok = validity_data_load_file (&store, VALIDITY_DATA_INIT,
tmpfile, &error);
g_assert_false (ok);
g_assert_nonnull (error);
g_error_free (error);
/* Tag should not be populated */
gsize len;
const guint8 *data = validity_data_get_bytes (&store, VALIDITY_DATA_INIT, &len);
g_assert_null (data);
validity_data_store_free (&store);
g_unlink (tmpfile);
}
/* ================================================================
* T8.5: Load file too small — should fail
* ================================================================ */
static void
test_data_load_too_small (void)
{
/* File with only 20 bytes — less than HMAC size (32) */
guint8 tiny[20];
memset (tiny, 0x42, sizeof (tiny));
g_autofree gchar *tmpfile = NULL;
gint fd = g_file_open_tmp ("validity-test-XXXXXX.bin", &tmpfile, NULL);
g_assert_cmpint (fd, >, 0);
g_assert_true (write (fd, tiny, sizeof (tiny)) == sizeof (tiny));
close (fd);
ValidityDataStore store;
validity_data_store_init (&store);
GError *error = NULL;
gboolean ok = validity_data_load_file (&store, VALIDITY_DATA_INIT,
tmpfile, &error);
g_assert_false (ok);
g_assert_nonnull (error);
g_error_free (error);
validity_data_store_free (&store);
g_unlink (tmpfile);
}
/* ================================================================
* T8.6: Load nonexistent file — should fail
* ================================================================ */
static void
test_data_load_nonexistent (void)
{
ValidityDataStore store;
validity_data_store_init (&store);
GError *error = NULL;
gboolean ok = validity_data_load_file (&store, VALIDITY_DATA_INIT,
"/nonexistent/path/blob.bin",
&error);
g_assert_false (ok);
g_assert_nonnull (error);
g_error_free (error);
validity_data_store_free (&store);
}
/* ================================================================
* T8.7: Tag enum values are contiguous
* ================================================================ */
static void
test_data_tag_enum (void)
{
g_assert_cmpint (VALIDITY_DATA_INIT, ==, 0);
g_assert_cmpint (VALIDITY_DATA_NUM_TAGS, ==, 11);
g_assert_cmpint (VALIDITY_DATA_FW_PUBKEY_Y, ==,
VALIDITY_DATA_NUM_TAGS - 1);
}
/* ================================================================
* Helper: write a file with valid HMAC-SHA256 trailer
* ================================================================ */
static void
write_hmac_file (const gchar *path,
const guint8 *payload,
gsize payload_len)
{
static const guint8 hmac_key[32] = {
0x6c, 0x69, 0x62, 0x66, 0x70, 0x72, 0x69, 0x6e,
0x74, 0x2d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69,
0x74, 0x79, 0x2d, 0x64, 0x61, 0x74, 0x61, 0x2d,
0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x69, 0x74,
};
GHmac *hmac = g_hmac_new (G_CHECKSUM_SHA256, hmac_key, sizeof (hmac_key));
g_hmac_update (hmac, payload, payload_len);
guint8 trailer[32];
gsize digest_len = sizeof (trailer);
g_hmac_get_digest (hmac, trailer, &digest_len);
g_hmac_unref (hmac);
gsize total = payload_len + 32;
g_autofree guint8 *buf = g_malloc (total);
memcpy (buf, payload, payload_len);
memcpy (buf + payload_len, trailer, 32);
g_assert_true (g_file_set_contents (path, (const gchar *) buf, total, NULL));
}
/* ================================================================
* T8.8: load_device — missing directory returns DATA_NOT_FOUND
* ================================================================ */
static void
test_data_load_device_missing (void)
{
ValidityDataStore store;
validity_data_store_init (&store);
/* Temporarily override search paths to a non-existent directory */
const gchar *saved = validity_data_search_paths[0];
validity_data_search_paths[0] = "/tmp/nonexistent_validity_data_dir";
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_device (&store, 0x06cb, 0x009a, &error);
g_assert_false (ok);
g_assert_nonnull (error);
g_assert_cmpint (error->code, ==, FP_DEVICE_ERROR_DATA_NOT_FOUND);
g_error_free (error);
/* Restore */
validity_data_search_paths[0] = saved;
validity_data_search_paths[1] = "/usr/local/share/libfprint/validity";
validity_data_store_free (&store);
}
/* ================================================================
* T8.9: load_device — directory exists but mandatory init.bin missing
* ================================================================ */
static void
test_data_load_device_missing_init (void)
{
/* Create temp dir with the expected subdir but no files */
g_autofree gchar *tmpdir = g_dir_make_tmp ("validity-data-XXXXXX", NULL);
g_assert_nonnull (tmpdir);
g_autofree gchar *devdir = g_build_filename (tmpdir, "06cb_009a", NULL);
g_assert_cmpint (g_mkdir (devdir, 0755), ==, 0);
ValidityDataStore store;
validity_data_store_init (&store);
const gchar *saved0 = validity_data_search_paths[0];
const gchar *saved1 = validity_data_search_paths[1];
validity_data_search_paths[0] = tmpdir;
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_device (&store, 0x06cb, 0x009a, &error);
g_assert_false (ok);
g_assert_nonnull (error);
g_assert_cmpint (error->code, ==, FP_DEVICE_ERROR_DATA_NOT_FOUND);
g_error_free (error);
validity_data_search_paths[0] = saved0;
validity_data_search_paths[1] = saved1;
validity_data_store_free (&store);
g_rmdir (devdir);
g_rmdir (tmpdir);
}
/* ================================================================
* T8.10: load_device — valid temp dir with init.bin loads correctly
* ================================================================ */
static void
test_data_load_device_valid (void)
{
g_autofree gchar *tmpdir = g_dir_make_tmp ("validity-data-XXXXXX", NULL);
g_assert_nonnull (tmpdir);
g_autofree gchar *devdir = g_build_filename (tmpdir, "06cb_009a", NULL);
g_assert_cmpint (g_mkdir (devdir, 0755), ==, 0);
/* Write a valid init.bin (mandatory) */
guint8 init_payload[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
g_autofree gchar *init_path = g_build_filename (devdir, "init.bin", NULL);
write_hmac_file (init_path, init_payload, sizeof (init_payload));
/* Write a valid db_write_enable.bin (optional) */
guint8 dbe_payload[] = { 0xAA, 0xBB };
g_autofree gchar *dbe_path =
g_build_filename (devdir, "db_write_enable.bin", NULL);
write_hmac_file (dbe_path, dbe_payload, sizeof (dbe_payload));
ValidityDataStore store;
validity_data_store_init (&store);
const gchar *saved0 = validity_data_search_paths[0];
const gchar *saved1 = validity_data_search_paths[1];
validity_data_search_paths[0] = tmpdir;
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_device (&store, 0x06cb, 0x009a, &error);
g_assert_no_error (error);
g_assert_true (ok);
/* Verify init was loaded */
gsize len;
const guint8 *data = validity_data_get_bytes (&store, VALIDITY_DATA_INIT, &len);
g_assert_nonnull (data);
g_assert_cmpuint (len, ==, sizeof (init_payload));
g_assert_cmpmem (data, len, init_payload, sizeof (init_payload));
/* Verify db_write_enable was loaded */
const guint8 *dbe = validity_data_get_bytes (&store,
VALIDITY_DATA_DB_WRITE_ENABLE,
&len);
g_assert_nonnull (dbe);
g_assert_cmpuint (len, ==, sizeof (dbe_payload));
g_assert_cmpmem (dbe, len, dbe_payload, sizeof (dbe_payload));
/* Optional files not present should be NULL */
const guint8 *reset = validity_data_get_bytes (&store,
VALIDITY_DATA_RESET, &len);
g_assert_null (reset);
g_assert_cmpuint (len, ==, 0);
validity_data_search_paths[0] = saved0;
validity_data_search_paths[1] = saved1;
validity_data_store_free (&store);
g_unlink (init_path);
g_unlink (dbe_path);
g_rmdir (devdir);
g_rmdir (tmpdir);
}
/* ================================================================
* T8.11: load_common — missing files returns DATA_NOT_FOUND
* ================================================================ */
static void
test_data_load_common_missing (void)
{
ValidityDataStore store;
validity_data_store_init (&store);
const gchar *saved0 = validity_data_search_paths[0];
const gchar *saved1 = validity_data_search_paths[1];
validity_data_search_paths[0] = "/tmp/nonexistent_validity_common_dir";
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_common (&store, &error);
g_assert_false (ok);
g_assert_nonnull (error);
g_assert_cmpint (error->code, ==, FP_DEVICE_ERROR_DATA_NOT_FOUND);
g_error_free (error);
validity_data_search_paths[0] = saved0;
validity_data_search_paths[1] = saved1;
validity_data_store_free (&store);
}
/* ================================================================
* T8.12: load_common — valid temp dir loads all 7 common files
* ================================================================ */
static void
test_data_load_common_valid (void)
{
g_autofree gchar *tmpdir = g_dir_make_tmp ("validity-common-XXXXXX", NULL);
g_assert_nonnull (tmpdir);
/* Write all 7 common files with test payloads */
static const struct {
const gchar *filename;
ValidityDataTag tag;
guint8 marker;
} files[] = {
{ "partition_sig_standard.bin", VALIDITY_DATA_PARTITION_SIG_STANDARD, 0x01 },
{ "partition_sig_0090.bin", VALIDITY_DATA_PARTITION_SIG_0090, 0x02 },
{ "ca_pubkey.bin", VALIDITY_DATA_CA_PUBKEY, 0x03 },
{ "tls_password.bin", VALIDITY_DATA_TLS_PASSWORD, 0x04 },
{ "gwk_sign.bin", VALIDITY_DATA_GWK_SIGN, 0x05 },
{ "fw_pubkey_x.bin", VALIDITY_DATA_FW_PUBKEY_X, 0x06 },
{ "fw_pubkey_y.bin", VALIDITY_DATA_FW_PUBKEY_Y, 0x07 },
};
g_autofree gchar *paths[7] = { NULL };
for (gsize i = 0; i < G_N_ELEMENTS (files); i++)
{
guint8 payload[4];
memset (payload, files[i].marker, sizeof (payload));
paths[i] = g_build_filename (tmpdir, files[i].filename, NULL);
write_hmac_file (paths[i], payload, sizeof (payload));
}
ValidityDataStore store;
validity_data_store_init (&store);
const gchar *saved0 = validity_data_search_paths[0];
const gchar *saved1 = validity_data_search_paths[1];
validity_data_search_paths[0] = tmpdir;
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_common (&store, &error);
g_assert_no_error (error);
g_assert_true (ok);
/* Verify each tag was loaded correctly */
for (gsize i = 0; i < G_N_ELEMENTS (files); i++)
{
gsize len;
const guint8 *data = validity_data_get_bytes (&store, files[i].tag, &len);
g_assert_nonnull (data);
g_assert_cmpuint (len, ==, 4);
g_assert_cmpuint (data[0], ==, files[i].marker);
}
validity_data_search_paths[0] = saved0;
validity_data_search_paths[1] = saved1;
/* Cleanup */
validity_data_store_free (&store);
for (gsize i = 0; i < G_N_ELEMENTS (files); i++)
{
g_unlink (paths[i]);
g_free (paths[i]);
paths[i] = NULL;
}
g_rmdir (tmpdir);
}
/* ================================================================
* T8.13: Enroll db_write_enable — returns NULL with no loaded data
*
* Verifies that the enroll/verify path fails gracefully when the
* runtime data files haven't been loaded (e.g., package not installed).
* ================================================================ */
static void
test_data_enroll_dbe_missing (void)
{
/* Create a minimal FpiDeviceValidity with empty data stores */
FpiDeviceValidity dev = { 0 };
validity_data_store_init (&dev.device_data);
validity_data_store_init (&dev.common_data);
/* db_write_enable is used in enroll, verify (match), and delete flows.
* When data files are not installed, it must return NULL gracefully. */
gsize len;
const guint8 *dbe = validity_db_get_write_enable_blob (&dev, &len);
g_assert_null (dbe);
g_assert_cmpuint (len, ==, 0);
/* fwext accessor also returns NULL */
const guint8 *fwe = validity_fwext_get_db_write_enable (&dev, &len);
g_assert_null (fwe);
g_assert_cmpuint (len, ==, 0);
/* TLS key pointers should be NULL */
g_assert_null (dev.tls.password);
g_assert_null (dev.tls.gwk_sign);
g_assert_null (dev.tls.fw_pubkey_x);
g_assert_null (dev.tls.fw_pubkey_y);
validity_data_store_free (&dev.device_data);
validity_data_store_free (&dev.common_data);
}
/* ================================================================
* T8.14: Enroll db_write_enable — returns data when store populated
*
* Verifies that after loading data files, the consumers can
* access the blob through the data store accessors.
* ================================================================ */
static void
test_data_enroll_dbe_loaded (void)
{
/* Create device with loaded db_write_enable */
g_autofree gchar *tmpdir = g_dir_make_tmp ("validity-dbe-XXXXXX", NULL);
g_assert_nonnull (tmpdir);
g_autofree gchar *devdir = g_build_filename (tmpdir, "06cb_009a", NULL);
g_assert_cmpint (g_mkdir (devdir, 0755), ==, 0);
/* Write init.bin (mandatory) and db_write_enable.bin */
guint8 init_data[] = { 0x11 };
g_autofree gchar *init_path = g_build_filename (devdir, "init.bin", NULL);
write_hmac_file (init_path, init_data, sizeof (init_data));
guint8 dbe_data[] = { 0xDB, 0xE0, 0x01, 0x02, 0x03 };
g_autofree gchar *dbe_path =
g_build_filename (devdir, "db_write_enable.bin", NULL);
write_hmac_file (dbe_path, dbe_data, sizeof (dbe_data));
FpiDeviceValidity dev = { 0 };
validity_data_store_init (&dev.device_data);
const gchar *saved0 = validity_data_search_paths[0];
const gchar *saved1 = validity_data_search_paths[1];
validity_data_search_paths[0] = tmpdir;
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_device (&dev.device_data,
0x06cb, 0x009a, &error);
g_assert_no_error (error);
g_assert_true (ok);
/* Now the enroll/verify consumer should find the data */
gsize len;
const guint8 *dbe = validity_db_get_write_enable_blob (&dev, &len);
g_assert_nonnull (dbe);
g_assert_cmpuint (len, ==, sizeof (dbe_data));
g_assert_cmpmem (dbe, len, dbe_data, sizeof (dbe_data));
/* fwext accessor should also work */
const guint8 *fwe = validity_fwext_get_db_write_enable (&dev, &len);
g_assert_nonnull (fwe);
g_assert_cmpuint (len, ==, sizeof (dbe_data));
validity_data_search_paths[0] = saved0;
validity_data_search_paths[1] = saved1;
validity_data_store_free (&dev.device_data);
g_unlink (init_path);
g_unlink (dbe_path);
g_rmdir (devdir);
g_rmdir (tmpdir);
}
/* ================================================================
* T8.15: load_device — corrupt init.bin fails with error
*
* Verifies that a corrupted data file in the device directory
* is detected by HMAC verification and the load is rejected.
* ================================================================ */
static void
test_data_load_device_corrupt (void)
{
g_autofree gchar *tmpdir = g_dir_make_tmp ("validity-corrupt-XXXXXX", NULL);
g_assert_nonnull (tmpdir);
g_autofree gchar *devdir = g_build_filename (tmpdir, "06cb_009a", NULL);
g_assert_cmpint (g_mkdir (devdir, 0755), ==, 0);
/* Write init.bin with bad HMAC */
guint8 bad_file[37]; /* 5 bytes payload + 32 bytes bad HMAC */
memset (bad_file, 0xAA, sizeof (bad_file));
g_autofree gchar *init_path = g_build_filename (devdir, "init.bin", NULL);
g_assert_true (g_file_set_contents (init_path, (const gchar *) bad_file,
sizeof (bad_file), NULL));
ValidityDataStore store;
validity_data_store_init (&store);
const gchar *saved0 = validity_data_search_paths[0];
const gchar *saved1 = validity_data_search_paths[1];
validity_data_search_paths[0] = tmpdir;
validity_data_search_paths[1] = NULL;
GError *error = NULL;
gboolean ok = validity_data_load_device (&store, 0x06cb, 0x009a, &error);
g_assert_false (ok);
g_assert_nonnull (error);
/* HMAC failure reports DATA_INVALID */
g_assert_cmpint (error->code, ==, FP_DEVICE_ERROR_DATA_INVALID);
g_error_free (error);
validity_data_search_paths[0] = saved0;
validity_data_search_paths[1] = saved1;
validity_data_store_free (&store);
g_unlink (init_path);
g_rmdir (devdir);
g_rmdir (tmpdir);
}
/* ================================================================
* Main
* ================================================================ */
@ -5074,6 +5675,38 @@ main (int argc, char *argv[])
g_test_add_func ("/validity/capture/split-real-prog",
test_capture_split_real_prog);
/* Data loader tests */
g_test_add_func ("/validity/data/store-empty",
test_data_store_empty);
g_test_add_func ("/validity/data/store-double-free",
test_data_store_double_free);
g_test_add_func ("/validity/data/load-valid-hmac",
test_data_load_valid_hmac);
g_test_add_func ("/validity/data/load-corrupt-hmac",
test_data_load_corrupt_hmac);
g_test_add_func ("/validity/data/load-too-small",
test_data_load_too_small);
g_test_add_func ("/validity/data/load-nonexistent",
test_data_load_nonexistent);
g_test_add_func ("/validity/data/tag-enum",
test_data_tag_enum);
g_test_add_func ("/validity/data/load-device-missing",
test_data_load_device_missing);
g_test_add_func ("/validity/data/load-device-missing-init",
test_data_load_device_missing_init);
g_test_add_func ("/validity/data/load-device-valid",
test_data_load_device_valid);
g_test_add_func ("/validity/data/load-common-missing",
test_data_load_common_missing);
g_test_add_func ("/validity/data/load-common-valid",
test_data_load_common_valid);
g_test_add_func ("/validity/data/enroll-dbe-missing",
test_data_enroll_dbe_missing);
g_test_add_func ("/validity/data/enroll-dbe-loaded",
test_data_enroll_dbe_loaded);
g_test_add_func ("/validity/data/load-device-corrupt",
test_data_load_device_corrupt);
return g_test_run ();
}