From 67360da8d2dfc19736f1fa6e1650c9a0a277d3d1 Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Tue, 17 Mar 2026 20:46:12 -0600 Subject: [PATCH 01/11] Add SW-only RSA PSS --- include/image.h | 10 ++++ include/loader.h | 9 ++-- include/user_settings.h | 26 +++++++-- include/wolfboot/wolfboot.h | 38 ++++++++++--- options.mk | 78 +++++++++++++++++++++++++++ src/image.c | 72 ++++++++++++++++++++++++- tools/keytools/keygen.c | 65 ++++++++++++++++------ tools/keytools/sign.c | 98 +++++++++++++++++++++++++++++++++- tools/keytools/user_settings.h | 1 + 9 files changed, 365 insertions(+), 32 deletions(-) diff --git a/include/image.h b/include/image.h index c9e7fcba10..38ea9f056b 100644 --- a/include/image.h +++ b/include/image.h @@ -68,6 +68,11 @@ extern "C" { defined (WOLFBOOT_SIGN_RSA4096ENC) #define wolfBoot_verify_signature_primary wolfBoot_verify_signature_rsa #endif +#if defined (WOLFBOOT_SIGN_RSAPSS2048) || \ + defined (WOLFBOOT_SIGN_RSAPSS3072) || \ + defined (WOLFBOOT_SIGN_RSAPSS4096) +#define wolfBoot_verify_signature_primary wolfBoot_verify_signature_rsa_pss +#endif #if defined (WOLFBOOT_SIGN_ECC256) || \ defined (WOLFBOOT_SIGN_ECC384) || \ defined (WOLFBOOT_SIGN_ECC521) @@ -97,6 +102,11 @@ extern "C" { defined (WOLFBOOT_SIGN_SECONDARY_RSA4096ENC) #define wolfBoot_verify_signature_secondary wolfBoot_verify_signature_rsa #endif +#if defined (WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined (WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined (WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) +#define wolfBoot_verify_signature_secondary wolfBoot_verify_signature_rsa_pss +#endif #if defined (WOLFBOOT_SIGN_SECONDARY_ECC256) || \ defined (WOLFBOOT_SIGN_SECONDARY_ECC384) || \ defined (WOLFBOOT_SIGN_SECONDARY_ECC521) diff --git a/include/loader.h b/include/loader.h index 9d2ef37653..2e9f5a3e24 100644 --- a/include/loader.h +++ b/include/loader.h @@ -40,11 +40,14 @@ extern "C" { #define ECC_IMAGE_SIGNATURE_SIZE (132) #endif -#if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) +#if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) || \ + defined(WOLFBOOT_SIGN_RSAPSS2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) #define RSA_IMAGE_SIGNATURE_SIZE (256) -#elif defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_SECONDARY_RSA3072) +#elif defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_SECONDARY_RSA3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS3072) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) #define RSA_IMAGE_SIGNATURE_SIZE (384) -#elif defined(WOLFBOOT_SIGN_RSA4096) || defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) +#elif defined(WOLFBOOT_SIGN_RSA4096) || defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) #define RSA_IMAGE_SIGNATURE_SIZE (512) #endif diff --git a/include/user_settings.h b/include/user_settings.h index c681839c07..b30500368f 100644 --- a/include/user_settings.h +++ b/include/user_settings.h @@ -222,12 +222,25 @@ extern int tolower(int c); defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) || \ defined(WOLFBOOT_SIGN_SECONDARY_RSA3072) || \ defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) || \ + defined(WOLFBOOT_SIGN_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) || \ (defined(WOLFCRYPT_SECURE_MODE) && (!defined(PKCS11_SMALL))) # define WC_RSA_BLINDING # define WC_RSA_DIRECT # define RSA_LOW_MEM # define WC_ASN_HASH_SHA256 +# if defined(WOLFBOOT_SIGN_RSAPSS2048) || defined(WOLFBOOT_SIGN_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) +# define WC_RSA_PSS +# endif # if !defined(WOLFBOOT_TPM) && !defined(WOLFCRYPT_SECURE_MODE) && \ !defined(WOLFCRYPT_TEST) && !defined(WOLFCRYPT_BENCHMARK) && \ !defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ @@ -235,7 +248,9 @@ extern int tolower(int c); # define WOLFSSL_RSA_VERIFY_INLINE # define WOLFSSL_RSA_VERIFY_ONLY # define WOLFSSL_RSA_PUBLIC_ONLY -# define WC_NO_RSA_OAEP +# if !defined(WC_RSA_PSS) +# define WC_NO_RSA_OAEP +# endif # define NO_RSA_BOUNDS_CHECK # endif # if !defined(USE_FAST_MATH) && !defined(WOLFSSL_SP_MATH_ALL) @@ -244,7 +259,8 @@ extern int tolower(int c); # define WOLFSSL_SP_SMALL # define WOLFSSL_SP_MATH # endif -# if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) +# if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) || \ + defined(WOLFBOOT_SIGN_RSAPSS2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) # define FP_MAX_BITS (2048 * 2) # define SP_INT_BITS 2048 # define WOLFSSL_SP_NO_3072 @@ -253,7 +269,8 @@ extern int tolower(int c); # define RSA_MIN_SIZE 2048 # define RSA_MAX_SIZE 2048 # endif -# if defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_SECONDARY_RSA3072) +# if defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_SECONDARY_RSA3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS3072) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) # define FP_MAX_BITS (3072 * 2) # define SP_INT_BITS 3072 # define WOLFSSL_SP_NO_2048 @@ -263,7 +280,8 @@ extern int tolower(int c); # define RSA_MAX_SIZE 3072 # endif -# if defined(WOLFBOOT_SIGN_RSA4096) || defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) +# if defined(WOLFBOOT_SIGN_RSA4096) || defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) # define FP_MAX_BITS (4096 * 2) # define SP_INT_BITS 4096 # define WOLFSSL_SP_NO_2048 diff --git a/include/wolfboot/wolfboot.h b/include/wolfboot/wolfboot.h index 201b232437..79cda35bfd 100644 --- a/include/wolfboot/wolfboot.h +++ b/include/wolfboot/wolfboot.h @@ -112,16 +112,16 @@ extern "C" { #ifndef IMAGE_HEADER_SIZE /* Largest cases first */ -# if defined(WOLFBOOT_SIGN_RSA4096) +# if defined(WOLFBOOT_SIGN_RSA4096) || defined(WOLFBOOT_SIGN_RSAPSS4096) # define IMAGE_HEADER_SIZE 1024 - /* RSA3072 + strong hash */ -# elif (defined(WOLFBOOT_SIGN_RSA3072) && \ + /* RSA3072/RSAPSS3072 + strong hash */ +# elif ((defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_RSAPSS3072)) && \ (defined(WOLFBOOT_HASH_SHA384) || defined(WOLFBOOT_HASH_SHA3_384))) # define IMAGE_HEADER_SIZE 1024 - /* RSA2048 + SHA256 */ -# elif defined(WOLFBOOT_SIGN_RSA2048) && defined(WOLFBOOT_HASH_SHA256) + /* RSA2048/RSAPSS2048 + SHA256 */ +# elif (defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_RSAPSS2048)) && defined(WOLFBOOT_HASH_SHA256) # define IMAGE_HEADER_SIZE 512 /* ECC384 requires 512 with SHA256 */ @@ -141,7 +141,7 @@ extern "C" { # define IMAGE_HEADER_SIZE 256 /* Secondary 512-byte fallbacks */ -# elif defined(WOLFBOOT_SIGN_RSA3072) || \ +# elif defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_RSAPSS3072) || \ defined(WOLFBOOT_SIGN_ECC521) || \ defined(WOLFBOOT_SIGN_ED448) || \ defined(WOLFBOOT_HASH_SHA384) || \ @@ -224,7 +224,10 @@ extern "C" { #define AUTH_KEY_ECC521 0x07 #define AUTH_KEY_RSA3072 0x08 #define AUTH_KEY_LMS 0x09 - /* 0x0A...0x0F reserved */ +#define AUTH_KEY_RSAPSS2048 0x0A +#define AUTH_KEY_RSAPSS3072 0x0B +#define AUTH_KEY_RSAPSS4096 0x0C + /* 0x0D...0x0F reserved */ #define AUTH_KEY_XMSS 0x10 #define AUTH_KEY_ML_DSA 0x11 @@ -245,6 +248,9 @@ extern "C" { #define HDR_IMG_TYPE_AUTH_ECC521 (AUTH_KEY_ECC521 << 8) #define HDR_IMG_TYPE_AUTH_RSA3072 (AUTH_KEY_RSA3072 << 8) #define HDR_IMG_TYPE_AUTH_LMS (AUTH_KEY_LMS << 8) +#define HDR_IMG_TYPE_AUTH_RSAPSS2048 (AUTH_KEY_RSAPSS2048 << 8) +#define HDR_IMG_TYPE_AUTH_RSAPSS3072 (AUTH_KEY_RSAPSS3072 << 8) +#define HDR_IMG_TYPE_AUTH_RSAPSS4096 (AUTH_KEY_RSAPSS4096 << 8) #define HDR_IMG_TYPE_AUTH_XMSS (AUTH_KEY_XMSS << 8) #define HDR_IMG_TYPE_AUTH_ML_DSA (AUTH_KEY_ML_DSA << 8) @@ -265,6 +271,9 @@ extern "C" { #define KEYSTORE_PUBKEY_SIZE_RSA2048 320 #define KEYSTORE_PUBKEY_SIZE_RSA3072 448 #define KEYSTORE_PUBKEY_SIZE_RSA4096 576 +#define KEYSTORE_PUBKEY_SIZE_RSAPSS2048 KEYSTORE_PUBKEY_SIZE_RSA2048 +#define KEYSTORE_PUBKEY_SIZE_RSAPSS3072 KEYSTORE_PUBKEY_SIZE_RSA3072 +#define KEYSTORE_PUBKEY_SIZE_RSAPSS4096 KEYSTORE_PUBKEY_SIZE_RSA4096 #define KEYSTORE_PUBKEY_SIZE_LMS 60 #define KEYSTORE_PUBKEY_SIZE_XMSS 68 @@ -439,6 +448,21 @@ extern "C" { # ifndef WOLFBOOT_UNIVERSAL_KEYSTORE # define KEYSTORE_PUBKEY_SIZE KEYSTORE_PUBKEY_SIZE_RSA4096 # endif + #elif defined(WOLFBOOT_SIGN_RSAPSS2048) + # define HDR_IMG_TYPE_AUTH HDR_IMG_TYPE_AUTH_RSAPSS2048 + # ifndef WOLFBOOT_UNIVERSAL_KEYSTORE + # define KEYSTORE_PUBKEY_SIZE KEYSTORE_PUBKEY_SIZE_RSA2048 + # endif + #elif defined(WOLFBOOT_SIGN_RSAPSS3072) + # define HDR_IMG_TYPE_AUTH HDR_IMG_TYPE_AUTH_RSAPSS3072 + # ifndef WOLFBOOT_UNIVERSAL_KEYSTORE + # define KEYSTORE_PUBKEY_SIZE KEYSTORE_PUBKEY_SIZE_RSA3072 + # endif + #elif defined(WOLFBOOT_SIGN_RSAPSS4096) + # define HDR_IMG_TYPE_AUTH HDR_IMG_TYPE_AUTH_RSAPSS4096 + # ifndef WOLFBOOT_UNIVERSAL_KEYSTORE + # define KEYSTORE_PUBKEY_SIZE KEYSTORE_PUBKEY_SIZE_RSA4096 + # endif #elif defined(WOLFBOOT_SIGN_LMS) # define HDR_IMG_TYPE_AUTH HDR_IMG_TYPE_AUTH_LMS # ifndef WOLFBOOT_UNIVERSAL_KEYSTORE diff --git a/options.mk b/options.mk index ff8df2c4ad..3a775e9014 100644 --- a/options.mk +++ b/options.mk @@ -298,6 +298,84 @@ ifeq ($(SIGN),ED448) endif endif +ifeq ($(SIGN),RSAPSS2048) + KEYGEN_OPTIONS+=--rsapss2048 + SIGN_OPTIONS+=--rsapss2048 + SIGN_ALG=RSAPSS2048 + WOLFCRYPT_OBJS+= $(RSA_OBJS) + WOLFCRYPT_OBJS+=$(MATH_OBJS) + CFLAGS+=-D"WOLFBOOT_SIGN_RSAPSS2048" $(RSA_EXTRA_CFLAGS) + ifeq ($(WOLFBOOT_SMALL_STACK),1) + ifneq ($(SPMATH),1) + STACK_USAGE=5008 + else + STACK_USAGE=4096 + endif + else + ifneq ($(SPMATH),1) + STACK_USAGE=35952 + else + STACK_USAGE=17568 + endif + endif + ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 512; echo $$?),0) + IMAGE_HEADER_SIZE=512 + endif +endif + +ifeq ($(SIGN),RSAPSS3072) + KEYGEN_OPTIONS+=--rsapss3072 + SIGN_OPTIONS+=--rsapss3072 + SIGN_ALG=RSAPSS3072 + WOLFCRYPT_OBJS+= $(RSA_OBJS) + WOLFCRYPT_OBJS+=$(MATH_OBJS) + CFLAGS+=-D"WOLFBOOT_SIGN_RSAPSS3072" $(RSA_EXTRA_CFLAGS) + ifeq ($(WOLFBOOT_SMALL_STACK),1) + ifneq ($(SPMATH),1) + STACK_USAGE=5008 + else + STACK_USAGE=4364 + endif + else + ifneq ($(SPMATH),1) + STACK_USAGE=52592 + else + STACK_USAGE=12288 + endif + endif + ifneq ($(HASH),SHA256) + IMAGE_HEADER_SIZE=1024 + endif + ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 512; echo $$?),0) + IMAGE_HEADER_SIZE=512 + endif +endif + +ifeq ($(SIGN),RSAPSS4096) + KEYGEN_OPTIONS+=--rsapss4096 + SIGN_OPTIONS+=--rsapss4096 + SIGN_ALG=RSAPSS4096 + WOLFCRYPT_OBJS+= $(RSA_OBJS) + WOLFCRYPT_OBJS+=$(MATH_OBJS) + CFLAGS+=-D"WOLFBOOT_SIGN_RSAPSS4096" $(RSA_EXTRA_CFLAGS) + ifeq ($(WOLFBOOT_SMALL_STACK),1) + ifneq ($(SPMATH),1) + STACK_USAGE=5888 + else + STACK_USAGE=5768 + endif + else + ifneq ($(SPMATH),1) + STACK_USAGE=69232 + else + STACK_USAGE=18064 + endif + endif + ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 1024; echo $$?),0) + IMAGE_HEADER_SIZE=1024 + endif +endif + ifneq ($(findstring RSA2048,$(SIGN)),) KEYGEN_OPTIONS+=--rsa2048 ifeq ($(SIGN),RSA2048ENC) diff --git a/src/image.c b/src/image.c index d5ff5f3e1a..87ffaadbc0 100644 --- a/src/image.c +++ b/src/image.c @@ -364,7 +364,13 @@ static void wolfBoot_verify_signature_ecc(uint8_t key_slot, defined(WOLFBOOT_SIGN_RSA4096) || \ defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) || \ defined(WOLFBOOT_SIGN_SECONDARY_RSA3072) || \ - defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) + defined(WOLFBOOT_SIGN_SECONDARY_RSA4096) || \ + defined(WOLFBOOT_SIGN_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) #include #include @@ -562,6 +568,65 @@ static void wolfBoot_verify_signature_rsa(uint8_t key_slot, * WOLFBOOT_SIGN_RSA4096 || WOLFBOOT_SIGN_SECONDARY_RSA2048 || * WOLFBOOT_SIGN_SECONDARY_RSA3072 || WOLFBOOT_SIGN_SECONDARY_RSA4096 */ +#if defined(WOLFBOOT_SIGN_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) + +static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, + struct wolfBoot_image *img, uint8_t *sig) +{ + int ret; + uint8_t output[RSA_IMAGE_SIGNATURE_SIZE]; + uint8_t* digest_out = NULL; + word32 inOutIdx = 0; + struct RsaKey rsa; + +#if defined(WOLFBOOT_HASH_SHA256) + enum wc_HashType hash_type = WC_HASH_TYPE_SHA256; + int mgf = WC_MGF1SHA256; +#elif defined(WOLFBOOT_HASH_SHA384) + enum wc_HashType hash_type = WC_HASH_TYPE_SHA384; + int mgf = WC_MGF1SHA384; +#else + #error "RSA-PSS requires SHA-256 or SHA-384" +#endif + + uint8_t *pubkey = keystore_get_buffer(key_slot); + int pubkey_sz = keystore_get_size(key_slot); + + if (pubkey == NULL || pubkey_sz < 0) { + return; + } + + /* wolfCrypt software RSA-PSS verify */ + ret = wc_InitRsaKey(&rsa, NULL); + if (ret == 0) { + /* Import public key */ + ret = wc_RsaPublicKeyDecode((byte*)pubkey, &inOutIdx, &rsa, pubkey_sz); + if (ret >= 0) { + XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); + RSA_VERIFY_FN(ret, + wc_RsaPSS_VerifyCheckInline, output, RSA_IMAGE_SIGNATURE_SIZE, + &digest_out, img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE, + hash_type, mgf, &rsa); + } + } + wc_FreeRsaKey(&rsa); + /* wc_RsaPSS_VerifyCheckInline returns the PSS-verified data length on + * success (>= digest size), or a negative error code on failure. + * The hash comparison is performed internally by the function. */ + if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img) { + wolfBoot_image_confirm_signature_ok(img); + } +} + +#endif /* WOLFBOOT_SIGN_RSAPSS2048 || WOLFBOOT_SIGN_RSAPSS3072 || \ + * WOLFBOOT_SIGN_RSAPSS4096 || WOLFBOOT_SIGN_SECONDARY_RSAPSS2048 || \ + * WOLFBOOT_SIGN_SECONDARY_RSAPSS3072 || WOLFBOOT_SIGN_SECONDARY_RSAPSS4096 */ + #ifdef WOLFBOOT_SIGN_LMS #include #ifdef HAVE_LIBLMS @@ -2272,7 +2337,10 @@ int wolfBoot_verify_authenticity(struct wolfBoot_image *img) defined (WOLFBOOT_SIGN_RSA4096) || \ defined (WOLFBOOT_SIGN_RSA2048ENC) || \ defined (WOLFBOOT_SIGN_RSA3072ENC) || \ - defined (WOLFBOOT_SIGN_RSA4096ENC) + defined (WOLFBOOT_SIGN_RSA4096ENC) || \ + defined (WOLFBOOT_SIGN_RSAPSS2048) || \ + defined (WOLFBOOT_SIGN_RSAPSS3072) || \ + defined (WOLFBOOT_SIGN_RSAPSS4096) if (stored_signature_size != RSA_IMAGE_SIGNATURE_SIZE) return -1; #elif defined (WOLFBOOT_SIGN_ECC256) || \ diff --git a/tools/keytools/keygen.c b/tools/keytools/keygen.c index 97f38340d6..4960352677 100644 --- a/tools/keytools/keygen.c +++ b/tools/keytools/keygen.c @@ -108,6 +108,9 @@ #define KEYGEN_LMS 9 #define KEYGEN_XMSS 10 #define KEYGEN_ML_DSA 11 +#define KEYGEN_RSAPSS2048 12 +#define KEYGEN_RSAPSS3072 13 +#define KEYGEN_RSAPSS4096 14 /* Globals */ static FILE *fpub, *fpub_image; @@ -296,7 +299,7 @@ static void fwritekey(uint8_t *key, int len, FILE *f) } } -const char KType[][17] = { +const char KType[][21] = { "AUTH_KEY_NONE", "AUTH_KEY_ED25519", "AUTH_KEY_ECC256", @@ -308,7 +311,10 @@ const char KType[][17] = { "AUTH_KEY_RSA3072", "AUTH_KEY_LMS", "AUTH_KEY_XMSS", - "AUTH_KEY_ML_DSA" + "AUTH_KEY_ML_DSA", + "AUTH_KEY_RSAPSS2048", + "AUTH_KEY_RSAPSS3072", + "AUTH_KEY_RSAPSS4096" }; const char KSize[][29] = { @@ -323,10 +329,13 @@ const char KSize[][29] = { "KEYSTORE_PUBKEY_SIZE_RSA3072", "KEYSTORE_PUBKEY_SIZE_LMS", "KEYSTORE_PUBKEY_SIZE_XMSS", - "KEYSTORE_PUBKEY_SIZE_ML_DSA" + "KEYSTORE_PUBKEY_SIZE_ML_DSA", + "KEYSTORE_PUBKEY_SIZE_RSA2048", + "KEYSTORE_PUBKEY_SIZE_RSA3072", + "KEYSTORE_PUBKEY_SIZE_RSA4096" }; -const char KName[][8] = { +const char KName[][12] = { "NONE", "ED25519", "ECC256", @@ -338,7 +347,10 @@ const char KName[][8] = { "RSA3072", "LMS", "XMSS", - "ML_DSA" + "ML_DSA", + "RSAPSS2048", + "RSAPSS3072", + "RSAPSS4096" }; #define MAX_PUBKEYS 64 @@ -446,6 +458,15 @@ static uint32_t get_pubkey_size(uint32_t keyType) case KEYGEN_RSA4096: size = KEYSTORE_PUBKEY_SIZE_RSA4096; break; + case KEYGEN_RSAPSS2048: + size = KEYSTORE_PUBKEY_SIZE_RSA2048; + break; + case KEYGEN_RSAPSS3072: + size = KEYSTORE_PUBKEY_SIZE_RSA3072; + break; + case KEYGEN_RSAPSS4096: + size = KEYSTORE_PUBKEY_SIZE_RSA4096; + break; case KEYGEN_LMS: size = KEYSTORE_PUBKEY_SIZE_LMS; break; @@ -541,7 +562,8 @@ void keystore_add(uint32_t ktype, uint8_t *key, uint32_t sz, const char *keyfile } -static void keygen_rsa(const char *keyfile, int kbits, uint32_t id_mask) +static void keygen_rsa(const char *keyfile, int kbits, uint32_t id_mask, + int ktype) { RsaKey k; uint8_t priv_der[4096], pub_der[2048]; @@ -583,12 +605,7 @@ static void keygen_rsa(const char *keyfile, int kbits, uint32_t id_mask) } } - if (kbits == 2048) - keystore_add(KEYGEN_RSA2048, pub_der, publen, keyfile, id_mask); - else if (kbits == 3072) - keystore_add(KEYGEN_RSA3072, pub_der, publen, keyfile, id_mask); - else if (kbits == 4096) - keystore_add(KEYGEN_RSA4096, pub_der, publen, keyfile, id_mask); + keystore_add(ktype, pub_der, publen, keyfile, id_mask); } #define MAX_ECC_KEY_SIZE 66 @@ -1210,13 +1227,22 @@ static void key_generate(uint32_t ktype, const char *kfilename, uint32_t id_mask #ifndef NO_RSA case KEYGEN_RSA2048: - keygen_rsa(kfilename, 2048, id_mask); + keygen_rsa(kfilename, 2048, id_mask, KEYGEN_RSA2048); break; case KEYGEN_RSA3072: - keygen_rsa(kfilename, 3072, id_mask); + keygen_rsa(kfilename, 3072, id_mask, KEYGEN_RSA3072); break; case KEYGEN_RSA4096: - keygen_rsa(kfilename, 4096, id_mask); + keygen_rsa(kfilename, 4096, id_mask, KEYGEN_RSA4096); + break; + case KEYGEN_RSAPSS2048: + keygen_rsa(kfilename, 2048, id_mask, KEYGEN_RSAPSS2048); + break; + case KEYGEN_RSAPSS3072: + keygen_rsa(kfilename, 3072, id_mask, KEYGEN_RSAPSS3072); + break; + case KEYGEN_RSAPSS4096: + keygen_rsa(kfilename, 4096, id_mask, KEYGEN_RSAPSS4096); break; #endif @@ -1391,6 +1417,15 @@ int main(int argc, char** argv) else if (strcmp(argv[i], "--rsa4096") == 0) { keytype = KEYGEN_RSA4096; } + else if (strcmp(argv[i], "--rsapss2048") == 0) { + keytype = KEYGEN_RSAPSS2048; + } + else if (strcmp(argv[i], "--rsapss3072") == 0) { + keytype = KEYGEN_RSAPSS3072; + } + else if (strcmp(argv[i], "--rsapss4096") == 0) { + keytype = KEYGEN_RSAPSS4096; + } #if defined(WOLFSSL_HAVE_LMS) else if (strcmp(argv[i], "--lms") == 0) { keytype = KEYGEN_LMS; diff --git a/tools/keytools/sign.c b/tools/keytools/sign.c index 5109c9d9a2..28039838b5 100644 --- a/tools/keytools/sign.c +++ b/tools/keytools/sign.c @@ -193,6 +193,9 @@ static inline int fp_truncate(FILE *f, size_t len) #define SIGN_RSA2048 HDR_IMG_TYPE_AUTH_RSA2048 #define SIGN_RSA3072 HDR_IMG_TYPE_AUTH_RSA3072 #define SIGN_RSA4096 HDR_IMG_TYPE_AUTH_RSA4096 +#define SIGN_RSAPSS2048 HDR_IMG_TYPE_AUTH_RSAPSS2048 +#define SIGN_RSAPSS3072 HDR_IMG_TYPE_AUTH_RSAPSS3072 +#define SIGN_RSAPSS4096 HDR_IMG_TYPE_AUTH_RSAPSS4096 #define SIGN_ED448 HDR_IMG_TYPE_AUTH_ED448 #define SIGN_ECC384 HDR_IMG_TYPE_AUTH_ECC384 #define SIGN_ECC521 HDR_IMG_TYPE_AUTH_ECC521 @@ -756,6 +759,25 @@ static uint8_t *load_key(uint8_t **key_buffer, uint32_t *key_buffer_sz, if (ret == 0) break; + FALL_THROUGH; /* we didn't solve the key, keep trying */ + case SIGN_RSAPSS2048: + ret = load_key_rsa(SIGN_RSAPSS2048, 256, KEYSTORE_PUBKEY_SIZE_RSA2048, 512, + key_buffer, key_buffer_sz, pubkey, pubkey_sz, secondary); + if (ret == 0) + break; + FALL_THROUGH; + case SIGN_RSAPSS3072: + ret = load_key_rsa(SIGN_RSAPSS3072, 384, KEYSTORE_PUBKEY_SIZE_RSA3072, 512, + key_buffer, key_buffer_sz, pubkey, pubkey_sz, secondary); + if (ret == 0) + break; + FALL_THROUGH; + case SIGN_RSAPSS4096: + ret = load_key_rsa(SIGN_RSAPSS4096, 512, KEYSTORE_PUBKEY_SIZE_RSA4096, 1024, + key_buffer, key_buffer_sz, pubkey, pubkey_sz, secondary); + if (ret == 0) + break; + FALL_THROUGH; /* we didn't solve the key, keep trying */ case SIGN_LMS: ret = -1; @@ -1029,6 +1051,30 @@ static int sign_digest(int sign, int hash_algo, } } else + if (sign == SIGN_RSAPSS2048 || + sign == SIGN_RSAPSS3072 || + sign == SIGN_RSAPSS4096) + { + enum wc_HashType hash_type; + int mgf; + if (hash_algo == HASH_SHA256) { + hash_type = WC_HASH_TYPE_SHA256; + mgf = WC_MGF1SHA256; + } else if (hash_algo == HASH_SHA384) { + hash_type = WC_HASH_TYPE_SHA384; + mgf = WC_MGF1SHA384; + } else { + fprintf(stderr, "RSA-PSS requires SHA-256 or SHA-384\n"); + return -1; + } + ret = wc_RsaPSS_Sign(digest, digest_sz, signature, *signature_sz, + hash_type, mgf, &key.rsa, &rng); + if (ret > 0) { + *signature_sz = ret; + ret = 0; + } + } + else if (sign == SIGN_LMS) { const char *key_file = CMD.key_file; if (secondary) { @@ -2342,6 +2388,23 @@ static void set_signature_sizes(int secondary) CMD.header_sz = 1024; *sz = 512; } + else if (*sign == SIGN_RSAPSS2048) { + if (CMD.header_sz < 512) + CMD.header_sz = 512; + *sz = 256; + } + else if (*sign == SIGN_RSAPSS3072) { + if ((CMD.header_sz < 1024) && (CMD.hash_algo != HASH_SHA256)) + CMD.header_sz = 1024; + if (CMD.header_sz < 512) + CMD.header_sz = 512; + *sz = 384; + } + else if (*sign == SIGN_RSAPSS4096) { + if (CMD.header_sz < 1024) + CMD.header_sz = 1024; + *sz = 512; + } else if (*sign == SIGN_LMS) { int lms_ret = 0; word32 sig_sz = 0; @@ -2635,6 +2698,36 @@ int main(int argc, char** argv) sign_str = "RSA4096"; } } + else if (strcmp(argv[i], "--rsapss2048") == 0) { + if (CMD.sign != SIGN_AUTO) { + CMD.hybrid = 1; + CMD.secondary_sign = SIGN_RSAPSS2048; + secondary_sign_str = "RSAPSS2048"; + } else { + CMD.sign = SIGN_RSAPSS2048; + sign_str = "RSAPSS2048"; + } + } + else if (strcmp(argv[i], "--rsapss3072") == 0) { + if (CMD.sign != SIGN_AUTO) { + CMD.hybrid = 1; + CMD.secondary_sign = SIGN_RSAPSS3072; + secondary_sign_str = "RSAPSS3072"; + } else { + CMD.sign = SIGN_RSAPSS3072; + sign_str = "RSAPSS3072"; + } + } + else if (strcmp(argv[i], "--rsapss4096") == 0) { + if (CMD.sign != SIGN_AUTO) { + CMD.hybrid = 1; + CMD.secondary_sign = SIGN_RSAPSS4096; + secondary_sign_str = "RSAPSS4096"; + } else { + CMD.sign = SIGN_RSAPSS4096; + sign_str = "RSAPSS4096"; + } + } else if (strcmp(argv[i], "--lms") == 0) { if (CMD.sign != SIGN_AUTO) { CMD.hybrid = 1; @@ -3043,7 +3136,10 @@ int main(int argc, char** argv) } else if (CMD.sign == SIGN_RSA2048 || CMD.sign == SIGN_RSA3072 || - CMD.sign == SIGN_RSA4096) { + CMD.sign == SIGN_RSA4096 || + CMD.sign == SIGN_RSAPSS2048 || + CMD.sign == SIGN_RSAPSS3072 || + CMD.sign == SIGN_RSAPSS4096) { wc_FreeRsaKey(&key.rsa); } else if (CMD.sign == SIGN_LMS) { diff --git a/tools/keytools/user_settings.h b/tools/keytools/user_settings.h index 7c888d115c..cb7d8a3d8d 100644 --- a/tools/keytools/user_settings.h +++ b/tools/keytools/user_settings.h @@ -68,6 +68,7 @@ /* RSA */ #define HAVE_RSA #define WC_RSA_BLINDING +#define WC_RSA_PSS #define WOLFSSL_KEY_GEN /* Hashing */ From e306cc0ef1c7f23e7ff8789e7699dcf0e78b72e3 Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Wed, 18 Mar 2026 13:57:07 -0600 Subject: [PATCH 02/11] expand tests, add additional macro protection, fix keygen type bug --- .github/workflows/test-sunnyday-simulator.yml | 240 ++++++++++++++++++ config/examples/sim-rsapss2048.config | 21 ++ options.mk | 12 + src/image.c | 16 +- tools/keytools/keygen.c | 11 +- 5 files changed, 297 insertions(+), 3 deletions(-) create mode 100644 config/examples/sim-rsapss2048.config diff --git a/.github/workflows/test-sunnyday-simulator.yml b/.github/workflows/test-sunnyday-simulator.yml index f8b3dd4b73..ebef5bbec3 100644 --- a/.github/workflows/test-sunnyday-simulator.yml +++ b/.github/workflows/test-sunnyday-simulator.yml @@ -171,6 +171,66 @@ jobs: run: | tools/scripts/sim-sunnyday-update.sh + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS2048) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS2048, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 WOLFBOOT_SMALL_STACK=1 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS3072) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS3072, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 WOLFBOOT_SMALL_STACK=1 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS4096) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS4096, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 WOLFBOOT_SMALL_STACK=1 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + # 32 Bit simulator, FASTMATH # - name: make clean @@ -301,6 +361,66 @@ jobs: run: | tools/scripts/sim-sunnyday-update.sh + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS2048, FASTMATH) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS2048, FASTMATH, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 WOLFBOOT_SMALL_STACK=1 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS3072, FASTMATH) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS3072, FASTMATH, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 WOLFBOOT_SMALL_STACK=1 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS4096, FASTMATH) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 SPMATH=0 WOLFBOOT_HUGE_STACK=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS4096, FASTMATH, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 WOLFBOOT_SMALL_STACK=1 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + # 64 Bit simulator, SP_MATH # @@ -432,6 +552,66 @@ jobs: run: | tools/scripts/sim-sunnyday-update.sh + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS2048) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS2048, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 WOLFBOOT_SMALL_STACK=1 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS3072) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS3072, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 WOLFBOOT_SMALL_STACK=1 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS4096) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS4096, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 WOLFBOOT_SMALL_STACK=1 SPMATH=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + # 64 Bit simulator, FASTMATH # - name: make clean @@ -562,6 +742,66 @@ jobs: run: | tools/scripts/sim-sunnyday-update.sh + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS2048, FASTMATH) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS2048, FASTMATH, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS2048 WOLFBOOT_SMALL_STACK=1 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS3072, FASTMATH) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS3072, FASTMATH, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS3072 WOLFBOOT_SMALL_STACK=1 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Cleanup to change key type + run: | + make keysclean + + - name: Build wolfboot.elf (RSAPSS4096, FASTMATH) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 SPMATH=0 WOLFBOOT_HUGE_STACK=1 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + + - name: Build wolfboot.elf (RSAPSS4096, FASTMATH, WOLFBOOT_SMALL_STACK) + run: | + make clean && make test-sim-internal-flash-with-update SIGN=RSAPSS4096 WOLFBOOT_SMALL_STACK=1 SPMATH=0 + + - name: Run sunny day update test + run: | + tools/scripts/sim-sunnyday-update.sh + - name: Run sunny day LMS update test run: | tools/scripts/sim-pq-sunnyday-update.sh config/examples/sim-lms.config diff --git a/config/examples/sim-rsapss2048.config b/config/examples/sim-rsapss2048.config new file mode 100644 index 0000000000..8effe6e57c --- /dev/null +++ b/config/examples/sim-rsapss2048.config @@ -0,0 +1,21 @@ +ARCH=sim +TARGET=sim +SIGN?=RSAPSS2048 +HASH?=SHA256 +WOLFBOOT_SMALL_STACK?=0 +SPI_FLASH=0 +DEBUG=1 + +# sizes should be multiple of system page size +WOLFBOOT_PARTITION_SIZE=0x40000 +WOLFBOOT_SECTOR_SIZE=0x1000 +WOLFBOOT_PARTITION_BOOT_ADDRESS=0x80000 +# if on external flash, it should be multiple of system page size +WOLFBOOT_PARTITION_UPDATE_ADDRESS=0x100000 +WOLFBOOT_PARTITION_SWAP_ADDRESS=0x180000 + +# required for keytools +WOLFBOOT_FIXED_PARTITIONS=1 + +# For debugging XMALLOC/XFREE +#CFLAGS_EXTRA+=-DWOLFBOOT_DEBUG_MALLOC diff --git a/options.mk b/options.mk index 3a775e9014..5120ccca3a 100644 --- a/options.mk +++ b/options.mk @@ -581,6 +581,18 @@ ifneq ($(SIGN_SECONDARY),) WOLFCRYPT_OBJS+=$(RSA_OBJS) WOLFCRYPT_OBJS+=$(MATH_OBJS) endif + ifeq ($(SIGN_SECONDARY),RSAPSS2048) + WOLFCRYPT_OBJS+=$(RSA_OBJS) + WOLFCRYPT_OBJS+=$(MATH_OBJS) + endif + ifeq ($(SIGN_SECONDARY),RSAPSS3072) + WOLFCRYPT_OBJS+=$(RSA_OBJS) + WOLFCRYPT_OBJS+=$(MATH_OBJS) + endif + ifeq ($(SIGN_SECONDARY),RSAPSS4096) + WOLFCRYPT_OBJS+=$(RSA_OBJS) + WOLFCRYPT_OBJS+=$(MATH_OBJS) + endif ifeq ($(SIGN_SECONDARY),ECC256) WOLFCRYPT_OBJS+=$(ECC_OBJS) WOLFCRYPT_OBJS+=$(MATH_OBJS) diff --git a/src/image.c b/src/image.c index 87ffaadbc0..815a25e2b5 100644 --- a/src/image.c +++ b/src/image.c @@ -617,7 +617,16 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, wc_FreeRsaKey(&rsa); /* wc_RsaPSS_VerifyCheckInline returns the PSS-verified data length on * success (>= digest size), or a negative error code on failure. - * The hash comparison is performed internally by the function. */ + * The hash comparison is performed internally by the function. + * + * Note: uses '>=' rather than '==' because PSS verify returns the digest + * size on success, unlike PKCS#1 v1.5 which returns exact decoded length. + * + * ARMORED limitation: the PKCS#1 v1.5 path uses both RSA_VERIFY_FN and + * RSA_VERIFY_HASH armored macros (two hardened gates), but PSS only uses + * RSA_VERIFY_FN because wc_RsaPSS_VerifyCheckInline performs the hash + * comparison internally. The branch below is not armored. Full armored + * hardening for PSS would require a new macro or restructuring. */ if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img) { wolfBoot_image_confirm_signature_ok(img); } @@ -2412,7 +2421,10 @@ int wolfBoot_verify_authenticity(struct wolfBoot_image *img) defined (WOLFBOOT_SIGN_SECONDARY_RSA4096) || \ defined (WOLFBOOT_SIGN_SECONDARY_RSA2048ENC) || \ defined (WOLFBOOT_SIGN_SECONDARY_RSA3072ENC) || \ - defined (WOLFBOOT_SIGN_SECONDARY_RSA4096ENC) + defined (WOLFBOOT_SIGN_SECONDARY_RSA4096ENC) || \ + defined (WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined (WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined (WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) expected_secondary_signature_size = RSA_IMAGE_SIGNATURE_SIZE; #elif defined (WOLFBOOT_SIGN_SECONDARY_ECC256) || \ defined (WOLFBOOT_SIGN_SECONDARY_ECC384) || \ diff --git a/tools/keytools/keygen.c b/tools/keytools/keygen.c index 4960352677..9d7e32a764 100644 --- a/tools/keytools/keygen.c +++ b/tools/keytools/keygen.c @@ -535,7 +535,16 @@ void keystore_add(uint32_t ktype, uint8_t *key, uint32_t sz, const char *keyfile memset(&sl, 0, sizeof(sl)); sl.slot_id = id_slot; - sl.key_type = ktype; + /* Map keygen key type to AUTH_KEY_* value for binary keystore. + * KEYGEN_RSAPSS* values (12-14) differ from AUTH_KEY_RSAPSS* (0x0A-0x0C). */ + if (ktype == KEYGEN_RSAPSS2048) + sl.key_type = AUTH_KEY_RSAPSS2048; + else if (ktype == KEYGEN_RSAPSS3072) + sl.key_type = AUTH_KEY_RSAPSS3072; + else if (ktype == KEYGEN_RSAPSS4096) + sl.key_type = AUTH_KEY_RSAPSS4096; + else + sl.key_type = ktype; sl.part_id_mask = id_mask; sl.pubkey_size = get_pubkey_size(ktype); From fc3185b017353d85153cbf57d6887fc7b441990e Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Wed, 18 Mar 2026 13:57:44 -0600 Subject: [PATCH 03/11] support rsa-pss in ARMORED mode --- include/image.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++++ src/image.c | 31 ++++++++++------------- 2 files changed, 79 insertions(+), 18 deletions(-) diff --git a/include/image.h b/include/image.h index 38ea9f056b..c2a14a79fe 100644 --- a/include/image.h +++ b/include/image.h @@ -478,6 +478,67 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("nop"); \ } +/** + * Second part of RSA-PSS verification. + * + * Call wc_RsaPSS_CheckPadding twice, then confirm via + * wolfBoot_image_confirm_signature_ok(); + */ +#define RSA_PSS_VERIFY_HASH(img, pss_data, pss_data_sz, hash_type) \ + { \ + volatile int pss_res; \ + if (!img || !pss_data) \ + asm volatile("b pnope"); \ + /* Redundant set of r0=50*/ \ + asm volatile("mov r0, #50":::"r0"); \ + asm volatile("mov r0, #50":::"r0"); \ + asm volatile("mov r0, #50":::"r0"); \ + pss_res = wc_RsaPSS_CheckPadding(img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE, \ + pss_data, pss_data_sz, hash_type); \ + /* Redundant checks that ensure the function actually returned 0 */ \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope":::"cc"); \ + asm volatile("cmp r0, #0"); \ + asm volatile("cmp r0, #0"); \ + asm volatile("cmp r0, #0"); \ + asm volatile("bne pnope":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope"); \ + /* Repeat wc_RsaPSS_CheckPadding call */ \ + pss_res = wc_RsaPSS_CheckPadding(img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE, \ + pss_data, pss_data_sz, hash_type); \ + pss_res; \ + /* Redundant checks that ensure the function actually returned 0 */ \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("cmp r0, #0":::"cc"); \ + asm volatile("bne pnope"); \ + /* Confirm that the signature is OK */ \ + wolfBoot_image_confirm_signature_ok(img); \ + asm volatile("pnope:"); \ + asm volatile("nop"); \ + } + /** * ECC / Ed / PQ signature verification. * Those verify functions set an additional value 'p_res' @@ -1247,6 +1308,11 @@ static void UNUSEDFUNCTION wolfBoot_image_clear_signature_ok( if (XMEMCMP(img->sha_hash, digest, WOLFBOOT_SHA_DIGEST_SIZE) == 0) \ wolfBoot_image_confirm_signature_ok(img); +#define RSA_PSS_VERIFY_HASH(img, pss_data, pss_data_sz, hash_type) \ + if (wc_RsaPSS_CheckPadding(img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE, \ + pss_data, pss_data_sz, hash_type) == 0) \ + wolfBoot_image_confirm_signature_ok(img); + #define PART_SANITY_CHECK(p) \ if (((p)->hdr_ok != 1) || ((p)->sha_ok != 1) || ((p)->signature_ok != 1)) \ wolfBoot_panic() diff --git a/src/image.c b/src/image.c index 815a25e2b5..a8f689faf3 100644 --- a/src/image.c +++ b/src/image.c @@ -601,7 +601,15 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, return; } - /* wolfCrypt software RSA-PSS verify */ + /* wolfCrypt software RSA-PSS verify (two-step) + * + * Step 1 (RSA_VERIFY_FN): wc_RsaPSS_VerifyInline performs the RSA + * operation and PSS unmasking, returning a pointer to the PSS data and + * its length. + * + * Step 2 (RSA_PSS_VERIFY_HASH): wc_RsaPSS_CheckPadding verifies the PSS + * padding against img->sha_hash. Returns 0 on success. Both steps are + * armored when WOLFBOOT_ARMORED is enabled. */ ret = wc_InitRsaKey(&rsa, NULL); if (ret == 0) { /* Import public key */ @@ -609,26 +617,13 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, if (ret >= 0) { XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); RSA_VERIFY_FN(ret, - wc_RsaPSS_VerifyCheckInline, output, RSA_IMAGE_SIGNATURE_SIZE, - &digest_out, img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE, - hash_type, mgf, &rsa); + wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, + &digest_out, hash_type, mgf, &rsa); } } wc_FreeRsaKey(&rsa); - /* wc_RsaPSS_VerifyCheckInline returns the PSS-verified data length on - * success (>= digest size), or a negative error code on failure. - * The hash comparison is performed internally by the function. - * - * Note: uses '>=' rather than '==' because PSS verify returns the digest - * size on success, unlike PKCS#1 v1.5 which returns exact decoded length. - * - * ARMORED limitation: the PKCS#1 v1.5 path uses both RSA_VERIFY_FN and - * RSA_VERIFY_HASH armored macros (two hardened gates), but PSS only uses - * RSA_VERIFY_FN because wc_RsaPSS_VerifyCheckInline performs the hash - * comparison internally. The branch below is not armored. Full armored - * hardening for PSS would require a new macro or restructuring. */ - if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img) { - wolfBoot_image_confirm_signature_ok(img); + if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { + RSA_PSS_VERIFY_HASH(img, digest_out, ret, hash_type); } } From f5b76a890864ac92188ec8e4914b00e093cfb30b Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Mon, 23 Mar 2026 12:49:26 -0600 Subject: [PATCH 04/11] add wolfHSM support --- src/image.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 81 insertions(+), 1 deletion(-) diff --git a/src/image.c b/src/image.c index a8f689faf3..eebc68333d 100644 --- a/src/image.c +++ b/src/image.c @@ -584,6 +584,8 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, word32 inOutIdx = 0; struct RsaKey rsa; + (void)inOutIdx; + #if defined(WOLFBOOT_HASH_SHA256) enum wc_HashType hash_type = WC_HASH_TYPE_SHA256; int mgf = WC_MGF1SHA256; @@ -594,14 +596,19 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, #error "RSA-PSS requires SHA-256 or SHA-384" #endif +#if (!defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ + !defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER)) || \ + (defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ + !defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID)) uint8_t *pubkey = keystore_get_buffer(key_slot); int pubkey_sz = keystore_get_size(key_slot); if (pubkey == NULL || pubkey_sz < 0) { return; } +#endif - /* wolfCrypt software RSA-PSS verify (two-step) + /* RSA-PSS verify (two-step) * * Step 1 (RSA_VERIFY_FN): wc_RsaPSS_VerifyInline performs the RSA * operation and PSS unmasking, returning a pointer to the PSS data and @@ -610,6 +617,78 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, * Step 2 (RSA_PSS_VERIFY_HASH): wc_RsaPSS_CheckPadding verifies the PSS * padding against img->sha_hash. Returns 0 on success. Both steps are * armored when WOLFBOOT_ARMORED is enabled. */ +#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) || \ + defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) + ret = wc_InitRsaKey_ex(&rsa, NULL, hsmDevIdPubKey); + if (ret != 0) { + return; + } +#if defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID) || \ + (defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) && \ + defined(WOLFBOOT_CERT_CHAIN_VERIFY)) + (void)key_slot; + /* public key is stored on server at hsmKeyIdPubKey*/ +#if defined(WOLFBOOT_CERT_CHAIN_VERIFY) + /* If using certificate chain verification and we have a verified leaf key + * ID */ + if (g_leafKeyIdValid) { + /* Use the leaf key ID from certificate verification */ +#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) + ret = wh_Client_RsaSetKeyId(&rsa, g_certLeafKeyId); +#elif defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) + ret = wh_Server_CacheExportRsaKey(&hsmServerCtx, g_certLeafKeyId, &rsa); +#endif + wolfBoot_printf( + "Using leaf cert public key (ID: %08x) for RSA-PSS verification\n", + (unsigned int)g_certLeafKeyId); + } + else { +#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) + /* Default behavior: use the pre-configured public key ID */ + ret = wh_Client_RsaSetKeyId(&rsa, hsmKeyIdPubKey); +#endif + } +#else + ret = wh_Client_RsaSetKeyId(&rsa, hsmKeyIdPubKey); +#endif + if (ret != 0) { + return; + } +#else + whKeyId hsmKeyId = WH_KEYID_ERASED; + /* Cache the public key on the server */ + ret = wh_Client_KeyCache(&hsmClientCtx, WH_NVM_FLAGS_USAGE_VERIFY, NULL, 0, + pubkey, pubkey_sz, &hsmKeyId); + if (ret != WH_ERROR_OK) { + return; + } + /* Associate this RSA struct with the keyId of the cached key */ + ret = wh_Client_RsaSetKeyId(&rsa, hsmKeyId); + if (ret != WH_ERROR_OK) { + return; + } +#endif /* !WOLFBOOT_USE_WOLFHSM_PUBKEY_ID */ + XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); + RSA_VERIFY_FN(ret, wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, + &digest_out, hash_type, mgf, &rsa); +#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ + !defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID) + /* evict the key after use, since we aren't using the RSA import API */ + if (WH_ERROR_OK != wh_Client_KeyEvict(&hsmClientCtx, hsmKeyId)) { + return; + } +#elif defined(WOLFBOOT_CERT_CHAIN_VERIFY) + if (g_leafKeyIdValid) { +#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) + (void)wh_Client_KeyEvict(&hsmClientCtx, g_certLeafKeyId); +#elif defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) + (void)wh_Server_KeystoreEvictKey(&hsmServerCtx, g_certLeafKeyId); +#endif + g_leafKeyIdValid = 0; + } +#endif /* !WOLFBOOT_USE_WOLFHSM_PUBKEY_ID */ +#else + /* wolfCrypt software RSA-PSS verify */ ret = wc_InitRsaKey(&rsa, NULL); if (ret == 0) { /* Import public key */ @@ -621,6 +700,7 @@ static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, &digest_out, hash_type, mgf, &rsa); } } +#endif /* WOLFBOOT_ENABLE_WOLFHSM */ wc_FreeRsaKey(&rsa); if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { RSA_PSS_VERIFY_HASH(img, digest_out, ret, hash_type); From 166f7cc03742eb75dcb989ff2831d39d2f277210 Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Thu, 26 Mar 2026 13:25:03 -0600 Subject: [PATCH 05/11] unify rsa and rsa-pss into single verify method --- include/image.h | 6 ++ include/loader.h | 11 +++ src/image.c | 215 +++++++++++++---------------------------------- 3 files changed, 76 insertions(+), 156 deletions(-) diff --git a/include/image.h b/include/image.h index c2a14a79fe..3faff9535a 100644 --- a/include/image.h +++ b/include/image.h @@ -122,6 +122,12 @@ extern "C" { #define wolfBoot_verify_signature_secondary wolfBoot_verify_signature_ml_dsa #endif +/* Thin wrappers: dispatch RSA / RSA-PSS to the unified verify function */ +#define wolfBoot_verify_signature_rsa(ks, img, sig) \ + wolfBoot_verify_signature_rsa_common(ks, img, sig, 0) +#define wolfBoot_verify_signature_rsa_pss(ks, img, sig) \ + wolfBoot_verify_signature_rsa_common(ks, img, sig, 1) + #if defined(WOLFBOOT_TPM) && defined (WOLFBOOT_TPM_VERIFY) #undef wolfBoot_verify_signature_primary #define wolfBoot_verify_signature_primary wolfBoot_verify_signature_tpm diff --git a/include/loader.h b/include/loader.h index 2e9f5a3e24..a3bcd5fe2d 100644 --- a/include/loader.h +++ b/include/loader.h @@ -40,6 +40,17 @@ extern "C" { #define ECC_IMAGE_SIGNATURE_SIZE (132) #endif +/* Consolidated RSA-PSS flag: set when any RSA-PSS variant is enabled + * (primary or secondary). Used to guard PSS-specific code paths in the + * unified RSA verify function. */ +#if defined(WOLFBOOT_SIGN_RSAPSS2048) || defined(WOLFBOOT_SIGN_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS4096) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ + defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) +#define WOLFBOOT_RSA_PSS +#endif + #if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) || \ defined(WOLFBOOT_SIGN_RSAPSS2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) #define RSA_IMAGE_SIGNATURE_SIZE (256) diff --git a/src/image.c b/src/image.c index eebc68333d..43572725ad 100644 --- a/src/image.c +++ b/src/image.c @@ -430,8 +430,8 @@ static int RsaDecodeSignature(uint8_t** pInput, int inputSz) } #endif /* !NO_RSA_SIG_ENCODING */ -static void wolfBoot_verify_signature_rsa(uint8_t key_slot, - struct wolfBoot_image *img, uint8_t *sig) +static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, + struct wolfBoot_image *img, uint8_t *sig, int is_pss) { int ret; uint8_t output[RSA_IMAGE_SIGNATURE_SIZE]; @@ -440,6 +440,21 @@ static void wolfBoot_verify_signature_rsa(uint8_t key_slot, struct RsaKey rsa; (void)inOutIdx; + (void)is_pss; + +#ifdef WOLFBOOT_RSA_PSS + enum wc_HashType hash_type; + int mgf; +#if defined(WOLFBOOT_HASH_SHA256) + hash_type = WC_HASH_TYPE_SHA256; + mgf = WC_MGF1SHA256; +#elif defined(WOLFBOOT_HASH_SHA384) + hash_type = WC_HASH_TYPE_SHA384; + mgf = WC_MGF1SHA384; +#else + #error "RSA-PSS requires SHA-256 or SHA-384" +#endif +#endif /* WOLFBOOT_RSA_PSS */ #if (!defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ !defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER)) || \ @@ -456,6 +471,7 @@ static void wolfBoot_verify_signature_rsa(uint8_t key_slot, #if defined(WOLFBOOT_RENESAS_SCEPROTECT) || \ defined(WOLFBOOT_RENESAS_TSIP) || \ defined(WOLFBOOT_RENESAS_RSIP) + /* Renesas crypto callback — RSA PKCS#1 v1.5 only */ ret = wc_InitRsaKey_ex(&rsa, NULL, RENESAS_DEVID); if (ret == 0) { XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); @@ -519,8 +535,17 @@ static void wolfBoot_verify_signature_rsa(uint8_t key_slot, } #endif /* !WOLFBOOT_USE_WOLFHSM_PUBKEY_ID */ XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); - RSA_VERIFY_FN(ret, wc_RsaSSL_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, - &digest_out, &rsa); +#ifdef WOLFBOOT_RSA_PSS + if (is_pss) { + RSA_VERIFY_FN(ret, wc_RsaPSS_VerifyInline, output, + RSA_IMAGE_SIGNATURE_SIZE, &digest_out, hash_type, mgf, + &rsa); + } else +#endif + { + RSA_VERIFY_FN(ret, wc_RsaSSL_VerifyInline, output, + RSA_IMAGE_SIGNATURE_SIZE, &digest_out, &rsa); + } #if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ !defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID) /* evict the key after use, since we aren't using the RSA import API */ @@ -545,170 +570,48 @@ static void wolfBoot_verify_signature_rsa(uint8_t key_slot, ret = wc_RsaPublicKeyDecode((byte*)pubkey, &inOutIdx, &rsa, pubkey_sz); if (ret >= 0) { XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); - RSA_VERIFY_FN(ret, - wc_RsaSSL_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, - &digest_out, &rsa); +#ifdef WOLFBOOT_RSA_PSS + if (is_pss) { + RSA_VERIFY_FN(ret, + wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, + &digest_out, hash_type, mgf, &rsa); + } else +#endif + { + RSA_VERIFY_FN(ret, + wc_RsaSSL_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, + &digest_out, &rsa); + } } } #endif /* SCE || TSIP */ wc_FreeRsaKey(&rsa); +#ifdef WOLFBOOT_RSA_PSS + if (is_pss) { + if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { + RSA_PSS_VERIFY_HASH(img, digest_out, ret, hash_type); + } + } else +#endif + { #ifndef NO_RSA_SIG_ENCODING - if (ret > WOLFBOOT_SHA_DIGEST_SIZE) { - /* larger result indicates it might have an ASN.1 encoded header */ - ret = RsaDecodeSignature(&digest_out, ret); - } + if (ret > WOLFBOOT_SHA_DIGEST_SIZE) { + /* larger result indicates it might have an ASN.1 encoded header */ + ret = RsaDecodeSignature(&digest_out, ret); + } #endif - if (ret == WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { - RSA_VERIFY_HASH(img, digest_out); + if (ret == WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { + RSA_VERIFY_HASH(img, digest_out); + } } } #endif /* WOLFBOOT_SIGN_RSA2048 || WOLFBOOT_SIGN_RSA3072 || \ * WOLFBOOT_SIGN_RSA4096 || WOLFBOOT_SIGN_SECONDARY_RSA2048 || - * WOLFBOOT_SIGN_SECONDARY_RSA3072 || WOLFBOOT_SIGN_SECONDARY_RSA4096 */ - -#if defined(WOLFBOOT_SIGN_RSAPSS2048) || \ - defined(WOLFBOOT_SIGN_RSAPSS3072) || \ - defined(WOLFBOOT_SIGN_RSAPSS4096) || \ - defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ - defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ - defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) - -static void wolfBoot_verify_signature_rsa_pss(uint8_t key_slot, - struct wolfBoot_image *img, uint8_t *sig) -{ - int ret; - uint8_t output[RSA_IMAGE_SIGNATURE_SIZE]; - uint8_t* digest_out = NULL; - word32 inOutIdx = 0; - struct RsaKey rsa; - - (void)inOutIdx; - -#if defined(WOLFBOOT_HASH_SHA256) - enum wc_HashType hash_type = WC_HASH_TYPE_SHA256; - int mgf = WC_MGF1SHA256; -#elif defined(WOLFBOOT_HASH_SHA384) - enum wc_HashType hash_type = WC_HASH_TYPE_SHA384; - int mgf = WC_MGF1SHA384; -#else - #error "RSA-PSS requires SHA-256 or SHA-384" -#endif - -#if (!defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ - !defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER)) || \ - (defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ - !defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID)) - uint8_t *pubkey = keystore_get_buffer(key_slot); - int pubkey_sz = keystore_get_size(key_slot); - - if (pubkey == NULL || pubkey_sz < 0) { - return; - } -#endif - - /* RSA-PSS verify (two-step) - * - * Step 1 (RSA_VERIFY_FN): wc_RsaPSS_VerifyInline performs the RSA - * operation and PSS unmasking, returning a pointer to the PSS data and - * its length. - * - * Step 2 (RSA_PSS_VERIFY_HASH): wc_RsaPSS_CheckPadding verifies the PSS - * padding against img->sha_hash. Returns 0 on success. Both steps are - * armored when WOLFBOOT_ARMORED is enabled. */ -#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) || \ - defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) - ret = wc_InitRsaKey_ex(&rsa, NULL, hsmDevIdPubKey); - if (ret != 0) { - return; - } -#if defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID) || \ - (defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) && \ - defined(WOLFBOOT_CERT_CHAIN_VERIFY)) - (void)key_slot; - /* public key is stored on server at hsmKeyIdPubKey*/ -#if defined(WOLFBOOT_CERT_CHAIN_VERIFY) - /* If using certificate chain verification and we have a verified leaf key - * ID */ - if (g_leafKeyIdValid) { - /* Use the leaf key ID from certificate verification */ -#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) - ret = wh_Client_RsaSetKeyId(&rsa, g_certLeafKeyId); -#elif defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) - ret = wh_Server_CacheExportRsaKey(&hsmServerCtx, g_certLeafKeyId, &rsa); -#endif - wolfBoot_printf( - "Using leaf cert public key (ID: %08x) for RSA-PSS verification\n", - (unsigned int)g_certLeafKeyId); - } - else { -#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) - /* Default behavior: use the pre-configured public key ID */ - ret = wh_Client_RsaSetKeyId(&rsa, hsmKeyIdPubKey); -#endif - } -#else - ret = wh_Client_RsaSetKeyId(&rsa, hsmKeyIdPubKey); -#endif - if (ret != 0) { - return; - } -#else - whKeyId hsmKeyId = WH_KEYID_ERASED; - /* Cache the public key on the server */ - ret = wh_Client_KeyCache(&hsmClientCtx, WH_NVM_FLAGS_USAGE_VERIFY, NULL, 0, - pubkey, pubkey_sz, &hsmKeyId); - if (ret != WH_ERROR_OK) { - return; - } - /* Associate this RSA struct with the keyId of the cached key */ - ret = wh_Client_RsaSetKeyId(&rsa, hsmKeyId); - if (ret != WH_ERROR_OK) { - return; - } -#endif /* !WOLFBOOT_USE_WOLFHSM_PUBKEY_ID */ - XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); - RSA_VERIFY_FN(ret, wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, - &digest_out, hash_type, mgf, &rsa); -#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ - !defined(WOLFBOOT_USE_WOLFHSM_PUBKEY_ID) - /* evict the key after use, since we aren't using the RSA import API */ - if (WH_ERROR_OK != wh_Client_KeyEvict(&hsmClientCtx, hsmKeyId)) { - return; - } -#elif defined(WOLFBOOT_CERT_CHAIN_VERIFY) - if (g_leafKeyIdValid) { -#if defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) - (void)wh_Client_KeyEvict(&hsmClientCtx, g_certLeafKeyId); -#elif defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER) - (void)wh_Server_KeystoreEvictKey(&hsmServerCtx, g_certLeafKeyId); -#endif - g_leafKeyIdValid = 0; - } -#endif /* !WOLFBOOT_USE_WOLFHSM_PUBKEY_ID */ -#else - /* wolfCrypt software RSA-PSS verify */ - ret = wc_InitRsaKey(&rsa, NULL); - if (ret == 0) { - /* Import public key */ - ret = wc_RsaPublicKeyDecode((byte*)pubkey, &inOutIdx, &rsa, pubkey_sz); - if (ret >= 0) { - XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); - RSA_VERIFY_FN(ret, - wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, - &digest_out, hash_type, mgf, &rsa); - } - } -#endif /* WOLFBOOT_ENABLE_WOLFHSM */ - wc_FreeRsaKey(&rsa); - if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { - RSA_PSS_VERIFY_HASH(img, digest_out, ret, hash_type); - } -} - -#endif /* WOLFBOOT_SIGN_RSAPSS2048 || WOLFBOOT_SIGN_RSAPSS3072 || \ - * WOLFBOOT_SIGN_RSAPSS4096 || WOLFBOOT_SIGN_SECONDARY_RSAPSS2048 || \ + * WOLFBOOT_SIGN_SECONDARY_RSA3072 || WOLFBOOT_SIGN_SECONDARY_RSA4096 || + * WOLFBOOT_SIGN_RSAPSS2048 || WOLFBOOT_SIGN_RSAPSS3072 || + * WOLFBOOT_SIGN_RSAPSS4096 || WOLFBOOT_SIGN_SECONDARY_RSAPSS2048 || * WOLFBOOT_SIGN_SECONDARY_RSAPSS3072 || WOLFBOOT_SIGN_SECONDARY_RSAPSS4096 */ #ifdef WOLFBOOT_SIGN_LMS From 757c7dd6e9954e78fef5efe2445f468965c2c796 Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Thu, 26 Mar 2026 13:25:29 -0600 Subject: [PATCH 06/11] prevent duplicate asm labels in ARMORED mode --- include/image.h | 84 +++++++++++++++++++++++++++---------------------- 1 file changed, 46 insertions(+), 38 deletions(-) diff --git a/include/image.h b/include/image.h index 3faff9535a..81a6103686 100644 --- a/include/image.h +++ b/include/image.h @@ -388,6 +388,8 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( * double checking its return value contains a valid * len (>= WOLFBOOT_SHA_DIGEST_SIZE). * + * Uses GAS local numeric labels (1f/1:) so the macro can be safely expanded + * multiple times in the same function (e.g. RSA PKCS#1.5 + RSA-PSS paths). */ #define RSA_VERIFY_FN(ret,fn,...) \ { \ @@ -406,22 +408,22 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ - asm volatile("blt nope"); \ + asm volatile("blt 1f"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ - asm volatile("blt nope"); \ + asm volatile("blt 1f"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ - asm volatile("blt nope"); \ + asm volatile("blt 1f"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ asm volatile("cmp r0, r2":::"cc"); \ - asm volatile("blt nope"); \ + asm volatile("blt 1f"); \ /* Return value is set here in case of success */ \ ret = tmp_ret; \ - asm volatile("nope:"); \ + asm volatile("1:"); \ asm volatile("nop"); \ } @@ -430,12 +432,14 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( * * Compare the digest twice, then confirm via * wolfBoot_image_confirm_signature_ok(); + * + * Uses GAS local numeric labels (2f/2:) for safe multi-expansion. */ #define RSA_VERIFY_HASH(img,digest) \ { \ volatile int compare_res; \ if (!img || !digest) \ - asm volatile("b hnope"); \ + asm volatile("b 2f"); \ /* Redundant set of r0=50*/ \ asm volatile("mov r0, #50":::"r0"); \ asm volatile("mov r0, #50":::"r0"); \ @@ -445,19 +449,19 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope":::"cc"); \ + asm volatile("bne 2f":::"cc"); \ asm volatile("cmp r0, #0"); \ asm volatile("cmp r0, #0"); \ asm volatile("cmp r0, #0"); \ - asm volatile("bne hnope":::"cc"); \ + asm volatile("bne 2f":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope"); \ + asm volatile("bne 2f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope"); \ + asm volatile("bne 2f"); \ /* Repeat memcmp call */ \ compare_res = XMEMCMP(digest, img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE); \ compare_res; \ @@ -465,22 +469,22 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope"); \ + asm volatile("bne 2f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope"); \ + asm volatile("bne 2f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope"); \ + asm volatile("bne 2f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne hnope"); \ + asm volatile("bne 2f"); \ /* Confirm that the signature is OK */ \ wolfBoot_image_confirm_signature_ok(img); \ - asm volatile("hnope:"); \ + asm volatile("2:"); \ asm volatile("nop"); \ } @@ -489,12 +493,14 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( * * Call wc_RsaPSS_CheckPadding twice, then confirm via * wolfBoot_image_confirm_signature_ok(); + * + * Uses GAS local numeric labels (3f/3:) for safe multi-expansion. */ #define RSA_PSS_VERIFY_HASH(img, pss_data, pss_data_sz, hash_type) \ { \ volatile int pss_res; \ if (!img || !pss_data) \ - asm volatile("b pnope"); \ + asm volatile("b 3f"); \ /* Redundant set of r0=50*/ \ asm volatile("mov r0, #50":::"r0"); \ asm volatile("mov r0, #50":::"r0"); \ @@ -505,19 +511,19 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope":::"cc"); \ + asm volatile("bne 3f":::"cc"); \ asm volatile("cmp r0, #0"); \ asm volatile("cmp r0, #0"); \ asm volatile("cmp r0, #0"); \ - asm volatile("bne pnope":::"cc"); \ + asm volatile("bne 3f":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope"); \ + asm volatile("bne 3f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope"); \ + asm volatile("bne 3f"); \ /* Repeat wc_RsaPSS_CheckPadding call */ \ pss_res = wc_RsaPSS_CheckPadding(img->sha_hash, WOLFBOOT_SHA_DIGEST_SIZE, \ pss_data, pss_data_sz, hash_type); \ @@ -526,22 +532,22 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope"); \ + asm volatile("bne 3f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope"); \ + asm volatile("bne 3f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope"); \ + asm volatile("bne 3f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne pnope"); \ + asm volatile("bne 3f"); \ /* Confirm that the signature is OK */ \ wolfBoot_image_confirm_signature_ok(img); \ - asm volatile("pnope:"); \ + asm volatile("3:"); \ asm volatile("nop"); \ } @@ -554,6 +560,8 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( * set the return value accordingly. * * Double check by reading the value in p_res from memory a few times. + * + * Uses GAS local numeric labels (4f/4:) for safe multi-expansion. */ #if defined(__GNUC__) @@ -568,63 +576,63 @@ static void __attribute__((noinline)) wolfBoot_image_clear_signature_ok( asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ asm volatile("cmp r0, #0":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ /* Check that res = 1, a few times, reading the value from memory */ \ asm volatile("ldr r2, [%0]" ::"r"(p_res)); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("mvn r3, r2":::"r3"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("ldr r2, [%0]" ::"r"(p_res)); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("mvn r3, r2":::"r3"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("ldr r2, [%0]" ::"r"(p_res)); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("mvn r3, r2":::"r3"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("ldr r2, [%0]" ::"r"(p_res)); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ asm volatile("cmp r2, #1":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ asm volatile("mvn r3, r2":::"r3"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ asm volatile("cmp r3, #0xFFFFFFFE":::"cc"); \ - asm volatile("bne nope"); \ + asm volatile("bne 4f"); \ /* Confirm that the signature is OK */ \ wolfBoot_image_confirm_signature_ok(img); \ - asm volatile("nope:"); \ + asm volatile("4:"); \ asm volatile("nop") \ #elif defined(__ICCARM__) && defined(__IAR_SYSTEMS_ICC__) From dba2aa3383deb8fae0fa42f0a528a098013aaf5b Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Thu, 26 Mar 2026 14:03:25 -0600 Subject: [PATCH 07/11] fix xmalloc RSA PSS macro build error --- src/xmalloc.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/xmalloc.c b/src/xmalloc.c index 69962d6aec..38cbf6efde 100644 --- a/src/xmalloc.c +++ b/src/xmalloc.c @@ -335,7 +335,9 @@ static struct xmalloc_slot xmalloc_pool[] = { #elif defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_RSA4096) || \ - defined(WOLFBOOT_SIGN_RSA3072) + defined(WOLFBOOT_SIGN_RSA3072) || \ + defined(WOLFBOOT_SIGN_RSAPSS2048) || defined(WOLFBOOT_SIGN_RSAPSS4096) || \ + defined(WOLFBOOT_SIGN_RSAPSS3072) #if defined(WOLFBOOT_HASH_SHA256) || defined(WOLFBOOT_HASH_SHA384) static uint32_t sha_block[HASH_BLOCK_SIZE]; @@ -349,7 +351,7 @@ static uint32_t sha_block[HASH_BLOCK_SIZE]; static uint8_t asncheck_buf[ASNCHECK_BUF_SIZE]; #ifndef USE_FAST_MATH - #ifdef WOLFBOOT_SIGN_RSA2048 + #if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_RSAPSS2048) #define MP_SCHEME "SP RSA2048" #define MP_INT_DYNAMIC_SIZE MP_INT_SIZEOF(MP_BITS_CNT(2048)) #define MP_BIGINT_MODEXP_SIZE (MP_INT_DYNAMIC_SIZE * 4) @@ -362,7 +364,7 @@ static uint8_t asncheck_buf[ASNCHECK_BUF_SIZE]; #define MPDIGIT_BUF1_SIZE (MP_DIGIT_SIZE * (72 * 4 + 3)) static uint8_t mp_digit_buf1[MPDIGIT_BUF1_SIZE]; #endif - #elif defined WOLFBOOT_SIGN_RSA3072 + #elif defined(WOLFBOOT_SIGN_RSA3072) || defined(WOLFBOOT_SIGN_RSAPSS3072) #define MP_SCHEME "SP RSA3072" #define MP_INT_DYNAMIC_SIZE MP_INT_SIZEOF(MP_BITS_CNT(3072)) #define MP_BIGINT_MODEXP_SIZE (MP_INT_DYNAMIC_SIZE * 4) From bf42aa86b06dca53c0c34ed8eac03b7165785d20 Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Thu, 26 Mar 2026 14:24:08 -0600 Subject: [PATCH 08/11] fix lingering IMAGE_HEADER_SIZE override in options.mk that should instead check for min size --- options.mk | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/options.mk b/options.mk index 5120ccca3a..2ec47bc191 100644 --- a/options.mk +++ b/options.mk @@ -344,7 +344,9 @@ ifeq ($(SIGN),RSAPSS3072) endif endif ifneq ($(HASH),SHA256) - IMAGE_HEADER_SIZE=1024 + ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 1024; echo $$?),0) + IMAGE_HEADER_SIZE=1024 + endif endif ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 512; echo $$?),0) IMAGE_HEADER_SIZE=512 @@ -438,7 +440,9 @@ ifneq ($(findstring RSA3072,$(SIGN)),) endif endif ifneq ($(HASH),SHA256) - IMAGE_HEADER_SIZE=1024 + ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 1024; echo $$?),0) + IMAGE_HEADER_SIZE=1024 + endif endif ifeq ($(shell test $(IMAGE_HEADER_SIZE) -lt 512; echo $$?),0) IMAGE_HEADER_SIZE=512 From 13ed6977d101a8c2d0de7df8cd9c69e67d1e64a6 Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Thu, 26 Mar 2026 14:44:50 -0600 Subject: [PATCH 09/11] add keysize string for PSS debugging --- tools/keytools/keygen.c | 8 +- .../generated/test_header.h | 89 ++ .../self-header-verify/generated/test_image.h | 1369 +++++++++++++++++ .../generated/test_pubkey.h | 49 + .../test-self-header-verify | Bin 0 -> 43608 bytes 5 files changed, 1511 insertions(+), 4 deletions(-) create mode 100644 tools/self-header-verify/generated/test_header.h create mode 100644 tools/self-header-verify/generated/test_image.h create mode 100644 tools/self-header-verify/generated/test_pubkey.h create mode 100755 tools/self-header-verify/test-self-header-verify diff --git a/tools/keytools/keygen.c b/tools/keytools/keygen.c index 9d7e32a764..b9a70a93f9 100644 --- a/tools/keytools/keygen.c +++ b/tools/keytools/keygen.c @@ -317,7 +317,7 @@ const char KType[][21] = { "AUTH_KEY_RSAPSS4096" }; -const char KSize[][29] = { +const char KSize[][32] = { "KEYSTORE_PUBKEY_SIZE_NONE", "KEYSTORE_PUBKEY_SIZE_ED25519", "KEYSTORE_PUBKEY_SIZE_ECC256", @@ -330,9 +330,9 @@ const char KSize[][29] = { "KEYSTORE_PUBKEY_SIZE_LMS", "KEYSTORE_PUBKEY_SIZE_XMSS", "KEYSTORE_PUBKEY_SIZE_ML_DSA", - "KEYSTORE_PUBKEY_SIZE_RSA2048", - "KEYSTORE_PUBKEY_SIZE_RSA3072", - "KEYSTORE_PUBKEY_SIZE_RSA4096" + "KEYSTORE_PUBKEY_SIZE_RSAPSS2048", + "KEYSTORE_PUBKEY_SIZE_RSAPSS3072", + "KEYSTORE_PUBKEY_SIZE_RSAPSS4096" }; const char KName[][12] = { diff --git a/tools/self-header-verify/generated/test_header.h b/tools/self-header-verify/generated/test_header.h new file mode 100644 index 0000000000..3db0c43ced --- /dev/null +++ b/tools/self-header-verify/generated/test_header.h @@ -0,0 +1,89 @@ +unsigned char dummy_firmware_v1_header_bin[] = { + 0x57, 0x4f, 0x4c, 0x46, 0x00, 0x40, 0x00, 0x00, 0x01, 0x00, 0x04, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x08, 0x00, + 0x7f, 0xe9, 0xa9, 0x69, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, + 0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x20, 0x00, + 0x35, 0xd1, 0xa4, 0xe1, 0x01, 0x1a, 0x05, 0xc0, 0x68, 0xbc, 0x0d, 0x31, + 0xf0, 0xd2, 0x6e, 0x07, 0x4e, 0x69, 0xa3, 0x09, 0x12, 0xa3, 0x7a, 0x0d, + 0x95, 0x82, 0x86, 0x69, 0xc1, 0x27, 0x56, 0x8f, 0xff, 0xff, 0xff, 0xff, + 0x03, 0x00, 0x20, 0x00, 0xb5, 0x49, 0x1d, 0x22, 0x24, 0x9d, 0x93, 0xc1, + 0x68, 0xa8, 0xa3, 0xb5, 0x62, 0x6e, 0xdb, 0xd6, 0xb5, 0x87, 0x9b, 0x27, + 0xd7, 0x91, 0xe3, 0x13, 0x86, 0x4f, 0x52, 0xc2, 0x1d, 0x9c, 0x56, 0xe8, + 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x02, 0x8c, 0xec, 0x5a, 0x8a, + 0xb8, 0xd3, 0x61, 0xc0, 0x70, 0x02, 0xad, 0x07, 0xd3, 0x48, 0x94, 0xfb, + 0xb2, 0x2f, 0x57, 0x33, 0x64, 0x61, 0x0f, 0xfa, 0x53, 0xa0, 0x13, 0x7e, + 0x8c, 0x12, 0x85, 0x44, 0x0f, 0xe4, 0x9a, 0x1d, 0xe5, 0xab, 0xeb, 0x97, + 0xd7, 0x43, 0xdf, 0x2e, 0x15, 0xa3, 0x9c, 0x87, 0x11, 0xc7, 0x1a, 0x80, + 0xb1, 0x9e, 0xbe, 0x07, 0xce, 0x30, 0xf5, 0x3e, 0xb9, 0x19, 0x30, 0xf9, + 0xb1, 0x26, 0xa2, 0x3a, 0xf1, 0xb3, 0x6a, 0x5b, 0x1c, 0x11, 0x6b, 0x45, + 0x2f, 0xa5, 0xf9, 0x77, 0xd5, 0xb9, 0x07, 0x37, 0xe1, 0x55, 0x61, 0x48, + 0x19, 0x6d, 0x8b, 0x99, 0x65, 0x53, 0x35, 0x90, 0x5d, 0xbf, 0xb6, 0x8f, + 0x37, 0x68, 0xfc, 0x6a, 0x7e, 0x3a, 0x2c, 0x4b, 0x35, 0x7e, 0x32, 0x28, + 0x76, 0x09, 0x1e, 0xd0, 0x6d, 0x08, 0x6d, 0xfa, 0x4a, 0x16, 0x7b, 0x38, + 0x48, 0xff, 0xbe, 0x9e, 0x8c, 0x88, 0x41, 0x42, 0xe5, 0xc0, 0x43, 0x09, + 0xac, 0x4e, 0xef, 0xe1, 0xef, 0xcd, 0x0f, 0x7a, 0x50, 0xf4, 0x2f, 0x30, + 0x7d, 0x94, 0x57, 0xaa, 0x61, 0x1f, 0x30, 0x17, 0x99, 0x6d, 0x12, 0x93, + 0x2e, 0xf1, 0xe9, 0xb3, 0x31, 0x86, 0x48, 0x2f, 0x59, 0x1c, 0x43, 0xd2, + 0xaf, 0xc1, 0x15, 0xc4, 0x1a, 0x4c, 0xd2, 0xdc, 0x40, 0x65, 0x52, 0xc4, + 0x04, 0xda, 0x73, 0x44, 0x4f, 0x9e, 0xd6, 0x1d, 0x5c, 0xff, 0x4c, 0x04, + 0x73, 0x74, 0xce, 0x02, 0x24, 0x01, 0x05, 0x6b, 0xfa, 0xe1, 0x39, 0x23, + 0xff, 0xd4, 0xcc, 0x0e, 0x54, 0x1c, 0x2e, 0xec, 0x4f, 0xef, 0x35, 0xec, + 0x51, 0x83, 0x27, 0x1b, 0xfc, 0x5a, 0x13, 0xfe, 0xcf, 0xd1, 0xef, 0x1a, + 0xf5, 0x62, 0x4a, 0x6d, 0x9d, 0x45, 0x1c, 0x9d, 0xab, 0x96, 0x14, 0xa1, + 0x4d, 0xe6, 0x00, 0x4f, 0xae, 0x8d, 0x3c, 0x60, 0x9c, 0x4c, 0x33, 0x24, + 0x5d, 0x9d, 0x43, 0xf2, 0xee, 0x44, 0xb2, 0xb5, 0x00, 0x74, 0x37, 0x68, + 0xc4, 0x46, 0x54, 0xda, 0xce, 0x42, 0x15, 0x0a, 0xf1, 0xc7, 0x14, 0x4e, + 0x0a, 0x29, 0xfe, 0x19, 0x12, 0x7a, 0x8a, 0x97, 0x6a, 0x10, 0xe9, 0x4e, + 0x49, 0x70, 0xfe, 0x15, 0x9f, 0x8b, 0x68, 0x0a, 0xc3, 0xcb, 0x2d, 0x81, + 0xa3, 0x0b, 0xe6, 0xad, 0x7b, 0x1a, 0xdb, 0xb7, 0x7a, 0x2b, 0x9d, 0xf6, + 0x03, 0x36, 0xab, 0x38, 0x0b, 0x82, 0x29, 0xdb, 0xcb, 0x2f, 0xd7, 0x86, + 0x98, 0x21, 0x87, 0x4a, 0xf0, 0x35, 0xf6, 0x20, 0x4c, 0xb3, 0xae, 0x41, + 0x0c, 0x49, 0x73, 0xea, 0xf4, 0x6a, 0xa6, 0x1c, 0x95, 0x7c, 0xc9, 0xe9, + 0xef, 0xab, 0x02, 0xd0, 0xfa, 0x61, 0xbe, 0x46, 0x11, 0x52, 0xd2, 0xfa, + 0x12, 0xe9, 0xcf, 0x61, 0xac, 0x2c, 0x93, 0x9e, 0xfa, 0x8c, 0x39, 0x20, + 0xcf, 0x6e, 0x73, 0x14, 0x72, 0x6e, 0x26, 0xb6, 0x58, 0xb4, 0x83, 0xa7, + 0xe9, 0xfb, 0xd3, 0x94, 0xcf, 0xe4, 0x9c, 0x40, 0xe0, 0x5c, 0x5f, 0x98, + 0x0a, 0xdc, 0x64, 0x88, 0x8e, 0x93, 0x58, 0xca, 0x95, 0x18, 0x40, 0x17, + 0x40, 0xad, 0x34, 0x69, 0x14, 0x89, 0x7b, 0xa7, 0xb9, 0x3a, 0xec, 0x31, + 0xd0, 0x9c, 0x4d, 0x4d, 0xf3, 0xf0, 0xcc, 0x2f, 0x1e, 0x34, 0x5f, 0xde, + 0x5c, 0xeb, 0x79, 0x4b, 0x73, 0x10, 0x67, 0xe0, 0x83, 0x49, 0x21, 0x2d, + 0x70, 0x0b, 0xde, 0xa7, 0xf6, 0x95, 0xf4, 0x13, 0xfc, 0x1f, 0x84, 0xef, + 0x74, 0x69, 0x0e, 0x23, 0xf7, 0x3a, 0x25, 0x68, 0x2c, 0x22, 0x31, 0xec, + 0x4c, 0x49, 0x1d, 0xbe, 0x71, 0x0a, 0x81, 0x40, 0x7e, 0xce, 0xde, 0xe3, + 0xf3, 0x7b, 0x36, 0xd3, 0xe7, 0x1d, 0x76, 0x52, 0x7e, 0x06, 0xd7, 0x3a, + 0xa7, 0x7c, 0x81, 0x67, 0x16, 0x41, 0x08, 0x5b, 0x04, 0x99, 0xde, 0xf5, + 0xa2, 0xcb, 0x44, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff +}; +unsigned int dummy_firmware_v1_header_bin_len = 1024; diff --git a/tools/self-header-verify/generated/test_image.h b/tools/self-header-verify/generated/test_image.h new file mode 100644 index 0000000000..9ba12ef36e --- /dev/null +++ b/tools/self-header-verify/generated/test_image.h @@ -0,0 +1,1369 @@ +unsigned char dummy_firmware_bin[] = { + 0x3b, 0x2a, 0xa8, 0x77, 0x77, 0x6d, 0x45, 0x5e, 0x40, 0x4f, 0xb3, 0xa2, + 0x32, 0x74, 0x06, 0xdf, 0xb4, 0x39, 0x36, 0xb0, 0x8b, 0xde, 0xa3, 0xfe, + 0xc9, 0x0d, 0x5b, 0x5a, 0xdb, 0xf6, 0x2a, 0x4c, 0xe8, 0x19, 0xe7, 0x4c, + 0x65, 0x9a, 0xae, 0x66, 0x83, 0xef, 0xc1, 0x3d, 0x3c, 0x52, 0xa2, 0x22, + 0x57, 0x31, 0x8a, 0x7a, 0xa0, 0xf6, 0xb2, 0x24, 0x2b, 0xb1, 0x6e, 0x44, + 0x9e, 0x0d, 0x4f, 0xf1, 0xab, 0xdc, 0x50, 0x30, 0x90, 0xb9, 0x6e, 0xa6, + 0xd7, 0x7f, 0x49, 0xb9, 0x1a, 0xad, 0xfb, 0x23, 0x9e, 0xbb, 0x81, 0xfe, + 0x95, 0x16, 0x5a, 0xd1, 0xe6, 0x30, 0x28, 0xf0, 0x5d, 0x6b, 0x7a, 0x04, + 0xe6, 0xf0, 0x19, 0x92, 0x96, 0xe3, 0x85, 0x75, 0x9e, 0x18, 0x02, 0xe6, + 0x1e, 0xcb, 0x2f, 0x5e, 0x4b, 0xe6, 0x72, 0xe0, 0x29, 0x05, 0xea, 0x4d, + 0x63, 0x3c, 0x8d, 0xcf, 0x28, 0x9a, 0x83, 0xe2, 0x7d, 0xd1, 0xf3, 0xdb, + 0xea, 0x9c, 0x2d, 0x0c, 0xf8, 0x64, 0x38, 0x55, 0xee, 0xa7, 0x2d, 0x5b, + 0x9c, 0x9d, 0xdd, 0xd4, 0x42, 0x48, 0xdd, 0x27, 0x4b, 0x38, 0xfb, 0x9c, + 0xe5, 0x42, 0x08, 0x6d, 0x5a, 0x03, 0x18, 0x2f, 0x6d, 0xd1, 0x57, 0x72, + 0xc5, 0x3a, 0xde, 0x68, 0xbc, 0x73, 0x91, 0x3f, 0xfe, 0xbe, 0xf0, 0xc4, + 0x86, 0x14, 0x4a, 0xa9, 0xcb, 0x1a, 0xa9, 0x99, 0x7d, 0x15, 0x03, 0xf8, + 0x81, 0x07, 0xa4, 0x4f, 0x7b, 0x9c, 0x3c, 0xd3, 0xb2, 0xf3, 0x9f, 0x50, + 0x62, 0x62, 0x89, 0x18, 0x27, 0x14, 0xdc, 0xc3, 0x8e, 0xee, 0x65, 0xb9, + 0x8c, 0x7c, 0xde, 0xf0, 0x9a, 0x62, 0x80, 0x9d, 0x0e, 0xa4, 0x1e, 0x27, + 0x57, 0xec, 0x39, 0x2a, 0xb0, 0xed, 0x3d, 0x72, 0xe1, 0x29, 0xb8, 0x9b, + 0x58, 0x74, 0x08, 0x63, 0x9c, 0xd7, 0x5e, 0xf7, 0x8b, 0xe6, 0x54, 0x92, + 0x66, 0x15, 0xca, 0xa2, 0xc5, 0x3a, 0xa9, 0x8a, 0xd4, 0xca, 0x7d, 0x53, + 0x99, 0x6f, 0x80, 0xa7, 0xa0, 0x6f, 0xa9, 0x66, 0xcd, 0xdc, 0xa8, 0x86, + 0x22, 0x9d, 0xe6, 0xb2, 0x22, 0xcf, 0x70, 0x79, 0xfa, 0x8e, 0xbb, 0xb7, + 0x03, 0xd4, 0x80, 0x2d, 0x94, 0x14, 0x72, 0x7e, 0xa6, 0x1c, 0x79, 0x34, + 0x76, 0xda, 0x87, 0x65, 0x56, 0x84, 0x34, 0x8d, 0xc9, 0x3c, 0x21, 0x66, + 0xdf, 0x5c, 0x2a, 0xe2, 0x47, 0xcf, 0xe7, 0x46, 0x69, 0xc2, 0x02, 0x0f, + 0x1b, 0x06, 0x7f, 0x7e, 0xe7, 0x60, 0x32, 0x74, 0xc8, 0x00, 0x53, 0x72, + 0x9b, 0x07, 0x89, 0x49, 0xfd, 0xc1, 0xa5, 0x6c, 0x2e, 0x83, 0xf5, 0x79, + 0x16, 0xab, 0x6e, 0x81, 0x6b, 0x78, 0x65, 0x9a, 0x21, 0x90, 0x18, 0x45, + 0x63, 0x55, 0x77, 0x44, 0x6c, 0x73, 0x11, 0x39, 0xa5, 0x0b, 0xc3, 0x51, + 0xd9, 0x36, 0xae, 0xaa, 0x94, 0xf2, 0xef, 0xed, 0x83, 0x50, 0x03, 0x94, + 0x53, 0x21, 0xb2, 0x4e, 0x94, 0x94, 0xa4, 0x48, 0x22, 0x59, 0x16, 0xf0, + 0x77, 0xf7, 0xbf, 0x48, 0x17, 0x92, 0xde, 0xfd, 0x31, 0xae, 0xf3, 0x25, + 0x41, 0xdf, 0x5c, 0xf0, 0x01, 0xf5, 0x72, 0x95, 0xd6, 0xa6, 0x17, 0xfb, + 0x48, 0xcc, 0x40, 0x94, 0x9c, 0x0c, 0x4d, 0x01, 0x56, 0xbe, 0xb1, 0x0a, + 0xff, 0xc7, 0x22, 0xda, 0x71, 0xe6, 0xea, 0x8c, 0x07, 0x1b, 0x59, 0x3b, + 0x62, 0x85, 0xdc, 0xd2, 0xdd, 0x95, 0x61, 0x94, 0xb0, 0x7b, 0x50, 0x7a, + 0x52, 0x3f, 0x6f, 0x4d, 0xd3, 0x26, 0x38, 0x8d, 0x64, 0x8a, 0x24, 0x8b, + 0x82, 0x13, 0x13, 0x47, 0xe2, 0x31, 0xbb, 0x07, 0x4e, 0xe5, 0x15, 0xf0, + 0x15, 0x65, 0x17, 0x1e, 0x41, 0x87, 0x45, 0xb5, 0x1a, 0xf0, 0x62, 0x67, + 0x83, 0xeb, 0xb0, 0x9f, 0x71, 0xd9, 0xb7, 0xa0, 0x9d, 0xeb, 0xa3, 0x0d, + 0xbc, 0xf5, 0x22, 0xb7, 0x0c, 0x1c, 0x51, 0xc3, 0xcb, 0xf2, 0x32, 0x30, + 0x7b, 0x59, 0x5d, 0x1c, 0x16, 0xa4, 0x0e, 0x17, 0x2b, 0x5c, 0x5c, 0x2f, + 0x28, 0xd9, 0xbd, 0x4f, 0x22, 0x60, 0x83, 0x55, 0x93, 0x96, 0x28, 0xfa, + 0x1b, 0xd1, 0xc8, 0x34, 0xc3, 0x78, 0x0d, 0xee, 0x45, 0x56, 0x5d, 0x9f, + 0x06, 0x6f, 0x00, 0x32, 0x9a, 0x62, 0x52, 0xe6, 0x24, 0xad, 0x6f, 0xee, + 0x32, 0xe6, 0xda, 0x2d, 0xc3, 0xb0, 0x73, 0xfd, 0x66, 0x1a, 0xa4, 0x91, + 0xf5, 0x10, 0x17, 0x7d, 0x5e, 0x45, 0xc5, 0xec, 0x65, 0x1e, 0x56, 0xfa, + 0x42, 0xc5, 0x7b, 0x6a, 0x9d, 0x33, 0x29, 0x7d, 0xf8, 0xd8, 0x23, 0x40, + 0xcd, 0xc6, 0xaf, 0x85, 0x5b, 0xa0, 0x86, 0x16, 0xab, 0x11, 0x92, 0x69, + 0xa7, 0x53, 0xb1, 0x65, 0x7f, 0x11, 0x15, 0x6d, 0x06, 0xfb, 0x8b, 0xb8, + 0xab, 0xa9, 0x7b, 0x00, 0x32, 0xa6, 0x0d, 0x2b, 0x20, 0xd1, 0xf8, 0x27, + 0xbf, 0xf5, 0xfa, 0xc6, 0x1d, 0x72, 0x43, 0xa2, 0xd4, 0x24, 0x62, 0x1a, + 0x94, 0xa9, 0x40, 0x12, 0x07, 0xc7, 0x64, 0x24, 0x98, 0xdf, 0x20, 0x3f, + 0xf9, 0x69, 0xb2, 0xdc, 0xe9, 0xd7, 0xe8, 0xde, 0x55, 0x4f, 0xa0, 0xb9, + 0xa7, 0xc3, 0x9f, 0xd7, 0x07, 0x22, 0x31, 0x70, 0xe6, 0x81, 0x99, 0x16, + 0x1f, 0x54, 0xea, 0xc3, 0xd1, 0x20, 0xfc, 0x1d, 0xa6, 0xd4, 0x81, 0x20, + 0xc0, 0x06, 0xa1, 0x5d, 0x76, 0xd5, 0x51, 0xa3, 0xde, 0x7d, 0xe0, 0xa9, + 0xa6, 0x63, 0xa8, 0xcd, 0xf5, 0xbe, 0xd7, 0x7d, 0x38, 0xca, 0x4e, 0xa1, + 0xdb, 0xc6, 0xc4, 0xe3, 0x81, 0x0d, 0xce, 0x5e, 0x6d, 0x65, 0xba, 0x5d, + 0x75, 0xb6, 0x86, 0xae, 0xbc, 0x12, 0x10, 0xc9, 0x03, 0xc4, 0x18, 0xe1, + 0xa1, 0x1c, 0x59, 0x30, 0xc1, 0xae, 0x20, 0xb0, 0x78, 0x75, 0x09, 0x43, + 0x2f, 0xa2, 0x1b, 0xf4, 0xb5, 0xe1, 0x6d, 0x3b, 0x67, 0x8f, 0xeb, 0x8f, + 0xdd, 0xbc, 0xbc, 0x01, 0x90, 0x7b, 0x45, 0xc0, 0xc6, 0xce, 0x4f, 0x0d, + 0x79, 0x65, 0xf5, 0xd7, 0xf4, 0x54, 0x17, 0x2b, 0xfc, 0x66, 0x83, 0xa3, + 0x04, 0xc7, 0x44, 0x82, 0x85, 0xca, 0xfe, 0x85, 0x54, 0x7e, 0x83, 0xcb, + 0x89, 0xc4, 0xc2, 0x5f, 0x87, 0xb4, 0xdb, 0xa4, 0x35, 0xcc, 0xe1, 0x09, + 0x3a, 0x84, 0x29, 0x73, 0xe8, 0x05, 0xd5, 0x9d, 0xf6, 0xf8, 0x1b, 0x03, + 0x1f, 0x17, 0xb9, 0x84, 0x10, 0x5f, 0x12, 0xec, 0x88, 0x39, 0xd4, 0x3b, + 0x28, 0x83, 0x54, 0x29, 0x34, 0xe5, 0xd9, 0x4e, 0xe2, 0x73, 0xf3, 0xa8, + 0x3b, 0x26, 0x13, 0xf0, 0x5f, 0x51, 0x9f, 0xc7, 0xd1, 0x76, 0x45, 0x1c, + 0xb0, 0xd9, 0xc5, 0x48, 0x69, 0x9c, 0x82, 0x00, 0x8d, 0x1d, 0x95, 0xa3, + 0x81, 0x34, 0x98, 0xb4, 0xed, 0xbe, 0xcb, 0x30, 0xfc, 0xf2, 0xed, 0xef, + 0xaa, 0x55, 0x80, 0x1f, 0x23, 0x49, 0x34, 0xaa, 0x51, 0x3a, 0x08, 0x22, + 0x86, 0x5b, 0x35, 0x91, 0x3c, 0x45, 0x2e, 0xba, 0x17, 0x42, 0x87, 0xc9, + 0x31, 0x92, 0xc8, 0x71, 0x32, 0x2e, 0x1b, 0x90, 0x35, 0x30, 0x4a, 0x73, + 0x00, 0x0a, 0x9a, 0xc8, 0x6b, 0xe4, 0x3d, 0x97, 0x61, 0x36, 0xdb, 0xdc, + 0x86, 0x36, 0xe8, 0x78, 0x1c, 0x86, 0xf5, 0xe8, 0x0f, 0xc0, 0x64, 0x21, + 0xde, 0x20, 0x99, 0xec, 0x05, 0xc2, 0x4c, 0x18, 0x97, 0xd0, 0xc2, 0xd1, + 0xd2, 0x79, 0x5c, 0x80, 0x13, 0x94, 0xd0, 0xb4, 0xcc, 0xeb, 0x70, 0x60, + 0xbc, 0x0a, 0xaf, 0x62, 0x36, 0x95, 0x71, 0x2b, 0xb7, 0x1c, 0x9a, 0x9b, + 0x6d, 0xff, 0xaa, 0xbb, 0x8b, 0x08, 0x40, 0xc9, 0x3f, 0x09, 0x71, 0x61, + 0xc4, 0xfd, 0x18, 0x1a, 0x4c, 0x99, 0x7b, 0x68, 0x17, 0x3c, 0xe4, 0x47, + 0x23, 0x09, 0xcd, 0x63, 0xef, 0xd2, 0x8d, 0xc5, 0x23, 0xd2, 0x57, 0x45, + 0x7e, 0x06, 0xe6, 0xa0, 0x89, 0xe8, 0x87, 0xb5, 0xdd, 0x2d, 0x60, 0x5d, + 0x07, 0x23, 0xae, 0x0a, 0x7b, 0x32, 0x4d, 0x37, 0xbe, 0x24, 0xf2, 0x6c, + 0xae, 0xb5, 0xfb, 0xa6, 0x11, 0x6e, 0x22, 0x2b, 0xe8, 0x84, 0xcc, 0x6f, + 0xfa, 0x73, 0x29, 0xef, 0x53, 0x24, 0x1b, 0xdf, 0x90, 0x59, 0x44, 0x48, + 0x09, 0xfe, 0x97, 0x05, 0xc5, 0xc5, 0xa2, 0xcf, 0xa8, 0xd5, 0x36, 0xd5, + 0x0c, 0xd7, 0x0e, 0xc4, 0x8d, 0xd4, 0xfd, 0x3e, 0x6b, 0x3f, 0xe1, 0x4a, + 0x15, 0xd5, 0x71, 0x61, 0xf4, 0x20, 0xe9, 0xcf, 0x91, 0x5f, 0xfc, 0x75, + 0xcf, 0x1e, 0x77, 0xcd, 0x27, 0x62, 0x75, 0xd1, 0xa4, 0x35, 0xbc, 0xa4, + 0xaa, 0xed, 0x79, 0x8f, 0x03, 0xcc, 0x05, 0x30, 0x4e, 0xd0, 0x05, 0x26, + 0x69, 0xc2, 0x50, 0xa8, 0x2f, 0x76, 0xf7, 0xf6, 0xcd, 0x43, 0x1d, 0x04, + 0x84, 0x42, 0x7b, 0xfd, 0xe0, 0x3c, 0xf9, 0xe4, 0xfb, 0x0c, 0x24, 0x2d, + 0xa7, 0x73, 0x1e, 0xa8, 0x93, 0xf6, 0xbb, 0xae, 0x81, 0xa2, 0x0d, 0x9b, + 0x30, 0xbb, 0x52, 0xf0, 0x13, 0x03, 0xbd, 0xe5, 0x22, 0x38, 0x64, 0x8a, + 0x32, 0x17, 0xae, 0xc4, 0x78, 0x10, 0x99, 0x31, 0x90, 0x3d, 0x21, 0xe9, + 0x59, 0xde, 0xdc, 0xfe, 0x44, 0x1c, 0xa7, 0x90, 0x12, 0xb4, 0x91, 0x9a, + 0x4e, 0xc6, 0x17, 0xfc, 0xe8, 0xfd, 0x23, 0x8f, 0xd4, 0x96, 0x0a, 0x7c, + 0x5a, 0x83, 0xde, 0x69, 0x6d, 0x83, 0x56, 0x74, 0x64, 0x37, 0xdc, 0xde, + 0xa0, 0x88, 0xe4, 0xb6, 0x80, 0x53, 0xad, 0xb9, 0x0f, 0xfc, 0xa3, 0x26, + 0xed, 0x24, 0xa1, 0xc0, 0x1f, 0x3f, 0x7b, 0xe3, 0xad, 0x87, 0xd1, 0x55, + 0xbb, 0x67, 0x30, 0xba, 0xfb, 0xcd, 0xa6, 0x8a, 0xbb, 0x38, 0x51, 0xff, + 0xe1, 0xb2, 0x39, 0x6d, 0xfc, 0x68, 0x18, 0x31, 0xc2, 0x35, 0xbb, 0xfb, + 0x4d, 0x7e, 0x86, 0x40, 0xb0, 0xfb, 0x6d, 0xf6, 0x89, 0xa2, 0xd0, 0x74, + 0x8c, 0xf7, 0xd6, 0xa5, 0x0a, 0xbc, 0x87, 0x69, 0xb4, 0xce, 0x7f, 0x5b, + 0xb7, 0x7f, 0xca, 0x9d, 0x2e, 0x2a, 0xd8, 0x4d, 0xf0, 0x94, 0xa5, 0x65, + 0x66, 0x48, 0x3d, 0xa0, 0xf2, 0xfe, 0x25, 0xe2, 0xa2, 0x33, 0xc4, 0x65, + 0x2d, 0xba, 0x90, 0xca, 0xd8, 0x42, 0x3a, 0x58, 0xd4, 0xff, 0xe9, 0xfb, + 0x01, 0x6c, 0x93, 0xb7, 0xc0, 0x3d, 0x75, 0xeb, 0xf3, 0xcd, 0xef, 0x90, + 0x2d, 0xaa, 0x2d, 0x49, 0x47, 0xcf, 0xec, 0x9f, 0xc6, 0xd1, 0x6e, 0x2d, + 0x37, 0xd5, 0xcf, 0x2a, 0x7d, 0x63, 0xa6, 0xf8, 0x92, 0xc5, 0xb4, 0xe4, + 0xf7, 0x8f, 0x33, 0x9e, 0x06, 0x46, 0x98, 0xe5, 0xf1, 0xa0, 0xa2, 0xf7, + 0xba, 0xc1, 0x44, 0x9c, 0xaa, 0xc9, 0x29, 0x2d, 0x40, 0x85, 0xf2, 0x22, + 0x98, 0xee, 0xff, 0xcc, 0xc0, 0x68, 0xbc, 0xe6, 0x37, 0x29, 0xaf, 0xdd, + 0x92, 0x69, 0x40, 0xa1, 0x07, 0xf8, 0x87, 0x0e, 0x25, 0xa9, 0x50, 0x22, + 0xd3, 0x63, 0x0f, 0x00, 0xfd, 0x7b, 0x58, 0x22, 0xd9, 0xc2, 0xde, 0x41, + 0x19, 0x6a, 0x88, 0x5e, 0x8d, 0x3a, 0xeb, 0x88, 0xfe, 0xbf, 0x1c, 0x5e, + 0x37, 0xf5, 0x6a, 0x7b, 0xfa, 0x72, 0x3c, 0x13, 0x98, 0xbc, 0x40, 0x1f, + 0x07, 0x94, 0xcd, 0x8b, 0x87, 0xe9, 0x1c, 0x0d, 0xd3, 0x0f, 0xca, 0x12, + 0xe6, 0xf8, 0x21, 0xd9, 0xb6, 0x01, 0x3e, 0x3d, 0x00, 0x4d, 0x2e, 0x53, + 0x40, 0x6e, 0x05, 0x0c, 0x66, 0x4b, 0x2b, 0xc5, 0x24, 0x89, 0x11, 0x94, + 0x0b, 0x4c, 0xec, 0xcf, 0xfa, 0xae, 0x3e, 0xf3, 0xb9, 0xca, 0xd0, 0xb7, + 0x34, 0x3c, 0x79, 0xa5, 0x74, 0x01, 0x21, 0x5e, 0x07, 0xb4, 0xd4, 0x34, + 0x10, 0x56, 0x96, 0x0d, 0xc6, 0xc1, 0x1c, 0xd3, 0xb0, 0x25, 0x99, 0xe6, + 0x62, 0xd0, 0x6b, 0x60, 0xf2, 0x63, 0x99, 0x84, 0xb1, 0xc4, 0x87, 0x1b, + 0x52, 0xda, 0x29, 0xe4, 0x81, 0x5d, 0xff, 0x7a, 0xf6, 0x64, 0x33, 0x51, + 0xab, 0x34, 0x97, 0x74, 0xe7, 0x73, 0xcf, 0x2f, 0xee, 0xb5, 0xda, 0x7b, + 0x03, 0xd6, 0xda, 0xb5, 0x45, 0xb7, 0x09, 0x3b, 0x75, 0xdf, 0x68, 0x2b, + 0x4c, 0x51, 0xb8, 0xe1, 0xe7, 0xe2, 0x1f, 0x36, 0xbf, 0x35, 0xe9, 0x5c, + 0xaa, 0xb1, 0xf2, 0x07, 0x2c, 0x93, 0x4e, 0x2c, 0xfc, 0x7e, 0x1d, 0xf7, + 0xba, 0xe0, 0x64, 0x58, 0xef, 0x94, 0xcf, 0x34, 0x46, 0xe9, 0xac, 0xfe, + 0x62, 0x01, 0xc0, 0x4c, 0x3f, 0x4b, 0xc0, 0x23, 0xda, 0xb0, 0x45, 0xf0, + 0x9e, 0x12, 0x6b, 0x1e, 0xfc, 0xce, 0xb2, 0xa3, 0xdb, 0x29, 0x56, 0xea, + 0xc1, 0x45, 0xd9, 0x45, 0xa5, 0x24, 0x19, 0xa0, 0x97, 0xfe, 0xa4, 0x97, + 0x8d, 0x04, 0xd8, 0x61, 0x0d, 0xfd, 0xce, 0xbc, 0xdc, 0x21, 0x80, 0x8c, + 0xbb, 0x9d, 0x8a, 0x76, 0x42, 0x71, 0x50, 0x1f, 0x32, 0x11, 0x03, 0x80, + 0xd2, 0x2a, 0xd2, 0x27, 0x53, 0xc5, 0x8d, 0xf6, 0x4c, 0x24, 0xf1, 0x64, + 0xfb, 0x0a, 0x95, 0x11, 0x83, 0x4a, 0xf6, 0x01, 0x00, 0xda, 0xc4, 0xc1, + 0x04, 0x1b, 0x29, 0xaa, 0xb4, 0x3b, 0x6d, 0xbc, 0x27, 0x54, 0x3a, 0xdc, + 0xe9, 0x6b, 0x32, 0x19, 0x1b, 0x74, 0xd5, 0x4b, 0xe0, 0xa5, 0x46, 0x7c, + 0xee, 0x8a, 0xcf, 0xa4, 0x47, 0xa0, 0xf5, 0x3a, 0x94, 0xf7, 0xea, 0x2c, + 0x3f, 0x03, 0xbb, 0xa5, 0xe4, 0xf0, 0xbd, 0x87, 0x68, 0x6e, 0x55, 0xf9, + 0x53, 0x1c, 0x09, 0x85, 0x79, 0x4b, 0x44, 0xe3, 0x47, 0x8a, 0x54, 0x97, + 0x7f, 0x97, 0xb0, 0x81, 0x2f, 0x07, 0x85, 0x40, 0x43, 0x5d, 0xf7, 0x04, + 0x86, 0xc8, 0x5c, 0x55, 0x2c, 0x32, 0xf4, 0x22, 0xcd, 0x38, 0x8c, 0x70, + 0x1a, 0xae, 0xb8, 0xa4, 0x96, 0x8c, 0x64, 0x44, 0x24, 0xd1, 0x5f, 0x53, + 0x00, 0x0c, 0xb5, 0x41, 0x23, 0x34, 0x2d, 0xb7, 0xaa, 0xea, 0xb0, 0x27, + 0xdd, 0xcc, 0xf4, 0xb4, 0x27, 0xdc, 0x63, 0x18, 0x2c, 0x10, 0x3b, 0x3d, + 0x90, 0x10, 0x51, 0x49, 0x32, 0xbd, 0x27, 0xd7, 0x90, 0x23, 0x85, 0x1c, + 0x8e, 0x6b, 0xd6, 0xfa, 0x38, 0x66, 0xb9, 0x94, 0xab, 0xb0, 0x71, 0x93, + 0x28, 0xe7, 0x6f, 0x18, 0x5f, 0x17, 0x22, 0xd2, 0x77, 0xe3, 0x85, 0x06, + 0x9f, 0x09, 0x8c, 0x17, 0xbc, 0xda, 0xfa, 0x3e, 0xcc, 0xc3, 0xae, 0x8f, + 0xfe, 0xe4, 0x24, 0x2c, 0x59, 0xfd, 0x2b, 0x61, 0xad, 0x90, 0x0b, 0xea, + 0x55, 0x24, 0x27, 0x10, 0x7f, 0x00, 0x00, 0x29, 0x97, 0xc9, 0x46, 0x09, + 0x72, 0xce, 0xde, 0xba, 0x94, 0x4e, 0xd3, 0xd4, 0x64, 0x47, 0x2b, 0xe9, + 0x98, 0x9f, 0x12, 0x0c, 0x14, 0xe9, 0x4e, 0x52, 0xae, 0x25, 0x14, 0x41, + 0x30, 0x36, 0x9d, 0x0a, 0x1f, 0x3e, 0x01, 0x73, 0x84, 0x14, 0x51, 0x64, + 0x9b, 0x29, 0x5e, 0x2d, 0xb3, 0xe9, 0x0b, 0xd2, 0x8a, 0x49, 0x63, 0xf1, + 0xa5, 0x17, 0x28, 0xd7, 0xc7, 0x19, 0x16, 0x78, 0xe7, 0x13, 0x0a, 0xd7, + 0x9f, 0x00, 0xf7, 0xc8, 0x06, 0xfd, 0x3f, 0x47, 0x4a, 0x2b, 0xf1, 0xd0, + 0xe0, 0x11, 0xc9, 0x64, 0x5e, 0xf4, 0xc8, 0x58, 0xba, 0x29, 0x84, 0x8c, + 0xf8, 0x65, 0x20, 0x6c, 0xe4, 0xa8, 0x23, 0x58, 0x99, 0x17, 0x25, 0xbe, + 0xc5, 0x2a, 0x0e, 0x34, 0xa5, 0xf3, 0x09, 0xfa, 0x97, 0x9e, 0xf5, 0x2c, + 0xd0, 0x84, 0xcd, 0xce, 0xbd, 0x56, 0xdc, 0xb2, 0xaf, 0x67, 0x5f, 0x67, + 0xec, 0xe9, 0x5f, 0xaf, 0xbb, 0x6e, 0x14, 0x01, 0x03, 0xe3, 0x8b, 0x43, + 0x54, 0xcc, 0xa1, 0x4b, 0x4e, 0x2e, 0x8f, 0xaa, 0x0f, 0xd7, 0x28, 0xe7, + 0x49, 0x68, 0x10, 0x61, 0x02, 0xf5, 0x1a, 0x6f, 0x94, 0x7c, 0xa5, 0x78, + 0xed, 0xea, 0x39, 0x4f, 0xe8, 0xaf, 0x64, 0x56, 0xe2, 0x7e, 0x42, 0x14, + 0xdf, 0x5e, 0xf0, 0xdd, 0x2d, 0xb7, 0xbc, 0x19, 0xe8, 0x9c, 0xa9, 0x1e, + 0x85, 0x68, 0xb4, 0x14, 0xed, 0x7b, 0xa2, 0x54, 0xcf, 0x37, 0x43, 0x4b, + 0x15, 0x43, 0x73, 0x6c, 0x63, 0x5c, 0x50, 0x42, 0x2a, 0x74, 0xaa, 0x41, + 0x22, 0x96, 0x73, 0xcc, 0x7b, 0x94, 0x6e, 0x94, 0x29, 0x84, 0xbb, 0xe9, + 0x6e, 0x0a, 0x93, 0x17, 0x60, 0x58, 0x6a, 0xbe, 0x83, 0x20, 0x05, 0x29, + 0x58, 0xf9, 0x98, 0x16, 0xc5, 0x37, 0xfd, 0x7d, 0xc0, 0x82, 0x2c, 0x87, + 0x69, 0x3a, 0x86, 0x5e, 0xb0, 0xe8, 0xc5, 0x85, 0x91, 0x03, 0x39, 0xce, + 0x45, 0xc2, 0x16, 0x07, 0x54, 0x91, 0xc3, 0x00, 0xbc, 0x72, 0xdf, 0x47, + 0x36, 0x7d, 0xf2, 0x66, 0x48, 0x56, 0x05, 0x56, 0x3c, 0x65, 0xda, 0x67, + 0x34, 0x5f, 0xf0, 0x1d, 0x25, 0x3a, 0x0a, 0xfb, 0x8a, 0x11, 0x44, 0x33, + 0xc9, 0xb8, 0x38, 0x1e, 0x86, 0xfd, 0x44, 0x80, 0x2d, 0x9a, 0x2f, 0xb7, + 0xb2, 0x5f, 0x15, 0x49, 0x6b, 0xde, 0x36, 0xbd, 0x5c, 0xf9, 0x72, 0x17, + 0x57, 0x16, 0x6a, 0xad, 0x30, 0xfa, 0x15, 0xbd, 0x36, 0x08, 0x9b, 0x2c, + 0xec, 0x82, 0x95, 0x78, 0x1b, 0xa8, 0x4e, 0x74, 0xfc, 0x2b, 0x5b, 0x38, + 0xfb, 0xe5, 0x03, 0x0e, 0x0c, 0x65, 0x5e, 0x76, 0x0e, 0xff, 0x6f, 0x91, + 0xac, 0x8b, 0x93, 0x7f, 0x83, 0xc4, 0xfd, 0x5b, 0x88, 0x8e, 0x47, 0x41, + 0xb1, 0xf2, 0xea, 0x26, 0x79, 0x49, 0x1b, 0xa5, 0x6c, 0xac, 0xd7, 0x75, + 0xc3, 0x81, 0x94, 0xd0, 0x4a, 0x5b, 0x4d, 0x32, 0xb7, 0xff, 0x1f, 0xeb, + 0x80, 0xd4, 0x60, 0x18, 0xe8, 0x3c, 0x43, 0xf4, 0xf8, 0xa1, 0xd9, 0xa4, + 0xd9, 0x71, 0x2c, 0x09, 0x44, 0xa2, 0x33, 0xc4, 0x22, 0x6f, 0xf7, 0xfb, + 0xa7, 0xb4, 0xab, 0x4e, 0x44, 0x83, 0x79, 0xa0, 0x81, 0xfb, 0xc7, 0x5c, + 0xab, 0x6e, 0x70, 0x4a, 0x09, 0x78, 0x9a, 0xf2, 0x3b, 0xa4, 0x3c, 0x05, + 0xb0, 0x83, 0x6f, 0xa1, 0xea, 0x5a, 0x8e, 0xbc, 0x2b, 0xb6, 0xff, 0x9b, + 0x78, 0xbc, 0x53, 0x51, 0xc5, 0x46, 0x7f, 0x9f, 0x4e, 0x79, 0x8e, 0xf8, + 0x41, 0xbe, 0x66, 0xdd, 0xa9, 0xd1, 0x20, 0xbd, 0xe2, 0xb0, 0xd8, 0xd0, + 0x27, 0xf2, 0x39, 0x84, 0xe8, 0x52, 0xab, 0x9f, 0xab, 0x9f, 0x8d, 0x3f, + 0xcb, 0xb0, 0x7a, 0x59, 0xba, 0x95, 0xb0, 0xdd, 0x8c, 0xd0, 0x31, 0x76, + 0x18, 0x26, 0x28, 0x14, 0x41, 0x72, 0x53, 0xdc, 0xa3, 0x85, 0xd0, 0xf7, + 0x3b, 0x0d, 0xf2, 0x5c, 0x20, 0xd0, 0x23, 0x6d, 0xed, 0x01, 0x05, 0x66, + 0xc1, 0x07, 0x1d, 0x82, 0x24, 0x72, 0xc7, 0x7b, 0xbe, 0xc2, 0x6b, 0xc0, + 0x52, 0xf4, 0x91, 0xa3, 0xae, 0x43, 0x71, 0x9a, 0xca, 0xef, 0x47, 0x1e, + 0xcb, 0x41, 0x73, 0x1d, 0xc4, 0x11, 0xdb, 0x34, 0x40, 0x11, 0x34, 0x6f, + 0x6d, 0xf6, 0xbb, 0x41, 0x5a, 0x75, 0x21, 0x59, 0x9e, 0x63, 0xb1, 0xb8, + 0x68, 0xdd, 0x64, 0xfb, 0xdc, 0x86, 0x6d, 0xfe, 0x3f, 0x42, 0x08, 0x60, + 0x57, 0xb8, 0xbd, 0xac, 0xa7, 0x9a, 0x6a, 0x5c, 0xf5, 0xb1, 0xca, 0xe5, + 0x6f, 0x3b, 0x1d, 0x20, 0x58, 0x21, 0x3b, 0x62, 0x67, 0xf6, 0x06, 0x6b, + 0xf7, 0xec, 0xfa, 0x8d, 0x5e, 0xd5, 0x54, 0x16, 0xf2, 0xb0, 0x0b, 0x7e, + 0x54, 0xee, 0x47, 0xd0, 0x04, 0xbc, 0x99, 0x1c, 0xa2, 0x87, 0x7b, 0xae, + 0xa5, 0x57, 0x47, 0x59, 0x02, 0x74, 0x8f, 0x00, 0x2e, 0x5b, 0xdf, 0x87, + 0xbd, 0x4f, 0x36, 0x63, 0x96, 0xb8, 0x47, 0x39, 0x63, 0xdb, 0x94, 0x6e, + 0xaa, 0xc5, 0x90, 0xf6, 0xff, 0x13, 0xe1, 0x52, 0x92, 0x5b, 0x05, 0xeb, + 0x2f, 0xa0, 0xdb, 0xb6, 0x13, 0x09, 0xc6, 0x2d, 0x70, 0xdf, 0xba, 0xaf, + 0xc0, 0x8f, 0x82, 0x0c, 0x45, 0x62, 0x3d, 0xf3, 0x84, 0xb4, 0x84, 0x76, + 0x86, 0x08, 0x3a, 0x9b, 0x7b, 0x57, 0x75, 0x78, 0x1c, 0x9f, 0x45, 0xbb, + 0x8b, 0x78, 0xbc, 0x87, 0x00, 0x02, 0x1a, 0xc5, 0x2a, 0xca, 0xb2, 0x77, + 0x69, 0x30, 0x80, 0x7d, 0x24, 0x9c, 0xc8, 0xcb, 0x05, 0xab, 0x69, 0xe6, + 0x7f, 0x61, 0x87, 0xbc, 0xfe, 0xb6, 0x5b, 0x1a, 0x12, 0x9b, 0x8c, 0x08, + 0xdf, 0xe2, 0xf5, 0xfb, 0x5c, 0x86, 0x7c, 0x1e, 0x37, 0xa2, 0xe1, 0xb9, + 0x88, 0x77, 0x86, 0x6a, 0x1d, 0x6b, 0x17, 0x50, 0xa2, 0xdd, 0x92, 0x79, + 0x34, 0x32, 0x00, 0xc7, 0x43, 0x31, 0x71, 0x55, 0xcd, 0x8d, 0x4e, 0x67, + 0x98, 0x2e, 0xb1, 0x27, 0x32, 0xbd, 0xbd, 0x08, 0x65, 0xe1, 0x74, 0x2d, + 0xef, 0xe3, 0xb2, 0x1c, 0x1b, 0x31, 0x3c, 0x61, 0xcc, 0xb5, 0x99, 0x1f, + 0x5f, 0x61, 0x35, 0x4d, 0x2a, 0xdd, 0xd0, 0xbe, 0x79, 0xe8, 0xbd, 0x35, + 0x0b, 0x40, 0xbf, 0xa0, 0x26, 0x4e, 0x27, 0xf0, 0x1b, 0x1a, 0xce, 0xf8, + 0xe1, 0x69, 0x2a, 0xdb, 0x9a, 0xfb, 0x5d, 0x91, 0x4e, 0xec, 0xd7, 0x92, + 0x8f, 0x26, 0x11, 0x3d, 0x08, 0x05, 0xdc, 0x0f, 0x45, 0xcd, 0xb1, 0x9e, + 0x93, 0xf8, 0x20, 0xa8, 0x4c, 0x8b, 0xab, 0x4c, 0x70, 0x0c, 0x60, 0xc4, + 0x8b, 0x59, 0x88, 0x15, 0xab, 0xc1, 0xe9, 0x7d, 0x2c, 0x28, 0xe1, 0xdd, + 0x20, 0x09, 0xe2, 0xf3, 0xca, 0xbe, 0x37, 0xe4, 0x5e, 0x27, 0x98, 0x92, + 0x94, 0x49, 0x3b, 0xb8, 0x6d, 0xc6, 0x0c, 0x9c, 0x0e, 0x79, 0x81, 0x2b, + 0xe3, 0x15, 0xba, 0x66, 0x2d, 0xba, 0x88, 0x8c, 0xa5, 0xb0, 0xf2, 0x4a, + 0xcd, 0x8f, 0x1a, 0xb0, 0x65, 0x82, 0xcb, 0x9f, 0x92, 0xc9, 0xbb, 0xb1, + 0x94, 0xcc, 0x61, 0xf2, 0x9a, 0x89, 0x7a, 0x15, 0x51, 0x36, 0x7b, 0x46, + 0xef, 0x76, 0xba, 0x9d, 0x39, 0x4c, 0xa5, 0x6b, 0x38, 0x67, 0x64, 0x7c, + 0xec, 0xbd, 0xbe, 0x30, 0xec, 0xc5, 0xf4, 0x64, 0x0d, 0x4a, 0x02, 0x10, + 0x6c, 0x67, 0x34, 0x70, 0xcc, 0x59, 0xfc, 0x94, 0x45, 0x83, 0xde, 0x21, + 0x25, 0x25, 0x66, 0x4e, 0xae, 0x60, 0xcc, 0xf4, 0x32, 0xf0, 0xe1, 0xb4, + 0xc2, 0x68, 0x96, 0x4d, 0x65, 0x29, 0xb6, 0x25, 0x3c, 0x6a, 0xd5, 0x0c, + 0xab, 0x18, 0xf1, 0x28, 0x6f, 0xfa, 0xac, 0x5c, 0xe1, 0x8f, 0x32, 0x16, + 0x0f, 0xa1, 0x45, 0x3a, 0x07, 0x83, 0x53, 0xb6, 0x2b, 0xe0, 0x90, 0x88, + 0x3d, 0x38, 0xb8, 0xe6, 0xb0, 0xff, 0xb4, 0xb7, 0x51, 0x23, 0x17, 0x4b, + 0x8a, 0xdc, 0x27, 0x79, 0x76, 0x9e, 0x3d, 0xdf, 0x91, 0x49, 0x7d, 0xc1, + 0xb4, 0x84, 0xce, 0x3a, 0x27, 0x4e, 0xfd, 0x40, 0x5a, 0x53, 0x11, 0x47, + 0xed, 0xfb, 0xf4, 0x89, 0x5d, 0x13, 0x73, 0x14, 0xbe, 0x73, 0x40, 0xff, + 0xe2, 0x83, 0x04, 0xf1, 0xab, 0x4e, 0x30, 0xba, 0xc5, 0x01, 0x18, 0xbd, + 0xbe, 0x75, 0x8a, 0x4f, 0x6c, 0x96, 0x77, 0xbe, 0x81, 0xf3, 0xd7, 0x6b, + 0x59, 0x6c, 0xd0, 0xfc, 0xa2, 0x51, 0xf5, 0x22, 0xc5, 0x1c, 0x54, 0x61, + 0xbd, 0x32, 0xf6, 0xb3, 0xee, 0xc1, 0x58, 0x63, 0x55, 0x18, 0x18, 0x3c, + 0x1a, 0xf0, 0x5a, 0x77, 0x2f, 0x0a, 0xad, 0x1c, 0x77, 0x20, 0x26, 0x67, + 0xe2, 0xb9, 0x27, 0x0d, 0x0d, 0xa0, 0x7e, 0xee, 0x25, 0x61, 0xc9, 0x5b, + 0xc2, 0xa0, 0x90, 0x16, 0xa1, 0xb8, 0x6b, 0x49, 0xee, 0xa1, 0x25, 0x24, + 0x24, 0xd3, 0x7e, 0x6c, 0x21, 0xa3, 0x5d, 0x22, 0x27, 0x41, 0xd3, 0x9c, + 0x08, 0x34, 0x1d, 0xf1, 0xf3, 0x6b, 0x7c, 0xae, 0x5a, 0x92, 0x18, 0xfd, + 0x80, 0x50, 0x83, 0x19, 0x73, 0x4b, 0x9d, 0x08, 0x09, 0x70, 0xa5, 0x38, + 0x73, 0xfa, 0xd6, 0x58, 0xb7, 0xc9, 0x0e, 0x4b, 0x3d, 0x6f, 0x33, 0x1c, + 0x87, 0xf0, 0x13, 0xb1, 0xe2, 0xec, 0x1e, 0x1a, 0x63, 0x20, 0x1a, 0xd1, + 0x56, 0x21, 0x70, 0x3d, 0x52, 0xd8, 0x27, 0xf6, 0x09, 0xec, 0x03, 0x75, + 0x2b, 0x1c, 0x0d, 0x02, 0x70, 0x29, 0xa6, 0xcc, 0xa1, 0xb9, 0x30, 0xd0, + 0x7f, 0xb8, 0x45, 0xcd, 0x43, 0x64, 0x2e, 0x14, 0x10, 0x78, 0xf6, 0xf3, + 0x99, 0xe2, 0x34, 0xbd, 0x8b, 0xec, 0xfe, 0x19, 0x49, 0x91, 0x76, 0x4a, + 0x4f, 0xdb, 0x1d, 0xaf, 0x32, 0xa3, 0x8b, 0x62, 0xef, 0x25, 0x08, 0x96, + 0x6f, 0x7c, 0x59, 0xad, 0xe9, 0x82, 0x3e, 0x57, 0x6b, 0xaa, 0x70, 0x97, + 0x5c, 0x15, 0x50, 0xef, 0xb6, 0xf5, 0x10, 0xae, 0x6f, 0xdf, 0x38, 0x57, + 0x7b, 0x87, 0xdd, 0x41, 0x17, 0x09, 0xcd, 0x6b, 0xb3, 0x55, 0xdd, 0xfb, + 0x63, 0xb3, 0xbd, 0x5b, 0x56, 0xd1, 0xb9, 0x96, 0xc6, 0xa2, 0x3d, 0xb3, + 0xdf, 0x43, 0x35, 0xdb, 0x71, 0x2a, 0xff, 0x53, 0x70, 0xc0, 0x62, 0xc8, + 0x07, 0x43, 0x9d, 0x78, 0xd6, 0x5f, 0x9f, 0x0b, 0xb4, 0xa3, 0x4e, 0x7f, + 0x3b, 0x32, 0x2e, 0xa9, 0x46, 0x18, 0x1b, 0x8a, 0x1b, 0xb3, 0x78, 0x69, + 0x68, 0xe1, 0x32, 0xe1, 0xa8, 0xd6, 0x5d, 0xfd, 0xbe, 0xd0, 0x44, 0x20, + 0xa6, 0xe5, 0x15, 0x75, 0x90, 0xf5, 0xcf, 0x08, 0x75, 0xab, 0xca, 0xc9, + 0x99, 0x58, 0xbc, 0xc8, 0x24, 0x8c, 0x7a, 0x54, 0x73, 0x23, 0x13, 0x3e, + 0x90, 0x4f, 0xdb, 0x20, 0x0b, 0xa0, 0x15, 0xbf, 0xcc, 0x0d, 0x30, 0xc3, + 0x14, 0xb5, 0x9f, 0xf5, 0xff, 0xe8, 0xbd, 0x80, 0xc2, 0x7a, 0x58, 0x52, + 0x96, 0x59, 0x9c, 0x26, 0x8f, 0x2b, 0x64, 0x0e, 0x8c, 0x4f, 0x46, 0x3d, + 0x10, 0xda, 0x62, 0xee, 0xef, 0x3a, 0x5f, 0x91, 0x6f, 0xd7, 0x4e, 0x97, + 0x5f, 0xa9, 0x60, 0x1e, 0x80, 0xce, 0xdc, 0x13, 0x5d, 0xd4, 0x19, 0x27, + 0xc0, 0x55, 0xa8, 0x44, 0x40, 0x63, 0x01, 0xc3, 0xc5, 0x1c, 0xc8, 0x60, + 0xfb, 0x0a, 0x5a, 0x13, 0xb1, 0xa2, 0x74, 0xfb, 0x7b, 0xc6, 0xc9, 0x4d, + 0x5f, 0xfd, 0x22, 0x75, 0x6c, 0xc1, 0x0d, 0xb1, 0xf6, 0xab, 0x03, 0x2f, + 0xe3, 0x47, 0xfc, 0x85, 0xde, 0x7b, 0x2c, 0x87, 0x3f, 0xa7, 0x73, 0xa8, + 0xba, 0x18, 0x5b, 0xe7, 0x36, 0x8e, 0xee, 0xdc, 0x56, 0x7d, 0x06, 0x79, + 0xb7, 0xcb, 0x0d, 0x3f, 0x8f, 0xd6, 0xdd, 0x07, 0x02, 0xbe, 0xff, 0x65, + 0x60, 0xdd, 0x3e, 0x9a, 0xe0, 0xea, 0x7b, 0x26, 0x51, 0x16, 0xf0, 0x77, + 0xf3, 0x5c, 0x93, 0xa3, 0x56, 0xce, 0xef, 0x56, 0x66, 0x51, 0x20, 0xaa, + 0x98, 0x65, 0x3d, 0x3a, 0x20, 0x67, 0xb7, 0x60, 0xa8, 0x36, 0x69, 0xc2, + 0x27, 0x76, 0x75, 0xc5, 0xdb, 0x1c, 0xa6, 0x16, 0xfb, 0x28, 0xc0, 0x79, + 0xc2, 0x4c, 0x9d, 0xa2, 0x45, 0x50, 0x39, 0xd2, 0x72, 0xc9, 0x88, 0x4c, + 0x99, 0xce, 0xbc, 0x7d, 0x73, 0x1c, 0x6c, 0x9c, 0x13, 0xd4, 0x34, 0x7e, + 0xe8, 0x9f, 0x57, 0xb7, 0xe8, 0xec, 0x73, 0x36, 0x53, 0xf6, 0x71, 0x0c, + 0x0a, 0x20, 0x93, 0x45, 0x16, 0x9d, 0xfc, 0xcd, 0xc9, 0x06, 0x08, 0x7f, + 0xeb, 0x56, 0x19, 0x50, 0x0c, 0x27, 0x4d, 0x83, 0xd6, 0x16, 0x84, 0x56, + 0xad, 0x7a, 0xcb, 0xf7, 0xbb, 0x36, 0x84, 0x15, 0xff, 0xd1, 0xe6, 0xcc, + 0x9a, 0xcf, 0x0c, 0x97, 0x3f, 0x9e, 0xcb, 0x57, 0x44, 0xce, 0x1c, 0x09, + 0xfa, 0x63, 0x17, 0x5d, 0x45, 0x9c, 0x6c, 0xfa, 0x8d, 0xdf, 0x11, 0x58, + 0x40, 0xba, 0xb9, 0x37, 0xb9, 0x86, 0x55, 0x71, 0x3d, 0x05, 0xe3, 0x81, + 0x9b, 0x20, 0xb4, 0xc0, 0x4c, 0xfe, 0x57, 0x43, 0x3b, 0x40, 0xbb, 0x58, + 0x29, 0x12, 0x3f, 0xe9, 0x52, 0x55, 0xed, 0xcf, 0xbf, 0x89, 0x53, 0x3a, + 0xaf, 0xcb, 0xc4, 0xf8, 0x3f, 0xe6, 0x36, 0x3f, 0xc2, 0x0a, 0x1e, 0x52, + 0x78, 0xe1, 0x56, 0x2a, 0x65, 0xb6, 0x49, 0x0d, 0x81, 0x54, 0x4b, 0xa2, + 0xbd, 0x97, 0x63, 0x09, 0x5e, 0xea, 0x46, 0x49, 0x2e, 0x2c, 0xe9, 0x7b, + 0xe6, 0x8b, 0x8d, 0x6c, 0x61, 0x20, 0x1f, 0x7c, 0x87, 0xe1, 0xbe, 0xcf, + 0x31, 0x1e, 0xc4, 0x3d, 0xde, 0x4c, 0xcf, 0xf9, 0x67, 0x5f, 0x08, 0x42, + 0x73, 0x78, 0x73, 0xa0, 0x20, 0x01, 0xcd, 0x7f, 0xfa, 0x06, 0x2c, 0xa6, + 0x45, 0x01, 0xa7, 0xf8, 0x0c, 0xa7, 0x89, 0xa7, 0x82, 0xf7, 0xe0, 0x4f, + 0xf7, 0xe1, 0x23, 0x38, 0x00, 0xfc, 0xc6, 0xdd, 0x7a, 0xf5, 0xc4, 0x7c, + 0x53, 0xf3, 0x55, 0xa9, 0x31, 0xac, 0x4c, 0x69, 0xf9, 0xfc, 0x76, 0x52, + 0xe3, 0x1f, 0x38, 0x36, 0x7c, 0x78, 0x26, 0x20, 0xd3, 0x73, 0x2c, 0x6f, + 0x4d, 0xf6, 0x81, 0x0b, 0xff, 0xa6, 0xe9, 0x6e, 0x68, 0x52, 0x91, 0x20, + 0xbd, 0xae, 0x87, 0xe3, 0x21, 0x31, 0xac, 0xf3, 0x40, 0xa5, 0x82, 0x70, + 0xf2, 0xc8, 0xee, 0x39, 0xf1, 0x2e, 0x6f, 0xb0, 0xa0, 0x35, 0xc6, 0xe8, + 0x5e, 0x9b, 0xd7, 0x9e, 0xfb, 0xba, 0x43, 0xc1, 0x69, 0x7a, 0x50, 0xc6, + 0x26, 0xc2, 0x84, 0x51, 0xfb, 0x12, 0x4c, 0x44, 0xaa, 0xab, 0x8d, 0x31, + 0xf8, 0xd0, 0x87, 0x4e, 0x38, 0xa8, 0x8f, 0x0b, 0xf7, 0xfd, 0x5a, 0x75, + 0xf4, 0x46, 0xf5, 0x4f, 0x6e, 0xa9, 0x03, 0x62, 0xfd, 0x0e, 0x57, 0x32, + 0xda, 0x22, 0xaa, 0x01, 0xf5, 0xcd, 0xba, 0x9a, 0x73, 0xa0, 0x3c, 0x1a, + 0xc2, 0xbb, 0xe2, 0xfd, 0xe2, 0x80, 0x53, 0x4d, 0xce, 0x68, 0xf0, 0xa5, + 0xcb, 0x55, 0x04, 0xa6, 0xb7, 0xf5, 0xdd, 0x89, 0xdd, 0xc5, 0x67, 0x44, + 0x7e, 0xe4, 0x6e, 0xfb, 0xaa, 0xc2, 0x37, 0x01, 0x81, 0x52, 0x96, 0x66, + 0xbd, 0xa9, 0x3f, 0xea, 0xdf, 0x36, 0x8b, 0x61, 0x13, 0xad, 0xa8, 0x4e, + 0x71, 0x3c, 0x7e, 0x03, 0xe3, 0x56, 0x05, 0xd3, 0xe2, 0x77, 0xb0, 0xea, + 0xa0, 0xbb, 0x57, 0x95, 0xa8, 0x70, 0x08, 0x97, 0x88, 0x5f, 0x9a, 0xa8, + 0x52, 0x46, 0xa2, 0x98, 0x62, 0xa5, 0x3e, 0x2f, 0x79, 0xd3, 0x57, 0x03, + 0x3e, 0x25, 0x0f, 0x4b, 0x90, 0x18, 0x08, 0x62, 0x35, 0x1e, 0x97, 0xbf, + 0x7c, 0xa3, 0x98, 0x36, 0x31, 0x1b, 0xa0, 0x67, 0x2b, 0x72, 0x5a, 0x01, + 0xf9, 0x20, 0x15, 0xf1, 0x31, 0xd0, 0x50, 0xc1, 0x2c, 0xa4, 0x76, 0x3e, + 0x28, 0x77, 0xe0, 0x4a, 0x7c, 0xd9, 0x76, 0x37, 0x0e, 0xbb, 0x9a, 0x2e, + 0x8c, 0xe2, 0x67, 0xbe, 0x56, 0xc1, 0xf6, 0xeb, 0x77, 0x71, 0xf0, 0xad, + 0x6f, 0xc8, 0x3e, 0x33, 0x98, 0x9f, 0xb9, 0x90, 0x69, 0xb5, 0x14, 0x3f, + 0x88, 0xcb, 0xaf, 0x8f, 0xe1, 0xcb, 0x36, 0x9d, 0xca, 0x6b, 0x73, 0x9d, + 0x25, 0x5a, 0x04, 0x65, 0x86, 0x8e, 0xd7, 0xbb, 0xd0, 0x66, 0x6f, 0x62, + 0xda, 0x19, 0x89, 0xc3, 0xa0, 0x63, 0x0d, 0xf8, 0x38, 0xb0, 0xca, 0xd2, + 0x56, 0x6b, 0x9e, 0x70, 0x61, 0xae, 0x41, 0xf9, 0xc1, 0xcc, 0xbc, 0x90, + 0x43, 0xee, 0xf7, 0x43, 0xed, 0xe7, 0x0a, 0x36, 0xe6, 0x33, 0xe7, 0x4b, + 0x1c, 0xf9, 0x43, 0x5f, 0x98, 0x80, 0xaf, 0xd2, 0x0d, 0x50, 0x60, 0xca, + 0x70, 0x22, 0xb7, 0x4e, 0x98, 0x19, 0xaa, 0x00, 0x76, 0xdc, 0xea, 0x46, + 0x48, 0xd8, 0x2a, 0x4e, 0x78, 0x3d, 0x66, 0x29, 0xa8, 0x53, 0xd2, 0x3b, + 0xc8, 0x66, 0x33, 0x67, 0xe5, 0xd8, 0xcf, 0x19, 0x30, 0x36, 0xc7, 0xb7, + 0xdb, 0xeb, 0x65, 0x8c, 0x3b, 0x6d, 0x98, 0x05, 0x8a, 0xd2, 0x21, 0x41, + 0xb9, 0x0b, 0xb3, 0xee, 0x7e, 0x82, 0x08, 0x8f, 0xc2, 0x0b, 0xe5, 0x3e, + 0x33, 0x53, 0x0e, 0xe9, 0xe4, 0x93, 0x13, 0x6d, 0xe7, 0xbf, 0x79, 0x0c, + 0x20, 0x8d, 0x62, 0x33, 0xbc, 0x7d, 0x15, 0x5a, 0xc4, 0x16, 0x09, 0xc8, + 0x92, 0x90, 0x28, 0x1c, 0xd7, 0x80, 0x6e, 0x9e, 0x2b, 0xe0, 0xdb, 0x57, + 0xe4, 0x8b, 0x53, 0xc5, 0x66, 0x10, 0xe0, 0xb3, 0x79, 0x66, 0x15, 0xf7, + 0x2c, 0x2c, 0x7d, 0xa1, 0x24, 0xb0, 0x63, 0x73, 0xc3, 0x34, 0xd4, 0x0a, + 0x54, 0xa0, 0x2b, 0x09, 0x9f, 0xf7, 0x40, 0x8f, 0xf8, 0x88, 0xc1, 0xc8, + 0x97, 0xe7, 0x4f, 0x3b, 0x5d, 0xa8, 0x0f, 0x22, 0x45, 0x47, 0x38, 0x63, + 0x92, 0x49, 0x3a, 0xd4, 0xf9, 0x44, 0xc1, 0x75, 0x6c, 0x45, 0xcf, 0xc4, + 0xd5, 0xa3, 0x4f, 0xa2, 0xf6, 0x6d, 0x47, 0x46, 0xac, 0x60, 0x0e, 0x7e, + 0xbd, 0x84, 0x48, 0x48, 0x20, 0xd9, 0x4f, 0xd0, 0x2b, 0x79, 0xd0, 0x2a, + 0xba, 0x06, 0x94, 0xda, 0x89, 0x4d, 0x4d, 0xfd, 0x32, 0x2a, 0x69, 0x3f, + 0xce, 0x1b, 0xe9, 0x89, 0x72, 0xe5, 0x58, 0x03, 0xb0, 0x1a, 0xf2, 0x33, + 0xb2, 0xc3, 0x41, 0x81, 0x8f, 0x0b, 0xb8, 0xa6, 0x09, 0x82, 0x52, 0x5d, + 0xa0, 0x60, 0x34, 0x0f, 0x75, 0xab, 0x8a, 0x08, 0x9b, 0xbc, 0x37, 0xc7, + 0x46, 0x9b, 0x67, 0xaa, 0x75, 0xf3, 0xb5, 0x31, 0xf6, 0x55, 0x98, 0x1b, + 0xfe, 0x44, 0x3c, 0xc3, 0x33, 0x77, 0x28, 0xe8, 0xe7, 0x6a, 0x44, 0x78, + 0x18, 0x67, 0x29, 0xaa, 0xa3, 0x73, 0xc5, 0x4c, 0xed, 0xe2, 0x10, 0xcb, + 0x0c, 0x36, 0x8b, 0x55, 0x2c, 0xad, 0xf8, 0xdc, 0x55, 0xcc, 0x35, 0xea, + 0x6c, 0x47, 0xf8, 0x3b, 0x2a, 0x25, 0x83, 0x48, 0xcb, 0xd0, 0xcc, 0xba, + 0x65, 0xc8, 0x92, 0x16, 0xc5, 0xa0, 0x04, 0x95, 0x30, 0x20, 0xdb, 0x0f, + 0xf5, 0x01, 0x57, 0x36, 0x7b, 0x70, 0x27, 0xf0, 0x2c, 0x1e, 0x6c, 0xab, + 0xa6, 0xa5, 0xb9, 0x84, 0x9b, 0x99, 0x31, 0xef, 0x9a, 0xa1, 0xd6, 0x83, + 0xaf, 0x83, 0x93, 0xb2, 0xa4, 0x2f, 0x30, 0xe1, 0xdc, 0xb4, 0x88, 0xb6, + 0x36, 0xaa, 0x04, 0x2b, 0x9b, 0x4d, 0xb6, 0xff, 0xe6, 0x80, 0xca, 0xa9, + 0x3e, 0x2f, 0xea, 0xf3, 0x17, 0xd5, 0x1d, 0x64, 0x98, 0x9e, 0xef, 0xe8, + 0xf7, 0x0c, 0xbe, 0xf8, 0xa6, 0x60, 0x8e, 0x8e, 0x68, 0x1b, 0x8e, 0x0d, + 0xed, 0xa4, 0x29, 0x4e, 0x82, 0x49, 0x27, 0x0e, 0xa0, 0xa5, 0x6a, 0x20, + 0x8d, 0xbc, 0xb9, 0xca, 0xec, 0x95, 0xf2, 0xf7, 0x09, 0x85, 0x42, 0x54, + 0xcc, 0x5a, 0xf6, 0x51, 0xb1, 0xa7, 0x95, 0x4d, 0x41, 0x79, 0xc9, 0xf0, + 0x07, 0x9c, 0x73, 0x68, 0xb1, 0xb7, 0x0a, 0x4e, 0xea, 0x03, 0x8a, 0x58, + 0x0f, 0x25, 0xcc, 0x73, 0x44, 0x1b, 0x9a, 0x03, 0xe8, 0x0c, 0x89, 0xfc, + 0x0f, 0x2a, 0xc8, 0x6e, 0xf8, 0xe4, 0x16, 0x2e, 0x43, 0x4f, 0x86, 0xf2, + 0x85, 0x0a, 0xbf, 0xb1, 0xe0, 0x00, 0x83, 0x1c, 0xf2, 0xb5, 0x3f, 0xad, + 0x01, 0xbb, 0x4f, 0x3c, 0xba, 0x46, 0xc0, 0x9e, 0xc3, 0xb6, 0x92, 0x79, + 0x0c, 0x97, 0xf4, 0x2d, 0x93, 0x10, 0xd4, 0xf8, 0x34, 0xf6, 0xcd, 0x3a, + 0xbd, 0x33, 0xb4, 0x08, 0xc3, 0xb3, 0x34, 0x76, 0x60, 0x96, 0xfe, 0x91, + 0xec, 0xe4, 0x33, 0xc6, 0x24, 0xd5, 0x15, 0xab, 0x25, 0xbb, 0x90, 0x68, + 0x74, 0xc8, 0xcd, 0xfc, 0x7a, 0x9b, 0x3b, 0x31, 0x07, 0x1d, 0x12, 0x98, + 0x43, 0x3a, 0x28, 0x93, 0x3a, 0x10, 0x33, 0x52, 0x15, 0x73, 0x76, 0x0a, + 0xa1, 0x54, 0x92, 0xa6, 0xf4, 0x9c, 0xf5, 0x11, 0x36, 0x1d, 0x1f, 0x65, + 0x30, 0x38, 0x35, 0x99, 0x1d, 0x3d, 0x54, 0x09, 0xa8, 0x92, 0x83, 0x66, + 0xbf, 0x49, 0x81, 0xf2, 0xd4, 0xf5, 0x5f, 0x6a, 0xf3, 0x8f, 0xde, 0x38, + 0xdc, 0x36, 0x8e, 0x57, 0x9e, 0x68, 0x9c, 0x40, 0x74, 0xf4, 0xf5, 0x14, + 0x8a, 0x68, 0x24, 0xf4, 0x14, 0x87, 0x58, 0x26, 0xd5, 0xbc, 0x37, 0xee, + 0xdc, 0xb4, 0x53, 0x38, 0xbe, 0x41, 0xda, 0x02, 0x15, 0xc8, 0x62, 0xd8, + 0x94, 0xf7, 0x15, 0x95, 0x18, 0xf5, 0x8e, 0x19, 0xf5, 0x00, 0x4b, 0xe3, + 0xc6, 0xf7, 0x27, 0x24, 0x53, 0x8e, 0x8f, 0x7d, 0xd3, 0xd2, 0x59, 0x8e, + 0xf6, 0x7b, 0x81, 0x8e, 0xcd, 0xc6, 0x45, 0x82, 0x4c, 0x2c, 0x63, 0x24, + 0xb7, 0x8d, 0xd6, 0x80, 0xa5, 0x93, 0xf8, 0x8a, 0x24, 0x59, 0x64, 0x58, + 0xf6, 0xfe, 0x50, 0x4e, 0x2f, 0x59, 0x80, 0x1e, 0xe5, 0x47, 0xec, 0x31, + 0xcb, 0x10, 0x29, 0x0f, 0xdc, 0x25, 0xc1, 0x11, 0xde, 0xdc, 0x9d, 0x41, + 0x01, 0xdc, 0x93, 0x38, 0x20, 0xcb, 0x42, 0xa7, 0xbb, 0x1a, 0x5f, 0x62, + 0x2e, 0x6d, 0x07, 0x30, 0xeb, 0xb4, 0x40, 0x37, 0x06, 0x21, 0x8f, 0x81, + 0x1c, 0x3a, 0xea, 0x25, 0xe3, 0xa6, 0xe6, 0x95, 0x50, 0x04, 0x18, 0x0f, + 0x7f, 0x29, 0xa9, 0x0b, 0x4f, 0xba, 0x95, 0xfd, 0xf7, 0xd3, 0x67, 0x2c, + 0x92, 0xc6, 0xcd, 0x57, 0xcf, 0xec, 0x7a, 0x9e, 0xc3, 0x34, 0xc6, 0x33, + 0xe9, 0x40, 0x54, 0x3f, 0xf7, 0x61, 0xab, 0x10, 0x24, 0xa6, 0x7f, 0x97, + 0x3f, 0x98, 0x65, 0x27, 0x2d, 0x6f, 0x14, 0xf0, 0x4d, 0x03, 0x92, 0x2c, + 0xe6, 0xb6, 0x36, 0x77, 0x37, 0xfa, 0x47, 0x11, 0x3b, 0xd2, 0xa5, 0x2e, + 0x34, 0x98, 0xfa, 0x71, 0x1c, 0x91, 0x20, 0x17, 0xb3, 0x0f, 0xec, 0xb0, + 0xbc, 0x07, 0x64, 0xdb, 0x88, 0x4d, 0x68, 0xd7, 0x91, 0xae, 0xd1, 0xd3, + 0xf1, 0xe4, 0xcd, 0xc4, 0xe2, 0xc7, 0xb5, 0x06, 0x9a, 0xb3, 0xe6, 0x0a, + 0xf2, 0x09, 0x5c, 0xff, 0x8b, 0x5b, 0x38, 0xa0, 0x54, 0xfe, 0x34, 0xcc, + 0xc0, 0x54, 0xeb, 0x42, 0x41, 0x84, 0xdc, 0x26, 0x28, 0xed, 0xea, 0xc0, + 0xdb, 0x05, 0x40, 0xf4, 0x9c, 0x5e, 0x39, 0x16, 0xa5, 0x59, 0x8a, 0x90, + 0x13, 0x71, 0x03, 0xbb, 0xec, 0x30, 0x96, 0x5b, 0xd4, 0x73, 0xf3, 0x98, + 0x1e, 0xbf, 0x78, 0xbd, 0x6a, 0x18, 0x69, 0x1a, 0x3e, 0xf8, 0x6e, 0x15, + 0x96, 0x33, 0x85, 0x4d, 0xe5, 0x39, 0xaa, 0x61, 0x03, 0xb8, 0xf9, 0x7d, + 0xe2, 0xcf, 0x1f, 0xe1, 0xb2, 0x54, 0x8e, 0xb8, 0x9b, 0x61, 0x0b, 0x04, + 0x25, 0xc9, 0xf7, 0x66, 0xb2, 0x88, 0xe7, 0xf1, 0xb1, 0x92, 0xb3, 0x6a, + 0x76, 0x33, 0x4d, 0x88, 0xa3, 0xad, 0xce, 0x71, 0x69, 0x9a, 0x8e, 0xe2, + 0x18, 0x50, 0x77, 0x21, 0x8e, 0xc0, 0x67, 0x40, 0x11, 0x9b, 0x9a, 0x6e, + 0x26, 0xcd, 0x68, 0x82, 0x14, 0x3f, 0xd2, 0x0e, 0x3c, 0x48, 0x61, 0x84, + 0xb9, 0xa7, 0x76, 0x29, 0x3d, 0x42, 0xc1, 0xee, 0x41, 0x9b, 0x6f, 0x92, + 0x00, 0xec, 0x23, 0x10, 0x6e, 0x39, 0xcc, 0xc4, 0x24, 0x05, 0x32, 0x61, + 0xa6, 0x99, 0xac, 0x95, 0x3b, 0xe6, 0xac, 0x8c, 0xe8, 0xd4, 0xa4, 0x9a, + 0x54, 0xf4, 0x54, 0x8d, 0x46, 0x36, 0x4c, 0xb2, 0x26, 0x10, 0xff, 0x3f, + 0x6c, 0x80, 0xeb, 0x99, 0x91, 0x33, 0x81, 0x51, 0x48, 0x9b, 0xe8, 0xe5, + 0xa0, 0x7f, 0x56, 0xf2, 0xd6, 0x59, 0x43, 0xe2, 0x85, 0xb6, 0x05, 0x65, + 0x7e, 0x56, 0x0a, 0x53, 0x20, 0x40, 0x92, 0x2d, 0x59, 0x3e, 0xa9, 0x33, + 0x81, 0xc8, 0xc8, 0x9a, 0x58, 0x90, 0x58, 0x9f, 0xca, 0xe7, 0x51, 0x4c, + 0x65, 0x87, 0xab, 0xc0, 0x7e, 0xf9, 0x9e, 0xf6, 0xf9, 0x86, 0xac, 0xcd, + 0xd8, 0xd1, 0x46, 0x9b, 0xb6, 0x4a, 0x15, 0xe7, 0xc7, 0xbc, 0x69, 0x0f, + 0xdf, 0xdc, 0xfd, 0x2e, 0x76, 0x56, 0xda, 0x92, 0xfa, 0x3e, 0x30, 0xe9, + 0xb5, 0x59, 0x4b, 0xd2, 0xc5, 0x4a, 0xab, 0xc0, 0x05, 0x16, 0xf1, 0x15, + 0xd5, 0xa2, 0xfc, 0x3d, 0xcc, 0x45, 0x13, 0x15, 0x06, 0x53, 0x78, 0xf8, + 0xff, 0x63, 0xfd, 0x4d, 0x61, 0x37, 0x5d, 0x2d, 0xf2, 0x7e, 0x6b, 0xe0, + 0x17, 0x21, 0x84, 0xc0, 0x4c, 0x06, 0xe8, 0x23, 0x12, 0xa5, 0x32, 0xfd, + 0xb5, 0x43, 0x00, 0x61, 0x9e, 0xba, 0xe3, 0xff, 0x29, 0x6f, 0x86, 0x0f, + 0xe3, 0x83, 0xcb, 0x3d, 0x55, 0x53, 0x18, 0xa1, 0x15, 0x63, 0x42, 0xf9, + 0xf2, 0x96, 0xc9, 0x74, 0xbd, 0x25, 0xcc, 0x66, 0x83, 0x31, 0x24, 0xd7, + 0x6e, 0xa7, 0x83, 0x7c, 0x0e, 0x06, 0x45, 0x5f, 0x20, 0x34, 0x83, 0xa9, + 0xa0, 0xf7, 0x82, 0x69, 0x77, 0xa2, 0x3d, 0x1d, 0xd2, 0x36, 0xa2, 0xe6, + 0xec, 0xf2, 0x6b, 0x03, 0x9e, 0xba, 0xb6, 0x55, 0xed, 0xe1, 0x4b, 0xb1, + 0xca, 0xf7, 0x71, 0x0f, 0x63, 0xe9, 0x6d, 0xa9, 0x5a, 0xc5, 0x02, 0xfc, + 0x14, 0xb8, 0x42, 0xa2, 0x5a, 0x9e, 0xe2, 0x23, 0x5c, 0xa5, 0x8c, 0xd4, + 0xff, 0x07, 0x7a, 0xb8, 0xab, 0x99, 0x60, 0x79, 0x8e, 0x49, 0xef, 0x15, + 0x1e, 0x24, 0x18, 0x34, 0xd7, 0x2d, 0x2e, 0x68, 0xc2, 0x3a, 0xa5, 0x68, + 0x21, 0xc0, 0x0d, 0xa6, 0x0f, 0x55, 0xa9, 0xfd, 0xf3, 0xe5, 0x58, 0x24, + 0x18, 0x17, 0x93, 0x3b, 0xa5, 0x10, 0xe0, 0x1a, 0x4b, 0x13, 0x6d, 0x09, + 0x01, 0x36, 0xcb, 0x0b, 0xc2, 0x7b, 0xe0, 0x06, 0x73, 0x55, 0x70, 0x2e, + 0x99, 0xdd, 0x4c, 0x08, 0xf0, 0x6e, 0xfd, 0xa5, 0x9d, 0x1d, 0xc7, 0xe5, + 0x80, 0x68, 0x69, 0x7c, 0x03, 0xd0, 0x56, 0x51, 0x62, 0xe9, 0x78, 0x5f, + 0x61, 0xd5, 0xa6, 0x8e, 0x1a, 0x5e, 0x7e, 0x97, 0xbe, 0x52, 0x0f, 0xe4, + 0x3c, 0x96, 0x73, 0x1a, 0xb3, 0x5a, 0x2e, 0xba, 0x6f, 0xcd, 0xa8, 0x26, + 0x41, 0xe2, 0x90, 0x04, 0x9d, 0xe2, 0x64, 0xc5, 0x9c, 0x20, 0xf1, 0xaf, + 0xa7, 0xad, 0x65, 0x5d, 0xeb, 0xfa, 0x79, 0xb7, 0xba, 0xa8, 0xbc, 0x18, + 0xc8, 0xd4, 0xb4, 0x5a, 0xab, 0x4a, 0x9a, 0x58, 0x67, 0x11, 0x17, 0xdd, + 0x3d, 0xf8, 0x45, 0xda, 0x42, 0x99, 0x87, 0xd4, 0x33, 0x7d, 0x36, 0x2b, + 0xd0, 0x2e, 0x90, 0x5e, 0x35, 0x04, 0xdb, 0xc4, 0x2b, 0x25, 0xed, 0xa9, + 0x8d, 0xac, 0xce, 0x32, 0xb2, 0x5c, 0x6e, 0xa5, 0xfa, 0x95, 0xa7, 0xd8, + 0xc5, 0xc9, 0xb0, 0x62, 0x8f, 0x30, 0xd4, 0x6a, 0xfc, 0x28, 0xc9, 0x1c, + 0x46, 0x2e, 0x9b, 0xa3, 0xcd, 0xae, 0x45, 0xee, 0xf7, 0x37, 0x32, 0x8a, + 0x8d, 0x4b, 0x5d, 0x6a, 0x8e, 0xbe, 0xb9, 0x89, 0xfb, 0x56, 0xca, 0x2a, + 0x59, 0x58, 0x57, 0x59, 0x8c, 0x8d, 0x38, 0xea, 0xea, 0x63, 0x0e, 0x44, + 0x62, 0x21, 0xdf, 0x64, 0x0d, 0xa7, 0x4f, 0xd6, 0x4c, 0xb1, 0x62, 0xce, + 0x3f, 0x33, 0x23, 0xfa, 0x5d, 0x4c, 0xa0, 0x5e, 0x79, 0x7b, 0xd5, 0x8d, + 0x8e, 0x4d, 0xcc, 0x62, 0x51, 0x4e, 0xd4, 0xc5, 0x9e, 0xb8, 0xff, 0x56, + 0xa2, 0x62, 0xc6, 0x30, 0x1d, 0x42, 0xd0, 0xa4, 0x8b, 0xb1, 0x86, 0xe1, + 0x92, 0xd7, 0xc3, 0xc0, 0xe8, 0xe0, 0x92, 0x70, 0xc6, 0xd7, 0x35, 0x1d, + 0x03, 0x53, 0x66, 0xcb, 0xb1, 0x82, 0xef, 0x39, 0xee, 0x79, 0xcb, 0x71, + 0xf2, 0x0b, 0x88, 0xb3, 0xf7, 0xce, 0x4f, 0x43, 0x7d, 0x07, 0x3c, 0x13, + 0x9c, 0xb0, 0x6b, 0xda, 0xcd, 0x49, 0xfb, 0x77, 0xef, 0x97, 0x43, 0x3a, + 0x64, 0x2b, 0xaa, 0xbb, 0xb3, 0x53, 0x10, 0x05, 0x02, 0x16, 0xdf, 0x31, + 0x79, 0xed, 0xd1, 0x2e, 0xe4, 0x20, 0xc2, 0xc5, 0x9e, 0xab, 0xa5, 0xab, + 0xf8, 0xe3, 0x92, 0x2e, 0xd6, 0x35, 0x1b, 0x91, 0xc9, 0x3d, 0x8c, 0xa5, + 0x65, 0x27, 0xe7, 0x22, 0x87, 0xd8, 0xde, 0x9c, 0x25, 0x7a, 0xc7, 0xdc, + 0xa2, 0x9a, 0x82, 0x33, 0xfa, 0xc6, 0x5f, 0x8d, 0x8a, 0x41, 0xe8, 0x1d, + 0x01, 0x7c, 0xf3, 0xf0, 0x76, 0xca, 0xbd, 0x3f, 0x1f, 0xde, 0x49, 0xd3, + 0xd7, 0xc2, 0x2f, 0x38, 0x15, 0x41, 0xda, 0x7f, 0x31, 0x80, 0xce, 0x32, + 0xfd, 0x6e, 0x54, 0x7e, 0x8f, 0xe0, 0xd7, 0x7f, 0x3f, 0x46, 0xa0, 0x99, + 0xa1, 0x7c, 0xac, 0xb6, 0xa3, 0x4b, 0x21, 0x53, 0x13, 0xd1, 0x7f, 0xf5, + 0xf5, 0x70, 0xd0, 0x17, 0xbb, 0x02, 0x82, 0xc5, 0x7b, 0x67, 0x25, 0xfb, + 0xc5, 0x93, 0x6d, 0xf8, 0x93, 0xf1, 0x6e, 0xbb, 0x3c, 0x90, 0x5d, 0xbc, + 0x9e, 0x88, 0xca, 0xd4, 0x75, 0x3b, 0x51, 0xea, 0xa2, 0xc1, 0x93, 0x30, + 0xf2, 0x3e, 0xed, 0xe7, 0xd2, 0x39, 0x86, 0x33, 0x3c, 0x30, 0x08, 0x32, + 0xd3, 0x60, 0xc4, 0xc4, 0x4b, 0x89, 0xfc, 0xf2, 0x05, 0x46, 0x27, 0xbd, + 0x04, 0xd9, 0x82, 0xc9, 0x42, 0x09, 0xfe, 0x3d, 0xf0, 0x44, 0xfa, 0x42, + 0x0b, 0xca, 0x17, 0xe9, 0x22, 0x90, 0xf2, 0x58, 0xf3, 0x75, 0x8a, 0x5c, + 0x3c, 0x18, 0x5d, 0xc9, 0x2c, 0x14, 0xbc, 0xa2, 0x0a, 0x5c, 0xab, 0x4f, + 0x26, 0x92, 0xd2, 0xc2, 0x87, 0x02, 0x6c, 0x62, 0x19, 0x1a, 0x6c, 0x91, + 0x71, 0x37, 0x3d, 0xd6, 0x34, 0x88, 0x6f, 0x68, 0xce, 0x88, 0x7f, 0x2f, + 0xa9, 0x6e, 0xa5, 0xcb, 0x97, 0xaa, 0xf4, 0x8e, 0x3e, 0x4e, 0x43, 0x65, + 0x81, 0x1e, 0x4e, 0x50, 0x41, 0x6c, 0x85, 0x3c, 0x97, 0x0f, 0xc5, 0xf2, + 0xbc, 0x11, 0x3e, 0x08, 0x7f, 0x3b, 0xb5, 0xbc, 0xa8, 0xf8, 0xbd, 0x0b, + 0x45, 0x26, 0xfe, 0x80, 0xde, 0x32, 0x6f, 0xe5, 0xc5, 0xbf, 0x17, 0x14, + 0x18, 0xc7, 0x11, 0xc8, 0x09, 0x08, 0x2a, 0x67, 0x1f, 0xd8, 0xd1, 0xcb, + 0x4f, 0x0d, 0xc3, 0x00, 0x41, 0x4e, 0xab, 0xd0, 0xf3, 0x82, 0x88, 0x15, + 0x9a, 0x75, 0xad, 0xbd, 0x92, 0x8f, 0x56, 0xe8, 0x7a, 0xb8, 0xb0, 0x4d, + 0x8a, 0xe9, 0xe1, 0x6e, 0x3f, 0xf0, 0xd3, 0x63, 0xb6, 0xc7, 0x25, 0x17, + 0xca, 0xfa, 0xc4, 0xc6, 0x17, 0xa5, 0x3b, 0xb9, 0x13, 0xe5, 0xf3, 0x6f, + 0xfc, 0x03, 0xaa, 0x3f, 0x81, 0x0f, 0x6b, 0x9c, 0x48, 0x5d, 0x26, 0x1c, + 0x48, 0x97, 0x17, 0xa7, 0x3b, 0xed, 0xec, 0xad, 0x58, 0x67, 0x34, 0x36, + 0xd1, 0x1e, 0x0d, 0x8b, 0xed, 0x61, 0xa4, 0x72, 0x54, 0x0a, 0x71, 0x2c, + 0xfd, 0x33, 0xf7, 0xd6, 0x92, 0xd1, 0x44, 0x7c, 0x03, 0x22, 0x68, 0xf8, + 0x85, 0x6f, 0x75, 0x55, 0x5f, 0xb3, 0x78, 0xa1, 0x11, 0xe9, 0xb7, 0x25, + 0x0e, 0xae, 0x9d, 0x61, 0x36, 0x21, 0x47, 0x8a, 0x3b, 0x61, 0xa7, 0xc4, + 0xe7, 0x4c, 0x30, 0x7d, 0x34, 0xe4, 0xc3, 0xdc, 0x8f, 0xc2, 0x1d, 0xb5, + 0x88, 0x33, 0xf0, 0x2a, 0xd2, 0x55, 0x29, 0x6f, 0x7e, 0xed, 0x6b, 0x78, + 0x97, 0x2a, 0x8f, 0xcf, 0x6a, 0x1a, 0x03, 0xd9, 0xfa, 0xf0, 0x11, 0x15, + 0xaf, 0x5e, 0xb9, 0xde, 0x75, 0xca, 0x14, 0x17, 0x9c, 0x03, 0x73, 0xd2, + 0x33, 0xe7, 0xf5, 0xa5, 0x2f, 0xef, 0x2d, 0x4d, 0x15, 0xdc, 0xa5, 0x4f, + 0x18, 0x4f, 0xf7, 0xce, 0xa9, 0x6a, 0x5c, 0x92, 0x6f, 0x39, 0x7f, 0x86, + 0xd3, 0x38, 0x01, 0xe5, 0xfe, 0xe9, 0x1a, 0x9e, 0x4e, 0xba, 0xe1, 0x31, + 0x88, 0x61, 0x13, 0x08, 0x29, 0x0a, 0xd7, 0xa0, 0x89, 0xd5, 0x3e, 0x4d, + 0x1d, 0xd0, 0x6d, 0xd1, 0x7b, 0x61, 0x0f, 0x01, 0xa1, 0x59, 0xe4, 0x98, + 0x32, 0xc2, 0x0c, 0x70, 0xe5, 0x67, 0xaa, 0x0b, 0xa4, 0x3f, 0x50, 0xe3, + 0x27, 0x50, 0xf7, 0x0d, 0x2a, 0x42, 0x2e, 0xcf, 0x13, 0xf7, 0x8b, 0x4e, + 0xa9, 0x4e, 0x27, 0xac, 0x5c, 0xbe, 0x47, 0x96, 0x49, 0xd5, 0xe8, 0x29, + 0x6a, 0x73, 0xff, 0xb3, 0x33, 0x8c, 0x3f, 0xba, 0xb3, 0x42, 0x91, 0x14, + 0x25, 0x93, 0x56, 0xb7, 0x80, 0xc6, 0x29, 0xd3, 0xfe, 0xfa, 0xc1, 0x78, + 0x80, 0x12, 0xf0, 0x06, 0x52, 0x44, 0xa4, 0x39, 0xfb, 0xeb, 0xf5, 0xc0, + 0x40, 0x4a, 0x80, 0x19, 0xc1, 0xdf, 0xed, 0x39, 0x09, 0x21, 0x5a, 0xd3, + 0x0f, 0x5a, 0x99, 0x34, 0x50, 0xe4, 0xa2, 0x76, 0x2a, 0x90, 0x83, 0xf5, + 0x9f, 0x35, 0x89, 0x00, 0x4e, 0x6a, 0x4b, 0x48, 0x74, 0x69, 0x27, 0xb8, + 0x7b, 0xe8, 0xd9, 0x65, 0x4a, 0x6d, 0x50, 0xe5, 0xb3, 0x82, 0x38, 0x96, + 0x82, 0x82, 0xca, 0xd4, 0x63, 0x7f, 0xac, 0x02, 0xc6, 0x83, 0xc2, 0x40, + 0x2a, 0x0d, 0xf9, 0xad, 0xb7, 0x17, 0x2b, 0xa6, 0x7b, 0xee, 0x80, 0x10, + 0x24, 0x4f, 0x7d, 0x86, 0xc5, 0x51, 0xdc, 0xc3, 0xb7, 0x5f, 0x33, 0xc9, + 0xe1, 0x6f, 0x95, 0x03, 0xb8, 0x84, 0xe8, 0x8d, 0xd0, 0x38, 0x9c, 0x0b, + 0xc1, 0xa3, 0x90, 0x32, 0xf0, 0x58, 0x0c, 0x51, 0xe0, 0xd8, 0x77, 0x6b, + 0x2e, 0x28, 0x10, 0xdf, 0x76, 0x38, 0x21, 0xd7, 0x81, 0x62, 0xcd, 0xdf, + 0x50, 0x19, 0xeb, 0x89, 0x6c, 0xb0, 0xb9, 0xa5, 0xb4, 0xb7, 0xc4, 0x47, + 0x58, 0xf7, 0x36, 0x14, 0x60, 0x53, 0xf0, 0x79, 0xd7, 0x0b, 0x22, 0x1c, + 0x3c, 0x82, 0x9a, 0xf7, 0x09, 0xba, 0xf5, 0x9a, 0x84, 0x2d, 0x5d, 0x49, + 0x41, 0x94, 0x33, 0xed, 0x39, 0x71, 0xd8, 0x6d, 0x43, 0xde, 0x0e, 0x10, + 0x0e, 0x2c, 0x79, 0x29, 0xe4, 0xfb, 0xa2, 0xd9, 0x3c, 0x71, 0x46, 0x1f, + 0x88, 0x02, 0xd3, 0x4a, 0x89, 0x8a, 0x4a, 0xba, 0x48, 0xf4, 0xfc, 0xb0, + 0x40, 0x6c, 0x27, 0x45, 0x6a, 0x7a, 0xc6, 0x67, 0xe0, 0xb3, 0x2b, 0x67, + 0xcd, 0x5f, 0xfe, 0x66, 0x62, 0x5f, 0x19, 0x9a, 0xaf, 0x95, 0x87, 0x2d, + 0xee, 0x17, 0xae, 0xd8, 0x5f, 0x32, 0x89, 0x67, 0xc1, 0xcb, 0xc2, 0xae, + 0xc6, 0x67, 0x22, 0xb3, 0x01, 0x49, 0x71, 0xd2, 0x59, 0x46, 0xd4, 0xa7, + 0xce, 0x2a, 0x27, 0xfa, 0x8e, 0xa5, 0x31, 0xbe, 0x3e, 0x02, 0x06, 0xaf, + 0x6a, 0x5f, 0x18, 0x00, 0xf5, 0xfd, 0x19, 0xba, 0x42, 0x94, 0x94, 0xd6, + 0xe4, 0xe7, 0x3f, 0x37, 0xca, 0x43, 0x9a, 0x4d, 0x67, 0x2f, 0x09, 0x01, + 0x00, 0x03, 0x83, 0x29, 0xb1, 0xde, 0xb0, 0xd9, 0x1c, 0x90, 0xd8, 0x9d, + 0xde, 0xca, 0x0e, 0x99, 0x7e, 0x74, 0x5a, 0x57, 0x08, 0xf7, 0x19, 0xa8, + 0xc6, 0x90, 0x22, 0xfb, 0x97, 0x36, 0xa7, 0xa6, 0x60, 0x17, 0x0f, 0x62, + 0x23, 0x75, 0xad, 0xbc, 0x0c, 0x49, 0x4d, 0x7b, 0x0b, 0xa6, 0x48, 0xde, + 0x02, 0xcf, 0x4c, 0x2e, 0xba, 0xb5, 0x10, 0xa6, 0xe4, 0xe2, 0xbc, 0x6b, + 0x95, 0x66, 0xd6, 0x67, 0x20, 0x6d, 0x7a, 0x47, 0x73, 0xd9, 0xa4, 0xc8, + 0x60, 0xdf, 0xf7, 0xc3, 0x8a, 0x6a, 0xec, 0x53, 0xcf, 0xb9, 0x13, 0x98, + 0xf7, 0x39, 0xd3, 0x09, 0xa6, 0xdb, 0x74, 0x0f, 0x11, 0x99, 0xaf, 0x20, + 0x82, 0xf1, 0xef, 0xae, 0x99, 0x49, 0xe4, 0x3e, 0xa2, 0x80, 0x19, 0xe2, + 0xac, 0x09, 0xe8, 0x5f, 0x2f, 0x8b, 0x15, 0xc3, 0x95, 0x62, 0xdc, 0x3b, + 0x22, 0x70, 0x93, 0xf7, 0xb3, 0x7c, 0xef, 0xf6, 0x08, 0xcf, 0xdf, 0x2f, + 0x02, 0xa4, 0x49, 0xe5, 0x18, 0x22, 0x0f, 0x94, 0x53, 0x66, 0xf0, 0xcb, + 0x24, 0x41, 0x0e, 0xed, 0xd2, 0x7f, 0xd9, 0x33, 0x75, 0x92, 0x1d, 0x94, + 0x81, 0x7d, 0x7b, 0x07, 0x53, 0x63, 0x3d, 0xdd, 0x1f, 0xd8, 0xaa, 0x2e, + 0xb4, 0x8a, 0x3d, 0x7a, 0x8f, 0xe2, 0x2b, 0xab, 0xb6, 0x47, 0xed, 0xe3, + 0xe1, 0x27, 0x70, 0x32, 0xf4, 0xc0, 0xb7, 0x14, 0x26, 0x3e, 0x9d, 0xec, + 0xc9, 0x8e, 0x6c, 0xfe, 0x67, 0x28, 0xc2, 0xde, 0xdc, 0x99, 0x41, 0x06, + 0xe7, 0x71, 0xa7, 0x2e, 0xf5, 0xf5, 0x32, 0x8b, 0xc5, 0x2d, 0x19, 0xea, + 0x18, 0xe3, 0xf8, 0x24, 0x98, 0x2e, 0x5a, 0x31, 0xe1, 0xe4, 0x5d, 0x56, + 0x7c, 0x98, 0x25, 0x43, 0x8f, 0xe1, 0xf8, 0x99, 0x13, 0x91, 0x6c, 0x9a, + 0xc6, 0xe1, 0x87, 0x87, 0x32, 0xde, 0x5b, 0x67, 0xf2, 0x1c, 0x44, 0x80, + 0x37, 0x2a, 0xd3, 0x6a, 0x55, 0x3f, 0x93, 0x7f, 0xd3, 0x6d, 0x3e, 0x80, + 0x66, 0xfa, 0x4a, 0x21, 0x73, 0x5a, 0xd8, 0x9a, 0xcb, 0x12, 0x8f, 0xb0, + 0x4a, 0x7f, 0x8c, 0x35, 0xed, 0xeb, 0xde, 0x87, 0x63, 0x31, 0xf4, 0x10, + 0x0c, 0xd4, 0xc8, 0xa7, 0x4e, 0x6d, 0xe3, 0x5d, 0x0c, 0x05, 0x48, 0x3c, + 0x62, 0x49, 0xfb, 0x7c, 0x87, 0x22, 0x41, 0x23, 0x59, 0x10, 0x9e, 0xd0, + 0x87, 0xd5, 0xde, 0xe6, 0x42, 0xba, 0x08, 0xe8, 0x93, 0xc6, 0x7e, 0x57, + 0x27, 0xea, 0x13, 0x3a, 0xdf, 0xbb, 0xa6, 0xae, 0x12, 0x58, 0x85, 0xdb, + 0x7c, 0x0b, 0x57, 0x52, 0xe6, 0xbf, 0x1b, 0xe0, 0x07, 0x80, 0x53, 0x7c, + 0xc8, 0x82, 0x94, 0xe4, 0x66, 0xdb, 0xcf, 0x6b, 0x8e, 0xdf, 0x41, 0x3b, + 0xcb, 0xab, 0x46, 0xa5, 0x41, 0x96, 0x0e, 0xf1, 0x65, 0xdd, 0x01, 0x9a, + 0xb3, 0x88, 0x32, 0xbb, 0xed, 0x5f, 0xbe, 0x4e, 0x66, 0x58, 0x9c, 0xb2, + 0xc9, 0x9d, 0x57, 0x40, 0xef, 0xdf, 0x13, 0xda, 0x14, 0x7a, 0x64, 0xeb, + 0x82, 0x81, 0x60, 0x32, 0x31, 0x06, 0x8e, 0xf6, 0x26, 0x63, 0xec, 0x16, + 0xf1, 0x6b, 0x8c, 0xd5, 0x9b, 0x4e, 0x91, 0xa1, 0xea, 0xc9, 0xe4, 0x77, + 0x79, 0xb1, 0x71, 0x22, 0xdc, 0xe3, 0x51, 0x1b, 0x3a, 0x20, 0x01, 0x1d, + 0xf9, 0x4d, 0xc7, 0x81, 0x99, 0xd4, 0xf8, 0x68, 0x7d, 0xd8, 0xaf, 0x51, + 0xc3, 0x39, 0x62, 0x5e, 0x94, 0xf3, 0x75, 0xe7, 0x02, 0x66, 0xb8, 0xa6, + 0x5a, 0x41, 0x14, 0xeb, 0x28, 0xcb, 0xda, 0x59, 0xdd, 0xf2, 0xb2, 0x1e, + 0xe9, 0x70, 0xa8, 0xbd, 0x7c, 0xe4, 0x73, 0x5a, 0xc6, 0x11, 0xd8, 0x78, + 0x59, 0xd1, 0xe8, 0x5a, 0x8d, 0x5f, 0x37, 0xe4, 0xe3, 0x17, 0xe9, 0x37, + 0xf6, 0xc4, 0x9f, 0x87, 0xe0, 0x81, 0x4c, 0xf5, 0x82, 0x7e, 0x30, 0xf6, + 0x15, 0x79, 0x32, 0x4a, 0xdb, 0xa5, 0x56, 0x01, 0xf6, 0x29, 0x38, 0x60, + 0xd8, 0x4b, 0x10, 0xf4, 0x14, 0xee, 0xa5, 0x9f, 0xda, 0xf6, 0x1d, 0x5a, + 0x9b, 0xa2, 0xe2, 0x96, 0xb9, 0x20, 0x06, 0x93, 0x6b, 0x2b, 0xdb, 0x9a, + 0x80, 0xe1, 0x51, 0x77, 0x80, 0xd0, 0x32, 0x44, 0x17, 0xf5, 0x3d, 0xa1, + 0x64, 0xcf, 0xb6, 0x98, 0xb5, 0x40, 0x0c, 0x60, 0x90, 0xa4, 0x4f, 0x0e, + 0xcc, 0x92, 0xe7, 0x46, 0xf6, 0x7a, 0x3e, 0xf9, 0x97, 0x1c, 0x05, 0x33, + 0xaf, 0xfb, 0x18, 0x0c, 0xdb, 0x44, 0x00, 0x82, 0x25, 0x33, 0x93, 0x7a, + 0xab, 0x56, 0xc7, 0xc4, 0x44, 0x0c, 0x9b, 0xed, 0x3c, 0xdd, 0xe3, 0xdd, + 0x03, 0xd8, 0xc0, 0x83, 0x86, 0x7e, 0x91, 0xd8, 0xa1, 0x0b, 0x18, 0x72, + 0x9e, 0xfa, 0xec, 0x3d, 0x9b, 0xb4, 0xba, 0x21, 0xc1, 0xef, 0x23, 0xb1, + 0xab, 0x3d, 0xa5, 0x09, 0x0f, 0x6f, 0xb1, 0x21, 0xfa, 0x5b, 0xb5, 0x1c, + 0x41, 0x92, 0xba, 0x2a, 0x58, 0x6e, 0x36, 0xe1, 0x09, 0x16, 0x57, 0xbe, + 0x1f, 0x3c, 0xb0, 0xaa, 0x77, 0x39, 0x52, 0x98, 0x21, 0x90, 0x91, 0xac, + 0xa6, 0x02, 0x67, 0x83, 0x3f, 0x77, 0x48, 0x21, 0xbd, 0xd0, 0x5a, 0x7d, + 0x26, 0x16, 0x59, 0x1b, 0x7e, 0x65, 0xd2, 0x79, 0x66, 0xe5, 0xbf, 0xb7, + 0x1a, 0x72, 0x34, 0x3c, 0x22, 0xca, 0xe8, 0x87, 0xe5, 0xa8, 0x1c, 0x96, + 0xfc, 0x1b, 0x19, 0x58, 0xf4, 0x9d, 0xb6, 0x10, 0x15, 0x00, 0xf6, 0x2f, + 0x7d, 0x20, 0xc7, 0xd4, 0x74, 0x4a, 0x44, 0x9d, 0x92, 0x44, 0x06, 0x79, + 0x31, 0xc0, 0xd4, 0x9f, 0x68, 0xb3, 0xc6, 0x17, 0x70, 0x64, 0x91, 0x8c, + 0x98, 0x35, 0xae, 0x07, 0x19, 0x46, 0x50, 0xe6, 0xf5, 0xf1, 0x49, 0xfb, + 0x79, 0x9b, 0xc0, 0xb4, 0xe9, 0x9d, 0x71, 0x40, 0xdd, 0x3b, 0xe4, 0xf7, + 0x6d, 0xc1, 0x1c, 0x40, 0xa2, 0xba, 0xce, 0x9b, 0x79, 0x20, 0xe8, 0xcf, + 0x8d, 0x8c, 0xe8, 0xf3, 0x25, 0x20, 0x2f, 0xd5, 0x64, 0x5b, 0x60, 0x7d, + 0x96, 0x70, 0x4a, 0xe6, 0xea, 0x3a, 0xe1, 0x22, 0x4c, 0x03, 0x1b, 0xdd, + 0xf1, 0x7f, 0x57, 0x37, 0xc8, 0x36, 0x99, 0x35, 0xde, 0x36, 0x4c, 0x16, + 0xb9, 0x33, 0x44, 0xf5, 0x44, 0x75, 0x03, 0xfc, 0xa0, 0xae, 0x1f, 0xcc, + 0x6c, 0x7a, 0x0b, 0x15, 0x95, 0x66, 0x21, 0x17, 0x86, 0xfb, 0x60, 0xf4, + 0x22, 0x39, 0x97, 0x0b, 0x95, 0xa8, 0xa2, 0xa7, 0x0f, 0x11, 0xc3, 0xd6, + 0xed, 0xc1, 0x2a, 0xe9, 0x6b, 0x6c, 0xca, 0x88, 0x2b, 0xd7, 0x17, 0x63, + 0x2d, 0xc2, 0x1d, 0xaf, 0xfd, 0xf2, 0xf0, 0x10, 0x0c, 0xcd, 0xce, 0x21, + 0xc6, 0x93, 0xbb, 0x52, 0xf3, 0x83, 0xde, 0xf7, 0x45, 0x8d, 0xb6, 0x70, + 0xc3, 0xf2, 0xab, 0x8d, 0xfc, 0x8f, 0x13, 0xad, 0xbf, 0xd3, 0x95, 0x68, + 0x42, 0xe5, 0x2c, 0x24, 0x63, 0xe5, 0x54, 0xa5, 0x97, 0x67, 0x2f, 0xba, + 0xab, 0x84, 0xa9, 0xb4, 0x0d, 0xcb, 0xbb, 0xac, 0x8e, 0x62, 0x71, 0xff, + 0xf0, 0x32, 0x5e, 0x64, 0x42, 0x0f, 0x09, 0x66, 0x4b, 0x22, 0xb2, 0x8e, + 0xeb, 0x79, 0x1b, 0x7c, 0x4f, 0xab, 0x87, 0xd8, 0x8a, 0xb3, 0x6e, 0x99, + 0xc6, 0x99, 0x8b, 0x14, 0x04, 0x9c, 0x20, 0x32, 0x62, 0xec, 0x15, 0x14, + 0x1b, 0xbb, 0xfa, 0xf1, 0x54, 0x21, 0x4d, 0xe4, 0x2f, 0xbc, 0xf7, 0xfc, + 0x24, 0xda, 0x82, 0x1a, 0xc2, 0x95, 0xb7, 0xfb, 0x8e, 0xee, 0x70, 0x7c, + 0x33, 0x54, 0xb1, 0xa3, 0x08, 0x16, 0x81, 0x63, 0x99, 0x30, 0xec, 0x41, + 0xce, 0x40, 0x19, 0xac, 0xe4, 0xb2, 0x81, 0x21, 0x54, 0xd2, 0xb6, 0x6c, + 0x48, 0x43, 0x47, 0x11, 0x81, 0xc1, 0xd3, 0x37, 0xa1, 0xf8, 0x64, 0xbe, + 0x1b, 0x60, 0x48, 0xda, 0x42, 0x37, 0xc3, 0x1b, 0x85, 0xe1, 0x23, 0xff, + 0xb9, 0x99, 0x35, 0xe3, 0x65, 0x48, 0xe6, 0x28, 0x31, 0x53, 0xea, 0xd0, + 0x92, 0xbc, 0xf0, 0x59, 0xbe, 0x91, 0xce, 0x26, 0xac, 0x91, 0x9d, 0xb3, + 0x36, 0x94, 0x28, 0xff, 0x92, 0xeb, 0x54, 0x6c, 0x2e, 0x96, 0x53, 0x3c, + 0x38, 0x16, 0x22, 0x8a, 0x65, 0x9b, 0x25, 0x9e, 0xe6, 0x27, 0x01, 0x06, + 0x7b, 0xb2, 0x6a, 0x36, 0xc0, 0x1d, 0x38, 0xdc, 0x6e, 0x56, 0xe9, 0xe6, + 0xe5, 0xf5, 0x86, 0x77, 0x3a, 0x57, 0xd7, 0xb9, 0x08, 0xdd, 0x15, 0x1c, + 0xf2, 0xd8, 0x5c, 0xd9, 0xf2, 0x6e, 0x4e, 0x84, 0x08, 0x66, 0xe9, 0x47, + 0x16, 0xba, 0x70, 0x3c, 0x0e, 0x64, 0xf1, 0x42, 0xba, 0xbe, 0x12, 0x36, + 0xbd, 0xac, 0x04, 0xb3, 0xfb, 0xfa, 0x69, 0xe7, 0xd7, 0x67, 0xb3, 0xdd, + 0x83, 0x34, 0x27, 0x4a, 0xb8, 0xa0, 0x85, 0xbc, 0x9b, 0xb8, 0x3f, 0x61, + 0xb6, 0x7c, 0xf8, 0x57, 0x74, 0xf8, 0x70, 0x9b, 0x68, 0x7e, 0x8b, 0xc0, + 0x02, 0xac, 0xac, 0x49, 0xae, 0xd9, 0x13, 0xe2, 0x9e, 0x24, 0x56, 0x41, + 0x77, 0x23, 0xea, 0xc0, 0x47, 0xb9, 0x16, 0xfe, 0xbf, 0x17, 0xb8, 0xae, + 0x95, 0xe8, 0xe3, 0xcf, 0x33, 0xbd, 0x76, 0x4d, 0x08, 0x1e, 0xf6, 0xd9, + 0x3a, 0x26, 0xd9, 0x08, 0x02, 0x0f, 0x26, 0xc2, 0x3b, 0xe1, 0xa9, 0xd4, + 0x81, 0x20, 0x34, 0xdf, 0xd2, 0xd9, 0xd1, 0x1a, 0x11, 0x64, 0xa9, 0x85, + 0x52, 0x44, 0x3f, 0xbc, 0xf0, 0x35, 0x55, 0x95, 0x70, 0x4b, 0x3e, 0xa9, + 0xaa, 0x23, 0xac, 0x7a, 0x34, 0x6f, 0xcd, 0x52, 0x74, 0x81, 0xbb, 0x3b, + 0x7e, 0x6a, 0x70, 0xd0, 0x47, 0xa0, 0xb8, 0xe5, 0x22, 0x73, 0x98, 0xb5, + 0xd6, 0x26, 0x1b, 0x93, 0xa3, 0xd6, 0x33, 0x3b, 0x5d, 0x0d, 0xd6, 0x84, + 0x74, 0x82, 0x5c, 0x95, 0xbb, 0xdc, 0x7b, 0x78, 0xca, 0x5d, 0x11, 0x60, + 0x0a, 0xc7, 0x86, 0x39, 0x58, 0xf7, 0x37, 0x67, 0xc2, 0x96, 0x93, 0xd9, + 0xea, 0x07, 0x21, 0x68, 0x28, 0x08, 0x66, 0x22, 0xb4, 0xdd, 0x55, 0x73, + 0xde, 0xbc, 0x10, 0x81, 0x9b, 0xf1, 0x20, 0x61, 0x5e, 0xdd, 0x0c, 0x00, + 0x24, 0x34, 0x5d, 0x20, 0x76, 0xd2, 0xfa, 0x1e, 0x66, 0x5c, 0x8e, 0xdd, + 0x15, 0x12, 0x0b, 0xe0, 0x0b, 0x0c, 0xe9, 0x7b, 0x39, 0xe9, 0xbf, 0x22, + 0x7a, 0xf1, 0x99, 0x8a, 0x75, 0x24, 0xdf, 0x5a, 0xec, 0x47, 0x88, 0x35, + 0x92, 0xdf, 0x4d, 0x32, 0xe0, 0x13, 0x12, 0xd8, 0x65, 0x0b, 0xa5, 0x1f, + 0xc5, 0xa4, 0x51, 0x56, 0x2a, 0xe5, 0x51, 0x92, 0x28, 0xec, 0x7a, 0xbb, + 0x03, 0x6b, 0x0a, 0xac, 0x47, 0x11, 0x42, 0x37, 0xfa, 0xa0, 0xa2, 0x9a, + 0x97, 0xa4, 0xc3, 0x60, 0x67, 0x34, 0x17, 0x39, 0x7b, 0x32, 0x3e, 0x7a, + 0x29, 0x9d, 0xc0, 0xd3, 0x4d, 0xe0, 0x7b, 0x25, 0xc3, 0xf1, 0xe1, 0xfb, + 0xee, 0xf9, 0xbc, 0xe2, 0x42, 0x07, 0xe3, 0x90, 0x17, 0xc1, 0x9a, 0xc6, + 0x7c, 0x1c, 0x09, 0x29, 0xaa, 0xc7, 0xd9, 0x9d, 0x2f, 0x68, 0xc6, 0x89, + 0x6b, 0xfd, 0x1b, 0x04, 0x16, 0x39, 0x44, 0xa3, 0xba, 0x33, 0x29, 0xbe, + 0x34, 0x28, 0x03, 0x57, 0x81, 0x38, 0x22, 0xb7, 0x2f, 0x3d, 0xbf, 0x5c, + 0x03, 0x12, 0x28, 0x2d, 0x71, 0xd1, 0x4b, 0x01, 0xfd, 0x24, 0x21, 0x21, + 0x6c, 0x16, 0x34, 0xc7, 0x4c, 0xb1, 0x0e, 0x16, 0x32, 0x16, 0xcb, 0x87, + 0x5e, 0x50, 0x88, 0xb1, 0x9d, 0xab, 0x56, 0xff, 0x08, 0x83, 0xc7, 0x8f, + 0x14, 0x2a, 0xbd, 0xd1, 0x47, 0xc9, 0x36, 0x02, 0x63, 0xfd, 0x60, 0x6f, + 0x11, 0x47, 0x9f, 0x4b, 0x4d, 0xda, 0x31, 0x45, 0xdd, 0x7c, 0x75, 0xa9, + 0xa4, 0x05, 0xdf, 0xe5, 0xa9, 0x1d, 0xd1, 0x4f, 0x9b, 0x5b, 0x3e, 0x5d, + 0xb8, 0xd7, 0x70, 0x8f, 0x75, 0x38, 0x6a, 0xba, 0x6e, 0x22, 0xb0, 0x79, + 0xe2, 0xf5, 0xa1, 0x8d, 0x9a, 0x9f, 0x0c, 0x22, 0x00, 0x83, 0x0a, 0x38, + 0xa8, 0x64, 0xec, 0x2b, 0xf9, 0xfa, 0x14, 0x81, 0x70, 0xf2, 0xc4, 0x54, + 0x33, 0x2e, 0xb9, 0x04, 0xdf, 0xf1, 0x6a, 0x7b, 0xf1, 0x29, 0x66, 0x20, + 0x5c, 0x79, 0xd0, 0x1a, 0x17, 0xbb, 0xc1, 0xd2, 0x0c, 0x1a, 0xd5, 0x0c, + 0x3f, 0x29, 0x69, 0x7a, 0x37, 0x38, 0x86, 0x61, 0x5b, 0xcb, 0x03, 0xa9, + 0x3f, 0x19, 0x1f, 0x8d, 0xdc, 0xc7, 0x32, 0x62, 0x81, 0x28, 0xd8, 0xc1, + 0xd9, 0xf5, 0xba, 0x58, 0x21, 0x28, 0xbe, 0x4a, 0x84, 0xc1, 0x1d, 0x7e, + 0x94, 0x48, 0xa8, 0x19, 0x01, 0x93, 0x86, 0xda, 0x90, 0x46, 0x52, 0x0e, + 0x6d, 0xd5, 0x0a, 0x61, 0x29, 0x75, 0x9d, 0x80, 0x7d, 0x97, 0x7d, 0xcd, + 0x6a, 0xe3, 0xdd, 0x01, 0xe5, 0x04, 0x5e, 0xe4, 0x00, 0x7b, 0xd3, 0x0b, + 0xb0, 0x8e, 0x51, 0x91, 0x6b, 0x72, 0x60, 0xc5, 0x73, 0xa4, 0x05, 0x0f, + 0x9d, 0x50, 0x3f, 0xf7, 0x1c, 0x23, 0x7e, 0x66, 0xaf, 0xf7, 0x9a, 0xde, + 0xce, 0x66, 0x9e, 0x60, 0xb8, 0x92, 0x36, 0xd4, 0xc7, 0x92, 0x42, 0x3f, + 0x87, 0x54, 0xb4, 0x96, 0xb2, 0xf1, 0xb5, 0x17, 0x6d, 0x6a, 0x4c, 0x66, + 0x2c, 0x6e, 0x79, 0x58, 0xc8, 0x60, 0x75, 0xb2, 0x61, 0x16, 0x99, 0x97, + 0x9d, 0x3b, 0xc2, 0x6f, 0xeb, 0xc0, 0x65, 0x6b, 0x1f, 0x79, 0xdf, 0x17, + 0x70, 0x08, 0x55, 0x48, 0x2a, 0xc4, 0x5f, 0x06, 0x94, 0xf7, 0x84, 0xb2, + 0xf9, 0x42, 0x86, 0x92, 0x6a, 0x91, 0xa4, 0xf1, 0x4a, 0xfe, 0x10, 0x8b, + 0x4c, 0xb1, 0x10, 0x00, 0x12, 0x52, 0xee, 0xd1, 0x0e, 0x96, 0x26, 0xf4, + 0x08, 0xd6, 0x40, 0x70, 0x7c, 0xc6, 0xcc, 0x4e, 0x4b, 0xf6, 0xe5, 0x99, + 0x9c, 0xea, 0xf9, 0x33, 0x88, 0x4a, 0xe7, 0x45, 0xd6, 0x5f, 0xc9, 0xb9, + 0x27, 0x6c, 0x64, 0xc0, 0x35, 0xe7, 0xd5, 0xbf, 0x91, 0x1e, 0xc3, 0xd0, + 0x9e, 0xb9, 0x3d, 0xeb, 0x7d, 0xf5, 0x4d, 0x76, 0x6c, 0xb2, 0x71, 0x72, + 0xfc, 0x77, 0xce, 0x7b, 0x73, 0xf3, 0x31, 0x76, 0xa8, 0xee, 0xef, 0x04, + 0xa2, 0xfe, 0x3d, 0xef, 0xf1, 0xd0, 0xa7, 0x5c, 0x71, 0xd9, 0xdb, 0x2b, + 0x0b, 0x4d, 0xf9, 0xad, 0xc1, 0xb4, 0x86, 0x19, 0xf3, 0xcf, 0x7b, 0x83, + 0xcf, 0xda, 0xf8, 0xbb, 0xf5, 0xdb, 0xe1, 0xf6, 0x61, 0x6b, 0xec, 0xbe, + 0x1e, 0x72, 0x96, 0x30, 0x6d, 0xaf, 0xd4, 0x17, 0x57, 0xb7, 0x9f, 0xdf, + 0x44, 0x1e, 0x60, 0x06, 0x51, 0xd7, 0x1d, 0x45, 0xc0, 0x77, 0x6a, 0x3d, + 0x8c, 0x9f, 0xe1, 0x92, 0x38, 0xd1, 0x68, 0xf5, 0x38, 0xfd, 0x98, 0xca, + 0x83, 0xdf, 0x26, 0x1c, 0x1d, 0xfc, 0xc1, 0xd3, 0x05, 0x0b, 0xff, 0x89, + 0x79, 0x56, 0xe7, 0x1c, 0x3a, 0x45, 0x83, 0x92, 0x05, 0x1d, 0x7f, 0x92, + 0xf0, 0x60, 0xc6, 0x7d, 0x0b, 0x2b, 0xb9, 0xc9, 0x3a, 0xf0, 0x6a, 0xe4, + 0xea, 0x36, 0x25, 0x5b, 0x01, 0xb5, 0x5e, 0x57, 0xf2, 0xcf, 0x7b, 0x43, + 0x62, 0xc7, 0x87, 0x19, 0xb6, 0xbc, 0x22, 0x6b, 0x46, 0x2a, 0x16, 0xd6, + 0x4b, 0x74, 0x98, 0xd2, 0x9f, 0xb4, 0xd3, 0xb4, 0x68, 0x63, 0xce, 0x00, + 0x78, 0xfe, 0xb7, 0x11, 0x40, 0xdc, 0x3d, 0x23, 0xa0, 0x9d, 0x1d, 0xde, + 0x5e, 0xe8, 0xdc, 0xbf, 0xe0, 0x68, 0xc7, 0x67, 0xaf, 0x0d, 0x90, 0x8d, + 0x42, 0xaa, 0xe5, 0xb3, 0x5c, 0xd7, 0xa7, 0x51, 0xf1, 0x47, 0xcf, 0xab, + 0x5a, 0xd9, 0x30, 0xa4, 0x72, 0xe9, 0xa9, 0x43, 0x56, 0x50, 0x6b, 0x8e, + 0x62, 0x26, 0x0f, 0x63, 0x19, 0x12, 0x21, 0x3d, 0x15, 0xc4, 0x5d, 0xac, + 0xaf, 0xdf, 0x67, 0xcc, 0x64, 0xcf, 0x8d, 0x5a, 0x7f, 0xb0, 0xb6, 0xfa, + 0xf0, 0x18, 0xcb, 0x77, 0x51, 0x6b, 0xf4, 0x52, 0x84, 0xa4, 0xad, 0x2b, + 0xcb, 0x45, 0x9b, 0x43, 0x13, 0x7f, 0xa5, 0xc1, 0x79, 0xc8, 0xaa, 0x57, + 0xbb, 0xb5, 0xf4, 0x55, 0x25, 0x44, 0xf8, 0x65, 0xde, 0x6e, 0x5b, 0x4b, + 0xf0, 0x00, 0xeb, 0x43, 0x1c, 0x2d, 0x25, 0x49, 0x79, 0x55, 0x98, 0x0d, + 0xba, 0x6b, 0xab, 0x7a, 0x81, 0xea, 0x00, 0xf8, 0xc1, 0x1f, 0xb8, 0x9e, + 0x87, 0x21, 0x75, 0xb1, 0xc9, 0x3c, 0x39, 0x00, 0x44, 0xc9, 0x45, 0xb9, + 0x2d, 0x9a, 0x4a, 0x1e, 0xf2, 0x67, 0x5f, 0x43, 0x1f, 0x35, 0xae, 0x69, + 0xa7, 0x68, 0x18, 0x5e, 0x53, 0x83, 0x0c, 0x6b, 0x8e, 0x8c, 0xee, 0x23, + 0x0e, 0x93, 0xe1, 0x97, 0xd7, 0x9a, 0x40, 0x74, 0x0f, 0x00, 0x9c, 0x18, + 0xa7, 0xf7, 0xa1, 0xb8, 0x27, 0x54, 0x87, 0x3c, 0x82, 0xe2, 0x4f, 0xd9, + 0xd9, 0xd5, 0xd6, 0x3a, 0xbe, 0x35, 0x43, 0x47, 0xe2, 0xaa, 0x37, 0x92, + 0x17, 0x49, 0x1d, 0xac, 0x40, 0xf9, 0xe0, 0xd9, 0x3e, 0x54, 0x6f, 0xfa, + 0xab, 0xd9, 0x5a, 0x0b, 0xa1, 0x3f, 0xd2, 0xf8, 0xd4, 0xd0, 0xda, 0x65, + 0xd7, 0x5e, 0x06, 0x91, 0xba, 0x09, 0xcd, 0x25, 0x08, 0x90, 0x69, 0xd1, + 0x31, 0x81, 0x2e, 0x2a, 0x03, 0x92, 0x81, 0xb5, 0xcd, 0x66, 0x1c, 0x43, + 0x2e, 0xb2, 0x4a, 0x2f, 0xcb, 0xfc, 0x14, 0x99, 0x73, 0xc4, 0xae, 0x09, + 0x95, 0x01, 0x03, 0x72, 0x31, 0x5c, 0xbd, 0x9b, 0x36, 0x30, 0xd3, 0x2d, + 0x16, 0xda, 0x8e, 0x3e, 0xa7, 0xcf, 0xc1, 0xd6, 0x2e, 0x8d, 0x1e, 0x8c, + 0x21, 0xc5, 0x9f, 0xe3, 0xcf, 0xeb, 0x7f, 0xef, 0xb9, 0x67, 0xf1, 0xad, + 0xe2, 0x76, 0xa6, 0x19, 0x19, 0xa2, 0x6f, 0x65, 0xce, 0x98, 0x44, 0xec, + 0xf2, 0x3d, 0xaf, 0x92, 0x33, 0x03, 0x33, 0x0d, 0xc6, 0x4c, 0x1b, 0x53, + 0x33, 0x33, 0x73, 0xc0, 0x1f, 0x20, 0x8b, 0x86, 0x2d, 0x16, 0x8b, 0x84, + 0xf1, 0x27, 0xfd, 0x4c, 0xab, 0x44, 0x15, 0xcd, 0x7b, 0x29, 0xc9, 0x73, + 0x12, 0x62, 0x3b, 0xc4, 0xb4, 0x12, 0x04, 0x52, 0x45, 0x9c, 0xc1, 0xef, + 0xef, 0x77, 0x2b, 0x56, 0xa4, 0x16, 0x1a, 0x27, 0xa4, 0x88, 0x1d, 0x29, + 0xcb, 0xe7, 0x71, 0xe4, 0xa0, 0x74, 0x68, 0x30, 0x15, 0x17, 0x5c, 0xca, + 0x5c, 0xc2, 0xc3, 0xd8, 0x69, 0xa7, 0x54, 0x05, 0xf7, 0x29, 0xb9, 0x07, + 0x21, 0x68, 0xc4, 0x20, 0x0f, 0x52, 0xc7, 0x2c, 0x58, 0x8a, 0x4c, 0xdc, + 0xe2, 0xdf, 0xed, 0x8e, 0x31, 0x06, 0x70, 0x93, 0x1b, 0x2f, 0x0d, 0x96, + 0xef, 0x60, 0xa1, 0x3d, 0x9c, 0x45, 0xe6, 0x7a, 0x1f, 0x7f, 0x86, 0x07, + 0xa9, 0xb3, 0xe7, 0x6c, 0x0d, 0x36, 0x66, 0x3a, 0xc0, 0x28, 0xd9, 0x9e, + 0x89, 0x87, 0xe8, 0x3f, 0x31, 0x3f, 0xf9, 0xd0, 0xeb, 0x3d, 0x32, 0xb3, + 0xa8, 0xdd, 0xda, 0x5c, 0x17, 0x6e, 0xe0, 0xab, 0x13, 0x5a, 0xf1, 0xb9, + 0x62, 0xc2, 0xee, 0x82, 0x5b, 0xca, 0x06, 0x88, 0x86, 0x05, 0xc5, 0x6d, + 0x73, 0xb5, 0x0c, 0x49, 0x96, 0x3f, 0xae, 0xfd, 0x7f, 0x47, 0xce, 0x4c, + 0x31, 0xa9, 0xb9, 0x15, 0x04, 0x68, 0x78, 0x4f, 0xe2, 0xf6, 0x8c, 0xe5, + 0x33, 0x99, 0xfa, 0x7a, 0x8d, 0x3a, 0x17, 0x93, 0xb8, 0xce, 0x07, 0x23, + 0x02, 0xdf, 0xd0, 0xab, 0x98, 0x73, 0xb2, 0xb2, 0x4c, 0xe9, 0x12, 0xae, + 0xb8, 0x16, 0xee, 0x90, 0x4b, 0xe9, 0xb2, 0xdb, 0xbb, 0xec, 0x35, 0xe7, + 0xbe, 0x80, 0x0c, 0x8c, 0xdf, 0xc4, 0x07, 0x50, 0xe5, 0xf7, 0xf5, 0xd1, + 0x9d, 0xe3, 0x81, 0x3a, 0x6e, 0xb5, 0x6f, 0xa8, 0xe2, 0xb9, 0x99, 0xa4, + 0x9d, 0xf9, 0xc2, 0xae, 0x0c, 0x4f, 0x90, 0x69, 0xf4, 0xd9, 0x3d, 0x4b, + 0x48, 0x33, 0x79, 0xf4, 0x6e, 0xad, 0x73, 0x9e, 0x08, 0x62, 0xd8, 0x9f, + 0x76, 0x72, 0xc0, 0x8a, 0xf8, 0x82, 0x3e, 0x4a, 0xa4, 0xc5, 0x24, 0x1e, + 0x04, 0x8f, 0xfa, 0x29, 0x43, 0x65, 0xa3, 0x2e, 0xc3, 0xf4, 0x2f, 0x0c, + 0x6e, 0x3e, 0x04, 0x91, 0x4e, 0x87, 0x88, 0x78, 0x5a, 0xac, 0x78, 0x5a, + 0xb8, 0xf2, 0xc0, 0x37, 0x45, 0xf1, 0x90, 0x53, 0x57, 0x5d, 0xe0, 0xaf, + 0x24, 0x90, 0x07, 0x04, 0xa5, 0x66, 0xa9, 0x71, 0xcc, 0x41, 0x32, 0xc1, + 0xbb, 0xfa, 0xb2, 0x14, 0xb2, 0x79, 0x4f, 0xbd, 0x93, 0x4a, 0x63, 0x2a, + 0xb7, 0x60, 0x24, 0x56, 0x70, 0x0f, 0x50, 0x7c, 0xda, 0xbd, 0x93, 0x72, + 0x3f, 0xa3, 0xd2, 0x7d, 0xd8, 0x64, 0x78, 0x2d, 0xf2, 0xbe, 0x2b, 0x00, + 0xef, 0xcb, 0x53, 0xd6, 0x26, 0xfb, 0x11, 0x96, 0xbd, 0x51, 0x3d, 0xe2, + 0xdd, 0x8d, 0x5d, 0x70, 0x80, 0x68, 0x21, 0x98, 0xf8, 0xb8, 0x3c, 0x68, + 0x62, 0x27, 0x15, 0xae, 0x75, 0x72, 0x5d, 0x4f, 0xcb, 0x14, 0x6b, 0x18, + 0x2f, 0xcf, 0x47, 0x8c, 0x7c, 0x67, 0x63, 0xd5, 0x45, 0xd5, 0x0b, 0x33, + 0xac, 0xe8, 0x25, 0xa5, 0x7b, 0x5f, 0x32, 0x3f, 0x5c, 0x9b, 0x72, 0x73, + 0x0f, 0x56, 0x35, 0x69, 0x5a, 0x4e, 0x80, 0x09, 0x54, 0xe9, 0x73, 0x4c, + 0xa2, 0x11, 0xca, 0xb0, 0xf7, 0x64, 0xc3, 0xd5, 0xd0, 0x66, 0x85, 0xbd, + 0x5e, 0x0e, 0x57, 0x83, 0x55, 0x3d, 0x5f, 0x9b, 0x25, 0x01, 0x8f, 0x0c, + 0xad, 0x99, 0xb3, 0x2a, 0xf1, 0xf9, 0x62, 0x6e, 0x26, 0x61, 0x74, 0x00, + 0x0c, 0x61, 0xbb, 0xc8, 0xf6, 0x08, 0x58, 0x44, 0xdf, 0x55, 0xd0, 0x4a, + 0xf2, 0xea, 0x7d, 0x79, 0x00, 0xa5, 0x7d, 0x50, 0x86, 0x6f, 0x9f, 0xae, + 0x61, 0xcf, 0xf0, 0x46, 0xa7, 0x4f, 0x30, 0x3b, 0xef, 0x14, 0xc4, 0x7d, + 0x0b, 0x38, 0x98, 0x8d, 0xa4, 0x27, 0x28, 0xec, 0x75, 0x15, 0x4d, 0x0e, + 0xc0, 0x59, 0xed, 0x63, 0x0b, 0x93, 0xcd, 0x92, 0xb1, 0x01, 0x44, 0x44, + 0x15, 0x6b, 0x1c, 0x15, 0x16, 0x0d, 0x88, 0xfc, 0x35, 0x58, 0x53, 0xed, + 0x00, 0x56, 0xfb, 0x96, 0xb7, 0x74, 0x11, 0x2e, 0x7a, 0xae, 0xda, 0xa9, + 0x6b, 0xd0, 0x2e, 0xc9, 0xe1, 0xf6, 0x84, 0x43, 0x69, 0x14, 0xcb, 0xd6, + 0xf5, 0x7d, 0xd2, 0x2c, 0xdc, 0x5d, 0x36, 0x38, 0xae, 0x70, 0xf9, 0x1f, + 0x7d, 0x49, 0xd9, 0xaf, 0x0a, 0xe3, 0x2a, 0x3c, 0xba, 0xb6, 0xd3, 0xac, + 0x09, 0x86, 0x8d, 0x48, 0xe9, 0x42, 0x13, 0x97, 0xf4, 0x40, 0x66, 0x0a, + 0x3f, 0xb9, 0x2d, 0x68, 0x47, 0x3b, 0x80, 0xa0, 0xb3, 0xe1, 0x88, 0x3a, + 0xac, 0xa5, 0x66, 0x20, 0x4f, 0xcf, 0xe0, 0x61, 0xae, 0xd4, 0x7d, 0xfd, + 0x25, 0x92, 0x9f, 0xaa, 0x52, 0xce, 0x03, 0x13, 0x21, 0xd7, 0xa3, 0x22, + 0x2f, 0x50, 0x28, 0x4d, 0xdf, 0x2b, 0x9b, 0x07, 0xd8, 0x72, 0x0b, 0xea, + 0xb5, 0xf4, 0xdc, 0x72, 0xce, 0x7b, 0x2f, 0xc2, 0xfa, 0xf9, 0x9b, 0xfe, + 0xa9, 0x81, 0xbe, 0xa2, 0x71, 0x97, 0x96, 0xef, 0x98, 0xd7, 0x04, 0xf6, + 0x45, 0x6c, 0xa9, 0xf8, 0x42, 0xcc, 0xb2, 0xd5, 0xbd, 0x89, 0x2a, 0xf3, + 0x43, 0xd8, 0xd5, 0xce, 0xca, 0x1b, 0xdd, 0xd1, 0x80, 0x2f, 0xb7, 0x94, + 0xf4, 0x71, 0x0d, 0x96, 0x8c, 0xb1, 0x92, 0xfa, 0x34, 0xbe, 0x69, 0x4d, + 0xf3, 0x1c, 0xba, 0x84, 0xad, 0x45, 0xa8, 0x6a, 0xf0, 0x7a, 0x28, 0xbf, + 0xd0, 0x55, 0x5e, 0x23, 0x51, 0x96, 0x73, 0x69, 0x23, 0xab, 0x1e, 0x34, + 0xfe, 0x22, 0x2d, 0x51, 0xbc, 0x41, 0x89, 0x8f, 0x8f, 0xc7, 0xd0, 0x72, + 0xd8, 0xd5, 0x86, 0xa9, 0xdd, 0x81, 0xe8, 0x62, 0x58, 0x77, 0xd9, 0x8d, + 0xa0, 0xe2, 0xfd, 0xa2, 0xd6, 0xa0, 0x0d, 0xc2, 0x0a, 0x53, 0xc9, 0x23, + 0x1a, 0x14, 0xa9, 0x21, 0x07, 0x54, 0x53, 0xa2, 0xa1, 0xc3, 0x0a, 0x20, + 0xed, 0x63, 0x35, 0xb8, 0x4d, 0xdc, 0x26, 0xf0, 0x30, 0x58, 0x66, 0x7a, + 0x09, 0xf6, 0x9b, 0xce, 0xb3, 0xf3, 0x65, 0xfe, 0xdb, 0x33, 0x11, 0xd4, + 0xb8, 0x21, 0xd4, 0x76, 0xeb, 0x5b, 0xe2, 0x59, 0x4e, 0xf2, 0x54, 0xb8, + 0xdc, 0x34, 0x9c, 0x70, 0x7e, 0xba, 0x63, 0x8e, 0x69, 0xeb, 0x3c, 0xe8, + 0x4f, 0x2e, 0x03, 0xf9, 0xf3, 0xf2, 0x09, 0x78, 0xbd, 0x8d, 0x59, 0xf2, + 0x40, 0xc1, 0x7e, 0xb0, 0xe2, 0xc5, 0x62, 0xf9, 0x7b, 0x80, 0x1b, 0x7b, + 0xb7, 0x5b, 0x80, 0x8f, 0x4d, 0x01, 0x01, 0x80, 0xe6, 0x57, 0x94, 0xa4, + 0xa6, 0x5c, 0xc5, 0x56, 0x9c, 0xb1, 0xab, 0xe3, 0x99, 0x44, 0x22, 0xce, + 0x1d, 0x06, 0x0c, 0xb5, 0x68, 0x23, 0xfe, 0xe3, 0x88, 0x6b, 0xc2, 0xc2, + 0x7d, 0x17, 0xc0, 0x28, 0x1d, 0xb3, 0x1b, 0xb4, 0x63, 0x81, 0x56, 0xb9, + 0xed, 0xed, 0xc4, 0x7d, 0xa4, 0x98, 0x4b, 0x63, 0x6a, 0x32, 0xfc, 0x1a, + 0xfc, 0xf9, 0x53, 0xad, 0x36, 0x67, 0xa6, 0xae, 0x42, 0xcc, 0xb7, 0xaa, + 0xf9, 0x74, 0x18, 0x99, 0xdb, 0xed, 0xb2, 0xfd, 0x7a, 0xce, 0xc9, 0x5a, + 0x9a, 0x4b, 0xdd, 0x76, 0x8b, 0x10, 0x76, 0x77, 0x7d, 0x60, 0x6a, 0x3d, + 0x5a, 0x64, 0xd1, 0x44, 0x85, 0x0c, 0xd5, 0xde, 0x71, 0x9c, 0x31, 0x28, + 0x7d, 0xb1, 0x4c, 0x20, 0xfe, 0xda, 0x1a, 0x64, 0xb0, 0xdb, 0x7e, 0x70, + 0x5e, 0x23, 0x75, 0xf4, 0xcc, 0x71, 0x79, 0xde, 0x6c, 0x05, 0xdb, 0xb7, + 0x40, 0xd1, 0xc0, 0xcb, 0x79, 0x8a, 0x64, 0x0f, 0x58, 0x5f, 0x12, 0x8a, + 0xa6, 0x20, 0x00, 0x31, 0xcb, 0x36, 0x9e, 0x96, 0xc3, 0x60, 0xad, 0x01, + 0xd2, 0xe3, 0xbd, 0x45, 0xbd, 0x2d, 0x69, 0xb8, 0x0a, 0xf0, 0xe5, 0x24, + 0x44, 0x5b, 0x7b, 0x64, 0xe3, 0x83, 0x9e, 0x74, 0x05, 0xff, 0x85, 0xd5, + 0xa6, 0x20, 0xd2, 0x65, 0xfe, 0x39, 0x46, 0x0c, 0x9e, 0x1c, 0x6e, 0x3d, + 0x0f, 0x6b, 0x48, 0xe2, 0xe0, 0xb2, 0x19, 0xba, 0x73, 0x07, 0x70, 0xd9, + 0x0a, 0x8f, 0x92, 0xa7, 0xef, 0x3e, 0x3e, 0xec, 0xc6, 0x83, 0xd7, 0x01, + 0x68, 0x03, 0x2d, 0x49, 0x0d, 0xe3, 0x61, 0xb9, 0x1c, 0xe5, 0x9b, 0x9b, + 0xee, 0x53, 0x15, 0xed, 0x52, 0x67, 0x54, 0x31, 0xcc, 0xba, 0xf9, 0x1a, + 0xe4, 0xf6, 0x1d, 0xd9, 0xbc, 0x13, 0x11, 0x46, 0x34, 0xfd, 0x5c, 0xb0, + 0xaf, 0x6c, 0x13, 0x14, 0xab, 0xe8, 0xae, 0x91, 0x0a, 0x8c, 0x83, 0x38, + 0xd1, 0x5d, 0x06, 0x54, 0x93, 0x79, 0x96, 0x91, 0x23, 0x89, 0x67, 0x97, + 0x22, 0xb9, 0x26, 0xfb, 0xbf, 0x38, 0x72, 0xa9, 0x8b, 0xb0, 0x3a, 0xde, + 0xdb, 0xa1, 0x08, 0x23, 0x3d, 0xaf, 0x4a, 0x7c, 0x34, 0x5c, 0x94, 0xaa, + 0xa6, 0x42, 0x50, 0x51, 0xb5, 0x29, 0x91, 0xf0, 0x12, 0xd8, 0xf1, 0x6c, + 0x51, 0xf9, 0x97, 0xc6, 0xcd, 0xb8, 0xb8, 0x77, 0xd5, 0xb2, 0xe4, 0xea, + 0x71, 0xef, 0x99, 0x7f, 0xe6, 0x27, 0x4d, 0xff, 0x3c, 0xf7, 0xc9, 0xd5, + 0xd0, 0x4f, 0x52, 0x1e, 0x36, 0x3c, 0xa0, 0xc8, 0x96, 0xad, 0xa5, 0xcb, + 0x2f, 0xcc, 0x73, 0x02, 0x41, 0x2f, 0x1c, 0x75, 0x0a, 0x67, 0x68, 0x07, + 0x36, 0x6e, 0xb8, 0x3c, 0x16, 0xe6, 0xac, 0x16, 0x43, 0x29, 0xe1, 0xc6, + 0xbf, 0x56, 0x78, 0x12, 0x3c, 0x09, 0x7c, 0x85, 0x6c, 0x87, 0x3f, 0x77, + 0x0a, 0xf7, 0xcf, 0xbc, 0xce, 0x94, 0xef, 0x4f, 0x13, 0x64, 0xf5, 0x6c, + 0xb7, 0x75, 0xdb, 0x83, 0x3f, 0x39, 0xc3, 0xba, 0xc0, 0x6a, 0xad, 0x43, + 0xdc, 0x6d, 0xa2, 0x62, 0x3b, 0xe7, 0xc2, 0xb0, 0xf1, 0x3e, 0x19, 0xae, + 0x83, 0x79, 0x36, 0x4a, 0xcc, 0xcf, 0x14, 0xdc, 0x0a, 0x20, 0x74, 0xd4, + 0x1a, 0x3a, 0x3b, 0x9a, 0x19, 0x51, 0x81, 0x8f, 0x3d, 0xa9, 0xe6, 0xaa, + 0x81, 0x5c, 0xcb, 0xee, 0x84, 0x45, 0x16, 0x40, 0xe7, 0xb3, 0x65, 0x01, + 0x29, 0xab, 0x08, 0x05, 0xa4, 0x38, 0x09, 0x97, 0x31, 0x78, 0x06, 0x69, + 0xb6, 0xfc, 0x47, 0x3f, 0x97, 0x55, 0x93, 0x5b, 0x4d, 0x28, 0x37, 0xde, + 0xfe, 0x19, 0xf1, 0xbf, 0xda, 0x32, 0xe2, 0x35, 0x2d, 0x25, 0xa2, 0xc9, + 0x56, 0x58, 0x7d, 0x11, 0xb7, 0x67, 0x79, 0xf7, 0x67, 0xc1, 0x1b, 0xf3, + 0x23, 0xe0, 0x86, 0x95, 0xbd, 0x71, 0x7a, 0xd5, 0x23, 0x2c, 0x9b, 0xfc, + 0x60, 0x4f, 0xa7, 0x38, 0xc6, 0xec, 0xfc, 0x43, 0x13, 0xf4, 0x62, 0xa4, + 0x1d, 0xb0, 0x05, 0x87, 0x11, 0xfe, 0x94, 0x90, 0x8d, 0xea, 0x8a, 0x95, + 0xb1, 0x98, 0xbd, 0x04, 0xcd, 0x84, 0xc8, 0xb6, 0x4b, 0x73, 0x4f, 0x4a, + 0xed, 0xda, 0xcc, 0x92, 0xbc, 0x07, 0xed, 0x74, 0x4e, 0xe0, 0x06, 0x08, + 0xe2, 0xec, 0xbe, 0x1c, 0x8d, 0xbb, 0x4c, 0x35, 0xe8, 0xa7, 0xde, 0x87, + 0x20, 0xcf, 0xd7, 0xf7, 0x95, 0xa2, 0x7e, 0x65, 0xc2, 0xcc, 0xeb, 0xdf, + 0x49, 0x02, 0x47, 0x86, 0x54, 0xf5, 0x6d, 0xc7, 0xec, 0xa9, 0xb4, 0x8d, + 0xc5, 0x67, 0xe9, 0xcb, 0x41, 0x07, 0x03, 0x74, 0x9c, 0xff, 0xc2, 0x1c, + 0x31, 0xb4, 0x22, 0x3e, 0x87, 0x9a, 0xdf, 0xa5, 0xc1, 0x3e, 0x5f, 0xb4, + 0xe7, 0x00, 0x44, 0xa3, 0x80, 0xd6, 0x39, 0x72, 0x54, 0x9a, 0x4e, 0xd9, + 0xe1, 0x82, 0x09, 0x3b, 0x47, 0x0d, 0x30, 0xd2, 0x3e, 0xd0, 0x63, 0x50, + 0x52, 0xf4, 0x73, 0xf8, 0xb1, 0x17, 0x61, 0x2c, 0x9a, 0x40, 0x7f, 0x54, + 0x7a, 0xfd, 0x55, 0x16, 0xd0, 0xb5, 0xdb, 0x6e, 0xf7, 0xcf, 0xac, 0x4e, + 0xb7, 0x7a, 0x2c, 0x9c, 0x3e, 0x9f, 0xc8, 0x91, 0x62, 0xfd, 0xda, 0xa0, + 0xfb, 0x4a, 0x46, 0xa0, 0xef, 0x6e, 0x49, 0x86, 0x9e, 0x4a, 0xb8, 0x94, + 0x2a, 0xa2, 0xbc, 0x4b, 0x8e, 0x5a, 0x32, 0xfd, 0x1b, 0x24, 0x64, 0x72, + 0xe0, 0x12, 0xb5, 0x25, 0xc1, 0x44, 0xbe, 0x4c, 0x68, 0x2a, 0xc9, 0x9f, + 0xc2, 0x62, 0x32, 0xbe, 0xd5, 0xcb, 0x3c, 0xa7, 0x06, 0x20, 0xeb, 0xea, + 0x38, 0x07, 0x07, 0xe6, 0xf3, 0xef, 0x7a, 0xbc, 0x28, 0x7d, 0x42, 0xde, + 0xd3, 0x45, 0x26, 0xfd, 0x83, 0x4c, 0xcc, 0xea, 0xd1, 0x70, 0xa6, 0x33, + 0xca, 0x34, 0x76, 0x74, 0x28, 0x2a, 0xf9, 0xc5, 0x6c, 0x87, 0xae, 0x70, + 0xd5, 0xcf, 0x82, 0xba, 0xf2, 0x5d, 0xcf, 0x73, 0xe8, 0xba, 0x77, 0x76, + 0x65, 0x40, 0xdd, 0x44, 0x5d, 0x24, 0xff, 0x4b, 0x2e, 0x98, 0xc1, 0x9b, + 0x97, 0xb1, 0x41, 0x7e, 0x48, 0xf9, 0x46, 0x08, 0x38, 0x6d, 0x8d, 0xdc, + 0xe7, 0x53, 0x96, 0x71, 0xab, 0x66, 0xd4, 0x00, 0xfe, 0xf4, 0x8d, 0xbb, + 0xb6, 0x32, 0xab, 0x4b, 0x79, 0xda, 0xc3, 0x97, 0xd8, 0x48, 0x72, 0x8c, + 0xee, 0x94, 0x74, 0xcc, 0x81, 0xef, 0x4f, 0xdd, 0xcc, 0x95, 0x8c, 0x6d, + 0x43, 0x02, 0x35, 0x79, 0x4f, 0xff, 0x96, 0x27, 0xaf, 0xcc, 0x37, 0xde, + 0xa5, 0xc4, 0x54, 0xb2, 0xd7, 0x73, 0x9b, 0xc2, 0x43, 0xb9, 0x07, 0xa4, + 0x71, 0x33, 0x0d, 0x9d, 0xfd, 0xf0, 0x23, 0xf0, 0xff, 0xd3, 0x86, 0x81, + 0x41, 0xb7, 0x04, 0x64, 0xcf, 0xe4, 0x32, 0x92, 0xc5, 0x80, 0xe4, 0xe0, + 0x4b, 0x3c, 0xd6, 0x9a, 0x77, 0x1a, 0x77, 0x5b, 0x95, 0x86, 0x63, 0x01, + 0x9e, 0xc7, 0xe9, 0x06, 0xee, 0x0a, 0x69, 0xee, 0x41, 0xf2, 0xa8, 0xb5, + 0x76, 0x83, 0xb9, 0xa7, 0x7d, 0xb2, 0x23, 0xe4, 0xbf, 0x5d, 0x22, 0xb5, + 0x24, 0xe7, 0x3b, 0x42, 0xa5, 0x25, 0xb2, 0x3f, 0x4a, 0xac, 0x5b, 0x40, + 0xe0, 0x5e, 0x39, 0xa1, 0x3c, 0xa8, 0x18, 0x7d, 0x7a, 0xa8, 0xf5, 0xd0, + 0x46, 0xb3, 0x6e, 0x82, 0x4e, 0x9d, 0x84, 0x03, 0xf5, 0x2a, 0x2d, 0x66, + 0x41, 0x71, 0xd2, 0x1f, 0x71, 0xa5, 0xab, 0xa9, 0xf6, 0xf9, 0x28, 0x12, + 0xe2, 0xcd, 0x62, 0x9f, 0xdc, 0x21, 0xce, 0xeb, 0xdc, 0x1c, 0x8f, 0x97, + 0xf5, 0xcb, 0x75, 0xe6, 0x35, 0x3c, 0x43, 0x43, 0xa2, 0xc5, 0x18, 0xc2, + 0x6c, 0xfc, 0xe7, 0xb2, 0x59, 0x10, 0x4c, 0x0c, 0xb7, 0x2c, 0x5a, 0xcb, + 0x14, 0x01, 0x66, 0x33, 0x4a, 0xa5, 0xe1, 0x25, 0xde, 0xcc, 0x19, 0x86, + 0xf4, 0xd4, 0xc8, 0x1e, 0xdd, 0x29, 0x7f, 0xd1, 0x86, 0x43, 0xa4, 0xab, + 0x39, 0x7b, 0x1f, 0x84, 0x5d, 0xf7, 0x2c, 0x12, 0xc6, 0xb4, 0x94, 0x4b, + 0x38, 0xe6, 0x18, 0xfb, 0x2b, 0x7a, 0xea, 0xcf, 0x38, 0x24, 0x52, 0x18, + 0x15, 0x0c, 0xf9, 0x57, 0x99, 0xff, 0x7f, 0xc2, 0x39, 0xe2, 0xa6, 0x42, + 0x71, 0x35, 0xeb, 0x7c, 0x13, 0x20, 0x20, 0x21, 0xc4, 0x51, 0x87, 0x63, + 0xf9, 0x69, 0x97, 0x65, 0x35, 0x37, 0xba, 0xb6, 0xf2, 0x43, 0xdd, 0xb4, + 0x44, 0x15, 0x4c, 0xe6, 0x22, 0xfe, 0x0a, 0x09, 0x7a, 0xfd, 0xde, 0x76, + 0x58, 0xd2, 0xac, 0x9e, 0x57, 0xc0, 0x46, 0x02, 0x62, 0x39, 0xd0, 0xb0, + 0x97, 0xf5, 0xaa, 0x1b, 0xfb, 0xc6, 0x2c, 0x92, 0x78, 0xc7, 0x61, 0x9a, + 0xca, 0xd1, 0xbb, 0x45, 0x3f, 0x5f, 0xcb, 0xf1, 0x4c, 0x16, 0x6b, 0x07, + 0x18, 0x2b, 0x46, 0x9d, 0x3c, 0x3b, 0xf9, 0xd1, 0x75, 0x09, 0x04, 0xc1, + 0x80, 0xc8, 0x9a, 0x5f, 0x5a, 0x50, 0xe7, 0x7c, 0xd5, 0x2d, 0x54, 0x76, + 0xbb, 0x8a, 0xc5, 0xc2, 0x9f, 0xad, 0x27, 0x88, 0x90, 0x90, 0x34, 0xb0, + 0xdc, 0x8d, 0xdd, 0x26, 0x97, 0x4c, 0x0c, 0xe4, 0x24, 0x7d, 0x24, 0xad, + 0x29, 0xd7, 0x2d, 0xd9, 0x14, 0x7b, 0xde, 0x29, 0xb1, 0x31, 0xde, 0xb3, + 0xa4, 0x6f, 0xc0, 0x15, 0x9e, 0xd0, 0xc4, 0xe2, 0x3b, 0x57, 0x13, 0x45, + 0xde, 0xd1, 0x70, 0x96, 0x05, 0xd7, 0xdc, 0x00, 0x28, 0x19, 0x16, 0xee, + 0x97, 0xa7, 0xc9, 0x54, 0x71, 0x9f, 0x74, 0x1b, 0x6c, 0x80, 0x6d, 0x43, + 0xf7, 0xa1, 0x42, 0x66, 0xa5, 0x2f, 0x4c, 0xb1, 0x16, 0x33, 0xbe, 0x46, + 0x6a, 0x4c, 0x58, 0x98, 0x2b, 0xa8, 0x47, 0xe2, 0xf4, 0xcb, 0x39, 0x8a, + 0x80, 0x2f, 0x9c, 0x0a, 0x6c, 0xaa, 0x1a, 0x4f, 0xa1, 0x1f, 0x95, 0x34, + 0x6d, 0x95, 0x31, 0xd3, 0xf8, 0x56, 0xc5, 0xf7, 0xf8, 0xfd, 0x7d, 0x32, + 0xab, 0xeb, 0x52, 0x06, 0x0d, 0x9f, 0x50, 0x51, 0xfb, 0x49, 0x76, 0x02, + 0xb6, 0xdc, 0x41, 0x86, 0xa1, 0x05, 0xd3, 0x6c, 0x7a, 0x0c, 0xce, 0x68, + 0x22, 0xe2, 0x7c, 0xc1, 0x45, 0x04, 0x93, 0xdd, 0x1c, 0xe5, 0x0f, 0xe1, + 0x52, 0x87, 0xb3, 0xe7, 0x00, 0xfb, 0xc3, 0x58, 0xa6, 0xc0, 0xd5, 0x12, + 0x0c, 0x1c, 0x22, 0x2c, 0x83, 0xa7, 0x02, 0x67, 0x96, 0x54, 0x90, 0x63, + 0x48, 0x99, 0xb1, 0x57, 0xab, 0x20, 0x88, 0x49, 0x5c, 0xdb, 0xa4, 0xc8, + 0x70, 0x23, 0x11, 0xb0, 0xe9, 0x69, 0x0b, 0x6d, 0xa9, 0xd0, 0x07, 0x87, + 0xd5, 0x3c, 0x3d, 0xf6, 0x85, 0x66, 0x28, 0xe3, 0x72, 0xca, 0xc3, 0x50, + 0x73, 0x40, 0x8b, 0xb1, 0xf1, 0x4d, 0x83, 0xc1, 0x3c, 0xd6, 0x7f, 0x77, + 0x1a, 0xf4, 0xd4, 0x7b, 0x46, 0x4f, 0x1c, 0x65, 0x72, 0x2b, 0x3a, 0xe0, + 0xa6, 0x9f, 0xfa, 0x27, 0x07, 0xec, 0xda, 0xb4, 0xe2, 0x5b, 0xcb, 0x32, + 0x03, 0x0b, 0x80, 0xbf, 0xe1, 0xa0, 0x6c, 0xca, 0x41, 0x42, 0xa4, 0xfb, + 0x86, 0x98, 0xaa, 0x2f, 0xc6, 0x76, 0x79, 0xbc, 0x2f, 0xe0, 0x07, 0xaf, + 0xed, 0x3a, 0x28, 0xd6, 0x01, 0x51, 0x54, 0x2d, 0xbc, 0x42, 0x79, 0x7b, + 0xdc, 0x15, 0x31, 0x4b, 0x6b, 0x42, 0x14, 0xe3, 0xda, 0xb5, 0x0e, 0xb0, + 0x40, 0xd0, 0x13, 0xcc, 0x17, 0xbe, 0x54, 0x0c, 0x8a, 0x05, 0x31, 0x6c, + 0x5f, 0xdf, 0x71, 0xc5, 0xa8, 0xf3, 0xea, 0xbc, 0xd3, 0x8f, 0x33, 0x0a, + 0x20, 0xcb, 0xd5, 0xfb, 0x11, 0x00, 0x6d, 0xf2, 0x84, 0xf2, 0x46, 0x25, + 0x1c, 0x5e, 0xe3, 0xdc, 0x1e, 0x37, 0x04, 0x48, 0xae, 0x5d, 0x0a, 0x01, + 0x66, 0xa8, 0xf1, 0x1b, 0x49, 0xb7, 0xb3, 0x7b, 0x37, 0xb4, 0xdf, 0xd8, + 0xd5, 0xf6, 0x73, 0x3d, 0xa4, 0x8c, 0x33, 0x5e, 0xeb, 0xcf, 0xcb, 0xfa, + 0x56, 0xa4, 0xd8, 0x24, 0x76, 0x8f, 0x09, 0x23, 0x9c, 0xa5, 0x9e, 0x8a, + 0x0b, 0x23, 0x6d, 0xd8, 0xf3, 0xf8, 0xcc, 0x59, 0xde, 0x0e, 0x96, 0x5e, + 0x96, 0xfb, 0xed, 0x02, 0x20, 0x18, 0x40, 0xcf, 0xfd, 0x67, 0xe9, 0xcf, + 0xa9, 0xff, 0x89, 0xc4, 0x61, 0x79, 0x88, 0x82, 0x22, 0xa1, 0x0a, 0x31, + 0xae, 0x53, 0x79, 0x1a, 0x6d, 0x31, 0xfe, 0x67, 0x83, 0x89, 0x4a, 0x37, + 0x77, 0x7d, 0x58, 0x0b, 0xc9, 0xdf, 0x4d, 0x94, 0xfa, 0x1d, 0xdd, 0x5b, + 0xfc, 0x48, 0xd7, 0xef, 0x3f, 0xc8, 0x9f, 0x87, 0x67, 0xfc, 0xdb, 0xc7, + 0xd3, 0x18, 0x7a, 0x50, 0x7d, 0x30, 0x18, 0x46, 0xf1, 0x55, 0x5d, 0x9c, + 0x70, 0x50, 0xe6, 0xa8, 0x6f, 0xc9, 0xbf, 0x7f, 0xf4, 0xee, 0xfd, 0x79, + 0xd3, 0xb8, 0x6b, 0x06, 0x26, 0x76, 0x38, 0x6a, 0x4a, 0x82, 0xea, 0x75, + 0x77, 0x2f, 0x52, 0x5c, 0x23, 0xf7, 0x7e, 0x39, 0xf0, 0xb1, 0xc7, 0x17, + 0x5e, 0xde, 0x06, 0xcb, 0xca, 0x24, 0xac, 0xf9, 0x71, 0xc2, 0xb8, 0x2b, + 0x95, 0xe9, 0xc8, 0x2e, 0x8a, 0x68, 0xed, 0xfd, 0xb7, 0xfa, 0xe8, 0xd9, + 0x79, 0x72, 0x81, 0x5b, 0x37, 0x55, 0xcf, 0xb2, 0xed, 0x2b, 0x5a, 0xa5, + 0x26, 0xbe, 0x80, 0x6e, 0xfe, 0xb4, 0xf9, 0x88, 0xbd, 0x62, 0xf9, 0x9c, + 0xe7, 0x2c, 0x47, 0x51, 0x8d, 0xe1, 0xbf, 0x89, 0x09, 0xfb, 0x8f, 0x74, + 0xee, 0x44, 0xbe, 0x39, 0x0f, 0xa6, 0x36, 0xd9, 0x8c, 0xe6, 0xf5, 0x2e, + 0x3b, 0xd9, 0x89, 0x7f, 0x40, 0x39, 0x4a, 0xc3, 0xce, 0xf4, 0x5c, 0x67, + 0x0c, 0x8a, 0xba, 0x9f, 0xf7, 0xe6, 0x3b, 0x14, 0x4e, 0xdd, 0x56, 0x87, + 0x7a, 0x4c, 0x13, 0x55, 0x9f, 0xc5, 0x3a, 0xdd, 0x19, 0x84, 0x28, 0xb3, + 0xb8, 0x2c, 0x3f, 0x1e, 0x3f, 0x45, 0xa3, 0x3b, 0x97, 0x8c, 0x16, 0xcd, + 0xc8, 0xe0, 0x8c, 0xa4, 0xc2, 0x80, 0x2a, 0xef, 0xb5, 0x9f, 0x61, 0x2f, + 0x6b, 0xaa, 0xce, 0xe7, 0xf8, 0xa8, 0xe3, 0x1b, 0xbb, 0x1d, 0x87, 0x8e, + 0x31, 0x8e, 0xcf, 0x88, 0x89, 0x0f, 0x65, 0x30, 0xcb, 0x0c, 0xb4, 0x1d, + 0xbd, 0xed, 0xee, 0x84, 0x03, 0x81, 0xbf, 0xa2, 0x22, 0x13, 0x6e, 0x21, + 0xe7, 0xc4, 0x08, 0xdc, 0x90, 0xd8, 0x9d, 0xb0, 0x43, 0x05, 0xfa, 0xd3, + 0x4e, 0x45, 0xf3, 0x42, 0x94, 0x44, 0x42, 0xf9, 0xbd, 0x4f, 0x33, 0x25, + 0x97, 0x97, 0x2a, 0x44, 0x5b, 0x55, 0x1c, 0xdd, 0xae, 0xd6, 0xc5, 0x4f, + 0x99, 0x24, 0x12, 0x23, 0x97, 0x6c, 0x2e, 0x17, 0x11, 0xf4, 0x8c, 0xbe, + 0x61, 0x5c, 0xf8, 0xa1, 0xae, 0x19, 0xaf, 0x0f, 0x0c, 0xd8, 0x6a, 0x67, + 0x8b, 0x7f, 0xf3, 0xdd, 0xbe, 0xdb, 0x3f, 0x58, 0x2e, 0xda, 0xab, 0x46, + 0x53, 0x68, 0x44, 0x7b, 0xc9, 0x1f, 0xe8, 0x77, 0x8c, 0x3e, 0x04, 0xbd, + 0xf7, 0x2c, 0x9d, 0x98, 0xa0, 0x22, 0x3b, 0xd3, 0xc1, 0x63, 0xe8, 0xdc, + 0x4a, 0x17, 0x17, 0x54, 0xd9, 0x62, 0xbd, 0xc9, 0xd9, 0xc7, 0xda, 0x02, + 0x65, 0x7c, 0xfa, 0xe7, 0xad, 0x99, 0xef, 0xa5, 0x94, 0x75, 0x08, 0x78, + 0x92, 0x6e, 0x0c, 0x7e, 0x37, 0x4c, 0x0d, 0xc6, 0x3b, 0x51, 0xbf, 0x64, + 0x6b, 0xcb, 0x96, 0x19, 0x5a, 0x41, 0xf5, 0x33, 0xb7, 0x23, 0x1a, 0xdf, + 0x36, 0x2c, 0xa1, 0xa5, 0x11, 0xeb, 0x89, 0x7e, 0x29, 0x52, 0x46, 0x73, + 0x65, 0x3d, 0x37, 0x5d, 0xc2, 0xcd, 0x89, 0xbe, 0xac, 0x10, 0x75, 0x3c, + 0x76, 0x40, 0x9f, 0x53, 0xbb, 0x6a, 0x89, 0xf0, 0xd9, 0x7a, 0x3f, 0x22, + 0x32, 0x4d, 0xb9, 0x90, 0xd2, 0x36, 0xf9, 0x1a, 0xc2, 0xf6, 0x83, 0xc0, + 0x47, 0x62, 0xd7, 0x4f, 0x86, 0x1a, 0xe1, 0xc0, 0x9f, 0xe7, 0x2c, 0x3c, + 0x9b, 0xbf, 0xbf, 0x8c, 0x34, 0x8a, 0x8f, 0x44, 0x25, 0xaa, 0xde, 0xbe, + 0x13, 0x36, 0x3f, 0x44, 0x5f, 0xfe, 0x32, 0xd0, 0x91, 0x11, 0xd9, 0x5b, + 0xe5, 0xc8, 0x13, 0x2d, 0xe8, 0xb3, 0x78, 0xbc, 0x01, 0xc3, 0x94, 0xbe, + 0xae, 0x62, 0xb3, 0xd8, 0x08, 0x83, 0x39, 0x7f, 0x22, 0xb8, 0xdf, 0xf0, + 0x8e, 0x81, 0x6d, 0xad, 0xf9, 0xbb, 0x84, 0x5f, 0x33, 0xe8, 0x4c, 0xb9, + 0x93, 0xd3, 0xd7, 0x64, 0x20, 0x77, 0xef, 0x17, 0x75, 0x20, 0xe2, 0x3d, + 0xab, 0x5b, 0xa7, 0x38, 0xc7, 0x52, 0xb1, 0xcf, 0xb9, 0x27, 0x20, 0x66, + 0x10, 0x30, 0x17, 0x7f, 0x83, 0xc4, 0xe9, 0x09, 0xd5, 0x57, 0xfe, 0x09, + 0x0d, 0x34, 0xf8, 0x63, 0xe5, 0xcb, 0x8d, 0x35, 0x64, 0xa6, 0xc9, 0xf4, + 0x2c, 0xcd, 0xea, 0xf7, 0x82, 0x01, 0xe6, 0xf8, 0xed, 0x1b, 0x1f, 0x2a, + 0x18, 0x09, 0xad, 0xb7, 0xff, 0x4d, 0xf0, 0xe1, 0x71, 0x61, 0xf1, 0x67, + 0xb5, 0x7c, 0xd5, 0x9c, 0xd6, 0xb4, 0xe3, 0x03, 0x15, 0x7a, 0xe4, 0x6b, + 0xc0, 0xd8, 0xbf, 0x33, 0x70, 0x30, 0x92, 0xfe, 0x4e, 0x4c, 0xef, 0x9d, + 0x51, 0x97, 0x4f, 0x03, 0x78, 0xfa, 0x7b, 0xe4, 0xb1, 0x7f, 0x05, 0xa7, + 0xca, 0x8f, 0x3a, 0x6e, 0x61, 0x3c, 0x17, 0xad, 0x90, 0xcc, 0x3a, 0x63, + 0x57, 0x62, 0xcb, 0x06, 0x01, 0x83, 0xb5, 0x98, 0x0e, 0x5c, 0x8f, 0xfc, + 0xbc, 0x97, 0xbf, 0x71, 0xc0, 0xaa, 0x0c, 0x61, 0x99, 0x7f, 0x3b, 0x4f, + 0x70, 0x4b, 0x70, 0x19, 0x08, 0xfc, 0x94, 0x9b, 0xf2, 0x42, 0x36, 0x3f, + 0xfe, 0x68, 0x43, 0xea, 0x74, 0xd9, 0x34, 0x90, 0x25, 0x71, 0xb3, 0xe3, + 0x42, 0x5b, 0xae, 0x40, 0xe8, 0x44, 0x5e, 0x1f, 0x6a, 0xda, 0xe2, 0x56, + 0x37, 0x9a, 0xa5, 0x94, 0xe7, 0x61, 0xc6, 0x74, 0x84, 0x8b, 0xae, 0xf0, + 0x33, 0x18, 0xd0, 0xaf, 0xa4, 0x02, 0x55, 0xa5, 0xa7, 0xd8, 0x0c, 0x77, + 0x27, 0x83, 0xdd, 0x57, 0x48, 0x53, 0x6d, 0xa3, 0xbf, 0x4f, 0x7a, 0x72, + 0x2b, 0xd1, 0x01, 0x3b, 0x36, 0x33, 0x1d, 0x75, 0x90, 0x6c, 0xca, 0x66, + 0xab, 0x8a, 0x05, 0x7a, 0xca, 0x99, 0xf3, 0x0b, 0xf3, 0xb1, 0xc8, 0xed, + 0x27, 0x18, 0xa9, 0xb6, 0x90, 0x08, 0x2d, 0xc5, 0x68, 0x2e, 0x9c, 0x31, + 0xeb, 0x61, 0xdd, 0x73, 0x9d, 0x56, 0xf0, 0x5b, 0x08, 0x99, 0x3c, 0x2d, + 0x29, 0x21, 0x48, 0xc7, 0xf9, 0x8c, 0x4c, 0x72, 0x47, 0x8c, 0x04, 0x42, + 0x64, 0x6b, 0x05, 0xf2, 0xcb, 0x40, 0x71, 0x6b, 0x1f, 0xd5, 0x4a, 0xee, + 0x3e, 0x02, 0x73, 0x7c, 0xce, 0x67, 0xfc, 0x89, 0x7d, 0x27, 0x4d, 0xf3, + 0x59, 0xcb, 0xd1, 0x36, 0xee, 0x82, 0x26, 0x9a, 0x7a, 0x2c, 0x64, 0xc1, + 0x4e, 0x17, 0x1d, 0xa9, 0x93, 0x48, 0xda, 0x68, 0x42, 0x05, 0x33, 0x71, + 0x8a, 0x8d, 0x06, 0xac, 0x64, 0xba, 0x20, 0x9e, 0x66, 0xc8, 0xc9, 0x56, + 0x63, 0x89, 0x67, 0xc6, 0x8e, 0xc1, 0x7f, 0x04, 0x05, 0x41, 0xb5, 0xe6, + 0xf9, 0xe5, 0x30, 0x69, 0x47, 0xbc, 0x52, 0xe1, 0x2f, 0xb8, 0x36, 0x05, + 0x45, 0x10, 0xad, 0x87, 0x28, 0xf2, 0xf1, 0xf9, 0x1c, 0x51, 0x30, 0x59, + 0x31, 0xca, 0x6f, 0x55, 0xc9, 0xfd, 0x87, 0x84, 0xa2, 0x3c, 0xe4, 0x9b, + 0x4d, 0x30, 0xc2, 0x38, 0x4b, 0x5a, 0x13, 0xfc, 0x72, 0x56, 0x7f, 0xe5, + 0x11, 0x2e, 0x6a, 0xf2, 0xa9, 0x41, 0xeb, 0x03, 0x23, 0xa9, 0xa2, 0x8d, + 0x4f, 0xb3, 0xba, 0xf3, 0x19, 0x27, 0x2e, 0x0b, 0xf0, 0x17, 0x05, 0x4d, + 0xbe, 0x8b, 0xb5, 0x1e, 0x18, 0xfc, 0x1b, 0x15, 0xb2, 0xd1, 0xa6, 0x5e, + 0xd9, 0xe5, 0xb1, 0x36, 0xe0, 0x83, 0x06, 0x1c, 0x22, 0x85, 0x7f, 0x30, + 0x39, 0x5e, 0xe9, 0x70, 0x56, 0x3a, 0x02, 0x35, 0xe7, 0xde, 0x60, 0x96, + 0x58, 0xfc, 0x32, 0xae, 0x13, 0xe7, 0x29, 0x5d, 0x8d, 0xb7, 0x60, 0x72, + 0x2d, 0x24, 0x22, 0xab, 0x6f, 0x5c, 0x20, 0x4c, 0x79, 0xf2, 0x89, 0xc2, + 0x21, 0x9a, 0x41, 0x91, 0x6c, 0x6a, 0xbf, 0xc1, 0xf8, 0x9f, 0x78, 0x27, + 0x1d, 0x72, 0xea, 0xb0, 0x9e, 0x02, 0x8f, 0xfc, 0x6e, 0x15, 0x51, 0xc7, + 0x10, 0xf9, 0x62, 0x7d, 0xe5, 0xcc, 0xb5, 0x2f, 0x0c, 0x8f, 0xe6, 0x66, + 0x94, 0xdb, 0x1d, 0x53, 0x23, 0xaf, 0xa8, 0xf5, 0xd3, 0x98, 0x9b, 0x28, + 0x5d, 0xbc, 0x6d, 0xf4, 0x80, 0x70, 0x24, 0x30, 0x9e, 0xd4, 0x71, 0xb3, + 0xe8, 0xa1, 0x1c, 0xac, 0xc6, 0xa4, 0x2a, 0x77, 0xd9, 0x27, 0x4e, 0x7c, + 0x52, 0x55, 0xa8, 0x01, 0x36, 0x98, 0xb8, 0x1e, 0xb2, 0x27, 0x03, 0xb8, + 0x32, 0x12, 0x41, 0xa7, 0x2e, 0xf5, 0x2f, 0x90, 0x0d, 0x2d, 0xb9, 0x3a, + 0x09, 0x3b, 0xb9, 0x86, 0x0e, 0xb5, 0x43, 0xc5, 0x80, 0x27, 0xca, 0xb1, + 0xa6, 0xab, 0x11, 0x45, 0xe8, 0xff, 0xd4, 0x58, 0x63, 0xec, 0xb5, 0x4c, + 0xe9, 0x3e, 0x57, 0x3d, 0xfd, 0xf4, 0x03, 0x6d, 0xd8, 0xf0, 0xcb, 0xd3, + 0xfd, 0x57, 0xdb, 0x21, 0x35, 0x8a, 0xa3, 0x2b, 0x8a, 0xa3, 0xfa, 0x07, + 0xeb, 0x3e, 0x72, 0xf6, 0x26, 0x64, 0x96, 0x7c, 0x42, 0x96, 0x1a, 0x92, + 0x4d, 0x35, 0x43, 0x68, 0x0e, 0x82, 0xf2, 0x58, 0x37, 0xb6, 0xc3, 0xc5, + 0x2c, 0xb9, 0x1a, 0x3d, 0xa6, 0x6c, 0x0f, 0xc5, 0x58, 0x8f, 0x7e, 0x4c, + 0xd7, 0x72, 0x7c, 0x06, 0xd0, 0x85, 0x8e, 0x76, 0x9d, 0x31, 0x2e, 0x80, + 0xcc, 0xcc, 0xaa, 0x85, 0x79, 0x0a, 0xf6, 0xc8, 0x13, 0xdc, 0x4a, 0x9a, + 0x46, 0x72, 0xb9, 0x22, 0x63, 0xe8, 0x29, 0x12, 0x04, 0xde, 0x94, 0x87, + 0x5b, 0xd4, 0xd5, 0x5c, 0x00, 0x03, 0x9a, 0x92, 0x13, 0x97, 0x22, 0x05, + 0x2e, 0xea, 0x4e, 0xb8, 0xa8, 0x9c, 0xa7, 0xc5, 0x50, 0x78, 0x02, 0xdd, + 0x3d, 0xb6, 0x68, 0x0a, 0x93, 0xe6, 0x01, 0x2c, 0x96, 0x7f, 0x19, 0x3c, + 0x23, 0xc9, 0x68, 0x00, 0xfa, 0x44, 0xeb, 0xe8, 0x19, 0xe9, 0xd1, 0x58, + 0x4a, 0x88, 0xa3, 0xdf, 0xa8, 0x8e, 0xa4, 0x2e, 0x46, 0xe1, 0xf0, 0x1f, + 0x6c, 0xe9, 0x38, 0x8f, 0x8f, 0x67, 0xc1, 0xc4, 0x0a, 0x44, 0x63, 0x0b, + 0x2c, 0xad, 0x01, 0x93, 0x66, 0x7c, 0x73, 0x1b, 0x94, 0x89, 0x21, 0x79, + 0xd5, 0x44, 0x57, 0x72, 0xcb, 0x8f, 0x95, 0x1a, 0x46, 0x87, 0x6c, 0x0e, + 0xd1, 0x91, 0xbe, 0xee, 0xc8, 0x7e, 0xfa, 0x2a, 0xe9, 0x49, 0xfe, 0x73, + 0x21, 0xb4, 0x96, 0x10, 0x8b, 0x9a, 0x49, 0xbc, 0x56, 0x2d, 0x55, 0xf3, + 0xe6, 0x8f, 0xd8, 0xfe, 0xd1, 0x32, 0x05, 0xb0, 0x30, 0xce, 0x70, 0x71, + 0x33, 0x46, 0x56, 0xcb, 0xd7, 0xa6, 0xa6, 0xad, 0x10, 0x3a, 0x37, 0x11, + 0x1d, 0xb5, 0xd1, 0xe4, 0x6d, 0x65, 0x45, 0xb3, 0x82, 0x00, 0x99, 0xff, + 0xc8, 0xe6, 0x7b, 0xd3, 0x73, 0x63, 0x1a, 0x62, 0x55, 0xd5, 0x15, 0x6d, + 0x37, 0xa2, 0x9f, 0x04, 0x7f, 0x10, 0x62, 0x50, 0xb5, 0x58, 0xae, 0x32, + 0xe8, 0xfa, 0x3c, 0x05, 0xf3, 0x50, 0x5f, 0x8d, 0x48, 0xa8, 0x23, 0xcd, + 0x8b, 0xfe, 0x66, 0xce, 0x09, 0xb5, 0xf4, 0x1f, 0x2a, 0x21, 0xf8, 0x0d, + 0x4b, 0x99, 0xdf, 0xac, 0xdf, 0x2b, 0xff, 0x59, 0xbd, 0xcb, 0x60, 0xd3, + 0x72, 0xe8, 0x25, 0xc4, 0x44, 0x92, 0xfb, 0x73, 0x0e, 0x90, 0x18, 0xe6, + 0x2e, 0x4c, 0x58, 0xe0, 0x11, 0x59, 0x69, 0x44, 0xda, 0x4f, 0xda, 0x91, + 0xc2, 0xdd, 0xcd, 0x0c, 0x1f, 0xf6, 0x96, 0x7c, 0x58, 0x62, 0xe9, 0x6b, + 0x62, 0x3d, 0xf1, 0x63, 0xe8, 0x53, 0xc7, 0x80, 0x92, 0xf6, 0x3b, 0xce, + 0x46, 0xbc, 0xe0, 0xd6, 0x03, 0xd0, 0xdd, 0xa1, 0x4c, 0xb0, 0x0a, 0xf2, + 0x26, 0xe8, 0x60, 0xf5, 0xbc, 0x32, 0xc0, 0xd5, 0x41, 0x3f, 0xfe, 0x1e, + 0xfa, 0xcb, 0xc5, 0x3a, 0xb7, 0x4b, 0xff, 0xa7, 0xe7, 0xbf, 0x8e, 0x1b, + 0xa4, 0x10, 0xa8, 0xe7, 0x9d, 0xa2, 0x3c, 0x9a, 0xcb, 0x53, 0xb5, 0x45, + 0xab, 0x4f, 0xeb, 0xe2, 0x18, 0x94, 0xfc, 0x7b, 0x1a, 0x7b, 0xaf, 0x05, + 0xfe, 0x94, 0xdb, 0xa4, 0x8b, 0xc3, 0x61, 0xb1, 0xa8, 0xab, 0xea, 0xef, + 0x99, 0x37, 0x07, 0xb7, 0xba, 0x4b, 0x1a, 0xa9, 0x43, 0x89, 0x3e, 0xff, + 0x71, 0xfd, 0x5b, 0x1a, 0xeb, 0x7d, 0x86, 0x55, 0x5a, 0x06, 0x98, 0x93, + 0x43, 0xba, 0x6c, 0xac, 0xb8, 0x8c, 0xba, 0x54, 0xc9, 0xbb, 0xe8, 0x12, + 0xcc, 0xa8, 0x80, 0x77, 0xaf, 0x00, 0xcd, 0x4b, 0xb2, 0x00, 0x1a, 0x96, + 0x7d, 0x80, 0xe6, 0x1b, 0xd0, 0x25, 0x60, 0x85, 0xc5, 0xc3, 0x5d, 0xa5, + 0xaa, 0xf8, 0xcd, 0xf6, 0xd6, 0x7f, 0xa5, 0xf5, 0x72, 0xb8, 0x42, 0xbe, + 0x5f, 0xa1, 0x76, 0xef, 0xa2, 0xda, 0xef, 0xad, 0x13, 0x3f, 0xdc, 0x77, + 0x23, 0x2b, 0x2f, 0xe1, 0x8b, 0xa0, 0x9c, 0x7b, 0x2a, 0x3a, 0xf8, 0x6b, + 0x6c, 0x53, 0x7f, 0x35, 0x7d, 0xbe, 0x59, 0xeb, 0xbe, 0x3c, 0x02, 0x09, + 0x92, 0xfb, 0x3e, 0x94, 0x21, 0x3b, 0x83, 0xef, 0x78, 0x89, 0xbd, 0x95, + 0xb6, 0x60, 0x59, 0x1c, 0xdf, 0xdc, 0x5d, 0x2d, 0x31, 0x05, 0x6a, 0x64, + 0x2f, 0xf3, 0x16, 0xf6, 0x40, 0x0b, 0xbf, 0x24, 0xba, 0x50, 0x26, 0x00, + 0x95, 0x7b, 0xf0, 0x27, 0xf2, 0xea, 0x5b, 0xac, 0x72, 0x70, 0xeb, 0x83, + 0x00, 0x52, 0xe8, 0xe5, 0xc7, 0x07, 0xcf, 0xf6, 0xb6, 0xb4, 0xc1, 0xc0, + 0x23, 0x63, 0x9f, 0xca, 0xf1, 0xce, 0x39, 0xc6, 0x54, 0x5b, 0xce, 0xa3, + 0x15, 0x79, 0x08, 0xe9, 0x87, 0x7c, 0x15, 0x2c, 0xf2, 0x2c, 0x52, 0x1d, + 0xa7, 0x1e, 0xdb, 0xd0, 0x2f, 0xe6, 0xf1, 0x01, 0x56, 0x93, 0x5a, 0x26, + 0xac, 0x5e, 0x5b, 0x82, 0xbc, 0x97, 0x62, 0xdd, 0xa9, 0x2b, 0x7d, 0xc2, + 0x31, 0xc2, 0xb8, 0x64, 0x9a, 0x79, 0x66, 0x4b, 0x02, 0x62, 0xbb, 0xff, + 0xa5, 0xc8, 0xdc, 0xa8, 0x79, 0xe7, 0x32, 0xb3, 0x43, 0xd5, 0x61, 0x3a, + 0x04, 0x95, 0xf1, 0x2c, 0xe6, 0x8b, 0xf0, 0xdd, 0x9d, 0x2b, 0x18, 0x2f, + 0x24, 0x7d, 0x3c, 0x55, 0x57, 0x66, 0xa9, 0x21, 0x34, 0x2a, 0xa9, 0x7c, + 0x4e, 0x30, 0x1a, 0x99, 0x05, 0x3e, 0x41, 0x1f, 0x08, 0xf4, 0x76, 0xef, + 0xbe, 0x52, 0xcf, 0xa6, 0x3a, 0xdd, 0xac, 0x7f, 0x5d, 0xf5, 0xfe, 0x03, + 0x31, 0x88, 0x13, 0x1b, 0x96, 0xde, 0x19, 0x07, 0x59, 0x8e, 0x84, 0xf5, + 0xc1, 0x36, 0xb8, 0xef, 0x1d, 0x2c, 0xaa, 0x82, 0xa1, 0xb0, 0xca, 0x71, + 0xf6, 0x07, 0xda, 0xff, 0x7d, 0x73, 0x50, 0x1b, 0x5f, 0x4c, 0x74, 0x2a, + 0x8e, 0xe1, 0xf6, 0x4f, 0x59, 0x77, 0x12, 0x59, 0xa1, 0x72, 0x23, 0xcd, + 0x51, 0x22, 0xa2, 0x74, 0xfc, 0x5d, 0xd8, 0xaa, 0x4f, 0xc5, 0xa4, 0xcb, + 0x14, 0xc8, 0x21, 0x1a, 0x19, 0xe9, 0x8b, 0xf8, 0x0b, 0x7d, 0x5a, 0x62, + 0xd8, 0x97, 0xdb, 0x0d, 0x9d, 0xb8, 0x96, 0x9f, 0xb6, 0x50, 0xb8, 0x88, + 0xd6, 0x10, 0xd2, 0x88, 0xc2, 0x2f, 0xe0, 0x8b, 0xd9, 0xd0, 0xd8, 0xa7, + 0x50, 0xc0, 0x62, 0x9f, 0xec, 0x28, 0xb1, 0xab, 0xd5, 0x46, 0x85, 0x27, + 0x84, 0x0a, 0x89, 0xa2, 0xf0, 0x87, 0xee, 0x0b, 0x22, 0x0a, 0xd4, 0xcb, + 0x53, 0xb9, 0xcd, 0x5c, 0x6d, 0xee, 0xc5, 0xc7, 0x6f, 0xb0, 0xbb, 0x05, + 0xc9, 0x4a, 0xa4, 0xbc, 0x96, 0xeb, 0x2b, 0x90, 0xbe, 0x96, 0xa2, 0xc1, + 0x02, 0x57, 0x06, 0xcf, 0xa0, 0x2f, 0xfd, 0xa8, 0xf6, 0x41, 0xd6, 0x20, + 0x4e, 0x08, 0xf2, 0x9a, 0x9b, 0x0f, 0x93, 0x88, 0xd1, 0x8f, 0xf8, 0xe5, + 0x3b, 0xf6, 0xcf, 0x4b, 0x09, 0x50, 0x2a, 0x76, 0x83, 0x60, 0x24, 0xa4, + 0xf9, 0x2c, 0xe1, 0x01, 0xea, 0xd2, 0x55, 0xb9, 0xb4, 0xf0, 0x98, 0x9b, + 0x3c, 0x21, 0x79, 0xe8, 0x01, 0x28, 0xff, 0xf6, 0x12, 0x4b, 0xb9, 0x8c, + 0xe1, 0x40, 0x9f, 0xa2, 0xe5, 0xbf, 0x10, 0xab, 0x2f, 0x53, 0x87, 0x0b, + 0x6e, 0xda, 0x98, 0xe6, 0xf6, 0x1b, 0x62, 0x26, 0x88, 0x96, 0x5b, 0x48, + 0x37, 0xbb, 0x48, 0x60, 0xe3, 0xb5, 0x47, 0xb9, 0x78, 0x26, 0xd8, 0x90, + 0x7c, 0x78, 0x9e, 0xbb, 0x41, 0xbb, 0x6b, 0xa5, 0xbb, 0x0e, 0x04, 0xc6, + 0xc0, 0xcd, 0x2e, 0x23, 0xa3, 0xbc, 0x28, 0x5c, 0x4c, 0x57, 0xc4, 0xab, + 0x7c, 0x91, 0xdc, 0x9e, 0xf1, 0x50, 0x8b, 0xd3, 0x34, 0xb8, 0xfd, 0x54, + 0x5a, 0x59, 0xfa, 0x3c, 0xb6, 0xe0, 0x61, 0x96, 0xb2, 0x59, 0x6e, 0x8c, + 0xae, 0x0b, 0x76, 0x35, 0x22, 0x1b, 0x8f, 0xbc, 0x90, 0xb9, 0xd7, 0x61, + 0xd2, 0xb0, 0xa0, 0xfd, 0x7c, 0xfa, 0xab, 0xa6, 0xc0, 0x77, 0xd0, 0xba, + 0x99, 0x64, 0x91, 0xd9, 0x43, 0xe0, 0xc1, 0x12, 0x8d, 0x87, 0xa0, 0x76, + 0x30, 0x83, 0x53, 0x9d, 0x8c, 0x2a, 0xd2, 0x15, 0xe3, 0xb0, 0xe3, 0x12, + 0x9c, 0x4a, 0x8e, 0x32, 0xb7, 0x83, 0x31, 0xe5, 0x2b, 0xc2, 0x9e, 0x7c, + 0x67, 0x9d, 0xc9, 0x52, 0x9c, 0x88, 0xdd, 0x9a, 0x14, 0x81, 0xf6, 0x0b, + 0x4a, 0x8b, 0x4b, 0x53, 0x41, 0x6f, 0x69, 0xe0, 0x04, 0xf6, 0xf3, 0xbc, + 0x55, 0xf9, 0xca, 0x47, 0xcd, 0xc0, 0x62, 0x27, 0xa5, 0x3f, 0x98, 0xa2, + 0x20, 0xad, 0x52, 0xde, 0xee, 0x80, 0x88, 0xf2, 0xa7, 0xe0, 0xe5, 0xec, + 0x5f, 0x0e, 0x54, 0x76, 0xec, 0x9f, 0x9d, 0xff, 0x38, 0xd8, 0x28, 0xb2, + 0xdd, 0x62, 0xa8, 0x80, 0xfb, 0x7b, 0xb9, 0x25, 0x4a, 0x25, 0xb8, 0x31, + 0x44, 0x0e, 0x7a, 0x71, 0xb1, 0xc7, 0xdc, 0xdb, 0xb8, 0x4e, 0x0f, 0x43, + 0x8e, 0xa5, 0xed, 0xd5, 0xcb, 0xca, 0xe3, 0x0f, 0xa2, 0xf5, 0xf3, 0x49, + 0x89, 0x44, 0x63, 0x38, 0xc0, 0x88, 0x94, 0x1f, 0xa3, 0x2c, 0x47, 0xa1, + 0x47, 0x51, 0x1a, 0xb4, 0xa2, 0xa7, 0x97, 0x78, 0x1a, 0x0e, 0x23, 0xc5, + 0xe4, 0x5b, 0x51, 0x41, 0x7a, 0x8b, 0xb2, 0xa5, 0x59, 0xab, 0x0b, 0xa9, + 0x0b, 0xea, 0xe2, 0x88, 0xcf, 0x93, 0xae, 0x07, 0x86, 0xa5, 0x15, 0x0c, + 0x2b, 0x5f, 0x6f, 0xaf, 0x2f, 0x20, 0x56, 0xe5, 0x02, 0xee, 0x13, 0xd5, + 0x9b, 0x51, 0x1c, 0x9e, 0xce, 0x78, 0x4f, 0xab, 0xd1, 0xf5, 0x48, 0x41, + 0x93, 0x65, 0xa5, 0x0b, 0x3a, 0xf9, 0x4f, 0xd0, 0x27, 0x5a, 0x06, 0xd4, + 0x85, 0xac, 0x10, 0xad, 0xad, 0xe4, 0xa0, 0x54, 0x8b, 0xfd, 0xdc, 0xaf, + 0x02, 0xfe, 0xff, 0xd3, 0xfb, 0x64, 0xb0, 0x25, 0xf6, 0xdc, 0x23, 0xaa, + 0xe2, 0x09, 0xaa, 0x0f, 0x08, 0x9f, 0x41, 0xbb, 0xb1, 0x41, 0x0f, 0x21, + 0x67, 0xb5, 0x66, 0xf2, 0xcc, 0x14, 0xdf, 0x33, 0x8f, 0x6b, 0x88, 0xd8, + 0xb0, 0x3a, 0x0f, 0xe8, 0x75, 0x49, 0x25, 0x71, 0x4e, 0xea, 0xd7, 0xf6, + 0x72, 0x05, 0xeb, 0x3d, 0xce, 0x28, 0xdc, 0x67, 0xca, 0x89, 0x8c, 0x6c, + 0xf2, 0xe2, 0x46, 0x1b, 0xf9, 0x97, 0xde, 0x6e, 0x09, 0xe9, 0xc7, 0x05, + 0x0d, 0xbc, 0x51, 0x1f, 0x61, 0x4b, 0x7d, 0x71, 0x6d, 0xaf, 0x06, 0x37, + 0x40, 0xcf, 0x98, 0xf7, 0x8c, 0x87, 0x23, 0xb3, 0x35, 0xfe, 0xff, 0xb8, + 0xe9, 0xba, 0x95, 0x08, 0xb4, 0x38, 0x2e, 0xe3, 0xa0, 0x7a, 0x95, 0xce, + 0xfc, 0x0b, 0xc4, 0x46, 0x70, 0x98, 0xad, 0xae, 0x1e, 0xb8, 0x6a, 0xf2, + 0x2d, 0x29, 0xdd, 0xff, 0xe8, 0xf4, 0xe0, 0x5d, 0x4b, 0xf1, 0x7a, 0x66, + 0xa8, 0x5b, 0xe5, 0x51, 0x21, 0x03, 0x8e, 0xb0, 0x55, 0x88, 0xec, 0x45, + 0xda, 0x22, 0xa1, 0xd7, 0xa6, 0x03, 0x24, 0xba, 0x7b, 0xee, 0xb0, 0xa5, + 0xd9, 0x58, 0x74, 0x09, 0x78, 0x7a, 0x51, 0x0e, 0x68, 0xad, 0x67, 0x8d, + 0xd9, 0x70, 0x95, 0x3c, 0x20, 0xa4, 0xce, 0x30, 0xb8, 0xa5, 0x47, 0x7e, + 0x89, 0x53, 0xbe, 0x99, 0x57, 0x7f, 0x06, 0x09, 0xda, 0x6f, 0x18, 0x5a, + 0x95, 0xfe, 0x92, 0x7a, 0x2e, 0x8b, 0x5e, 0x1d, 0x62, 0xf8, 0xfd, 0x4d, + 0xd0, 0x86, 0x75, 0xf1, 0x31, 0x70, 0x3c, 0xf4, 0x25, 0x55, 0x54, 0x7c, + 0xc2, 0x6f, 0x47, 0xb1, 0xeb, 0x22, 0x5a, 0x0d, 0x64, 0xaa, 0x3d, 0xf8, + 0xc5, 0x0f, 0xd4, 0x2d, 0x78, 0x48, 0x80, 0x21, 0xd5, 0x4b, 0x43, 0xbd, + 0xdc, 0xcc, 0xba, 0x5c, 0xaa, 0x80, 0xd5, 0xa4, 0xee, 0x5f, 0xaa, 0x05, + 0x16, 0x98, 0x19, 0xec, 0x37, 0x8f, 0x0e, 0x1e, 0xa5, 0x77, 0x1b, 0x42, + 0x8f, 0x43, 0x1c, 0x4c, 0xa0, 0x2d, 0x50, 0x61, 0xe8, 0x31, 0x4d, 0xd4, + 0x48, 0x57, 0x70, 0xa2, 0xc8, 0x1a, 0xb3, 0x28, 0x05, 0x1f, 0xb9, 0x4e, + 0x2c, 0xed, 0x93, 0x73, 0x08, 0xf2, 0xc3, 0x3a, 0x86, 0x34, 0x06, 0xf0, + 0x0d, 0x2a, 0x30, 0xec, 0xe2, 0xb9, 0x41, 0xec, 0xf0, 0xd7, 0x07, 0xc5, + 0x48, 0x8a, 0xcb, 0xb9, 0xa9, 0x16, 0xf2, 0xf5, 0xc5, 0xa5, 0x3b, 0x12, + 0x8a, 0x97, 0xe8, 0x60, 0x07, 0x57, 0x93, 0xbc, 0x91, 0x97, 0x4f, 0x48, + 0xad, 0x59, 0x12, 0xc7, 0x8f, 0x2b, 0xd4, 0x29, 0x22, 0xde, 0x23, 0x05, + 0x46, 0x58, 0xa0, 0xc2, 0xd2, 0x33, 0x91, 0x6e, 0x8e, 0x28, 0x75, 0xe5, + 0x38, 0x78, 0x6c, 0xb8, 0xe7, 0xeb, 0x53, 0xb9, 0x08, 0x16, 0x1d, 0xfc, + 0x12, 0x99, 0x18, 0x53, 0x14, 0xe9, 0x23, 0xf5, 0xe8, 0x98, 0xcf, 0x66, + 0xe6, 0x55, 0xb8, 0xc8, 0xe1, 0xcf, 0xb6, 0x48, 0xaa, 0x49, 0xee, 0x00, + 0x52, 0xa4, 0xe0, 0xe2, 0x66, 0x23, 0x41, 0xff, 0x1d, 0x69, 0xac, 0x0e, + 0xfa, 0x4c, 0x2a, 0x3f, 0x24, 0x90, 0xfa, 0xde, 0x2e, 0xbc, 0x93, 0x09, + 0xf1, 0x18, 0x3a, 0xc9, 0xb7, 0x7d, 0x81, 0xe5, 0xe6, 0xfe, 0x6d, 0x3a, + 0xb8, 0x28, 0xb3, 0xbd, 0x50, 0x82, 0x44, 0x40, 0x8c, 0x9c, 0x30, 0xe5, + 0x43, 0x3a, 0x9e, 0x94, 0x16, 0xf7, 0xbc, 0x16, 0xe8, 0x34, 0x4d, 0xa4, + 0x62, 0x2e, 0x52, 0xc5, 0x0e, 0x83, 0xef, 0x18, 0x5f, 0x79, 0xd7, 0x1e, + 0x02, 0x4d, 0x89, 0x9a, 0x6e, 0xe1, 0x22, 0x66, 0x43, 0xcf, 0x5d, 0x2e, + 0xea, 0x47, 0x21, 0xc4, 0x94, 0xf4, 0xb2, 0x20, 0xbf, 0xd7, 0x5f, 0xcc, + 0x79, 0x4b, 0x76, 0x00, 0x63, 0x5a, 0xdf, 0x43, 0xde, 0x5e, 0x7f, 0x59, + 0x8c, 0xc4, 0x6e, 0x28, 0x8b, 0x08, 0xac, 0xaa, 0xfb, 0xaa, 0x55, 0x4d, + 0xce, 0xa2, 0x4a, 0xa2, 0xf7, 0x45, 0x09, 0x54, 0xcf, 0x90, 0x53, 0xbe, + 0xa1, 0xe9, 0xe1, 0x49, 0x10, 0xcf, 0x72, 0xa5, 0xd3, 0xe7, 0x47, 0xab, + 0x7f, 0xa7, 0x4c, 0x81, 0x82, 0x9b, 0xd1, 0xdf, 0x00, 0x12, 0x95, 0x18, + 0xe3, 0xa4, 0x19, 0xf7, 0x5f, 0x56, 0x04, 0xa0, 0x5c, 0xdd, 0xd2, 0xdc, + 0xd2, 0x1c, 0xf4, 0x7f, 0x43, 0x05, 0x93, 0x06, 0x78, 0x49, 0x82, 0x24, + 0x83, 0x41, 0x0e, 0xad, 0x31, 0x88, 0xee, 0x99, 0x5c, 0x6b, 0xbd, 0xd6, + 0x35, 0x42, 0x98, 0xb5, 0x03, 0x19, 0xba, 0xd1, 0x83, 0x71, 0xfa, 0x0d, + 0x2d, 0x4e, 0x04, 0xb3, 0x73, 0xae, 0x75, 0x61, 0x56, 0xad, 0xe3, 0x95, + 0xe7, 0x68, 0x36, 0x65, 0xc5, 0x00, 0x33, 0x5d, 0xdd, 0xff, 0xbe, 0xe8, + 0xb2, 0x9e, 0xfe, 0xd5, 0xf9, 0xbf, 0x81, 0x2c, 0xf7, 0x64, 0x2e, 0x53, + 0x88, 0x85, 0x23, 0xb8, 0x44, 0x43, 0x1e, 0xe1, 0x99, 0xd7, 0x41, 0x67, + 0x51, 0xed, 0xa7, 0x1d, 0xcb, 0x8f, 0x9e, 0xcf, 0x7c, 0x9f, 0xbe, 0x01, + 0xf6, 0x59, 0x52, 0xfe, 0xf8, 0xc1, 0x1c, 0x52, 0x91, 0xe9, 0x02, 0x26, + 0x23, 0x30, 0x72, 0x8a, 0x99, 0x3b, 0xe3, 0xad, 0xce, 0x5f, 0x01, 0xf2, + 0x80, 0xf2, 0x97, 0xbe, 0x28, 0x8c, 0x98, 0x07, 0xa6, 0xf2, 0xcf, 0xaa, + 0x7e, 0x16, 0x41, 0x5c, 0x90, 0x58, 0x62, 0xa0, 0x51, 0xb1, 0x4c, 0x80, + 0xbb, 0xe3, 0x07, 0x5e, 0x74, 0xbf, 0x7a, 0x62, 0x5a, 0x6c, 0xce, 0x20, + 0x74, 0x67, 0x2a, 0xe3, 0x89, 0xeb, 0xe8, 0xc5, 0xcf, 0xdc, 0x7c, 0xfe, + 0x33, 0x51, 0x9d, 0x5d, 0x2b, 0x20, 0x25, 0x88, 0x70, 0xec, 0xa1, 0x7b, + 0x77, 0x37, 0x2d, 0xaf, 0x7e, 0x58, 0xf7, 0x5f, 0x00, 0xce, 0x0f, 0x0e, + 0x23, 0x47, 0xd2, 0x78, 0xeb, 0xa5, 0x14, 0x2d, 0x26, 0x25, 0x36, 0x6a, + 0xd4, 0x1a, 0x77, 0x4c, 0xc0, 0x93, 0x96, 0x07, 0x6b, 0x63, 0x0f, 0x53, + 0x09, 0x44, 0xfe, 0x37, 0xcb, 0x87, 0xb5, 0x5e, 0xd7, 0x71, 0xe5, 0x9a, + 0xe5, 0x92, 0x7a, 0x9f, 0xe2, 0x0c, 0x78, 0x5f, 0xa6, 0x11, 0x7f, 0x79, + 0x7b, 0xbe, 0x91, 0xe9, 0xdf, 0xf0, 0x0f, 0x0d, 0x51, 0x50, 0x42, 0x78, + 0x6e, 0xfe, 0x48, 0x4a, 0xf9, 0xf1, 0xfd, 0x6c, 0x8e, 0xec, 0x93, 0xf0, + 0x90, 0x5a, 0xce, 0x79, 0xa6, 0x06, 0x34, 0x0b, 0x5a, 0x6f, 0x78, 0x45, + 0x62, 0x65, 0x7b, 0x83, 0xfd, 0xc7, 0x0b, 0x21, 0x91, 0x8f, 0x4c, 0xa3, + 0x56, 0xae, 0xb1, 0xf8, 0x2f, 0x7b, 0x26, 0xb8, 0x28, 0xef, 0x1a, 0xee, + 0xf2, 0xba, 0xc6, 0x00, 0x39, 0xf4, 0x04, 0xc5, 0xeb, 0xde, 0x12, 0xc2, + 0x1d, 0x08, 0x0c, 0xcf, 0x2c, 0x7b, 0x16, 0xdc, 0x38, 0xf2, 0x5d, 0x5a, + 0x70, 0x35, 0x00, 0x21, 0x7d, 0x1d, 0xa3, 0x26, 0x6a, 0x3b, 0xa8, 0xf1, + 0x19, 0x30, 0x23, 0xa4, 0x97, 0x52, 0xe5, 0xf2, 0x79, 0x5a, 0x9b, 0xd0, + 0x3d, 0x01, 0xc9, 0xcb, 0x9c, 0x89, 0xb6, 0x3b, 0xc5, 0x7a, 0x06, 0x2e, + 0x88, 0xf2, 0x51, 0x3c, 0xe6, 0xb9, 0x1e, 0xb8, 0x9f, 0xcb, 0xf0, 0x6f, + 0x38, 0x9d, 0x19, 0x92, 0x7e, 0x81, 0x0d, 0x68, 0x0a, 0xbc, 0xf1, 0xe2, + 0x93, 0x4e, 0x6f, 0x1f, 0x06, 0xf7, 0x29, 0xa8, 0x02, 0x2e, 0xf9, 0xae, + 0x46, 0xa8, 0x74, 0x87, 0x51, 0x40, 0x58, 0xc1, 0x5b, 0x0b, 0xb9, 0xb4, + 0x79, 0x73, 0x15, 0x8f, 0x90, 0x9d, 0x0f, 0xf7, 0x27, 0xbb, 0x25, 0x81, + 0x96, 0xe2, 0x39, 0x2f, 0x73, 0x5a, 0x7d, 0xfc, 0x8e, 0x96, 0xb2, 0x84, + 0xf5, 0x9d, 0x0f, 0x2a, 0x8c, 0x61, 0xb1, 0x6a, 0x9f, 0xa0, 0x09, 0x0b, + 0xfb, 0x2f, 0x9b, 0x1c, 0xf0, 0x8a, 0x68, 0xca, 0xae, 0x29, 0x4b, 0x44, + 0xc5, 0xfa, 0x84, 0x6f, 0x3d, 0x04, 0x51, 0x40, 0xaf, 0x07, 0x6e, 0xeb, + 0x75, 0xb2, 0xc8, 0x08, 0xd4, 0x6b, 0x66, 0xb3, 0xf2, 0x4c, 0x31, 0x15, + 0x8b, 0x9c, 0x2c, 0xc5, 0xe0, 0x8d, 0x23, 0x3b, 0x93, 0xef, 0xfb, 0x55, + 0x4b, 0x66, 0x49, 0xfd, 0x03, 0x73, 0x44, 0xda, 0x2c, 0x9e, 0x3e, 0x1f, + 0xce, 0x29, 0xd7, 0x5d, 0x36, 0xc3, 0x7a, 0x9e, 0x67, 0x1d, 0xe0, 0x27, + 0x69, 0x5d, 0x25, 0xfb, 0x46, 0x83, 0x0e, 0x0c, 0x8c, 0xa4, 0x4a, 0x3b, + 0x63, 0x75, 0x10, 0x28, 0x1b, 0x56, 0xce, 0xff, 0xeb, 0x63, 0x85, 0xc9, + 0xcf, 0xfa, 0xe0, 0x6c, 0xfe, 0x2d, 0xb1, 0x52, 0xd8, 0xf7, 0xb8, 0xcf, + 0x62, 0x3f, 0x24, 0x63, 0x4a, 0xa9, 0x8c, 0x97, 0x0a, 0xc4, 0x62, 0xcb, + 0x6e, 0x75, 0x4c, 0xc3, 0x12, 0xee, 0x9d, 0x48, 0xc4, 0xb6, 0xb2, 0x86, + 0xaa, 0xee, 0x4e, 0xb6, 0x52, 0xb1, 0x14, 0x00, 0x31, 0xfb, 0x22, 0x65, + 0x8d, 0xf8, 0xc5, 0x53, 0x89, 0xfc, 0x85, 0xad, 0xb0, 0xb7, 0x96, 0x4e, + 0xee, 0x39, 0x0f, 0xea, 0x6b, 0xbc, 0x36, 0x29, 0x0a, 0x9e, 0xcd, 0x09, + 0x47, 0x5f, 0x89, 0x1b, 0x84, 0x2f, 0xed, 0x67, 0xe4, 0x9f, 0x1e, 0xb3, + 0x06, 0xc1, 0x61, 0x8d, 0xe0, 0x70, 0x11, 0x8d, 0xc0, 0x39, 0x76, 0x40, + 0x63, 0xf9, 0x8c, 0x35, 0x78, 0xea, 0x0b, 0xae, 0xc2, 0x0e, 0x22, 0x73, + 0x48, 0x1c, 0xc9, 0x4b, 0x80, 0x1e, 0xa3, 0x5e, 0x41, 0x70, 0xb1, 0x6a, + 0x77, 0xb5, 0x43, 0xb0, 0x20, 0xc1, 0xd1, 0x79, 0x19, 0xdf, 0xe5, 0xf6, + 0xc6, 0xbf, 0x2d, 0xdf, 0x5f, 0x26, 0x27, 0x83, 0xa5, 0x22, 0xc1, 0x30, + 0x46, 0xf3, 0xa6, 0x6b, 0xde, 0xee, 0x66, 0xb8, 0xf9, 0x9a, 0xe6, 0x29, + 0xdf, 0xa1, 0x45, 0xbd, 0xa1, 0x11, 0x7e, 0x4a, 0x26, 0x62, 0x5a, 0xe1, + 0x25, 0x48, 0x12, 0x61, 0xe8, 0xf2, 0xac, 0xc0, 0xe7, 0x15, 0x03, 0xd9, + 0x38, 0x40, 0xd1, 0x55, 0x7d, 0xcf, 0xf9, 0xac, 0xd6, 0x76, 0x14, 0xc4, + 0x01, 0xd5, 0x5a, 0xb4, 0xbd, 0x9a, 0xae, 0x59, 0x9f, 0x16, 0x36, 0x72, + 0xcb, 0x94, 0x21, 0x89, 0x64, 0xbd, 0xe2, 0x87, 0x46, 0x15, 0x13, 0x54, + 0xa5, 0xae, 0x5b, 0x74, 0x91, 0x62, 0x38, 0xd4, 0x02, 0xa9, 0x26, 0x25, + 0xcb, 0xc2, 0x12, 0xba, 0x64, 0x76, 0x79, 0x00, 0x6c, 0x3d, 0x63, 0xdb, + 0x31, 0x2c, 0x7a, 0x4c, 0x5f, 0x48, 0xff, 0x7c, 0x07, 0x05, 0xd8, 0xd3, + 0x45, 0xf4, 0x46, 0x19, 0x7f, 0xc8, 0xff, 0xb6, 0xa4, 0x51, 0x40, 0xd5, + 0x00, 0xb5, 0x94, 0xb9, 0x6f, 0xef, 0xf1, 0x4b, 0x03, 0xd8, 0x34, 0xc1, + 0x70, 0x76, 0x70, 0x6c, 0xe0, 0x54, 0xd7, 0x7f, 0xd1, 0xf1, 0x65, 0xee, + 0xd1, 0x49, 0x02, 0x0d, 0x9b, 0x22, 0xef, 0x37, 0x21, 0x9e, 0x5f, 0xf0, + 0xab, 0x05, 0x13, 0xa6, 0xaf, 0xc0, 0x7e, 0xa1, 0x17, 0x99, 0x01, 0xda, + 0xba, 0xf0, 0x5a, 0x8f, 0x95, 0xf2, 0x85, 0x34, 0x94, 0x38, 0xfe, 0xb4, + 0x43, 0x40, 0xad, 0xe3, 0x4e, 0x9d, 0x87, 0x77, 0x44, 0xb2, 0x6c, 0x64, + 0xc8, 0xc8, 0xa9, 0x87, 0x2a, 0x73, 0x6d, 0xad, 0x40, 0x57, 0x37, 0x50, + 0x71, 0x4e, 0x9d, 0x0f, 0x42, 0x65, 0x56, 0x64, 0xeb, 0xc6, 0x7f, 0x69, + 0xa4, 0x41, 0x16, 0x4e, 0xf2, 0xdf, 0x3b, 0xc0, 0x0b, 0xbf, 0x91, 0xcb, + 0xee, 0x38, 0x17, 0x5e, 0xa7, 0x76, 0x03, 0xef, 0x93, 0x4b, 0x99, 0x29, + 0x28, 0xe1, 0x2d, 0xe3, 0x85, 0xf7, 0xab, 0xd1, 0x4f, 0x7e, 0x1d, 0xde, + 0x13, 0x8d, 0x22, 0x60, 0x29, 0x75, 0xfe, 0x73, 0x52, 0x2d, 0x48, 0xb4, + 0x1b, 0xd7, 0x3e, 0x61, 0x25, 0x91, 0x8e, 0x50, 0xab, 0xbf, 0xe9, 0x72, + 0x15, 0xbf, 0x61, 0x97, 0x2d, 0x8f, 0x0e, 0xf0, 0x3f, 0x41, 0xc0, 0x9b, + 0xa9, 0x8d, 0xba, 0x3c, 0xe4, 0x97, 0xc2, 0xa9, 0xb6, 0xf1, 0xbc, 0xaa, + 0xd3, 0x3c, 0x13, 0x36, 0x31, 0x94, 0x36, 0xa3, 0xab, 0x4b, 0x4a, 0x22, + 0x6a, 0x5d, 0x69, 0x34, 0x54, 0x20, 0x87, 0x0f, 0xd8, 0x33, 0x6f, 0x5a, + 0x3d, 0xff, 0xec, 0x62, 0x82, 0xf6, 0xf4, 0x4b, 0x74, 0x31, 0x17, 0x5a, + 0x52, 0x47, 0x04, 0x1b, 0xc5, 0xf1, 0x94, 0x57, 0xe6, 0x4d, 0xe4, 0x5a, + 0x6c, 0xdd, 0x58, 0xc2, 0x46, 0xe2, 0xb9, 0x0f, 0xe6, 0x1c, 0x23, 0x64, + 0x34, 0x5c, 0x8c, 0x3a, 0xe4, 0x7c, 0x4c, 0x4d, 0xaf, 0x09, 0x22, 0xdf, + 0x63, 0xaf, 0x09, 0xf6, 0x54, 0xa8, 0x47, 0xbc, 0x01, 0x18, 0x76, 0x1f, + 0x5f, 0x71, 0x00, 0x4e, 0xb9, 0x49, 0xeb, 0x91, 0xff, 0x00, 0xd6, 0x5c, + 0x74, 0x83, 0xbd, 0xf3, 0xca, 0x8c, 0x2c, 0x81, 0x48, 0xc5, 0xea, 0xf6, + 0x03, 0xa2, 0x9f, 0xc6, 0x88, 0xd9, 0x41, 0xda, 0x82, 0x01, 0x72, 0x31, + 0xed, 0xc9, 0xec, 0xa1, 0xb2, 0x42, 0x3d, 0x82, 0xf3, 0x92, 0x2c, 0xa9, + 0xed, 0xcd, 0xfa, 0x3d, 0x8d, 0xf9, 0xcf, 0x5f, 0x28, 0x50, 0x7e, 0x20, + 0x4a, 0x8b, 0x19, 0x98, 0x1a, 0xca, 0x99, 0xa3, 0xb4, 0xd9, 0xa4, 0xf1, + 0x11, 0xcd, 0xa9, 0x99, 0xe4, 0xcc, 0xb7, 0x09, 0xb4, 0x2e, 0xd5, 0xfc, + 0x24, 0x3c, 0x6d, 0x0c, 0xab, 0xec, 0x0c, 0x64, 0x10, 0x7c, 0x41, 0x85, + 0xff, 0x27, 0x88, 0x9c, 0xa0, 0x8c, 0xfe, 0xec, 0xc9, 0x85, 0xaa, 0x9e, + 0xb0, 0xf2, 0xc4, 0x61, 0x2e, 0xca, 0xd8, 0x86, 0x54, 0xeb, 0x1f, 0xad, + 0x04, 0xe9, 0x67, 0x4a, 0xb2, 0x65, 0x88, 0x93, 0x2c, 0x33, 0x31, 0x3e, + 0x0b, 0x5a, 0xdf, 0x9f, 0xd4, 0xd0, 0x09, 0xab, 0xd4, 0xd2, 0xf2, 0x80, + 0x37, 0x06, 0x8e, 0x28, 0x8c, 0x05, 0x59, 0x06, 0xa8, 0x6f, 0xf8, 0x45, + 0x5a, 0xaa, 0xd9, 0x6c, 0xd1, 0x35, 0x08, 0xc7, 0xcf, 0x77, 0x8a, 0x92, + 0x47, 0xf0, 0x3c, 0x9b, 0x2e, 0xf4, 0x05, 0x77, 0xd8, 0x82, 0xfe, 0x8e, + 0xb6, 0x93, 0x3a, 0x72, 0xbe, 0x28, 0x9e, 0x3a, 0x26, 0x1b, 0x99, 0x28, + 0xa0, 0x37, 0x74, 0xe6, 0xdb, 0xb2, 0xa8, 0x99, 0xe8, 0xe9, 0x72, 0x38, + 0x86, 0xf7, 0x7e, 0x6a, 0xbc, 0xd7, 0xdf, 0x0a, 0xba, 0x18, 0x7d, 0xa7, + 0x66, 0x53, 0x93, 0x8f, 0x66, 0x1b, 0x41, 0x2b, 0x9f, 0x86, 0x5a, 0x7f, + 0x0b, 0x90, 0x6f, 0x5a, 0xe0, 0x97, 0x7f, 0x37, 0x42, 0xe1, 0x1d, 0xfa, + 0x3e, 0x57, 0x9c, 0xeb, 0xe7, 0x04, 0xb0, 0x01, 0x7e, 0xa8, 0x6c, 0xcb, + 0xdf, 0xd0, 0x1b, 0x20, 0xf4, 0x8b, 0x56, 0x33, 0xc2, 0xe4, 0xf3, 0xe8, + 0x6a, 0x64, 0xaf, 0x50, 0x5b, 0x00, 0x9a, 0x4e, 0x97, 0x8d, 0x4d, 0xb5, + 0xe6, 0xcb, 0x49, 0x2b, 0x71, 0x37, 0x8e, 0xbf, 0x17, 0xed, 0xa0, 0xa1, + 0xdc, 0xd4, 0xc1, 0xe6, 0xc1, 0x2e, 0xf4, 0x80, 0x56, 0x77, 0xc6, 0xf7, + 0x12, 0x1e, 0xcc, 0x67, 0xc5, 0xb8, 0xe0, 0x46, 0xbe, 0xd7, 0x28, 0x99, + 0x9e, 0x4e, 0x7d, 0x3a, 0x35, 0x13, 0x31, 0x44, 0xc0, 0x62, 0x19, 0x4d, + 0x50, 0xac, 0xa5, 0xc3, 0x30, 0x9d, 0xf5, 0xfb, 0xfa, 0x8f, 0x92, 0xbd, + 0x87, 0xbd, 0x68, 0x3b, 0x8d, 0x0e, 0xd3, 0x03, 0xcb, 0xc7, 0x4c, 0xc9, + 0xe2, 0x0c, 0x31, 0x51, 0xa4, 0xe9, 0x8e, 0xda, 0x57, 0xc6, 0x45, 0xab, + 0x04, 0xb9, 0xb6, 0x1b, 0x76, 0x4b, 0x99, 0x0d, 0xe2, 0xa6, 0xe2, 0x2f, + 0x1a, 0xbb, 0x32, 0x93, 0xd9, 0x75, 0xfd, 0xe9, 0xd5, 0xf5, 0xcf, 0xfb, + 0x39, 0x08, 0xb9, 0x4a, 0xd1, 0x4a, 0x7b, 0x94, 0x61, 0x43, 0x87, 0x93, + 0xa8, 0x20, 0xbc, 0xae, 0x8c, 0x97, 0xbf, 0x3a, 0x79, 0x53, 0x0e, 0x6f, + 0x35, 0xc3, 0x3b, 0xa1, 0xa5, 0xee, 0xa9, 0xb1, 0xfd, 0xeb, 0xe8, 0xa0, + 0x2b, 0x56, 0x09, 0x3a, 0x93, 0x5a, 0x0c, 0xdc, 0x32, 0x64, 0x6e, 0x4c, + 0x6e, 0x26, 0x09, 0x22, 0x2f, 0x82, 0x78, 0xb6, 0xad, 0xff, 0xc2, 0xb5, + 0x78, 0x3a, 0x5b, 0x0d, 0x63, 0x0c, 0x86, 0x68, 0xcd, 0x49, 0x65, 0x28, + 0x16, 0xa6, 0x3a, 0xa8, 0xab, 0xd7, 0x4f, 0xb6, 0x33, 0x26, 0x37, 0xf0, + 0x91, 0x63, 0x63, 0x93, 0x67, 0x99, 0xa8, 0x1b, 0xe4, 0x49, 0x34, 0x2f, + 0xbf, 0x22, 0xb0, 0x05, 0x13, 0x67, 0x97, 0xdf, 0xc2, 0x51, 0x35, 0xae, + 0xa5, 0xe9, 0xe2, 0x10, 0xdc, 0x9e, 0xdc, 0x26, 0xde, 0x3b, 0x54, 0x2d, + 0xef, 0x23, 0x27, 0xf2, 0x7b, 0xf6, 0x68, 0xa1, 0xe0, 0x67, 0xe0, 0xe6, + 0xa5, 0xaf, 0x07, 0x9d, 0xa9, 0xdc, 0xfb, 0xef, 0xb9, 0x8a, 0xde, 0x3e, + 0x9b, 0x61, 0x36, 0x5a, 0x86, 0x7e, 0xd4, 0x8b, 0x42, 0x8a, 0x19, 0x71, + 0x6a, 0xc2, 0xb1, 0xd1, 0x40, 0xd3, 0xeb, 0x00, 0xce, 0x78, 0xd7, 0x08, + 0x4b, 0xea, 0x54, 0x36, 0x30, 0x92, 0x0f, 0x1a, 0x41, 0xc0, 0x32, 0x8d, + 0x9e, 0x48, 0x82, 0x0b, 0xad, 0x76, 0x68, 0xe3, 0xb0, 0x57, 0xc3, 0x33, + 0xb2, 0xcc, 0x3c, 0x75, 0x92, 0x9b, 0x9d, 0xe0, 0x27, 0x32, 0xff, 0xe9, + 0x26, 0x85, 0xf5, 0xd1, 0x82, 0xa4, 0xc9, 0xf2, 0xf2, 0x66, 0xf1, 0xf2, + 0xc2, 0x4e, 0x19, 0x85, 0xd5, 0xc6, 0xb8, 0x74, 0x54, 0xd9, 0x61, 0x6b, + 0x8d, 0x4e, 0x19, 0x3c, 0x7e, 0x75, 0x10, 0x85, 0xc5, 0xaf, 0x9e, 0x4d, + 0x07, 0xee, 0x96, 0xf7, 0xec, 0x16, 0xe4, 0x78, 0x5e, 0x3f, 0x1f, 0xb0, + 0x17, 0x7e, 0x90, 0xb5, 0xb4, 0xda, 0xcf, 0xab, 0xca, 0xc6, 0xb5, 0xcf, + 0xbd, 0x11, 0xac, 0x13, 0xec, 0x2e, 0xd3, 0x0b, 0x89, 0x11, 0x10, 0x44, + 0x6b, 0xea, 0x0e, 0xec, 0x58, 0x7c, 0x38, 0x99, 0xca, 0xaf, 0xc9, 0xec, + 0x00, 0x10, 0x0e, 0x41, 0xce, 0xa1, 0x77, 0xf3, 0xfc, 0xe9, 0x7d, 0x09, + 0xd5, 0x4a, 0x35, 0x89, 0x3f, 0x05, 0xfc, 0x19, 0xac, 0x9b, 0x7f, 0xb6, + 0x29, 0x02, 0x29, 0x1a, 0x59, 0x11, 0x75, 0xcc, 0x17, 0xb9, 0xb0, 0x0d, + 0x0d, 0x66, 0x87, 0x1d, 0xd2, 0x83, 0xa4, 0x47, 0x86, 0x30, 0x0e, 0xe6, + 0xbf, 0x0f, 0xba, 0x59, 0xa6, 0x8d, 0x9e, 0x36, 0xa1, 0xe6, 0xd6, 0xc1, + 0x5a, 0xe7, 0xe0, 0x2f, 0x25, 0x3b, 0xd2, 0xab, 0x1c, 0xa5, 0xde, 0x3d, + 0x96, 0x05, 0x8c, 0x8b, 0xce, 0x01, 0xef, 0x9c, 0x4a, 0x01, 0x5d, 0x8e, + 0x6a, 0x29, 0x75, 0xab, 0x70, 0xd2, 0xd1, 0x3f, 0x7e, 0x16, 0xd6, 0xda, + 0xcf, 0x1e, 0x6c, 0x91, 0x27, 0xe8, 0x40, 0x5e, 0x77, 0xf1, 0x95, 0x3b, + 0x3a, 0x56, 0x86, 0xdb, 0x60, 0xea, 0x2a, 0xf5, 0x12, 0x53, 0x71, 0xbc, + 0xb9, 0xef, 0x12, 0x8a, 0x39, 0xa9, 0x40, 0x4a, 0x60, 0x8d, 0x96, 0x9c, + 0xb8, 0x1b, 0x30, 0x0a, 0xcf, 0xb0, 0xed, 0x72, 0xb3, 0x03, 0x67, 0x31, + 0x09, 0x75, 0x2f, 0x9a, 0x13, 0x40, 0xa1, 0x97, 0xb1, 0xc8, 0x20, 0x03, + 0x47, 0xf8, 0x36, 0x9b, 0x16, 0x55, 0xa2, 0xed, 0x56, 0x77, 0x54, 0xe4, + 0x0b, 0x72, 0xed, 0x3f, 0x66, 0x0d, 0xb4, 0x2f, 0x99, 0xfd, 0x68, 0xab, + 0x2d, 0xa9, 0xee, 0x99, 0x37, 0xb7, 0x81, 0x69, 0x19, 0xb8, 0xdb, 0x99, + 0x43, 0x16, 0xf4, 0x4c, 0x10, 0x54, 0x89, 0x22, 0x30, 0xb0, 0xe1, 0xf2, + 0x0a, 0x15, 0xe7, 0xf0, 0x95, 0x6b, 0xc4, 0x6b, 0xb9, 0x6a, 0xee, 0x50, + 0xc0, 0xec, 0xd8, 0x9d, 0xde, 0xa2, 0x8b, 0x80, 0x6e, 0xe3, 0x5a, 0x9d, + 0xb3, 0xcf, 0x45, 0x96, 0xa2, 0x02, 0x8a, 0x58, 0xd8, 0x7c, 0xbd, 0xfa, + 0xa9, 0x0f, 0x0e, 0xcb, 0x3c, 0x9f, 0x16, 0x3d, 0x1c, 0x12, 0x3e, 0x0b, + 0xd6, 0xa0, 0x2f, 0x47, 0x02, 0x6a, 0x04, 0x1b, 0xd6, 0xea, 0x2f, 0x4f, + 0xdf, 0x5e, 0x7a, 0xc5, 0x25, 0x6d, 0xf6, 0x31, 0x02, 0xbd, 0x99, 0x91, + 0x1c, 0x49, 0xaf, 0x4b, 0xf1, 0x95, 0x35, 0x52, 0x94, 0x70, 0x77, 0x6e, + 0x8d, 0x34, 0x9b, 0x06, 0x0d, 0x9b, 0x3d, 0x85, 0xd2, 0x75, 0x96, 0x5d, + 0xfe, 0x2a, 0xab, 0x07, 0x07, 0xda, 0xbd, 0xb9, 0xad, 0x72, 0xc6, 0x7a, + 0x0a, 0x28, 0x20, 0x69, 0x0d, 0x07, 0x09, 0xed, 0x7a, 0x18, 0x79, 0x47, + 0xde, 0x5f, 0xca, 0x8b, 0x06, 0xc5, 0x04, 0x6a, 0x2b, 0x3e, 0xc7, 0x64, + 0x50, 0x21, 0xb9, 0x70, 0xfd, 0x42, 0x80, 0x02, 0x59, 0x48, 0x0c, 0x6e, + 0x5b, 0xd8, 0x39, 0xe0, 0x66, 0xc4, 0xe0, 0xd6, 0x9c, 0x7b, 0xc4, 0xf1, + 0x98, 0xa6, 0xda, 0x05, 0x77, 0x50, 0x00, 0x39, 0xc5, 0x3c, 0xaf, 0xb5, + 0xcd, 0x08, 0xb0, 0xff, 0x29, 0x03, 0x66, 0x70, 0x13, 0x79, 0x8f, 0x18, + 0x39, 0x72, 0x6e, 0x8f, 0x14, 0xb3, 0x3e, 0x5b, 0xd3, 0x23, 0x62, 0xb6, + 0x8e, 0x02, 0x91, 0x82, 0x72, 0x3d, 0xb0, 0x96, 0xea, 0x6e, 0xaf, 0x4e, + 0x02, 0x30, 0xb1, 0x4a, 0xbe, 0xa5, 0x15, 0x4f, 0xef, 0x50, 0x64, 0x08, + 0xc7, 0x3b, 0x2b, 0x2e, 0xd8, 0x95, 0x60, 0x04, 0x2b, 0xc2, 0x71, 0x57, + 0xc9, 0x44, 0x84, 0x09, 0x1d, 0xba, 0xef, 0x27, 0xe2, 0xe2, 0xd3, 0x26, + 0xae, 0x8f, 0xa6, 0x17, 0x45, 0xe3, 0x9d, 0xb7, 0x29, 0xa9, 0x7a, 0x23, + 0x3c, 0x31, 0x8f, 0x07, 0x91, 0x4d, 0x13, 0x43, 0xeb, 0xd8, 0x86, 0x1e, + 0xd6, 0x6e, 0x9f, 0xde, 0x83, 0x79, 0x76, 0x3c, 0x4c, 0x06, 0x3e, 0x7f, + 0x66, 0xc2, 0x16, 0x4f, 0xcc, 0x5c, 0xf3, 0xb6, 0xe4, 0x5b, 0x79, 0x0a, + 0xc1, 0x7d, 0x2c, 0xce, 0x9d, 0xfc, 0x31, 0xe9, 0xdb, 0x4d, 0xbd, 0xb5, + 0xfb, 0x30, 0xdb, 0xa4, 0xdb, 0xd1, 0xf3, 0x2d, 0x68, 0x34, 0x37, 0x41, + 0xab, 0x1e, 0x73, 0x3a, 0x80, 0xac, 0xb4, 0x1f, 0xbb, 0xb7, 0x8f, 0x85, + 0x57, 0x16, 0xa9, 0x77, 0xa0, 0x90, 0x9d, 0x2e, 0x30, 0x70, 0x10, 0x4d, + 0xfb, 0x0a, 0x3d, 0xa3, 0xcc, 0xa3, 0xf7, 0xbf, 0xc3, 0x16, 0xf7, 0x3b, + 0x18, 0x1b, 0xea, 0x09 +}; +unsigned int dummy_firmware_bin_len = 16384; diff --git a/tools/self-header-verify/generated/test_pubkey.h b/tools/self-header-verify/generated/test_pubkey.h new file mode 100644 index 0000000000..321feb093a --- /dev/null +++ b/tools/self-header-verify/generated/test_pubkey.h @@ -0,0 +1,49 @@ +unsigned char test_signing_key_pub_der[] = { + 0x30, 0x82, 0x02, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0f, 0x00, + 0x30, 0x82, 0x02, 0x0a, 0x02, 0x82, 0x02, 0x01, 0x00, 0x9d, 0xe7, 0x94, + 0xe8, 0x5e, 0x2b, 0x17, 0x47, 0x18, 0xfa, 0xc2, 0x52, 0x6a, 0x4b, 0x2e, + 0xa6, 0xd0, 0x11, 0xd5, 0x91, 0xbe, 0x7e, 0x06, 0x31, 0x07, 0x0e, 0xd6, + 0x8a, 0x77, 0x29, 0x71, 0xe9, 0xdc, 0xea, 0x4e, 0x93, 0x41, 0xbf, 0xe6, + 0x1a, 0x61, 0x0a, 0x69, 0xbd, 0x50, 0x02, 0xce, 0x1d, 0x3e, 0xe5, 0x8b, + 0x1e, 0x1a, 0x6a, 0xbb, 0xdb, 0x40, 0xe8, 0x73, 0x2c, 0x5b, 0x09, 0x34, + 0xcf, 0x93, 0x38, 0xa7, 0x4a, 0xce, 0xd6, 0x81, 0x7d, 0x33, 0x86, 0x6d, + 0xf8, 0x4a, 0xa5, 0xa9, 0xa0, 0x51, 0xb1, 0xb5, 0x54, 0x66, 0x21, 0xa8, + 0x8a, 0x6f, 0x62, 0x8f, 0xe8, 0xa0, 0x35, 0x55, 0x61, 0x08, 0xdb, 0x1c, + 0x79, 0x31, 0x14, 0x40, 0xf8, 0x59, 0x09, 0xef, 0xf0, 0x58, 0x74, 0x31, + 0x1b, 0x96, 0x46, 0x85, 0xf2, 0xd9, 0xd6, 0x26, 0xa8, 0xa4, 0x26, 0x43, + 0x43, 0x84, 0xdb, 0x54, 0x90, 0xdb, 0x30, 0x03, 0x5d, 0x8e, 0xd7, 0x39, + 0x1b, 0x44, 0xc0, 0x13, 0x05, 0x73, 0x8f, 0x27, 0x24, 0xec, 0xc8, 0x60, + 0x74, 0x8e, 0xd9, 0x95, 0x62, 0x1b, 0x85, 0xd9, 0x8a, 0xc3, 0x14, 0xe5, + 0x83, 0x81, 0xdf, 0x35, 0xa7, 0x16, 0xcb, 0xd5, 0x40, 0x41, 0xd7, 0x0a, + 0xf0, 0x94, 0x83, 0x92, 0xa8, 0xf8, 0xe4, 0xe8, 0x28, 0x63, 0x9e, 0xbe, + 0x95, 0xf5, 0xe4, 0x8e, 0xb6, 0x0d, 0x44, 0x41, 0x3f, 0xb8, 0x91, 0xb9, + 0xfe, 0xbe, 0xe3, 0x0a, 0xed, 0xf9, 0x1c, 0x3a, 0x92, 0x44, 0xff, 0x8f, + 0xe3, 0xf4, 0xcd, 0x24, 0xfb, 0x3f, 0xe9, 0x86, 0x81, 0x5f, 0xb7, 0x54, + 0x2c, 0x2a, 0xd3, 0xac, 0x23, 0x47, 0x60, 0x7b, 0x3e, 0xde, 0x5f, 0x52, + 0x39, 0xa9, 0x49, 0x2a, 0xb7, 0xf6, 0xa8, 0x07, 0x3d, 0xbf, 0x15, 0x79, + 0x61, 0x97, 0x3c, 0xf8, 0xd9, 0x9b, 0xef, 0x58, 0xb8, 0xb7, 0xd0, 0x95, + 0x8f, 0xa6, 0x97, 0x4d, 0x70, 0x84, 0x55, 0xc0, 0x77, 0x4b, 0xde, 0x55, + 0xc2, 0xef, 0x8d, 0xfd, 0x3d, 0x32, 0xd2, 0x86, 0x53, 0x1c, 0x3a, 0x41, + 0x0e, 0x30, 0x71, 0xd1, 0x9d, 0x22, 0x8d, 0xba, 0xcd, 0xed, 0x01, 0xd8, + 0xd5, 0xe7, 0xd0, 0xda, 0xb1, 0x33, 0x17, 0xe9, 0x15, 0x0b, 0x06, 0x58, + 0x99, 0x9c, 0x15, 0x82, 0x3c, 0xad, 0x24, 0x33, 0x90, 0x89, 0x02, 0x79, + 0x06, 0x3c, 0x38, 0xe7, 0xfd, 0xb9, 0x65, 0x25, 0x85, 0xb7, 0xa5, 0xfb, + 0x51, 0x19, 0xe5, 0x77, 0x33, 0xd0, 0xdd, 0xbe, 0xa9, 0x22, 0x34, 0xac, + 0x84, 0x5d, 0x0c, 0x47, 0xdd, 0xd5, 0x1b, 0x82, 0xf0, 0x7f, 0xc9, 0x3a, + 0xf7, 0xcb, 0x3b, 0x3d, 0x9a, 0x37, 0xed, 0x7c, 0x19, 0xaa, 0x1b, 0x42, + 0x00, 0xb3, 0x3d, 0xdf, 0x65, 0x23, 0xdd, 0xce, 0x83, 0x26, 0xc5, 0x7b, + 0xd1, 0x00, 0xea, 0x51, 0x7e, 0x36, 0x29, 0x4e, 0x35, 0x1e, 0xe3, 0x92, + 0x9a, 0xc7, 0x48, 0xef, 0x96, 0x62, 0x10, 0xa5, 0xce, 0x6e, 0xe8, 0xa7, + 0x73, 0x2b, 0x04, 0x83, 0xa7, 0x71, 0x7a, 0xbb, 0xc6, 0x8c, 0x42, 0xed, + 0x5d, 0x76, 0xb1, 0xaf, 0x21, 0xc8, 0x2f, 0xaf, 0xc6, 0x4a, 0xdc, 0x78, + 0x92, 0xf3, 0x0d, 0x69, 0xf0, 0x39, 0x39, 0x2b, 0xf5, 0xae, 0xbe, 0xa6, + 0x06, 0x6b, 0xe6, 0xfc, 0x2b, 0xac, 0xc2, 0x78, 0xe8, 0xf8, 0x0b, 0xa5, + 0xcb, 0xda, 0x2c, 0x46, 0xb5, 0x27, 0x28, 0x55, 0xb0, 0x58, 0x5a, 0x24, + 0x93, 0xf2, 0x6e, 0xce, 0xb4, 0xa7, 0xdd, 0x30, 0xcc, 0x1c, 0x4b, 0xb1, + 0x2c, 0x79, 0x38, 0x7f, 0x9c, 0x80, 0x96, 0x41, 0x77, 0x45, 0x5a, 0x65, + 0x5b, 0x0c, 0x18, 0xad, 0x1f, 0x12, 0x4c, 0xbc, 0x77, 0xd2, 0x4b, 0x53, + 0xf8, 0x9b, 0x2c, 0xd5, 0x0f, 0x26, 0x4a, 0x13, 0x70, 0x2d, 0xf5, 0x25, + 0x00, 0xcf, 0x9c, 0x6b, 0x9b, 0x02, 0x03, 0x01, 0x00, 0x01 +}; +unsigned int test_signing_key_pub_der_len = 550; diff --git a/tools/self-header-verify/test-self-header-verify b/tools/self-header-verify/test-self-header-verify new file mode 100755 index 0000000000000000000000000000000000000000..94c1e8b53e87ce80840f419739c1c378008603f6 GIT binary patch literal 43608 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 Date: Thu, 26 Mar 2026 14:54:42 -0600 Subject: [PATCH 10/11] rename aggregate RSA PSS macro, add Renesas protection --- include/loader.h | 2 +- src/image.c | 15 +++++++++------ 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/include/loader.h b/include/loader.h index a3bcd5fe2d..9eadc1660c 100644 --- a/include/loader.h +++ b/include/loader.h @@ -48,7 +48,7 @@ extern "C" { defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS2048) || \ defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS3072) || \ defined(WOLFBOOT_SIGN_SECONDARY_RSAPSS4096) -#define WOLFBOOT_RSA_PSS +#define WOLFBOOT_SIGN_RSAPSS_ANY #endif #if defined(WOLFBOOT_SIGN_RSA2048) || defined(WOLFBOOT_SIGN_SECONDARY_RSA2048) || \ diff --git a/src/image.c b/src/image.c index 43572725ad..a390eefb43 100644 --- a/src/image.c +++ b/src/image.c @@ -442,7 +442,7 @@ static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, (void)inOutIdx; (void)is_pss; -#ifdef WOLFBOOT_RSA_PSS +#ifdef WOLFBOOT_SIGN_RSAPSS_ANY enum wc_HashType hash_type; int mgf; #if defined(WOLFBOOT_HASH_SHA256) @@ -454,7 +454,7 @@ static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, #else #error "RSA-PSS requires SHA-256 or SHA-384" #endif -#endif /* WOLFBOOT_RSA_PSS */ +#endif /* WOLFBOOT_SIGN_RSAPSS_ANY */ #if (!defined(WOLFBOOT_ENABLE_WOLFHSM_CLIENT) && \ !defined(WOLFBOOT_ENABLE_WOLFHSM_SERVER)) || \ @@ -471,7 +471,10 @@ static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, #if defined(WOLFBOOT_RENESAS_SCEPROTECT) || \ defined(WOLFBOOT_RENESAS_TSIP) || \ defined(WOLFBOOT_RENESAS_RSIP) - /* Renesas crypto callback — RSA PKCS#1 v1.5 only */ + /* Renesas crypto callback supports RSA PKCS#1 v1.5 only */ +#ifdef WOLFBOOT_SIGN_RSAPSS_ANY + #error "RSA-PSS is not yet supported with Renesas crypto callbacks" +#endif ret = wc_InitRsaKey_ex(&rsa, NULL, RENESAS_DEVID); if (ret == 0) { XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); @@ -535,7 +538,7 @@ static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, } #endif /* !WOLFBOOT_USE_WOLFHSM_PUBKEY_ID */ XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); -#ifdef WOLFBOOT_RSA_PSS +#ifdef WOLFBOOT_SIGN_RSAPSS_ANY if (is_pss) { RSA_VERIFY_FN(ret, wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, &digest_out, hash_type, mgf, @@ -570,7 +573,7 @@ static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, ret = wc_RsaPublicKeyDecode((byte*)pubkey, &inOutIdx, &rsa, pubkey_sz); if (ret >= 0) { XMEMCPY(output, sig, RSA_IMAGE_SIGNATURE_SIZE); -#ifdef WOLFBOOT_RSA_PSS +#ifdef WOLFBOOT_SIGN_RSAPSS_ANY if (is_pss) { RSA_VERIFY_FN(ret, wc_RsaPSS_VerifyInline, output, RSA_IMAGE_SIGNATURE_SIZE, @@ -587,7 +590,7 @@ static void wolfBoot_verify_signature_rsa_common(uint8_t key_slot, #endif /* SCE || TSIP */ wc_FreeRsaKey(&rsa); -#ifdef WOLFBOOT_RSA_PSS +#ifdef WOLFBOOT_SIGN_RSAPSS_ANY if (is_pss) { if (ret >= WOLFBOOT_SHA_DIGEST_SIZE && img && digest_out) { RSA_PSS_VERIFY_HASH(img, digest_out, ret, hash_type); From 16f2c8b34385113914b8a1ef1b19e91c11821a6a Mon Sep 17 00:00:00 2001 From: Brett Nicholas <7547222+bigbrett@users.noreply.github.com> Date: Thu, 26 Mar 2026 19:36:37 -0600 Subject: [PATCH 11/11] remove accidentally committed files --- .../generated/test_header.h | 89 -- .../self-header-verify/generated/test_image.h | 1369 ----------------- .../generated/test_pubkey.h | 49 - .../test-self-header-verify | Bin 43608 -> 0 bytes 4 files changed, 1507 deletions(-) delete mode 100644 tools/self-header-verify/generated/test_header.h delete mode 100644 tools/self-header-verify/generated/test_image.h delete mode 100644 tools/self-header-verify/generated/test_pubkey.h delete mode 100755 tools/self-header-verify/test-self-header-verify diff --git a/tools/self-header-verify/generated/test_header.h b/tools/self-header-verify/generated/test_header.h deleted file mode 100644 index 3db0c43ced..0000000000 --- a/tools/self-header-verify/generated/test_header.h +++ /dev/null @@ -1,89 +0,0 @@ -unsigned char dummy_firmware_v1_header_bin[] = { - 0x57, 0x4f, 0x4c, 0x46, 0x00, 0x40, 0x00, 0x00, 0x01, 0x00, 0x04, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x08, 0x00, - 0x7f, 0xe9, 0xa9, 0x69, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, - 0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x20, 0x00, - 0x35, 0xd1, 0xa4, 0xe1, 0x01, 0x1a, 0x05, 0xc0, 0x68, 0xbc, 0x0d, 0x31, - 0xf0, 0xd2, 0x6e, 0x07, 0x4e, 0x69, 0xa3, 0x09, 0x12, 0xa3, 0x7a, 0x0d, - 0x95, 0x82, 0x86, 0x69, 0xc1, 0x27, 0x56, 0x8f, 0xff, 0xff, 0xff, 0xff, - 0x03, 0x00, 0x20, 0x00, 0xb5, 0x49, 0x1d, 0x22, 0x24, 0x9d, 0x93, 0xc1, - 0x68, 0xa8, 0xa3, 0xb5, 0x62, 0x6e, 0xdb, 0xd6, 0xb5, 0x87, 0x9b, 0x27, - 0xd7, 0x91, 0xe3, 0x13, 0x86, 0x4f, 0x52, 0xc2, 0x1d, 0x9c, 0x56, 0xe8, - 0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x02, 0x8c, 0xec, 0x5a, 0x8a, - 0xb8, 0xd3, 0x61, 0xc0, 0x70, 0x02, 0xad, 0x07, 0xd3, 0x48, 0x94, 0xfb, - 0xb2, 0x2f, 0x57, 0x33, 0x64, 0x61, 0x0f, 0xfa, 0x53, 0xa0, 0x13, 0x7e, - 0x8c, 0x12, 0x85, 0x44, 0x0f, 0xe4, 0x9a, 0x1d, 0xe5, 0xab, 0xeb, 0x97, - 0xd7, 0x43, 0xdf, 0x2e, 0x15, 0xa3, 0x9c, 0x87, 0x11, 0xc7, 0x1a, 0x80, - 0xb1, 0x9e, 0xbe, 0x07, 0xce, 0x30, 0xf5, 0x3e, 0xb9, 0x19, 0x30, 0xf9, - 0xb1, 0x26, 0xa2, 0x3a, 0xf1, 0xb3, 0x6a, 0x5b, 0x1c, 0x11, 0x6b, 0x45, - 0x2f, 0xa5, 0xf9, 0x77, 0xd5, 0xb9, 0x07, 0x37, 0xe1, 0x55, 0x61, 0x48, - 0x19, 0x6d, 0x8b, 0x99, 0x65, 0x53, 0x35, 0x90, 0x5d, 0xbf, 0xb6, 0x8f, - 0x37, 0x68, 0xfc, 0x6a, 0x7e, 0x3a, 0x2c, 0x4b, 0x35, 0x7e, 0x32, 0x28, - 0x76, 0x09, 0x1e, 0xd0, 0x6d, 0x08, 0x6d, 0xfa, 0x4a, 0x16, 0x7b, 0x38, - 0x48, 0xff, 0xbe, 0x9e, 0x8c, 0x88, 0x41, 0x42, 0xe5, 0xc0, 0x43, 0x09, - 0xac, 0x4e, 0xef, 0xe1, 0xef, 0xcd, 0x0f, 0x7a, 0x50, 0xf4, 0x2f, 0x30, - 0x7d, 0x94, 0x57, 0xaa, 0x61, 0x1f, 0x30, 0x17, 0x99, 0x6d, 0x12, 0x93, - 0x2e, 0xf1, 0xe9, 0xb3, 0x31, 0x86, 0x48, 0x2f, 0x59, 0x1c, 0x43, 0xd2, - 0xaf, 0xc1, 0x15, 0xc4, 0x1a, 0x4c, 0xd2, 0xdc, 0x40, 0x65, 0x52, 0xc4, - 0x04, 0xda, 0x73, 0x44, 0x4f, 0x9e, 0xd6, 0x1d, 0x5c, 0xff, 0x4c, 0x04, - 0x73, 0x74, 0xce, 0x02, 0x24, 0x01, 0x05, 0x6b, 0xfa, 0xe1, 0x39, 0x23, - 0xff, 0xd4, 0xcc, 0x0e, 0x54, 0x1c, 0x2e, 0xec, 0x4f, 0xef, 0x35, 0xec, - 0x51, 0x83, 0x27, 0x1b, 0xfc, 0x5a, 0x13, 0xfe, 0xcf, 0xd1, 0xef, 0x1a, - 0xf5, 0x62, 0x4a, 0x6d, 0x9d, 0x45, 0x1c, 0x9d, 0xab, 0x96, 0x14, 0xa1, - 0x4d, 0xe6, 0x00, 0x4f, 0xae, 0x8d, 0x3c, 0x60, 0x9c, 0x4c, 0x33, 0x24, - 0x5d, 0x9d, 0x43, 0xf2, 0xee, 0x44, 0xb2, 0xb5, 0x00, 0x74, 0x37, 0x68, - 0xc4, 0x46, 0x54, 0xda, 0xce, 0x42, 0x15, 0x0a, 0xf1, 0xc7, 0x14, 0x4e, - 0x0a, 0x29, 0xfe, 0x19, 0x12, 0x7a, 0x8a, 0x97, 0x6a, 0x10, 0xe9, 0x4e, - 0x49, 0x70, 0xfe, 0x15, 0x9f, 0x8b, 0x68, 0x0a, 0xc3, 0xcb, 0x2d, 0x81, - 0xa3, 0x0b, 0xe6, 0xad, 0x7b, 0x1a, 0xdb, 0xb7, 0x7a, 0x2b, 0x9d, 0xf6, - 0x03, 0x36, 0xab, 0x38, 0x0b, 0x82, 0x29, 0xdb, 0xcb, 0x2f, 0xd7, 0x86, - 0x98, 0x21, 0x87, 0x4a, 0xf0, 0x35, 0xf6, 0x20, 0x4c, 0xb3, 0xae, 0x41, - 0x0c, 0x49, 0x73, 0xea, 0xf4, 0x6a, 0xa6, 0x1c, 0x95, 0x7c, 0xc9, 0xe9, - 0xef, 0xab, 0x02, 0xd0, 0xfa, 0x61, 0xbe, 0x46, 0x11, 0x52, 0xd2, 0xfa, - 0x12, 0xe9, 0xcf, 0x61, 0xac, 0x2c, 0x93, 0x9e, 0xfa, 0x8c, 0x39, 0x20, - 0xcf, 0x6e, 0x73, 0x14, 0x72, 0x6e, 0x26, 0xb6, 0x58, 0xb4, 0x83, 0xa7, - 0xe9, 0xfb, 0xd3, 0x94, 0xcf, 0xe4, 0x9c, 0x40, 0xe0, 0x5c, 0x5f, 0x98, - 0x0a, 0xdc, 0x64, 0x88, 0x8e, 0x93, 0x58, 0xca, 0x95, 0x18, 0x40, 0x17, - 0x40, 0xad, 0x34, 0x69, 0x14, 0x89, 0x7b, 0xa7, 0xb9, 0x3a, 0xec, 0x31, - 0xd0, 0x9c, 0x4d, 0x4d, 0xf3, 0xf0, 0xcc, 0x2f, 0x1e, 0x34, 0x5f, 0xde, - 0x5c, 0xeb, 0x79, 0x4b, 0x73, 0x10, 0x67, 0xe0, 0x83, 0x49, 0x21, 0x2d, - 0x70, 0x0b, 0xde, 0xa7, 0xf6, 0x95, 0xf4, 0x13, 0xfc, 0x1f, 0x84, 0xef, - 0x74, 0x69, 0x0e, 0x23, 0xf7, 0x3a, 0x25, 0x68, 0x2c, 0x22, 0x31, 0xec, - 0x4c, 0x49, 0x1d, 0xbe, 0x71, 0x0a, 0x81, 0x40, 0x7e, 0xce, 0xde, 0xe3, - 0xf3, 0x7b, 0x36, 0xd3, 0xe7, 0x1d, 0x76, 0x52, 0x7e, 0x06, 0xd7, 0x3a, - 0xa7, 0x7c, 0x81, 0x67, 0x16, 0x41, 0x08, 0x5b, 0x04, 0x99, 0xde, 0xf5, - 0xa2, 0xcb, 0x44, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff -}; -unsigned int dummy_firmware_v1_header_bin_len = 1024; diff --git a/tools/self-header-verify/generated/test_image.h b/tools/self-header-verify/generated/test_image.h deleted file mode 100644 index 9ba12ef36e..0000000000 --- a/tools/self-header-verify/generated/test_image.h +++ /dev/null @@ -1,1369 +0,0 @@ -unsigned char dummy_firmware_bin[] = { - 0x3b, 0x2a, 0xa8, 0x77, 0x77, 0x6d, 0x45, 0x5e, 0x40, 0x4f, 0xb3, 0xa2, - 0x32, 0x74, 0x06, 0xdf, 0xb4, 0x39, 0x36, 0xb0, 0x8b, 0xde, 0xa3, 0xfe, - 0xc9, 0x0d, 0x5b, 0x5a, 0xdb, 0xf6, 0x2a, 0x4c, 0xe8, 0x19, 0xe7, 0x4c, - 0x65, 0x9a, 0xae, 0x66, 0x83, 0xef, 0xc1, 0x3d, 0x3c, 0x52, 0xa2, 0x22, - 0x57, 0x31, 0x8a, 0x7a, 0xa0, 0xf6, 0xb2, 0x24, 0x2b, 0xb1, 0x6e, 0x44, - 0x9e, 0x0d, 0x4f, 0xf1, 0xab, 0xdc, 0x50, 0x30, 0x90, 0xb9, 0x6e, 0xa6, - 0xd7, 0x7f, 0x49, 0xb9, 0x1a, 0xad, 0xfb, 0x23, 0x9e, 0xbb, 0x81, 0xfe, - 0x95, 0x16, 0x5a, 0xd1, 0xe6, 0x30, 0x28, 0xf0, 0x5d, 0x6b, 0x7a, 0x04, - 0xe6, 0xf0, 0x19, 0x92, 0x96, 0xe3, 0x85, 0x75, 0x9e, 0x18, 0x02, 0xe6, - 0x1e, 0xcb, 0x2f, 0x5e, 0x4b, 0xe6, 0x72, 0xe0, 0x29, 0x05, 0xea, 0x4d, - 0x63, 0x3c, 0x8d, 0xcf, 0x28, 0x9a, 0x83, 0xe2, 0x7d, 0xd1, 0xf3, 0xdb, - 0xea, 0x9c, 0x2d, 0x0c, 0xf8, 0x64, 0x38, 0x55, 0xee, 0xa7, 0x2d, 0x5b, - 0x9c, 0x9d, 0xdd, 0xd4, 0x42, 0x48, 0xdd, 0x27, 0x4b, 0x38, 0xfb, 0x9c, - 0xe5, 0x42, 0x08, 0x6d, 0x5a, 0x03, 0x18, 0x2f, 0x6d, 0xd1, 0x57, 0x72, - 0xc5, 0x3a, 0xde, 0x68, 0xbc, 0x73, 0x91, 0x3f, 0xfe, 0xbe, 0xf0, 0xc4, - 0x86, 0x14, 0x4a, 0xa9, 0xcb, 0x1a, 0xa9, 0x99, 0x7d, 0x15, 0x03, 0xf8, - 0x81, 0x07, 0xa4, 0x4f, 0x7b, 0x9c, 0x3c, 0xd3, 0xb2, 0xf3, 0x9f, 0x50, - 0x62, 0x62, 0x89, 0x18, 0x27, 0x14, 0xdc, 0xc3, 0x8e, 0xee, 0x65, 0xb9, - 0x8c, 0x7c, 0xde, 0xf0, 0x9a, 0x62, 0x80, 0x9d, 0x0e, 0xa4, 0x1e, 0x27, - 0x57, 0xec, 0x39, 0x2a, 0xb0, 0xed, 0x3d, 0x72, 0xe1, 0x29, 0xb8, 0x9b, - 0x58, 0x74, 0x08, 0x63, 0x9c, 0xd7, 0x5e, 0xf7, 0x8b, 0xe6, 0x54, 0x92, - 0x66, 0x15, 0xca, 0xa2, 0xc5, 0x3a, 0xa9, 0x8a, 0xd4, 0xca, 0x7d, 0x53, - 0x99, 0x6f, 0x80, 0xa7, 0xa0, 0x6f, 0xa9, 0x66, 0xcd, 0xdc, 0xa8, 0x86, - 0x22, 0x9d, 0xe6, 0xb2, 0x22, 0xcf, 0x70, 0x79, 0xfa, 0x8e, 0xbb, 0xb7, - 0x03, 0xd4, 0x80, 0x2d, 0x94, 0x14, 0x72, 0x7e, 0xa6, 0x1c, 0x79, 0x34, - 0x76, 0xda, 0x87, 0x65, 0x56, 0x84, 0x34, 0x8d, 0xc9, 0x3c, 0x21, 0x66, - 0xdf, 0x5c, 0x2a, 0xe2, 0x47, 0xcf, 0xe7, 0x46, 0x69, 0xc2, 0x02, 0x0f, - 0x1b, 0x06, 0x7f, 0x7e, 0xe7, 0x60, 0x32, 0x74, 0xc8, 0x00, 0x53, 0x72, - 0x9b, 0x07, 0x89, 0x49, 0xfd, 0xc1, 0xa5, 0x6c, 0x2e, 0x83, 0xf5, 0x79, - 0x16, 0xab, 0x6e, 0x81, 0x6b, 0x78, 0x65, 0x9a, 0x21, 0x90, 0x18, 0x45, - 0x63, 0x55, 0x77, 0x44, 0x6c, 0x73, 0x11, 0x39, 0xa5, 0x0b, 0xc3, 0x51, - 0xd9, 0x36, 0xae, 0xaa, 0x94, 0xf2, 0xef, 0xed, 0x83, 0x50, 0x03, 0x94, - 0x53, 0x21, 0xb2, 0x4e, 0x94, 0x94, 0xa4, 0x48, 0x22, 0x59, 0x16, 0xf0, - 0x77, 0xf7, 0xbf, 0x48, 0x17, 0x92, 0xde, 0xfd, 0x31, 0xae, 0xf3, 0x25, - 0x41, 0xdf, 0x5c, 0xf0, 0x01, 0xf5, 0x72, 0x95, 0xd6, 0xa6, 0x17, 0xfb, - 0x48, 0xcc, 0x40, 0x94, 0x9c, 0x0c, 0x4d, 0x01, 0x56, 0xbe, 0xb1, 0x0a, - 0xff, 0xc7, 0x22, 0xda, 0x71, 0xe6, 0xea, 0x8c, 0x07, 0x1b, 0x59, 0x3b, - 0x62, 0x85, 0xdc, 0xd2, 0xdd, 0x95, 0x61, 0x94, 0xb0, 0x7b, 0x50, 0x7a, - 0x52, 0x3f, 0x6f, 0x4d, 0xd3, 0x26, 0x38, 0x8d, 0x64, 0x8a, 0x24, 0x8b, - 0x82, 0x13, 0x13, 0x47, 0xe2, 0x31, 0xbb, 0x07, 0x4e, 0xe5, 0x15, 0xf0, - 0x15, 0x65, 0x17, 0x1e, 0x41, 0x87, 0x45, 0xb5, 0x1a, 0xf0, 0x62, 0x67, - 0x83, 0xeb, 0xb0, 0x9f, 0x71, 0xd9, 0xb7, 0xa0, 0x9d, 0xeb, 0xa3, 0x0d, - 0xbc, 0xf5, 0x22, 0xb7, 0x0c, 0x1c, 0x51, 0xc3, 0xcb, 0xf2, 0x32, 0x30, - 0x7b, 0x59, 0x5d, 0x1c, 0x16, 0xa4, 0x0e, 0x17, 0x2b, 0x5c, 0x5c, 0x2f, - 0x28, 0xd9, 0xbd, 0x4f, 0x22, 0x60, 0x83, 0x55, 0x93, 0x96, 0x28, 0xfa, - 0x1b, 0xd1, 0xc8, 0x34, 0xc3, 0x78, 0x0d, 0xee, 0x45, 0x56, 0x5d, 0x9f, - 0x06, 0x6f, 0x00, 0x32, 0x9a, 0x62, 0x52, 0xe6, 0x24, 0xad, 0x6f, 0xee, - 0x32, 0xe6, 0xda, 0x2d, 0xc3, 0xb0, 0x73, 0xfd, 0x66, 0x1a, 0xa4, 0x91, - 0xf5, 0x10, 0x17, 0x7d, 0x5e, 0x45, 0xc5, 0xec, 0x65, 0x1e, 0x56, 0xfa, - 0x42, 0xc5, 0x7b, 0x6a, 0x9d, 0x33, 0x29, 0x7d, 0xf8, 0xd8, 0x23, 0x40, - 0xcd, 0xc6, 0xaf, 0x85, 0x5b, 0xa0, 0x86, 0x16, 0xab, 0x11, 0x92, 0x69, - 0xa7, 0x53, 0xb1, 0x65, 0x7f, 0x11, 0x15, 0x6d, 0x06, 0xfb, 0x8b, 0xb8, - 0xab, 0xa9, 0x7b, 0x00, 0x32, 0xa6, 0x0d, 0x2b, 0x20, 0xd1, 0xf8, 0x27, - 0xbf, 0xf5, 0xfa, 0xc6, 0x1d, 0x72, 0x43, 0xa2, 0xd4, 0x24, 0x62, 0x1a, - 0x94, 0xa9, 0x40, 0x12, 0x07, 0xc7, 0x64, 0x24, 0x98, 0xdf, 0x20, 0x3f, - 0xf9, 0x69, 0xb2, 0xdc, 0xe9, 0xd7, 0xe8, 0xde, 0x55, 0x4f, 0xa0, 0xb9, - 0xa7, 0xc3, 0x9f, 0xd7, 0x07, 0x22, 0x31, 0x70, 0xe6, 0x81, 0x99, 0x16, - 0x1f, 0x54, 0xea, 0xc3, 0xd1, 0x20, 0xfc, 0x1d, 0xa6, 0xd4, 0x81, 0x20, - 0xc0, 0x06, 0xa1, 0x5d, 0x76, 0xd5, 0x51, 0xa3, 0xde, 0x7d, 0xe0, 0xa9, - 0xa6, 0x63, 0xa8, 0xcd, 0xf5, 0xbe, 0xd7, 0x7d, 0x38, 0xca, 0x4e, 0xa1, - 0xdb, 0xc6, 0xc4, 0xe3, 0x81, 0x0d, 0xce, 0x5e, 0x6d, 0x65, 0xba, 0x5d, - 0x75, 0xb6, 0x86, 0xae, 0xbc, 0x12, 0x10, 0xc9, 0x03, 0xc4, 0x18, 0xe1, - 0xa1, 0x1c, 0x59, 0x30, 0xc1, 0xae, 0x20, 0xb0, 0x78, 0x75, 0x09, 0x43, - 0x2f, 0xa2, 0x1b, 0xf4, 0xb5, 0xe1, 0x6d, 0x3b, 0x67, 0x8f, 0xeb, 0x8f, - 0xdd, 0xbc, 0xbc, 0x01, 0x90, 0x7b, 0x45, 0xc0, 0xc6, 0xce, 0x4f, 0x0d, - 0x79, 0x65, 0xf5, 0xd7, 0xf4, 0x54, 0x17, 0x2b, 0xfc, 0x66, 0x83, 0xa3, - 0x04, 0xc7, 0x44, 0x82, 0x85, 0xca, 0xfe, 0x85, 0x54, 0x7e, 0x83, 0xcb, - 0x89, 0xc4, 0xc2, 0x5f, 0x87, 0xb4, 0xdb, 0xa4, 0x35, 0xcc, 0xe1, 0x09, - 0x3a, 0x84, 0x29, 0x73, 0xe8, 0x05, 0xd5, 0x9d, 0xf6, 0xf8, 0x1b, 0x03, - 0x1f, 0x17, 0xb9, 0x84, 0x10, 0x5f, 0x12, 0xec, 0x88, 0x39, 0xd4, 0x3b, - 0x28, 0x83, 0x54, 0x29, 0x34, 0xe5, 0xd9, 0x4e, 0xe2, 0x73, 0xf3, 0xa8, - 0x3b, 0x26, 0x13, 0xf0, 0x5f, 0x51, 0x9f, 0xc7, 0xd1, 0x76, 0x45, 0x1c, - 0xb0, 0xd9, 0xc5, 0x48, 0x69, 0x9c, 0x82, 0x00, 0x8d, 0x1d, 0x95, 0xa3, - 0x81, 0x34, 0x98, 0xb4, 0xed, 0xbe, 0xcb, 0x30, 0xfc, 0xf2, 0xed, 0xef, - 0xaa, 0x55, 0x80, 0x1f, 0x23, 0x49, 0x34, 0xaa, 0x51, 0x3a, 0x08, 0x22, - 0x86, 0x5b, 0x35, 0x91, 0x3c, 0x45, 0x2e, 0xba, 0x17, 0x42, 0x87, 0xc9, - 0x31, 0x92, 0xc8, 0x71, 0x32, 0x2e, 0x1b, 0x90, 0x35, 0x30, 0x4a, 0x73, - 0x00, 0x0a, 0x9a, 0xc8, 0x6b, 0xe4, 0x3d, 0x97, 0x61, 0x36, 0xdb, 0xdc, - 0x86, 0x36, 0xe8, 0x78, 0x1c, 0x86, 0xf5, 0xe8, 0x0f, 0xc0, 0x64, 0x21, - 0xde, 0x20, 0x99, 0xec, 0x05, 0xc2, 0x4c, 0x18, 0x97, 0xd0, 0xc2, 0xd1, - 0xd2, 0x79, 0x5c, 0x80, 0x13, 0x94, 0xd0, 0xb4, 0xcc, 0xeb, 0x70, 0x60, - 0xbc, 0x0a, 0xaf, 0x62, 0x36, 0x95, 0x71, 0x2b, 0xb7, 0x1c, 0x9a, 0x9b, - 0x6d, 0xff, 0xaa, 0xbb, 0x8b, 0x08, 0x40, 0xc9, 0x3f, 0x09, 0x71, 0x61, - 0xc4, 0xfd, 0x18, 0x1a, 0x4c, 0x99, 0x7b, 0x68, 0x17, 0x3c, 0xe4, 0x47, - 0x23, 0x09, 0xcd, 0x63, 0xef, 0xd2, 0x8d, 0xc5, 0x23, 0xd2, 0x57, 0x45, - 0x7e, 0x06, 0xe6, 0xa0, 0x89, 0xe8, 0x87, 0xb5, 0xdd, 0x2d, 0x60, 0x5d, - 0x07, 0x23, 0xae, 0x0a, 0x7b, 0x32, 0x4d, 0x37, 0xbe, 0x24, 0xf2, 0x6c, - 0xae, 0xb5, 0xfb, 0xa6, 0x11, 0x6e, 0x22, 0x2b, 0xe8, 0x84, 0xcc, 0x6f, - 0xfa, 0x73, 0x29, 0xef, 0x53, 0x24, 0x1b, 0xdf, 0x90, 0x59, 0x44, 0x48, - 0x09, 0xfe, 0x97, 0x05, 0xc5, 0xc5, 0xa2, 0xcf, 0xa8, 0xd5, 0x36, 0xd5, - 0x0c, 0xd7, 0x0e, 0xc4, 0x8d, 0xd4, 0xfd, 0x3e, 0x6b, 0x3f, 0xe1, 0x4a, - 0x15, 0xd5, 0x71, 0x61, 0xf4, 0x20, 0xe9, 0xcf, 0x91, 0x5f, 0xfc, 0x75, - 0xcf, 0x1e, 0x77, 0xcd, 0x27, 0x62, 0x75, 0xd1, 0xa4, 0x35, 0xbc, 0xa4, - 0xaa, 0xed, 0x79, 0x8f, 0x03, 0xcc, 0x05, 0x30, 0x4e, 0xd0, 0x05, 0x26, - 0x69, 0xc2, 0x50, 0xa8, 0x2f, 0x76, 0xf7, 0xf6, 0xcd, 0x43, 0x1d, 0x04, - 0x84, 0x42, 0x7b, 0xfd, 0xe0, 0x3c, 0xf9, 0xe4, 0xfb, 0x0c, 0x24, 0x2d, - 0xa7, 0x73, 0x1e, 0xa8, 0x93, 0xf6, 0xbb, 0xae, 0x81, 0xa2, 0x0d, 0x9b, - 0x30, 0xbb, 0x52, 0xf0, 0x13, 0x03, 0xbd, 0xe5, 0x22, 0x38, 0x64, 0x8a, - 0x32, 0x17, 0xae, 0xc4, 0x78, 0x10, 0x99, 0x31, 0x90, 0x3d, 0x21, 0xe9, - 0x59, 0xde, 0xdc, 0xfe, 0x44, 0x1c, 0xa7, 0x90, 0x12, 0xb4, 0x91, 0x9a, - 0x4e, 0xc6, 0x17, 0xfc, 0xe8, 0xfd, 0x23, 0x8f, 0xd4, 0x96, 0x0a, 0x7c, - 0x5a, 0x83, 0xde, 0x69, 0x6d, 0x83, 0x56, 0x74, 0x64, 0x37, 0xdc, 0xde, - 0xa0, 0x88, 0xe4, 0xb6, 0x80, 0x53, 0xad, 0xb9, 0x0f, 0xfc, 0xa3, 0x26, - 0xed, 0x24, 0xa1, 0xc0, 0x1f, 0x3f, 0x7b, 0xe3, 0xad, 0x87, 0xd1, 0x55, - 0xbb, 0x67, 0x30, 0xba, 0xfb, 0xcd, 0xa6, 0x8a, 0xbb, 0x38, 0x51, 0xff, - 0xe1, 0xb2, 0x39, 0x6d, 0xfc, 0x68, 0x18, 0x31, 0xc2, 0x35, 0xbb, 0xfb, - 0x4d, 0x7e, 0x86, 0x40, 0xb0, 0xfb, 0x6d, 0xf6, 0x89, 0xa2, 0xd0, 0x74, - 0x8c, 0xf7, 0xd6, 0xa5, 0x0a, 0xbc, 0x87, 0x69, 0xb4, 0xce, 0x7f, 0x5b, - 0xb7, 0x7f, 0xca, 0x9d, 0x2e, 0x2a, 0xd8, 0x4d, 0xf0, 0x94, 0xa5, 0x65, - 0x66, 0x48, 0x3d, 0xa0, 0xf2, 0xfe, 0x25, 0xe2, 0xa2, 0x33, 0xc4, 0x65, - 0x2d, 0xba, 0x90, 0xca, 0xd8, 0x42, 0x3a, 0x58, 0xd4, 0xff, 0xe9, 0xfb, - 0x01, 0x6c, 0x93, 0xb7, 0xc0, 0x3d, 0x75, 0xeb, 0xf3, 0xcd, 0xef, 0x90, - 0x2d, 0xaa, 0x2d, 0x49, 0x47, 0xcf, 0xec, 0x9f, 0xc6, 0xd1, 0x6e, 0x2d, - 0x37, 0xd5, 0xcf, 0x2a, 0x7d, 0x63, 0xa6, 0xf8, 0x92, 0xc5, 0xb4, 0xe4, - 0xf7, 0x8f, 0x33, 0x9e, 0x06, 0x46, 0x98, 0xe5, 0xf1, 0xa0, 0xa2, 0xf7, - 0xba, 0xc1, 0x44, 0x9c, 0xaa, 0xc9, 0x29, 0x2d, 0x40, 0x85, 0xf2, 0x22, - 0x98, 0xee, 0xff, 0xcc, 0xc0, 0x68, 0xbc, 0xe6, 0x37, 0x29, 0xaf, 0xdd, - 0x92, 0x69, 0x40, 0xa1, 0x07, 0xf8, 0x87, 0x0e, 0x25, 0xa9, 0x50, 0x22, - 0xd3, 0x63, 0x0f, 0x00, 0xfd, 0x7b, 0x58, 0x22, 0xd9, 0xc2, 0xde, 0x41, - 0x19, 0x6a, 0x88, 0x5e, 0x8d, 0x3a, 0xeb, 0x88, 0xfe, 0xbf, 0x1c, 0x5e, - 0x37, 0xf5, 0x6a, 0x7b, 0xfa, 0x72, 0x3c, 0x13, 0x98, 0xbc, 0x40, 0x1f, - 0x07, 0x94, 0xcd, 0x8b, 0x87, 0xe9, 0x1c, 0x0d, 0xd3, 0x0f, 0xca, 0x12, - 0xe6, 0xf8, 0x21, 0xd9, 0xb6, 0x01, 0x3e, 0x3d, 0x00, 0x4d, 0x2e, 0x53, - 0x40, 0x6e, 0x05, 0x0c, 0x66, 0x4b, 0x2b, 0xc5, 0x24, 0x89, 0x11, 0x94, - 0x0b, 0x4c, 0xec, 0xcf, 0xfa, 0xae, 0x3e, 0xf3, 0xb9, 0xca, 0xd0, 0xb7, - 0x34, 0x3c, 0x79, 0xa5, 0x74, 0x01, 0x21, 0x5e, 0x07, 0xb4, 0xd4, 0x34, - 0x10, 0x56, 0x96, 0x0d, 0xc6, 0xc1, 0x1c, 0xd3, 0xb0, 0x25, 0x99, 0xe6, - 0x62, 0xd0, 0x6b, 0x60, 0xf2, 0x63, 0x99, 0x84, 0xb1, 0xc4, 0x87, 0x1b, - 0x52, 0xda, 0x29, 0xe4, 0x81, 0x5d, 0xff, 0x7a, 0xf6, 0x64, 0x33, 0x51, - 0xab, 0x34, 0x97, 0x74, 0xe7, 0x73, 0xcf, 0x2f, 0xee, 0xb5, 0xda, 0x7b, - 0x03, 0xd6, 0xda, 0xb5, 0x45, 0xb7, 0x09, 0x3b, 0x75, 0xdf, 0x68, 0x2b, - 0x4c, 0x51, 0xb8, 0xe1, 0xe7, 0xe2, 0x1f, 0x36, 0xbf, 0x35, 0xe9, 0x5c, - 0xaa, 0xb1, 0xf2, 0x07, 0x2c, 0x93, 0x4e, 0x2c, 0xfc, 0x7e, 0x1d, 0xf7, - 0xba, 0xe0, 0x64, 0x58, 0xef, 0x94, 0xcf, 0x34, 0x46, 0xe9, 0xac, 0xfe, - 0x62, 0x01, 0xc0, 0x4c, 0x3f, 0x4b, 0xc0, 0x23, 0xda, 0xb0, 0x45, 0xf0, - 0x9e, 0x12, 0x6b, 0x1e, 0xfc, 0xce, 0xb2, 0xa3, 0xdb, 0x29, 0x56, 0xea, - 0xc1, 0x45, 0xd9, 0x45, 0xa5, 0x24, 0x19, 0xa0, 0x97, 0xfe, 0xa4, 0x97, - 0x8d, 0x04, 0xd8, 0x61, 0x0d, 0xfd, 0xce, 0xbc, 0xdc, 0x21, 0x80, 0x8c, - 0xbb, 0x9d, 0x8a, 0x76, 0x42, 0x71, 0x50, 0x1f, 0x32, 0x11, 0x03, 0x80, - 0xd2, 0x2a, 0xd2, 0x27, 0x53, 0xc5, 0x8d, 0xf6, 0x4c, 0x24, 0xf1, 0x64, - 0xfb, 0x0a, 0x95, 0x11, 0x83, 0x4a, 0xf6, 0x01, 0x00, 0xda, 0xc4, 0xc1, - 0x04, 0x1b, 0x29, 0xaa, 0xb4, 0x3b, 0x6d, 0xbc, 0x27, 0x54, 0x3a, 0xdc, - 0xe9, 0x6b, 0x32, 0x19, 0x1b, 0x74, 0xd5, 0x4b, 0xe0, 0xa5, 0x46, 0x7c, - 0xee, 0x8a, 0xcf, 0xa4, 0x47, 0xa0, 0xf5, 0x3a, 0x94, 0xf7, 0xea, 0x2c, - 0x3f, 0x03, 0xbb, 0xa5, 0xe4, 0xf0, 0xbd, 0x87, 0x68, 0x6e, 0x55, 0xf9, - 0x53, 0x1c, 0x09, 0x85, 0x79, 0x4b, 0x44, 0xe3, 0x47, 0x8a, 0x54, 0x97, - 0x7f, 0x97, 0xb0, 0x81, 0x2f, 0x07, 0x85, 0x40, 0x43, 0x5d, 0xf7, 0x04, - 0x86, 0xc8, 0x5c, 0x55, 0x2c, 0x32, 0xf4, 0x22, 0xcd, 0x38, 0x8c, 0x70, - 0x1a, 0xae, 0xb8, 0xa4, 0x96, 0x8c, 0x64, 0x44, 0x24, 0xd1, 0x5f, 0x53, - 0x00, 0x0c, 0xb5, 0x41, 0x23, 0x34, 0x2d, 0xb7, 0xaa, 0xea, 0xb0, 0x27, - 0xdd, 0xcc, 0xf4, 0xb4, 0x27, 0xdc, 0x63, 0x18, 0x2c, 0x10, 0x3b, 0x3d, - 0x90, 0x10, 0x51, 0x49, 0x32, 0xbd, 0x27, 0xd7, 0x90, 0x23, 0x85, 0x1c, - 0x8e, 0x6b, 0xd6, 0xfa, 0x38, 0x66, 0xb9, 0x94, 0xab, 0xb0, 0x71, 0x93, - 0x28, 0xe7, 0x6f, 0x18, 0x5f, 0x17, 0x22, 0xd2, 0x77, 0xe3, 0x85, 0x06, - 0x9f, 0x09, 0x8c, 0x17, 0xbc, 0xda, 0xfa, 0x3e, 0xcc, 0xc3, 0xae, 0x8f, - 0xfe, 0xe4, 0x24, 0x2c, 0x59, 0xfd, 0x2b, 0x61, 0xad, 0x90, 0x0b, 0xea, - 0x55, 0x24, 0x27, 0x10, 0x7f, 0x00, 0x00, 0x29, 0x97, 0xc9, 0x46, 0x09, - 0x72, 0xce, 0xde, 0xba, 0x94, 0x4e, 0xd3, 0xd4, 0x64, 0x47, 0x2b, 0xe9, - 0x98, 0x9f, 0x12, 0x0c, 0x14, 0xe9, 0x4e, 0x52, 0xae, 0x25, 0x14, 0x41, - 0x30, 0x36, 0x9d, 0x0a, 0x1f, 0x3e, 0x01, 0x73, 0x84, 0x14, 0x51, 0x64, - 0x9b, 0x29, 0x5e, 0x2d, 0xb3, 0xe9, 0x0b, 0xd2, 0x8a, 0x49, 0x63, 0xf1, - 0xa5, 0x17, 0x28, 0xd7, 0xc7, 0x19, 0x16, 0x78, 0xe7, 0x13, 0x0a, 0xd7, - 0x9f, 0x00, 0xf7, 0xc8, 0x06, 0xfd, 0x3f, 0x47, 0x4a, 0x2b, 0xf1, 0xd0, - 0xe0, 0x11, 0xc9, 0x64, 0x5e, 0xf4, 0xc8, 0x58, 0xba, 0x29, 0x84, 0x8c, - 0xf8, 0x65, 0x20, 0x6c, 0xe4, 0xa8, 0x23, 0x58, 0x99, 0x17, 0x25, 0xbe, - 0xc5, 0x2a, 0x0e, 0x34, 0xa5, 0xf3, 0x09, 0xfa, 0x97, 0x9e, 0xf5, 0x2c, - 0xd0, 0x84, 0xcd, 0xce, 0xbd, 0x56, 0xdc, 0xb2, 0xaf, 0x67, 0x5f, 0x67, - 0xec, 0xe9, 0x5f, 0xaf, 0xbb, 0x6e, 0x14, 0x01, 0x03, 0xe3, 0x8b, 0x43, - 0x54, 0xcc, 0xa1, 0x4b, 0x4e, 0x2e, 0x8f, 0xaa, 0x0f, 0xd7, 0x28, 0xe7, - 0x49, 0x68, 0x10, 0x61, 0x02, 0xf5, 0x1a, 0x6f, 0x94, 0x7c, 0xa5, 0x78, - 0xed, 0xea, 0x39, 0x4f, 0xe8, 0xaf, 0x64, 0x56, 0xe2, 0x7e, 0x42, 0x14, - 0xdf, 0x5e, 0xf0, 0xdd, 0x2d, 0xb7, 0xbc, 0x19, 0xe8, 0x9c, 0xa9, 0x1e, - 0x85, 0x68, 0xb4, 0x14, 0xed, 0x7b, 0xa2, 0x54, 0xcf, 0x37, 0x43, 0x4b, - 0x15, 0x43, 0x73, 0x6c, 0x63, 0x5c, 0x50, 0x42, 0x2a, 0x74, 0xaa, 0x41, - 0x22, 0x96, 0x73, 0xcc, 0x7b, 0x94, 0x6e, 0x94, 0x29, 0x84, 0xbb, 0xe9, - 0x6e, 0x0a, 0x93, 0x17, 0x60, 0x58, 0x6a, 0xbe, 0x83, 0x20, 0x05, 0x29, - 0x58, 0xf9, 0x98, 0x16, 0xc5, 0x37, 0xfd, 0x7d, 0xc0, 0x82, 0x2c, 0x87, - 0x69, 0x3a, 0x86, 0x5e, 0xb0, 0xe8, 0xc5, 0x85, 0x91, 0x03, 0x39, 0xce, - 0x45, 0xc2, 0x16, 0x07, 0x54, 0x91, 0xc3, 0x00, 0xbc, 0x72, 0xdf, 0x47, - 0x36, 0x7d, 0xf2, 0x66, 0x48, 0x56, 0x05, 0x56, 0x3c, 0x65, 0xda, 0x67, - 0x34, 0x5f, 0xf0, 0x1d, 0x25, 0x3a, 0x0a, 0xfb, 0x8a, 0x11, 0x44, 0x33, - 0xc9, 0xb8, 0x38, 0x1e, 0x86, 0xfd, 0x44, 0x80, 0x2d, 0x9a, 0x2f, 0xb7, - 0xb2, 0x5f, 0x15, 0x49, 0x6b, 0xde, 0x36, 0xbd, 0x5c, 0xf9, 0x72, 0x17, - 0x57, 0x16, 0x6a, 0xad, 0x30, 0xfa, 0x15, 0xbd, 0x36, 0x08, 0x9b, 0x2c, - 0xec, 0x82, 0x95, 0x78, 0x1b, 0xa8, 0x4e, 0x74, 0xfc, 0x2b, 0x5b, 0x38, - 0xfb, 0xe5, 0x03, 0x0e, 0x0c, 0x65, 0x5e, 0x76, 0x0e, 0xff, 0x6f, 0x91, - 0xac, 0x8b, 0x93, 0x7f, 0x83, 0xc4, 0xfd, 0x5b, 0x88, 0x8e, 0x47, 0x41, - 0xb1, 0xf2, 0xea, 0x26, 0x79, 0x49, 0x1b, 0xa5, 0x6c, 0xac, 0xd7, 0x75, - 0xc3, 0x81, 0x94, 0xd0, 0x4a, 0x5b, 0x4d, 0x32, 0xb7, 0xff, 0x1f, 0xeb, - 0x80, 0xd4, 0x60, 0x18, 0xe8, 0x3c, 0x43, 0xf4, 0xf8, 0xa1, 0xd9, 0xa4, - 0xd9, 0x71, 0x2c, 0x09, 0x44, 0xa2, 0x33, 0xc4, 0x22, 0x6f, 0xf7, 0xfb, - 0xa7, 0xb4, 0xab, 0x4e, 0x44, 0x83, 0x79, 0xa0, 0x81, 0xfb, 0xc7, 0x5c, - 0xab, 0x6e, 0x70, 0x4a, 0x09, 0x78, 0x9a, 0xf2, 0x3b, 0xa4, 0x3c, 0x05, - 0xb0, 0x83, 0x6f, 0xa1, 0xea, 0x5a, 0x8e, 0xbc, 0x2b, 0xb6, 0xff, 0x9b, - 0x78, 0xbc, 0x53, 0x51, 0xc5, 0x46, 0x7f, 0x9f, 0x4e, 0x79, 0x8e, 0xf8, - 0x41, 0xbe, 0x66, 0xdd, 0xa9, 0xd1, 0x20, 0xbd, 0xe2, 0xb0, 0xd8, 0xd0, - 0x27, 0xf2, 0x39, 0x84, 0xe8, 0x52, 0xab, 0x9f, 0xab, 0x9f, 0x8d, 0x3f, - 0xcb, 0xb0, 0x7a, 0x59, 0xba, 0x95, 0xb0, 0xdd, 0x8c, 0xd0, 0x31, 0x76, - 0x18, 0x26, 0x28, 0x14, 0x41, 0x72, 0x53, 0xdc, 0xa3, 0x85, 0xd0, 0xf7, - 0x3b, 0x0d, 0xf2, 0x5c, 0x20, 0xd0, 0x23, 0x6d, 0xed, 0x01, 0x05, 0x66, - 0xc1, 0x07, 0x1d, 0x82, 0x24, 0x72, 0xc7, 0x7b, 0xbe, 0xc2, 0x6b, 0xc0, - 0x52, 0xf4, 0x91, 0xa3, 0xae, 0x43, 0x71, 0x9a, 0xca, 0xef, 0x47, 0x1e, - 0xcb, 0x41, 0x73, 0x1d, 0xc4, 0x11, 0xdb, 0x34, 0x40, 0x11, 0x34, 0x6f, - 0x6d, 0xf6, 0xbb, 0x41, 0x5a, 0x75, 0x21, 0x59, 0x9e, 0x63, 0xb1, 0xb8, - 0x68, 0xdd, 0x64, 0xfb, 0xdc, 0x86, 0x6d, 0xfe, 0x3f, 0x42, 0x08, 0x60, - 0x57, 0xb8, 0xbd, 0xac, 0xa7, 0x9a, 0x6a, 0x5c, 0xf5, 0xb1, 0xca, 0xe5, - 0x6f, 0x3b, 0x1d, 0x20, 0x58, 0x21, 0x3b, 0x62, 0x67, 0xf6, 0x06, 0x6b, - 0xf7, 0xec, 0xfa, 0x8d, 0x5e, 0xd5, 0x54, 0x16, 0xf2, 0xb0, 0x0b, 0x7e, - 0x54, 0xee, 0x47, 0xd0, 0x04, 0xbc, 0x99, 0x1c, 0xa2, 0x87, 0x7b, 0xae, - 0xa5, 0x57, 0x47, 0x59, 0x02, 0x74, 0x8f, 0x00, 0x2e, 0x5b, 0xdf, 0x87, - 0xbd, 0x4f, 0x36, 0x63, 0x96, 0xb8, 0x47, 0x39, 0x63, 0xdb, 0x94, 0x6e, - 0xaa, 0xc5, 0x90, 0xf6, 0xff, 0x13, 0xe1, 0x52, 0x92, 0x5b, 0x05, 0xeb, - 0x2f, 0xa0, 0xdb, 0xb6, 0x13, 0x09, 0xc6, 0x2d, 0x70, 0xdf, 0xba, 0xaf, - 0xc0, 0x8f, 0x82, 0x0c, 0x45, 0x62, 0x3d, 0xf3, 0x84, 0xb4, 0x84, 0x76, - 0x86, 0x08, 0x3a, 0x9b, 0x7b, 0x57, 0x75, 0x78, 0x1c, 0x9f, 0x45, 0xbb, - 0x8b, 0x78, 0xbc, 0x87, 0x00, 0x02, 0x1a, 0xc5, 0x2a, 0xca, 0xb2, 0x77, - 0x69, 0x30, 0x80, 0x7d, 0x24, 0x9c, 0xc8, 0xcb, 0x05, 0xab, 0x69, 0xe6, - 0x7f, 0x61, 0x87, 0xbc, 0xfe, 0xb6, 0x5b, 0x1a, 0x12, 0x9b, 0x8c, 0x08, - 0xdf, 0xe2, 0xf5, 0xfb, 0x5c, 0x86, 0x7c, 0x1e, 0x37, 0xa2, 0xe1, 0xb9, - 0x88, 0x77, 0x86, 0x6a, 0x1d, 0x6b, 0x17, 0x50, 0xa2, 0xdd, 0x92, 0x79, - 0x34, 0x32, 0x00, 0xc7, 0x43, 0x31, 0x71, 0x55, 0xcd, 0x8d, 0x4e, 0x67, - 0x98, 0x2e, 0xb1, 0x27, 0x32, 0xbd, 0xbd, 0x08, 0x65, 0xe1, 0x74, 0x2d, - 0xef, 0xe3, 0xb2, 0x1c, 0x1b, 0x31, 0x3c, 0x61, 0xcc, 0xb5, 0x99, 0x1f, - 0x5f, 0x61, 0x35, 0x4d, 0x2a, 0xdd, 0xd0, 0xbe, 0x79, 0xe8, 0xbd, 0x35, - 0x0b, 0x40, 0xbf, 0xa0, 0x26, 0x4e, 0x27, 0xf0, 0x1b, 0x1a, 0xce, 0xf8, - 0xe1, 0x69, 0x2a, 0xdb, 0x9a, 0xfb, 0x5d, 0x91, 0x4e, 0xec, 0xd7, 0x92, - 0x8f, 0x26, 0x11, 0x3d, 0x08, 0x05, 0xdc, 0x0f, 0x45, 0xcd, 0xb1, 0x9e, - 0x93, 0xf8, 0x20, 0xa8, 0x4c, 0x8b, 0xab, 0x4c, 0x70, 0x0c, 0x60, 0xc4, - 0x8b, 0x59, 0x88, 0x15, 0xab, 0xc1, 0xe9, 0x7d, 0x2c, 0x28, 0xe1, 0xdd, - 0x20, 0x09, 0xe2, 0xf3, 0xca, 0xbe, 0x37, 0xe4, 0x5e, 0x27, 0x98, 0x92, - 0x94, 0x49, 0x3b, 0xb8, 0x6d, 0xc6, 0x0c, 0x9c, 0x0e, 0x79, 0x81, 0x2b, - 0xe3, 0x15, 0xba, 0x66, 0x2d, 0xba, 0x88, 0x8c, 0xa5, 0xb0, 0xf2, 0x4a, - 0xcd, 0x8f, 0x1a, 0xb0, 0x65, 0x82, 0xcb, 0x9f, 0x92, 0xc9, 0xbb, 0xb1, - 0x94, 0xcc, 0x61, 0xf2, 0x9a, 0x89, 0x7a, 0x15, 0x51, 0x36, 0x7b, 0x46, - 0xef, 0x76, 0xba, 0x9d, 0x39, 0x4c, 0xa5, 0x6b, 0x38, 0x67, 0x64, 0x7c, - 0xec, 0xbd, 0xbe, 0x30, 0xec, 0xc5, 0xf4, 0x64, 0x0d, 0x4a, 0x02, 0x10, - 0x6c, 0x67, 0x34, 0x70, 0xcc, 0x59, 0xfc, 0x94, 0x45, 0x83, 0xde, 0x21, - 0x25, 0x25, 0x66, 0x4e, 0xae, 0x60, 0xcc, 0xf4, 0x32, 0xf0, 0xe1, 0xb4, - 0xc2, 0x68, 0x96, 0x4d, 0x65, 0x29, 0xb6, 0x25, 0x3c, 0x6a, 0xd5, 0x0c, - 0xab, 0x18, 0xf1, 0x28, 0x6f, 0xfa, 0xac, 0x5c, 0xe1, 0x8f, 0x32, 0x16, - 0x0f, 0xa1, 0x45, 0x3a, 0x07, 0x83, 0x53, 0xb6, 0x2b, 0xe0, 0x90, 0x88, - 0x3d, 0x38, 0xb8, 0xe6, 0xb0, 0xff, 0xb4, 0xb7, 0x51, 0x23, 0x17, 0x4b, - 0x8a, 0xdc, 0x27, 0x79, 0x76, 0x9e, 0x3d, 0xdf, 0x91, 0x49, 0x7d, 0xc1, - 0xb4, 0x84, 0xce, 0x3a, 0x27, 0x4e, 0xfd, 0x40, 0x5a, 0x53, 0x11, 0x47, - 0xed, 0xfb, 0xf4, 0x89, 0x5d, 0x13, 0x73, 0x14, 0xbe, 0x73, 0x40, 0xff, - 0xe2, 0x83, 0x04, 0xf1, 0xab, 0x4e, 0x30, 0xba, 0xc5, 0x01, 0x18, 0xbd, - 0xbe, 0x75, 0x8a, 0x4f, 0x6c, 0x96, 0x77, 0xbe, 0x81, 0xf3, 0xd7, 0x6b, - 0x59, 0x6c, 0xd0, 0xfc, 0xa2, 0x51, 0xf5, 0x22, 0xc5, 0x1c, 0x54, 0x61, - 0xbd, 0x32, 0xf6, 0xb3, 0xee, 0xc1, 0x58, 0x63, 0x55, 0x18, 0x18, 0x3c, - 0x1a, 0xf0, 0x5a, 0x77, 0x2f, 0x0a, 0xad, 0x1c, 0x77, 0x20, 0x26, 0x67, - 0xe2, 0xb9, 0x27, 0x0d, 0x0d, 0xa0, 0x7e, 0xee, 0x25, 0x61, 0xc9, 0x5b, - 0xc2, 0xa0, 0x90, 0x16, 0xa1, 0xb8, 0x6b, 0x49, 0xee, 0xa1, 0x25, 0x24, - 0x24, 0xd3, 0x7e, 0x6c, 0x21, 0xa3, 0x5d, 0x22, 0x27, 0x41, 0xd3, 0x9c, - 0x08, 0x34, 0x1d, 0xf1, 0xf3, 0x6b, 0x7c, 0xae, 0x5a, 0x92, 0x18, 0xfd, - 0x80, 0x50, 0x83, 0x19, 0x73, 0x4b, 0x9d, 0x08, 0x09, 0x70, 0xa5, 0x38, - 0x73, 0xfa, 0xd6, 0x58, 0xb7, 0xc9, 0x0e, 0x4b, 0x3d, 0x6f, 0x33, 0x1c, - 0x87, 0xf0, 0x13, 0xb1, 0xe2, 0xec, 0x1e, 0x1a, 0x63, 0x20, 0x1a, 0xd1, - 0x56, 0x21, 0x70, 0x3d, 0x52, 0xd8, 0x27, 0xf6, 0x09, 0xec, 0x03, 0x75, - 0x2b, 0x1c, 0x0d, 0x02, 0x70, 0x29, 0xa6, 0xcc, 0xa1, 0xb9, 0x30, 0xd0, - 0x7f, 0xb8, 0x45, 0xcd, 0x43, 0x64, 0x2e, 0x14, 0x10, 0x78, 0xf6, 0xf3, - 0x99, 0xe2, 0x34, 0xbd, 0x8b, 0xec, 0xfe, 0x19, 0x49, 0x91, 0x76, 0x4a, - 0x4f, 0xdb, 0x1d, 0xaf, 0x32, 0xa3, 0x8b, 0x62, 0xef, 0x25, 0x08, 0x96, - 0x6f, 0x7c, 0x59, 0xad, 0xe9, 0x82, 0x3e, 0x57, 0x6b, 0xaa, 0x70, 0x97, - 0x5c, 0x15, 0x50, 0xef, 0xb6, 0xf5, 0x10, 0xae, 0x6f, 0xdf, 0x38, 0x57, - 0x7b, 0x87, 0xdd, 0x41, 0x17, 0x09, 0xcd, 0x6b, 0xb3, 0x55, 0xdd, 0xfb, - 0x63, 0xb3, 0xbd, 0x5b, 0x56, 0xd1, 0xb9, 0x96, 0xc6, 0xa2, 0x3d, 0xb3, - 0xdf, 0x43, 0x35, 0xdb, 0x71, 0x2a, 0xff, 0x53, 0x70, 0xc0, 0x62, 0xc8, - 0x07, 0x43, 0x9d, 0x78, 0xd6, 0x5f, 0x9f, 0x0b, 0xb4, 0xa3, 0x4e, 0x7f, - 0x3b, 0x32, 0x2e, 0xa9, 0x46, 0x18, 0x1b, 0x8a, 0x1b, 0xb3, 0x78, 0x69, - 0x68, 0xe1, 0x32, 0xe1, 0xa8, 0xd6, 0x5d, 0xfd, 0xbe, 0xd0, 0x44, 0x20, - 0xa6, 0xe5, 0x15, 0x75, 0x90, 0xf5, 0xcf, 0x08, 0x75, 0xab, 0xca, 0xc9, - 0x99, 0x58, 0xbc, 0xc8, 0x24, 0x8c, 0x7a, 0x54, 0x73, 0x23, 0x13, 0x3e, - 0x90, 0x4f, 0xdb, 0x20, 0x0b, 0xa0, 0x15, 0xbf, 0xcc, 0x0d, 0x30, 0xc3, - 0x14, 0xb5, 0x9f, 0xf5, 0xff, 0xe8, 0xbd, 0x80, 0xc2, 0x7a, 0x58, 0x52, - 0x96, 0x59, 0x9c, 0x26, 0x8f, 0x2b, 0x64, 0x0e, 0x8c, 0x4f, 0x46, 0x3d, - 0x10, 0xda, 0x62, 0xee, 0xef, 0x3a, 0x5f, 0x91, 0x6f, 0xd7, 0x4e, 0x97, - 0x5f, 0xa9, 0x60, 0x1e, 0x80, 0xce, 0xdc, 0x13, 0x5d, 0xd4, 0x19, 0x27, - 0xc0, 0x55, 0xa8, 0x44, 0x40, 0x63, 0x01, 0xc3, 0xc5, 0x1c, 0xc8, 0x60, - 0xfb, 0x0a, 0x5a, 0x13, 0xb1, 0xa2, 0x74, 0xfb, 0x7b, 0xc6, 0xc9, 0x4d, - 0x5f, 0xfd, 0x22, 0x75, 0x6c, 0xc1, 0x0d, 0xb1, 0xf6, 0xab, 0x03, 0x2f, - 0xe3, 0x47, 0xfc, 0x85, 0xde, 0x7b, 0x2c, 0x87, 0x3f, 0xa7, 0x73, 0xa8, - 0xba, 0x18, 0x5b, 0xe7, 0x36, 0x8e, 0xee, 0xdc, 0x56, 0x7d, 0x06, 0x79, - 0xb7, 0xcb, 0x0d, 0x3f, 0x8f, 0xd6, 0xdd, 0x07, 0x02, 0xbe, 0xff, 0x65, - 0x60, 0xdd, 0x3e, 0x9a, 0xe0, 0xea, 0x7b, 0x26, 0x51, 0x16, 0xf0, 0x77, - 0xf3, 0x5c, 0x93, 0xa3, 0x56, 0xce, 0xef, 0x56, 0x66, 0x51, 0x20, 0xaa, - 0x98, 0x65, 0x3d, 0x3a, 0x20, 0x67, 0xb7, 0x60, 0xa8, 0x36, 0x69, 0xc2, - 0x27, 0x76, 0x75, 0xc5, 0xdb, 0x1c, 0xa6, 0x16, 0xfb, 0x28, 0xc0, 0x79, - 0xc2, 0x4c, 0x9d, 0xa2, 0x45, 0x50, 0x39, 0xd2, 0x72, 0xc9, 0x88, 0x4c, - 0x99, 0xce, 0xbc, 0x7d, 0x73, 0x1c, 0x6c, 0x9c, 0x13, 0xd4, 0x34, 0x7e, - 0xe8, 0x9f, 0x57, 0xb7, 0xe8, 0xec, 0x73, 0x36, 0x53, 0xf6, 0x71, 0x0c, - 0x0a, 0x20, 0x93, 0x45, 0x16, 0x9d, 0xfc, 0xcd, 0xc9, 0x06, 0x08, 0x7f, - 0xeb, 0x56, 0x19, 0x50, 0x0c, 0x27, 0x4d, 0x83, 0xd6, 0x16, 0x84, 0x56, - 0xad, 0x7a, 0xcb, 0xf7, 0xbb, 0x36, 0x84, 0x15, 0xff, 0xd1, 0xe6, 0xcc, - 0x9a, 0xcf, 0x0c, 0x97, 0x3f, 0x9e, 0xcb, 0x57, 0x44, 0xce, 0x1c, 0x09, - 0xfa, 0x63, 0x17, 0x5d, 0x45, 0x9c, 0x6c, 0xfa, 0x8d, 0xdf, 0x11, 0x58, - 0x40, 0xba, 0xb9, 0x37, 0xb9, 0x86, 0x55, 0x71, 0x3d, 0x05, 0xe3, 0x81, - 0x9b, 0x20, 0xb4, 0xc0, 0x4c, 0xfe, 0x57, 0x43, 0x3b, 0x40, 0xbb, 0x58, - 0x29, 0x12, 0x3f, 0xe9, 0x52, 0x55, 0xed, 0xcf, 0xbf, 0x89, 0x53, 0x3a, - 0xaf, 0xcb, 0xc4, 0xf8, 0x3f, 0xe6, 0x36, 0x3f, 0xc2, 0x0a, 0x1e, 0x52, - 0x78, 0xe1, 0x56, 0x2a, 0x65, 0xb6, 0x49, 0x0d, 0x81, 0x54, 0x4b, 0xa2, - 0xbd, 0x97, 0x63, 0x09, 0x5e, 0xea, 0x46, 0x49, 0x2e, 0x2c, 0xe9, 0x7b, - 0xe6, 0x8b, 0x8d, 0x6c, 0x61, 0x20, 0x1f, 0x7c, 0x87, 0xe1, 0xbe, 0xcf, - 0x31, 0x1e, 0xc4, 0x3d, 0xde, 0x4c, 0xcf, 0xf9, 0x67, 0x5f, 0x08, 0x42, - 0x73, 0x78, 0x73, 0xa0, 0x20, 0x01, 0xcd, 0x7f, 0xfa, 0x06, 0x2c, 0xa6, - 0x45, 0x01, 0xa7, 0xf8, 0x0c, 0xa7, 0x89, 0xa7, 0x82, 0xf7, 0xe0, 0x4f, - 0xf7, 0xe1, 0x23, 0x38, 0x00, 0xfc, 0xc6, 0xdd, 0x7a, 0xf5, 0xc4, 0x7c, - 0x53, 0xf3, 0x55, 0xa9, 0x31, 0xac, 0x4c, 0x69, 0xf9, 0xfc, 0x76, 0x52, - 0xe3, 0x1f, 0x38, 0x36, 0x7c, 0x78, 0x26, 0x20, 0xd3, 0x73, 0x2c, 0x6f, - 0x4d, 0xf6, 0x81, 0x0b, 0xff, 0xa6, 0xe9, 0x6e, 0x68, 0x52, 0x91, 0x20, - 0xbd, 0xae, 0x87, 0xe3, 0x21, 0x31, 0xac, 0xf3, 0x40, 0xa5, 0x82, 0x70, - 0xf2, 0xc8, 0xee, 0x39, 0xf1, 0x2e, 0x6f, 0xb0, 0xa0, 0x35, 0xc6, 0xe8, - 0x5e, 0x9b, 0xd7, 0x9e, 0xfb, 0xba, 0x43, 0xc1, 0x69, 0x7a, 0x50, 0xc6, - 0x26, 0xc2, 0x84, 0x51, 0xfb, 0x12, 0x4c, 0x44, 0xaa, 0xab, 0x8d, 0x31, - 0xf8, 0xd0, 0x87, 0x4e, 0x38, 0xa8, 0x8f, 0x0b, 0xf7, 0xfd, 0x5a, 0x75, - 0xf4, 0x46, 0xf5, 0x4f, 0x6e, 0xa9, 0x03, 0x62, 0xfd, 0x0e, 0x57, 0x32, - 0xda, 0x22, 0xaa, 0x01, 0xf5, 0xcd, 0xba, 0x9a, 0x73, 0xa0, 0x3c, 0x1a, - 0xc2, 0xbb, 0xe2, 0xfd, 0xe2, 0x80, 0x53, 0x4d, 0xce, 0x68, 0xf0, 0xa5, - 0xcb, 0x55, 0x04, 0xa6, 0xb7, 0xf5, 0xdd, 0x89, 0xdd, 0xc5, 0x67, 0x44, - 0x7e, 0xe4, 0x6e, 0xfb, 0xaa, 0xc2, 0x37, 0x01, 0x81, 0x52, 0x96, 0x66, - 0xbd, 0xa9, 0x3f, 0xea, 0xdf, 0x36, 0x8b, 0x61, 0x13, 0xad, 0xa8, 0x4e, - 0x71, 0x3c, 0x7e, 0x03, 0xe3, 0x56, 0x05, 0xd3, 0xe2, 0x77, 0xb0, 0xea, - 0xa0, 0xbb, 0x57, 0x95, 0xa8, 0x70, 0x08, 0x97, 0x88, 0x5f, 0x9a, 0xa8, - 0x52, 0x46, 0xa2, 0x98, 0x62, 0xa5, 0x3e, 0x2f, 0x79, 0xd3, 0x57, 0x03, - 0x3e, 0x25, 0x0f, 0x4b, 0x90, 0x18, 0x08, 0x62, 0x35, 0x1e, 0x97, 0xbf, - 0x7c, 0xa3, 0x98, 0x36, 0x31, 0x1b, 0xa0, 0x67, 0x2b, 0x72, 0x5a, 0x01, - 0xf9, 0x20, 0x15, 0xf1, 0x31, 0xd0, 0x50, 0xc1, 0x2c, 0xa4, 0x76, 0x3e, - 0x28, 0x77, 0xe0, 0x4a, 0x7c, 0xd9, 0x76, 0x37, 0x0e, 0xbb, 0x9a, 0x2e, - 0x8c, 0xe2, 0x67, 0xbe, 0x56, 0xc1, 0xf6, 0xeb, 0x77, 0x71, 0xf0, 0xad, - 0x6f, 0xc8, 0x3e, 0x33, 0x98, 0x9f, 0xb9, 0x90, 0x69, 0xb5, 0x14, 0x3f, - 0x88, 0xcb, 0xaf, 0x8f, 0xe1, 0xcb, 0x36, 0x9d, 0xca, 0x6b, 0x73, 0x9d, - 0x25, 0x5a, 0x04, 0x65, 0x86, 0x8e, 0xd7, 0xbb, 0xd0, 0x66, 0x6f, 0x62, - 0xda, 0x19, 0x89, 0xc3, 0xa0, 0x63, 0x0d, 0xf8, 0x38, 0xb0, 0xca, 0xd2, - 0x56, 0x6b, 0x9e, 0x70, 0x61, 0xae, 0x41, 0xf9, 0xc1, 0xcc, 0xbc, 0x90, - 0x43, 0xee, 0xf7, 0x43, 0xed, 0xe7, 0x0a, 0x36, 0xe6, 0x33, 0xe7, 0x4b, - 0x1c, 0xf9, 0x43, 0x5f, 0x98, 0x80, 0xaf, 0xd2, 0x0d, 0x50, 0x60, 0xca, - 0x70, 0x22, 0xb7, 0x4e, 0x98, 0x19, 0xaa, 0x00, 0x76, 0xdc, 0xea, 0x46, - 0x48, 0xd8, 0x2a, 0x4e, 0x78, 0x3d, 0x66, 0x29, 0xa8, 0x53, 0xd2, 0x3b, - 0xc8, 0x66, 0x33, 0x67, 0xe5, 0xd8, 0xcf, 0x19, 0x30, 0x36, 0xc7, 0xb7, - 0xdb, 0xeb, 0x65, 0x8c, 0x3b, 0x6d, 0x98, 0x05, 0x8a, 0xd2, 0x21, 0x41, - 0xb9, 0x0b, 0xb3, 0xee, 0x7e, 0x82, 0x08, 0x8f, 0xc2, 0x0b, 0xe5, 0x3e, - 0x33, 0x53, 0x0e, 0xe9, 0xe4, 0x93, 0x13, 0x6d, 0xe7, 0xbf, 0x79, 0x0c, - 0x20, 0x8d, 0x62, 0x33, 0xbc, 0x7d, 0x15, 0x5a, 0xc4, 0x16, 0x09, 0xc8, - 0x92, 0x90, 0x28, 0x1c, 0xd7, 0x80, 0x6e, 0x9e, 0x2b, 0xe0, 0xdb, 0x57, - 0xe4, 0x8b, 0x53, 0xc5, 0x66, 0x10, 0xe0, 0xb3, 0x79, 0x66, 0x15, 0xf7, - 0x2c, 0x2c, 0x7d, 0xa1, 0x24, 0xb0, 0x63, 0x73, 0xc3, 0x34, 0xd4, 0x0a, - 0x54, 0xa0, 0x2b, 0x09, 0x9f, 0xf7, 0x40, 0x8f, 0xf8, 0x88, 0xc1, 0xc8, - 0x97, 0xe7, 0x4f, 0x3b, 0x5d, 0xa8, 0x0f, 0x22, 0x45, 0x47, 0x38, 0x63, - 0x92, 0x49, 0x3a, 0xd4, 0xf9, 0x44, 0xc1, 0x75, 0x6c, 0x45, 0xcf, 0xc4, - 0xd5, 0xa3, 0x4f, 0xa2, 0xf6, 0x6d, 0x47, 0x46, 0xac, 0x60, 0x0e, 0x7e, - 0xbd, 0x84, 0x48, 0x48, 0x20, 0xd9, 0x4f, 0xd0, 0x2b, 0x79, 0xd0, 0x2a, - 0xba, 0x06, 0x94, 0xda, 0x89, 0x4d, 0x4d, 0xfd, 0x32, 0x2a, 0x69, 0x3f, - 0xce, 0x1b, 0xe9, 0x89, 0x72, 0xe5, 0x58, 0x03, 0xb0, 0x1a, 0xf2, 0x33, - 0xb2, 0xc3, 0x41, 0x81, 0x8f, 0x0b, 0xb8, 0xa6, 0x09, 0x82, 0x52, 0x5d, - 0xa0, 0x60, 0x34, 0x0f, 0x75, 0xab, 0x8a, 0x08, 0x9b, 0xbc, 0x37, 0xc7, - 0x46, 0x9b, 0x67, 0xaa, 0x75, 0xf3, 0xb5, 0x31, 0xf6, 0x55, 0x98, 0x1b, - 0xfe, 0x44, 0x3c, 0xc3, 0x33, 0x77, 0x28, 0xe8, 0xe7, 0x6a, 0x44, 0x78, - 0x18, 0x67, 0x29, 0xaa, 0xa3, 0x73, 0xc5, 0x4c, 0xed, 0xe2, 0x10, 0xcb, - 0x0c, 0x36, 0x8b, 0x55, 0x2c, 0xad, 0xf8, 0xdc, 0x55, 0xcc, 0x35, 0xea, - 0x6c, 0x47, 0xf8, 0x3b, 0x2a, 0x25, 0x83, 0x48, 0xcb, 0xd0, 0xcc, 0xba, - 0x65, 0xc8, 0x92, 0x16, 0xc5, 0xa0, 0x04, 0x95, 0x30, 0x20, 0xdb, 0x0f, - 0xf5, 0x01, 0x57, 0x36, 0x7b, 0x70, 0x27, 0xf0, 0x2c, 0x1e, 0x6c, 0xab, - 0xa6, 0xa5, 0xb9, 0x84, 0x9b, 0x99, 0x31, 0xef, 0x9a, 0xa1, 0xd6, 0x83, - 0xaf, 0x83, 0x93, 0xb2, 0xa4, 0x2f, 0x30, 0xe1, 0xdc, 0xb4, 0x88, 0xb6, - 0x36, 0xaa, 0x04, 0x2b, 0x9b, 0x4d, 0xb6, 0xff, 0xe6, 0x80, 0xca, 0xa9, - 0x3e, 0x2f, 0xea, 0xf3, 0x17, 0xd5, 0x1d, 0x64, 0x98, 0x9e, 0xef, 0xe8, - 0xf7, 0x0c, 0xbe, 0xf8, 0xa6, 0x60, 0x8e, 0x8e, 0x68, 0x1b, 0x8e, 0x0d, - 0xed, 0xa4, 0x29, 0x4e, 0x82, 0x49, 0x27, 0x0e, 0xa0, 0xa5, 0x6a, 0x20, - 0x8d, 0xbc, 0xb9, 0xca, 0xec, 0x95, 0xf2, 0xf7, 0x09, 0x85, 0x42, 0x54, - 0xcc, 0x5a, 0xf6, 0x51, 0xb1, 0xa7, 0x95, 0x4d, 0x41, 0x79, 0xc9, 0xf0, - 0x07, 0x9c, 0x73, 0x68, 0xb1, 0xb7, 0x0a, 0x4e, 0xea, 0x03, 0x8a, 0x58, - 0x0f, 0x25, 0xcc, 0x73, 0x44, 0x1b, 0x9a, 0x03, 0xe8, 0x0c, 0x89, 0xfc, - 0x0f, 0x2a, 0xc8, 0x6e, 0xf8, 0xe4, 0x16, 0x2e, 0x43, 0x4f, 0x86, 0xf2, - 0x85, 0x0a, 0xbf, 0xb1, 0xe0, 0x00, 0x83, 0x1c, 0xf2, 0xb5, 0x3f, 0xad, - 0x01, 0xbb, 0x4f, 0x3c, 0xba, 0x46, 0xc0, 0x9e, 0xc3, 0xb6, 0x92, 0x79, - 0x0c, 0x97, 0xf4, 0x2d, 0x93, 0x10, 0xd4, 0xf8, 0x34, 0xf6, 0xcd, 0x3a, - 0xbd, 0x33, 0xb4, 0x08, 0xc3, 0xb3, 0x34, 0x76, 0x60, 0x96, 0xfe, 0x91, - 0xec, 0xe4, 0x33, 0xc6, 0x24, 0xd5, 0x15, 0xab, 0x25, 0xbb, 0x90, 0x68, - 0x74, 0xc8, 0xcd, 0xfc, 0x7a, 0x9b, 0x3b, 0x31, 0x07, 0x1d, 0x12, 0x98, - 0x43, 0x3a, 0x28, 0x93, 0x3a, 0x10, 0x33, 0x52, 0x15, 0x73, 0x76, 0x0a, - 0xa1, 0x54, 0x92, 0xa6, 0xf4, 0x9c, 0xf5, 0x11, 0x36, 0x1d, 0x1f, 0x65, - 0x30, 0x38, 0x35, 0x99, 0x1d, 0x3d, 0x54, 0x09, 0xa8, 0x92, 0x83, 0x66, - 0xbf, 0x49, 0x81, 0xf2, 0xd4, 0xf5, 0x5f, 0x6a, 0xf3, 0x8f, 0xde, 0x38, - 0xdc, 0x36, 0x8e, 0x57, 0x9e, 0x68, 0x9c, 0x40, 0x74, 0xf4, 0xf5, 0x14, - 0x8a, 0x68, 0x24, 0xf4, 0x14, 0x87, 0x58, 0x26, 0xd5, 0xbc, 0x37, 0xee, - 0xdc, 0xb4, 0x53, 0x38, 0xbe, 0x41, 0xda, 0x02, 0x15, 0xc8, 0x62, 0xd8, - 0x94, 0xf7, 0x15, 0x95, 0x18, 0xf5, 0x8e, 0x19, 0xf5, 0x00, 0x4b, 0xe3, - 0xc6, 0xf7, 0x27, 0x24, 0x53, 0x8e, 0x8f, 0x7d, 0xd3, 0xd2, 0x59, 0x8e, - 0xf6, 0x7b, 0x81, 0x8e, 0xcd, 0xc6, 0x45, 0x82, 0x4c, 0x2c, 0x63, 0x24, - 0xb7, 0x8d, 0xd6, 0x80, 0xa5, 0x93, 0xf8, 0x8a, 0x24, 0x59, 0x64, 0x58, - 0xf6, 0xfe, 0x50, 0x4e, 0x2f, 0x59, 0x80, 0x1e, 0xe5, 0x47, 0xec, 0x31, - 0xcb, 0x10, 0x29, 0x0f, 0xdc, 0x25, 0xc1, 0x11, 0xde, 0xdc, 0x9d, 0x41, - 0x01, 0xdc, 0x93, 0x38, 0x20, 0xcb, 0x42, 0xa7, 0xbb, 0x1a, 0x5f, 0x62, - 0x2e, 0x6d, 0x07, 0x30, 0xeb, 0xb4, 0x40, 0x37, 0x06, 0x21, 0x8f, 0x81, - 0x1c, 0x3a, 0xea, 0x25, 0xe3, 0xa6, 0xe6, 0x95, 0x50, 0x04, 0x18, 0x0f, - 0x7f, 0x29, 0xa9, 0x0b, 0x4f, 0xba, 0x95, 0xfd, 0xf7, 0xd3, 0x67, 0x2c, - 0x92, 0xc6, 0xcd, 0x57, 0xcf, 0xec, 0x7a, 0x9e, 0xc3, 0x34, 0xc6, 0x33, - 0xe9, 0x40, 0x54, 0x3f, 0xf7, 0x61, 0xab, 0x10, 0x24, 0xa6, 0x7f, 0x97, - 0x3f, 0x98, 0x65, 0x27, 0x2d, 0x6f, 0x14, 0xf0, 0x4d, 0x03, 0x92, 0x2c, - 0xe6, 0xb6, 0x36, 0x77, 0x37, 0xfa, 0x47, 0x11, 0x3b, 0xd2, 0xa5, 0x2e, - 0x34, 0x98, 0xfa, 0x71, 0x1c, 0x91, 0x20, 0x17, 0xb3, 0x0f, 0xec, 0xb0, - 0xbc, 0x07, 0x64, 0xdb, 0x88, 0x4d, 0x68, 0xd7, 0x91, 0xae, 0xd1, 0xd3, - 0xf1, 0xe4, 0xcd, 0xc4, 0xe2, 0xc7, 0xb5, 0x06, 0x9a, 0xb3, 0xe6, 0x0a, - 0xf2, 0x09, 0x5c, 0xff, 0x8b, 0x5b, 0x38, 0xa0, 0x54, 0xfe, 0x34, 0xcc, - 0xc0, 0x54, 0xeb, 0x42, 0x41, 0x84, 0xdc, 0x26, 0x28, 0xed, 0xea, 0xc0, - 0xdb, 0x05, 0x40, 0xf4, 0x9c, 0x5e, 0x39, 0x16, 0xa5, 0x59, 0x8a, 0x90, - 0x13, 0x71, 0x03, 0xbb, 0xec, 0x30, 0x96, 0x5b, 0xd4, 0x73, 0xf3, 0x98, - 0x1e, 0xbf, 0x78, 0xbd, 0x6a, 0x18, 0x69, 0x1a, 0x3e, 0xf8, 0x6e, 0x15, - 0x96, 0x33, 0x85, 0x4d, 0xe5, 0x39, 0xaa, 0x61, 0x03, 0xb8, 0xf9, 0x7d, - 0xe2, 0xcf, 0x1f, 0xe1, 0xb2, 0x54, 0x8e, 0xb8, 0x9b, 0x61, 0x0b, 0x04, - 0x25, 0xc9, 0xf7, 0x66, 0xb2, 0x88, 0xe7, 0xf1, 0xb1, 0x92, 0xb3, 0x6a, - 0x76, 0x33, 0x4d, 0x88, 0xa3, 0xad, 0xce, 0x71, 0x69, 0x9a, 0x8e, 0xe2, - 0x18, 0x50, 0x77, 0x21, 0x8e, 0xc0, 0x67, 0x40, 0x11, 0x9b, 0x9a, 0x6e, - 0x26, 0xcd, 0x68, 0x82, 0x14, 0x3f, 0xd2, 0x0e, 0x3c, 0x48, 0x61, 0x84, - 0xb9, 0xa7, 0x76, 0x29, 0x3d, 0x42, 0xc1, 0xee, 0x41, 0x9b, 0x6f, 0x92, - 0x00, 0xec, 0x23, 0x10, 0x6e, 0x39, 0xcc, 0xc4, 0x24, 0x05, 0x32, 0x61, - 0xa6, 0x99, 0xac, 0x95, 0x3b, 0xe6, 0xac, 0x8c, 0xe8, 0xd4, 0xa4, 0x9a, - 0x54, 0xf4, 0x54, 0x8d, 0x46, 0x36, 0x4c, 0xb2, 0x26, 0x10, 0xff, 0x3f, - 0x6c, 0x80, 0xeb, 0x99, 0x91, 0x33, 0x81, 0x51, 0x48, 0x9b, 0xe8, 0xe5, - 0xa0, 0x7f, 0x56, 0xf2, 0xd6, 0x59, 0x43, 0xe2, 0x85, 0xb6, 0x05, 0x65, - 0x7e, 0x56, 0x0a, 0x53, 0x20, 0x40, 0x92, 0x2d, 0x59, 0x3e, 0xa9, 0x33, - 0x81, 0xc8, 0xc8, 0x9a, 0x58, 0x90, 0x58, 0x9f, 0xca, 0xe7, 0x51, 0x4c, - 0x65, 0x87, 0xab, 0xc0, 0x7e, 0xf9, 0x9e, 0xf6, 0xf9, 0x86, 0xac, 0xcd, - 0xd8, 0xd1, 0x46, 0x9b, 0xb6, 0x4a, 0x15, 0xe7, 0xc7, 0xbc, 0x69, 0x0f, - 0xdf, 0xdc, 0xfd, 0x2e, 0x76, 0x56, 0xda, 0x92, 0xfa, 0x3e, 0x30, 0xe9, - 0xb5, 0x59, 0x4b, 0xd2, 0xc5, 0x4a, 0xab, 0xc0, 0x05, 0x16, 0xf1, 0x15, - 0xd5, 0xa2, 0xfc, 0x3d, 0xcc, 0x45, 0x13, 0x15, 0x06, 0x53, 0x78, 0xf8, - 0xff, 0x63, 0xfd, 0x4d, 0x61, 0x37, 0x5d, 0x2d, 0xf2, 0x7e, 0x6b, 0xe0, - 0x17, 0x21, 0x84, 0xc0, 0x4c, 0x06, 0xe8, 0x23, 0x12, 0xa5, 0x32, 0xfd, - 0xb5, 0x43, 0x00, 0x61, 0x9e, 0xba, 0xe3, 0xff, 0x29, 0x6f, 0x86, 0x0f, - 0xe3, 0x83, 0xcb, 0x3d, 0x55, 0x53, 0x18, 0xa1, 0x15, 0x63, 0x42, 0xf9, - 0xf2, 0x96, 0xc9, 0x74, 0xbd, 0x25, 0xcc, 0x66, 0x83, 0x31, 0x24, 0xd7, - 0x6e, 0xa7, 0x83, 0x7c, 0x0e, 0x06, 0x45, 0x5f, 0x20, 0x34, 0x83, 0xa9, - 0xa0, 0xf7, 0x82, 0x69, 0x77, 0xa2, 0x3d, 0x1d, 0xd2, 0x36, 0xa2, 0xe6, - 0xec, 0xf2, 0x6b, 0x03, 0x9e, 0xba, 0xb6, 0x55, 0xed, 0xe1, 0x4b, 0xb1, - 0xca, 0xf7, 0x71, 0x0f, 0x63, 0xe9, 0x6d, 0xa9, 0x5a, 0xc5, 0x02, 0xfc, - 0x14, 0xb8, 0x42, 0xa2, 0x5a, 0x9e, 0xe2, 0x23, 0x5c, 0xa5, 0x8c, 0xd4, - 0xff, 0x07, 0x7a, 0xb8, 0xab, 0x99, 0x60, 0x79, 0x8e, 0x49, 0xef, 0x15, - 0x1e, 0x24, 0x18, 0x34, 0xd7, 0x2d, 0x2e, 0x68, 0xc2, 0x3a, 0xa5, 0x68, - 0x21, 0xc0, 0x0d, 0xa6, 0x0f, 0x55, 0xa9, 0xfd, 0xf3, 0xe5, 0x58, 0x24, - 0x18, 0x17, 0x93, 0x3b, 0xa5, 0x10, 0xe0, 0x1a, 0x4b, 0x13, 0x6d, 0x09, - 0x01, 0x36, 0xcb, 0x0b, 0xc2, 0x7b, 0xe0, 0x06, 0x73, 0x55, 0x70, 0x2e, - 0x99, 0xdd, 0x4c, 0x08, 0xf0, 0x6e, 0xfd, 0xa5, 0x9d, 0x1d, 0xc7, 0xe5, - 0x80, 0x68, 0x69, 0x7c, 0x03, 0xd0, 0x56, 0x51, 0x62, 0xe9, 0x78, 0x5f, - 0x61, 0xd5, 0xa6, 0x8e, 0x1a, 0x5e, 0x7e, 0x97, 0xbe, 0x52, 0x0f, 0xe4, - 0x3c, 0x96, 0x73, 0x1a, 0xb3, 0x5a, 0x2e, 0xba, 0x6f, 0xcd, 0xa8, 0x26, - 0x41, 0xe2, 0x90, 0x04, 0x9d, 0xe2, 0x64, 0xc5, 0x9c, 0x20, 0xf1, 0xaf, - 0xa7, 0xad, 0x65, 0x5d, 0xeb, 0xfa, 0x79, 0xb7, 0xba, 0xa8, 0xbc, 0x18, - 0xc8, 0xd4, 0xb4, 0x5a, 0xab, 0x4a, 0x9a, 0x58, 0x67, 0x11, 0x17, 0xdd, - 0x3d, 0xf8, 0x45, 0xda, 0x42, 0x99, 0x87, 0xd4, 0x33, 0x7d, 0x36, 0x2b, - 0xd0, 0x2e, 0x90, 0x5e, 0x35, 0x04, 0xdb, 0xc4, 0x2b, 0x25, 0xed, 0xa9, - 0x8d, 0xac, 0xce, 0x32, 0xb2, 0x5c, 0x6e, 0xa5, 0xfa, 0x95, 0xa7, 0xd8, - 0xc5, 0xc9, 0xb0, 0x62, 0x8f, 0x30, 0xd4, 0x6a, 0xfc, 0x28, 0xc9, 0x1c, - 0x46, 0x2e, 0x9b, 0xa3, 0xcd, 0xae, 0x45, 0xee, 0xf7, 0x37, 0x32, 0x8a, - 0x8d, 0x4b, 0x5d, 0x6a, 0x8e, 0xbe, 0xb9, 0x89, 0xfb, 0x56, 0xca, 0x2a, - 0x59, 0x58, 0x57, 0x59, 0x8c, 0x8d, 0x38, 0xea, 0xea, 0x63, 0x0e, 0x44, - 0x62, 0x21, 0xdf, 0x64, 0x0d, 0xa7, 0x4f, 0xd6, 0x4c, 0xb1, 0x62, 0xce, - 0x3f, 0x33, 0x23, 0xfa, 0x5d, 0x4c, 0xa0, 0x5e, 0x79, 0x7b, 0xd5, 0x8d, - 0x8e, 0x4d, 0xcc, 0x62, 0x51, 0x4e, 0xd4, 0xc5, 0x9e, 0xb8, 0xff, 0x56, - 0xa2, 0x62, 0xc6, 0x30, 0x1d, 0x42, 0xd0, 0xa4, 0x8b, 0xb1, 0x86, 0xe1, - 0x92, 0xd7, 0xc3, 0xc0, 0xe8, 0xe0, 0x92, 0x70, 0xc6, 0xd7, 0x35, 0x1d, - 0x03, 0x53, 0x66, 0xcb, 0xb1, 0x82, 0xef, 0x39, 0xee, 0x79, 0xcb, 0x71, - 0xf2, 0x0b, 0x88, 0xb3, 0xf7, 0xce, 0x4f, 0x43, 0x7d, 0x07, 0x3c, 0x13, - 0x9c, 0xb0, 0x6b, 0xda, 0xcd, 0x49, 0xfb, 0x77, 0xef, 0x97, 0x43, 0x3a, - 0x64, 0x2b, 0xaa, 0xbb, 0xb3, 0x53, 0x10, 0x05, 0x02, 0x16, 0xdf, 0x31, - 0x79, 0xed, 0xd1, 0x2e, 0xe4, 0x20, 0xc2, 0xc5, 0x9e, 0xab, 0xa5, 0xab, - 0xf8, 0xe3, 0x92, 0x2e, 0xd6, 0x35, 0x1b, 0x91, 0xc9, 0x3d, 0x8c, 0xa5, - 0x65, 0x27, 0xe7, 0x22, 0x87, 0xd8, 0xde, 0x9c, 0x25, 0x7a, 0xc7, 0xdc, - 0xa2, 0x9a, 0x82, 0x33, 0xfa, 0xc6, 0x5f, 0x8d, 0x8a, 0x41, 0xe8, 0x1d, - 0x01, 0x7c, 0xf3, 0xf0, 0x76, 0xca, 0xbd, 0x3f, 0x1f, 0xde, 0x49, 0xd3, - 0xd7, 0xc2, 0x2f, 0x38, 0x15, 0x41, 0xda, 0x7f, 0x31, 0x80, 0xce, 0x32, - 0xfd, 0x6e, 0x54, 0x7e, 0x8f, 0xe0, 0xd7, 0x7f, 0x3f, 0x46, 0xa0, 0x99, - 0xa1, 0x7c, 0xac, 0xb6, 0xa3, 0x4b, 0x21, 0x53, 0x13, 0xd1, 0x7f, 0xf5, - 0xf5, 0x70, 0xd0, 0x17, 0xbb, 0x02, 0x82, 0xc5, 0x7b, 0x67, 0x25, 0xfb, - 0xc5, 0x93, 0x6d, 0xf8, 0x93, 0xf1, 0x6e, 0xbb, 0x3c, 0x90, 0x5d, 0xbc, - 0x9e, 0x88, 0xca, 0xd4, 0x75, 0x3b, 0x51, 0xea, 0xa2, 0xc1, 0x93, 0x30, - 0xf2, 0x3e, 0xed, 0xe7, 0xd2, 0x39, 0x86, 0x33, 0x3c, 0x30, 0x08, 0x32, - 0xd3, 0x60, 0xc4, 0xc4, 0x4b, 0x89, 0xfc, 0xf2, 0x05, 0x46, 0x27, 0xbd, - 0x04, 0xd9, 0x82, 0xc9, 0x42, 0x09, 0xfe, 0x3d, 0xf0, 0x44, 0xfa, 0x42, - 0x0b, 0xca, 0x17, 0xe9, 0x22, 0x90, 0xf2, 0x58, 0xf3, 0x75, 0x8a, 0x5c, - 0x3c, 0x18, 0x5d, 0xc9, 0x2c, 0x14, 0xbc, 0xa2, 0x0a, 0x5c, 0xab, 0x4f, - 0x26, 0x92, 0xd2, 0xc2, 0x87, 0x02, 0x6c, 0x62, 0x19, 0x1a, 0x6c, 0x91, - 0x71, 0x37, 0x3d, 0xd6, 0x34, 0x88, 0x6f, 0x68, 0xce, 0x88, 0x7f, 0x2f, - 0xa9, 0x6e, 0xa5, 0xcb, 0x97, 0xaa, 0xf4, 0x8e, 0x3e, 0x4e, 0x43, 0x65, - 0x81, 0x1e, 0x4e, 0x50, 0x41, 0x6c, 0x85, 0x3c, 0x97, 0x0f, 0xc5, 0xf2, - 0xbc, 0x11, 0x3e, 0x08, 0x7f, 0x3b, 0xb5, 0xbc, 0xa8, 0xf8, 0xbd, 0x0b, - 0x45, 0x26, 0xfe, 0x80, 0xde, 0x32, 0x6f, 0xe5, 0xc5, 0xbf, 0x17, 0x14, - 0x18, 0xc7, 0x11, 0xc8, 0x09, 0x08, 0x2a, 0x67, 0x1f, 0xd8, 0xd1, 0xcb, - 0x4f, 0x0d, 0xc3, 0x00, 0x41, 0x4e, 0xab, 0xd0, 0xf3, 0x82, 0x88, 0x15, - 0x9a, 0x75, 0xad, 0xbd, 0x92, 0x8f, 0x56, 0xe8, 0x7a, 0xb8, 0xb0, 0x4d, - 0x8a, 0xe9, 0xe1, 0x6e, 0x3f, 0xf0, 0xd3, 0x63, 0xb6, 0xc7, 0x25, 0x17, - 0xca, 0xfa, 0xc4, 0xc6, 0x17, 0xa5, 0x3b, 0xb9, 0x13, 0xe5, 0xf3, 0x6f, - 0xfc, 0x03, 0xaa, 0x3f, 0x81, 0x0f, 0x6b, 0x9c, 0x48, 0x5d, 0x26, 0x1c, - 0x48, 0x97, 0x17, 0xa7, 0x3b, 0xed, 0xec, 0xad, 0x58, 0x67, 0x34, 0x36, - 0xd1, 0x1e, 0x0d, 0x8b, 0xed, 0x61, 0xa4, 0x72, 0x54, 0x0a, 0x71, 0x2c, - 0xfd, 0x33, 0xf7, 0xd6, 0x92, 0xd1, 0x44, 0x7c, 0x03, 0x22, 0x68, 0xf8, - 0x85, 0x6f, 0x75, 0x55, 0x5f, 0xb3, 0x78, 0xa1, 0x11, 0xe9, 0xb7, 0x25, - 0x0e, 0xae, 0x9d, 0x61, 0x36, 0x21, 0x47, 0x8a, 0x3b, 0x61, 0xa7, 0xc4, - 0xe7, 0x4c, 0x30, 0x7d, 0x34, 0xe4, 0xc3, 0xdc, 0x8f, 0xc2, 0x1d, 0xb5, - 0x88, 0x33, 0xf0, 0x2a, 0xd2, 0x55, 0x29, 0x6f, 0x7e, 0xed, 0x6b, 0x78, - 0x97, 0x2a, 0x8f, 0xcf, 0x6a, 0x1a, 0x03, 0xd9, 0xfa, 0xf0, 0x11, 0x15, - 0xaf, 0x5e, 0xb9, 0xde, 0x75, 0xca, 0x14, 0x17, 0x9c, 0x03, 0x73, 0xd2, - 0x33, 0xe7, 0xf5, 0xa5, 0x2f, 0xef, 0x2d, 0x4d, 0x15, 0xdc, 0xa5, 0x4f, - 0x18, 0x4f, 0xf7, 0xce, 0xa9, 0x6a, 0x5c, 0x92, 0x6f, 0x39, 0x7f, 0x86, - 0xd3, 0x38, 0x01, 0xe5, 0xfe, 0xe9, 0x1a, 0x9e, 0x4e, 0xba, 0xe1, 0x31, - 0x88, 0x61, 0x13, 0x08, 0x29, 0x0a, 0xd7, 0xa0, 0x89, 0xd5, 0x3e, 0x4d, - 0x1d, 0xd0, 0x6d, 0xd1, 0x7b, 0x61, 0x0f, 0x01, 0xa1, 0x59, 0xe4, 0x98, - 0x32, 0xc2, 0x0c, 0x70, 0xe5, 0x67, 0xaa, 0x0b, 0xa4, 0x3f, 0x50, 0xe3, - 0x27, 0x50, 0xf7, 0x0d, 0x2a, 0x42, 0x2e, 0xcf, 0x13, 0xf7, 0x8b, 0x4e, - 0xa9, 0x4e, 0x27, 0xac, 0x5c, 0xbe, 0x47, 0x96, 0x49, 0xd5, 0xe8, 0x29, - 0x6a, 0x73, 0xff, 0xb3, 0x33, 0x8c, 0x3f, 0xba, 0xb3, 0x42, 0x91, 0x14, - 0x25, 0x93, 0x56, 0xb7, 0x80, 0xc6, 0x29, 0xd3, 0xfe, 0xfa, 0xc1, 0x78, - 0x80, 0x12, 0xf0, 0x06, 0x52, 0x44, 0xa4, 0x39, 0xfb, 0xeb, 0xf5, 0xc0, - 0x40, 0x4a, 0x80, 0x19, 0xc1, 0xdf, 0xed, 0x39, 0x09, 0x21, 0x5a, 0xd3, - 0x0f, 0x5a, 0x99, 0x34, 0x50, 0xe4, 0xa2, 0x76, 0x2a, 0x90, 0x83, 0xf5, - 0x9f, 0x35, 0x89, 0x00, 0x4e, 0x6a, 0x4b, 0x48, 0x74, 0x69, 0x27, 0xb8, - 0x7b, 0xe8, 0xd9, 0x65, 0x4a, 0x6d, 0x50, 0xe5, 0xb3, 0x82, 0x38, 0x96, - 0x82, 0x82, 0xca, 0xd4, 0x63, 0x7f, 0xac, 0x02, 0xc6, 0x83, 0xc2, 0x40, - 0x2a, 0x0d, 0xf9, 0xad, 0xb7, 0x17, 0x2b, 0xa6, 0x7b, 0xee, 0x80, 0x10, - 0x24, 0x4f, 0x7d, 0x86, 0xc5, 0x51, 0xdc, 0xc3, 0xb7, 0x5f, 0x33, 0xc9, - 0xe1, 0x6f, 0x95, 0x03, 0xb8, 0x84, 0xe8, 0x8d, 0xd0, 0x38, 0x9c, 0x0b, - 0xc1, 0xa3, 0x90, 0x32, 0xf0, 0x58, 0x0c, 0x51, 0xe0, 0xd8, 0x77, 0x6b, - 0x2e, 0x28, 0x10, 0xdf, 0x76, 0x38, 0x21, 0xd7, 0x81, 0x62, 0xcd, 0xdf, - 0x50, 0x19, 0xeb, 0x89, 0x6c, 0xb0, 0xb9, 0xa5, 0xb4, 0xb7, 0xc4, 0x47, - 0x58, 0xf7, 0x36, 0x14, 0x60, 0x53, 0xf0, 0x79, 0xd7, 0x0b, 0x22, 0x1c, - 0x3c, 0x82, 0x9a, 0xf7, 0x09, 0xba, 0xf5, 0x9a, 0x84, 0x2d, 0x5d, 0x49, - 0x41, 0x94, 0x33, 0xed, 0x39, 0x71, 0xd8, 0x6d, 0x43, 0xde, 0x0e, 0x10, - 0x0e, 0x2c, 0x79, 0x29, 0xe4, 0xfb, 0xa2, 0xd9, 0x3c, 0x71, 0x46, 0x1f, - 0x88, 0x02, 0xd3, 0x4a, 0x89, 0x8a, 0x4a, 0xba, 0x48, 0xf4, 0xfc, 0xb0, - 0x40, 0x6c, 0x27, 0x45, 0x6a, 0x7a, 0xc6, 0x67, 0xe0, 0xb3, 0x2b, 0x67, - 0xcd, 0x5f, 0xfe, 0x66, 0x62, 0x5f, 0x19, 0x9a, 0xaf, 0x95, 0x87, 0x2d, - 0xee, 0x17, 0xae, 0xd8, 0x5f, 0x32, 0x89, 0x67, 0xc1, 0xcb, 0xc2, 0xae, - 0xc6, 0x67, 0x22, 0xb3, 0x01, 0x49, 0x71, 0xd2, 0x59, 0x46, 0xd4, 0xa7, - 0xce, 0x2a, 0x27, 0xfa, 0x8e, 0xa5, 0x31, 0xbe, 0x3e, 0x02, 0x06, 0xaf, - 0x6a, 0x5f, 0x18, 0x00, 0xf5, 0xfd, 0x19, 0xba, 0x42, 0x94, 0x94, 0xd6, - 0xe4, 0xe7, 0x3f, 0x37, 0xca, 0x43, 0x9a, 0x4d, 0x67, 0x2f, 0x09, 0x01, - 0x00, 0x03, 0x83, 0x29, 0xb1, 0xde, 0xb0, 0xd9, 0x1c, 0x90, 0xd8, 0x9d, - 0xde, 0xca, 0x0e, 0x99, 0x7e, 0x74, 0x5a, 0x57, 0x08, 0xf7, 0x19, 0xa8, - 0xc6, 0x90, 0x22, 0xfb, 0x97, 0x36, 0xa7, 0xa6, 0x60, 0x17, 0x0f, 0x62, - 0x23, 0x75, 0xad, 0xbc, 0x0c, 0x49, 0x4d, 0x7b, 0x0b, 0xa6, 0x48, 0xde, - 0x02, 0xcf, 0x4c, 0x2e, 0xba, 0xb5, 0x10, 0xa6, 0xe4, 0xe2, 0xbc, 0x6b, - 0x95, 0x66, 0xd6, 0x67, 0x20, 0x6d, 0x7a, 0x47, 0x73, 0xd9, 0xa4, 0xc8, - 0x60, 0xdf, 0xf7, 0xc3, 0x8a, 0x6a, 0xec, 0x53, 0xcf, 0xb9, 0x13, 0x98, - 0xf7, 0x39, 0xd3, 0x09, 0xa6, 0xdb, 0x74, 0x0f, 0x11, 0x99, 0xaf, 0x20, - 0x82, 0xf1, 0xef, 0xae, 0x99, 0x49, 0xe4, 0x3e, 0xa2, 0x80, 0x19, 0xe2, - 0xac, 0x09, 0xe8, 0x5f, 0x2f, 0x8b, 0x15, 0xc3, 0x95, 0x62, 0xdc, 0x3b, - 0x22, 0x70, 0x93, 0xf7, 0xb3, 0x7c, 0xef, 0xf6, 0x08, 0xcf, 0xdf, 0x2f, - 0x02, 0xa4, 0x49, 0xe5, 0x18, 0x22, 0x0f, 0x94, 0x53, 0x66, 0xf0, 0xcb, - 0x24, 0x41, 0x0e, 0xed, 0xd2, 0x7f, 0xd9, 0x33, 0x75, 0x92, 0x1d, 0x94, - 0x81, 0x7d, 0x7b, 0x07, 0x53, 0x63, 0x3d, 0xdd, 0x1f, 0xd8, 0xaa, 0x2e, - 0xb4, 0x8a, 0x3d, 0x7a, 0x8f, 0xe2, 0x2b, 0xab, 0xb6, 0x47, 0xed, 0xe3, - 0xe1, 0x27, 0x70, 0x32, 0xf4, 0xc0, 0xb7, 0x14, 0x26, 0x3e, 0x9d, 0xec, - 0xc9, 0x8e, 0x6c, 0xfe, 0x67, 0x28, 0xc2, 0xde, 0xdc, 0x99, 0x41, 0x06, - 0xe7, 0x71, 0xa7, 0x2e, 0xf5, 0xf5, 0x32, 0x8b, 0xc5, 0x2d, 0x19, 0xea, - 0x18, 0xe3, 0xf8, 0x24, 0x98, 0x2e, 0x5a, 0x31, 0xe1, 0xe4, 0x5d, 0x56, - 0x7c, 0x98, 0x25, 0x43, 0x8f, 0xe1, 0xf8, 0x99, 0x13, 0x91, 0x6c, 0x9a, - 0xc6, 0xe1, 0x87, 0x87, 0x32, 0xde, 0x5b, 0x67, 0xf2, 0x1c, 0x44, 0x80, - 0x37, 0x2a, 0xd3, 0x6a, 0x55, 0x3f, 0x93, 0x7f, 0xd3, 0x6d, 0x3e, 0x80, - 0x66, 0xfa, 0x4a, 0x21, 0x73, 0x5a, 0xd8, 0x9a, 0xcb, 0x12, 0x8f, 0xb0, - 0x4a, 0x7f, 0x8c, 0x35, 0xed, 0xeb, 0xde, 0x87, 0x63, 0x31, 0xf4, 0x10, - 0x0c, 0xd4, 0xc8, 0xa7, 0x4e, 0x6d, 0xe3, 0x5d, 0x0c, 0x05, 0x48, 0x3c, - 0x62, 0x49, 0xfb, 0x7c, 0x87, 0x22, 0x41, 0x23, 0x59, 0x10, 0x9e, 0xd0, - 0x87, 0xd5, 0xde, 0xe6, 0x42, 0xba, 0x08, 0xe8, 0x93, 0xc6, 0x7e, 0x57, - 0x27, 0xea, 0x13, 0x3a, 0xdf, 0xbb, 0xa6, 0xae, 0x12, 0x58, 0x85, 0xdb, - 0x7c, 0x0b, 0x57, 0x52, 0xe6, 0xbf, 0x1b, 0xe0, 0x07, 0x80, 0x53, 0x7c, - 0xc8, 0x82, 0x94, 0xe4, 0x66, 0xdb, 0xcf, 0x6b, 0x8e, 0xdf, 0x41, 0x3b, - 0xcb, 0xab, 0x46, 0xa5, 0x41, 0x96, 0x0e, 0xf1, 0x65, 0xdd, 0x01, 0x9a, - 0xb3, 0x88, 0x32, 0xbb, 0xed, 0x5f, 0xbe, 0x4e, 0x66, 0x58, 0x9c, 0xb2, - 0xc9, 0x9d, 0x57, 0x40, 0xef, 0xdf, 0x13, 0xda, 0x14, 0x7a, 0x64, 0xeb, - 0x82, 0x81, 0x60, 0x32, 0x31, 0x06, 0x8e, 0xf6, 0x26, 0x63, 0xec, 0x16, - 0xf1, 0x6b, 0x8c, 0xd5, 0x9b, 0x4e, 0x91, 0xa1, 0xea, 0xc9, 0xe4, 0x77, - 0x79, 0xb1, 0x71, 0x22, 0xdc, 0xe3, 0x51, 0x1b, 0x3a, 0x20, 0x01, 0x1d, - 0xf9, 0x4d, 0xc7, 0x81, 0x99, 0xd4, 0xf8, 0x68, 0x7d, 0xd8, 0xaf, 0x51, - 0xc3, 0x39, 0x62, 0x5e, 0x94, 0xf3, 0x75, 0xe7, 0x02, 0x66, 0xb8, 0xa6, - 0x5a, 0x41, 0x14, 0xeb, 0x28, 0xcb, 0xda, 0x59, 0xdd, 0xf2, 0xb2, 0x1e, - 0xe9, 0x70, 0xa8, 0xbd, 0x7c, 0xe4, 0x73, 0x5a, 0xc6, 0x11, 0xd8, 0x78, - 0x59, 0xd1, 0xe8, 0x5a, 0x8d, 0x5f, 0x37, 0xe4, 0xe3, 0x17, 0xe9, 0x37, - 0xf6, 0xc4, 0x9f, 0x87, 0xe0, 0x81, 0x4c, 0xf5, 0x82, 0x7e, 0x30, 0xf6, - 0x15, 0x79, 0x32, 0x4a, 0xdb, 0xa5, 0x56, 0x01, 0xf6, 0x29, 0x38, 0x60, - 0xd8, 0x4b, 0x10, 0xf4, 0x14, 0xee, 0xa5, 0x9f, 0xda, 0xf6, 0x1d, 0x5a, - 0x9b, 0xa2, 0xe2, 0x96, 0xb9, 0x20, 0x06, 0x93, 0x6b, 0x2b, 0xdb, 0x9a, - 0x80, 0xe1, 0x51, 0x77, 0x80, 0xd0, 0x32, 0x44, 0x17, 0xf5, 0x3d, 0xa1, - 0x64, 0xcf, 0xb6, 0x98, 0xb5, 0x40, 0x0c, 0x60, 0x90, 0xa4, 0x4f, 0x0e, - 0xcc, 0x92, 0xe7, 0x46, 0xf6, 0x7a, 0x3e, 0xf9, 0x97, 0x1c, 0x05, 0x33, - 0xaf, 0xfb, 0x18, 0x0c, 0xdb, 0x44, 0x00, 0x82, 0x25, 0x33, 0x93, 0x7a, - 0xab, 0x56, 0xc7, 0xc4, 0x44, 0x0c, 0x9b, 0xed, 0x3c, 0xdd, 0xe3, 0xdd, - 0x03, 0xd8, 0xc0, 0x83, 0x86, 0x7e, 0x91, 0xd8, 0xa1, 0x0b, 0x18, 0x72, - 0x9e, 0xfa, 0xec, 0x3d, 0x9b, 0xb4, 0xba, 0x21, 0xc1, 0xef, 0x23, 0xb1, - 0xab, 0x3d, 0xa5, 0x09, 0x0f, 0x6f, 0xb1, 0x21, 0xfa, 0x5b, 0xb5, 0x1c, - 0x41, 0x92, 0xba, 0x2a, 0x58, 0x6e, 0x36, 0xe1, 0x09, 0x16, 0x57, 0xbe, - 0x1f, 0x3c, 0xb0, 0xaa, 0x77, 0x39, 0x52, 0x98, 0x21, 0x90, 0x91, 0xac, - 0xa6, 0x02, 0x67, 0x83, 0x3f, 0x77, 0x48, 0x21, 0xbd, 0xd0, 0x5a, 0x7d, - 0x26, 0x16, 0x59, 0x1b, 0x7e, 0x65, 0xd2, 0x79, 0x66, 0xe5, 0xbf, 0xb7, - 0x1a, 0x72, 0x34, 0x3c, 0x22, 0xca, 0xe8, 0x87, 0xe5, 0xa8, 0x1c, 0x96, - 0xfc, 0x1b, 0x19, 0x58, 0xf4, 0x9d, 0xb6, 0x10, 0x15, 0x00, 0xf6, 0x2f, - 0x7d, 0x20, 0xc7, 0xd4, 0x74, 0x4a, 0x44, 0x9d, 0x92, 0x44, 0x06, 0x79, - 0x31, 0xc0, 0xd4, 0x9f, 0x68, 0xb3, 0xc6, 0x17, 0x70, 0x64, 0x91, 0x8c, - 0x98, 0x35, 0xae, 0x07, 0x19, 0x46, 0x50, 0xe6, 0xf5, 0xf1, 0x49, 0xfb, - 0x79, 0x9b, 0xc0, 0xb4, 0xe9, 0x9d, 0x71, 0x40, 0xdd, 0x3b, 0xe4, 0xf7, - 0x6d, 0xc1, 0x1c, 0x40, 0xa2, 0xba, 0xce, 0x9b, 0x79, 0x20, 0xe8, 0xcf, - 0x8d, 0x8c, 0xe8, 0xf3, 0x25, 0x20, 0x2f, 0xd5, 0x64, 0x5b, 0x60, 0x7d, - 0x96, 0x70, 0x4a, 0xe6, 0xea, 0x3a, 0xe1, 0x22, 0x4c, 0x03, 0x1b, 0xdd, - 0xf1, 0x7f, 0x57, 0x37, 0xc8, 0x36, 0x99, 0x35, 0xde, 0x36, 0x4c, 0x16, - 0xb9, 0x33, 0x44, 0xf5, 0x44, 0x75, 0x03, 0xfc, 0xa0, 0xae, 0x1f, 0xcc, - 0x6c, 0x7a, 0x0b, 0x15, 0x95, 0x66, 0x21, 0x17, 0x86, 0xfb, 0x60, 0xf4, - 0x22, 0x39, 0x97, 0x0b, 0x95, 0xa8, 0xa2, 0xa7, 0x0f, 0x11, 0xc3, 0xd6, - 0xed, 0xc1, 0x2a, 0xe9, 0x6b, 0x6c, 0xca, 0x88, 0x2b, 0xd7, 0x17, 0x63, - 0x2d, 0xc2, 0x1d, 0xaf, 0xfd, 0xf2, 0xf0, 0x10, 0x0c, 0xcd, 0xce, 0x21, - 0xc6, 0x93, 0xbb, 0x52, 0xf3, 0x83, 0xde, 0xf7, 0x45, 0x8d, 0xb6, 0x70, - 0xc3, 0xf2, 0xab, 0x8d, 0xfc, 0x8f, 0x13, 0xad, 0xbf, 0xd3, 0x95, 0x68, - 0x42, 0xe5, 0x2c, 0x24, 0x63, 0xe5, 0x54, 0xa5, 0x97, 0x67, 0x2f, 0xba, - 0xab, 0x84, 0xa9, 0xb4, 0x0d, 0xcb, 0xbb, 0xac, 0x8e, 0x62, 0x71, 0xff, - 0xf0, 0x32, 0x5e, 0x64, 0x42, 0x0f, 0x09, 0x66, 0x4b, 0x22, 0xb2, 0x8e, - 0xeb, 0x79, 0x1b, 0x7c, 0x4f, 0xab, 0x87, 0xd8, 0x8a, 0xb3, 0x6e, 0x99, - 0xc6, 0x99, 0x8b, 0x14, 0x04, 0x9c, 0x20, 0x32, 0x62, 0xec, 0x15, 0x14, - 0x1b, 0xbb, 0xfa, 0xf1, 0x54, 0x21, 0x4d, 0xe4, 0x2f, 0xbc, 0xf7, 0xfc, - 0x24, 0xda, 0x82, 0x1a, 0xc2, 0x95, 0xb7, 0xfb, 0x8e, 0xee, 0x70, 0x7c, - 0x33, 0x54, 0xb1, 0xa3, 0x08, 0x16, 0x81, 0x63, 0x99, 0x30, 0xec, 0x41, - 0xce, 0x40, 0x19, 0xac, 0xe4, 0xb2, 0x81, 0x21, 0x54, 0xd2, 0xb6, 0x6c, - 0x48, 0x43, 0x47, 0x11, 0x81, 0xc1, 0xd3, 0x37, 0xa1, 0xf8, 0x64, 0xbe, - 0x1b, 0x60, 0x48, 0xda, 0x42, 0x37, 0xc3, 0x1b, 0x85, 0xe1, 0x23, 0xff, - 0xb9, 0x99, 0x35, 0xe3, 0x65, 0x48, 0xe6, 0x28, 0x31, 0x53, 0xea, 0xd0, - 0x92, 0xbc, 0xf0, 0x59, 0xbe, 0x91, 0xce, 0x26, 0xac, 0x91, 0x9d, 0xb3, - 0x36, 0x94, 0x28, 0xff, 0x92, 0xeb, 0x54, 0x6c, 0x2e, 0x96, 0x53, 0x3c, - 0x38, 0x16, 0x22, 0x8a, 0x65, 0x9b, 0x25, 0x9e, 0xe6, 0x27, 0x01, 0x06, - 0x7b, 0xb2, 0x6a, 0x36, 0xc0, 0x1d, 0x38, 0xdc, 0x6e, 0x56, 0xe9, 0xe6, - 0xe5, 0xf5, 0x86, 0x77, 0x3a, 0x57, 0xd7, 0xb9, 0x08, 0xdd, 0x15, 0x1c, - 0xf2, 0xd8, 0x5c, 0xd9, 0xf2, 0x6e, 0x4e, 0x84, 0x08, 0x66, 0xe9, 0x47, - 0x16, 0xba, 0x70, 0x3c, 0x0e, 0x64, 0xf1, 0x42, 0xba, 0xbe, 0x12, 0x36, - 0xbd, 0xac, 0x04, 0xb3, 0xfb, 0xfa, 0x69, 0xe7, 0xd7, 0x67, 0xb3, 0xdd, - 0x83, 0x34, 0x27, 0x4a, 0xb8, 0xa0, 0x85, 0xbc, 0x9b, 0xb8, 0x3f, 0x61, - 0xb6, 0x7c, 0xf8, 0x57, 0x74, 0xf8, 0x70, 0x9b, 0x68, 0x7e, 0x8b, 0xc0, - 0x02, 0xac, 0xac, 0x49, 0xae, 0xd9, 0x13, 0xe2, 0x9e, 0x24, 0x56, 0x41, - 0x77, 0x23, 0xea, 0xc0, 0x47, 0xb9, 0x16, 0xfe, 0xbf, 0x17, 0xb8, 0xae, - 0x95, 0xe8, 0xe3, 0xcf, 0x33, 0xbd, 0x76, 0x4d, 0x08, 0x1e, 0xf6, 0xd9, - 0x3a, 0x26, 0xd9, 0x08, 0x02, 0x0f, 0x26, 0xc2, 0x3b, 0xe1, 0xa9, 0xd4, - 0x81, 0x20, 0x34, 0xdf, 0xd2, 0xd9, 0xd1, 0x1a, 0x11, 0x64, 0xa9, 0x85, - 0x52, 0x44, 0x3f, 0xbc, 0xf0, 0x35, 0x55, 0x95, 0x70, 0x4b, 0x3e, 0xa9, - 0xaa, 0x23, 0xac, 0x7a, 0x34, 0x6f, 0xcd, 0x52, 0x74, 0x81, 0xbb, 0x3b, - 0x7e, 0x6a, 0x70, 0xd0, 0x47, 0xa0, 0xb8, 0xe5, 0x22, 0x73, 0x98, 0xb5, - 0xd6, 0x26, 0x1b, 0x93, 0xa3, 0xd6, 0x33, 0x3b, 0x5d, 0x0d, 0xd6, 0x84, - 0x74, 0x82, 0x5c, 0x95, 0xbb, 0xdc, 0x7b, 0x78, 0xca, 0x5d, 0x11, 0x60, - 0x0a, 0xc7, 0x86, 0x39, 0x58, 0xf7, 0x37, 0x67, 0xc2, 0x96, 0x93, 0xd9, - 0xea, 0x07, 0x21, 0x68, 0x28, 0x08, 0x66, 0x22, 0xb4, 0xdd, 0x55, 0x73, - 0xde, 0xbc, 0x10, 0x81, 0x9b, 0xf1, 0x20, 0x61, 0x5e, 0xdd, 0x0c, 0x00, - 0x24, 0x34, 0x5d, 0x20, 0x76, 0xd2, 0xfa, 0x1e, 0x66, 0x5c, 0x8e, 0xdd, - 0x15, 0x12, 0x0b, 0xe0, 0x0b, 0x0c, 0xe9, 0x7b, 0x39, 0xe9, 0xbf, 0x22, - 0x7a, 0xf1, 0x99, 0x8a, 0x75, 0x24, 0xdf, 0x5a, 0xec, 0x47, 0x88, 0x35, - 0x92, 0xdf, 0x4d, 0x32, 0xe0, 0x13, 0x12, 0xd8, 0x65, 0x0b, 0xa5, 0x1f, - 0xc5, 0xa4, 0x51, 0x56, 0x2a, 0xe5, 0x51, 0x92, 0x28, 0xec, 0x7a, 0xbb, - 0x03, 0x6b, 0x0a, 0xac, 0x47, 0x11, 0x42, 0x37, 0xfa, 0xa0, 0xa2, 0x9a, - 0x97, 0xa4, 0xc3, 0x60, 0x67, 0x34, 0x17, 0x39, 0x7b, 0x32, 0x3e, 0x7a, - 0x29, 0x9d, 0xc0, 0xd3, 0x4d, 0xe0, 0x7b, 0x25, 0xc3, 0xf1, 0xe1, 0xfb, - 0xee, 0xf9, 0xbc, 0xe2, 0x42, 0x07, 0xe3, 0x90, 0x17, 0xc1, 0x9a, 0xc6, - 0x7c, 0x1c, 0x09, 0x29, 0xaa, 0xc7, 0xd9, 0x9d, 0x2f, 0x68, 0xc6, 0x89, - 0x6b, 0xfd, 0x1b, 0x04, 0x16, 0x39, 0x44, 0xa3, 0xba, 0x33, 0x29, 0xbe, - 0x34, 0x28, 0x03, 0x57, 0x81, 0x38, 0x22, 0xb7, 0x2f, 0x3d, 0xbf, 0x5c, - 0x03, 0x12, 0x28, 0x2d, 0x71, 0xd1, 0x4b, 0x01, 0xfd, 0x24, 0x21, 0x21, - 0x6c, 0x16, 0x34, 0xc7, 0x4c, 0xb1, 0x0e, 0x16, 0x32, 0x16, 0xcb, 0x87, - 0x5e, 0x50, 0x88, 0xb1, 0x9d, 0xab, 0x56, 0xff, 0x08, 0x83, 0xc7, 0x8f, - 0x14, 0x2a, 0xbd, 0xd1, 0x47, 0xc9, 0x36, 0x02, 0x63, 0xfd, 0x60, 0x6f, - 0x11, 0x47, 0x9f, 0x4b, 0x4d, 0xda, 0x31, 0x45, 0xdd, 0x7c, 0x75, 0xa9, - 0xa4, 0x05, 0xdf, 0xe5, 0xa9, 0x1d, 0xd1, 0x4f, 0x9b, 0x5b, 0x3e, 0x5d, - 0xb8, 0xd7, 0x70, 0x8f, 0x75, 0x38, 0x6a, 0xba, 0x6e, 0x22, 0xb0, 0x79, - 0xe2, 0xf5, 0xa1, 0x8d, 0x9a, 0x9f, 0x0c, 0x22, 0x00, 0x83, 0x0a, 0x38, - 0xa8, 0x64, 0xec, 0x2b, 0xf9, 0xfa, 0x14, 0x81, 0x70, 0xf2, 0xc4, 0x54, - 0x33, 0x2e, 0xb9, 0x04, 0xdf, 0xf1, 0x6a, 0x7b, 0xf1, 0x29, 0x66, 0x20, - 0x5c, 0x79, 0xd0, 0x1a, 0x17, 0xbb, 0xc1, 0xd2, 0x0c, 0x1a, 0xd5, 0x0c, - 0x3f, 0x29, 0x69, 0x7a, 0x37, 0x38, 0x86, 0x61, 0x5b, 0xcb, 0x03, 0xa9, - 0x3f, 0x19, 0x1f, 0x8d, 0xdc, 0xc7, 0x32, 0x62, 0x81, 0x28, 0xd8, 0xc1, - 0xd9, 0xf5, 0xba, 0x58, 0x21, 0x28, 0xbe, 0x4a, 0x84, 0xc1, 0x1d, 0x7e, - 0x94, 0x48, 0xa8, 0x19, 0x01, 0x93, 0x86, 0xda, 0x90, 0x46, 0x52, 0x0e, - 0x6d, 0xd5, 0x0a, 0x61, 0x29, 0x75, 0x9d, 0x80, 0x7d, 0x97, 0x7d, 0xcd, - 0x6a, 0xe3, 0xdd, 0x01, 0xe5, 0x04, 0x5e, 0xe4, 0x00, 0x7b, 0xd3, 0x0b, - 0xb0, 0x8e, 0x51, 0x91, 0x6b, 0x72, 0x60, 0xc5, 0x73, 0xa4, 0x05, 0x0f, - 0x9d, 0x50, 0x3f, 0xf7, 0x1c, 0x23, 0x7e, 0x66, 0xaf, 0xf7, 0x9a, 0xde, - 0xce, 0x66, 0x9e, 0x60, 0xb8, 0x92, 0x36, 0xd4, 0xc7, 0x92, 0x42, 0x3f, - 0x87, 0x54, 0xb4, 0x96, 0xb2, 0xf1, 0xb5, 0x17, 0x6d, 0x6a, 0x4c, 0x66, - 0x2c, 0x6e, 0x79, 0x58, 0xc8, 0x60, 0x75, 0xb2, 0x61, 0x16, 0x99, 0x97, - 0x9d, 0x3b, 0xc2, 0x6f, 0xeb, 0xc0, 0x65, 0x6b, 0x1f, 0x79, 0xdf, 0x17, - 0x70, 0x08, 0x55, 0x48, 0x2a, 0xc4, 0x5f, 0x06, 0x94, 0xf7, 0x84, 0xb2, - 0xf9, 0x42, 0x86, 0x92, 0x6a, 0x91, 0xa4, 0xf1, 0x4a, 0xfe, 0x10, 0x8b, - 0x4c, 0xb1, 0x10, 0x00, 0x12, 0x52, 0xee, 0xd1, 0x0e, 0x96, 0x26, 0xf4, - 0x08, 0xd6, 0x40, 0x70, 0x7c, 0xc6, 0xcc, 0x4e, 0x4b, 0xf6, 0xe5, 0x99, - 0x9c, 0xea, 0xf9, 0x33, 0x88, 0x4a, 0xe7, 0x45, 0xd6, 0x5f, 0xc9, 0xb9, - 0x27, 0x6c, 0x64, 0xc0, 0x35, 0xe7, 0xd5, 0xbf, 0x91, 0x1e, 0xc3, 0xd0, - 0x9e, 0xb9, 0x3d, 0xeb, 0x7d, 0xf5, 0x4d, 0x76, 0x6c, 0xb2, 0x71, 0x72, - 0xfc, 0x77, 0xce, 0x7b, 0x73, 0xf3, 0x31, 0x76, 0xa8, 0xee, 0xef, 0x04, - 0xa2, 0xfe, 0x3d, 0xef, 0xf1, 0xd0, 0xa7, 0x5c, 0x71, 0xd9, 0xdb, 0x2b, - 0x0b, 0x4d, 0xf9, 0xad, 0xc1, 0xb4, 0x86, 0x19, 0xf3, 0xcf, 0x7b, 0x83, - 0xcf, 0xda, 0xf8, 0xbb, 0xf5, 0xdb, 0xe1, 0xf6, 0x61, 0x6b, 0xec, 0xbe, - 0x1e, 0x72, 0x96, 0x30, 0x6d, 0xaf, 0xd4, 0x17, 0x57, 0xb7, 0x9f, 0xdf, - 0x44, 0x1e, 0x60, 0x06, 0x51, 0xd7, 0x1d, 0x45, 0xc0, 0x77, 0x6a, 0x3d, - 0x8c, 0x9f, 0xe1, 0x92, 0x38, 0xd1, 0x68, 0xf5, 0x38, 0xfd, 0x98, 0xca, - 0x83, 0xdf, 0x26, 0x1c, 0x1d, 0xfc, 0xc1, 0xd3, 0x05, 0x0b, 0xff, 0x89, - 0x79, 0x56, 0xe7, 0x1c, 0x3a, 0x45, 0x83, 0x92, 0x05, 0x1d, 0x7f, 0x92, - 0xf0, 0x60, 0xc6, 0x7d, 0x0b, 0x2b, 0xb9, 0xc9, 0x3a, 0xf0, 0x6a, 0xe4, - 0xea, 0x36, 0x25, 0x5b, 0x01, 0xb5, 0x5e, 0x57, 0xf2, 0xcf, 0x7b, 0x43, - 0x62, 0xc7, 0x87, 0x19, 0xb6, 0xbc, 0x22, 0x6b, 0x46, 0x2a, 0x16, 0xd6, - 0x4b, 0x74, 0x98, 0xd2, 0x9f, 0xb4, 0xd3, 0xb4, 0x68, 0x63, 0xce, 0x00, - 0x78, 0xfe, 0xb7, 0x11, 0x40, 0xdc, 0x3d, 0x23, 0xa0, 0x9d, 0x1d, 0xde, - 0x5e, 0xe8, 0xdc, 0xbf, 0xe0, 0x68, 0xc7, 0x67, 0xaf, 0x0d, 0x90, 0x8d, - 0x42, 0xaa, 0xe5, 0xb3, 0x5c, 0xd7, 0xa7, 0x51, 0xf1, 0x47, 0xcf, 0xab, - 0x5a, 0xd9, 0x30, 0xa4, 0x72, 0xe9, 0xa9, 0x43, 0x56, 0x50, 0x6b, 0x8e, - 0x62, 0x26, 0x0f, 0x63, 0x19, 0x12, 0x21, 0x3d, 0x15, 0xc4, 0x5d, 0xac, - 0xaf, 0xdf, 0x67, 0xcc, 0x64, 0xcf, 0x8d, 0x5a, 0x7f, 0xb0, 0xb6, 0xfa, - 0xf0, 0x18, 0xcb, 0x77, 0x51, 0x6b, 0xf4, 0x52, 0x84, 0xa4, 0xad, 0x2b, - 0xcb, 0x45, 0x9b, 0x43, 0x13, 0x7f, 0xa5, 0xc1, 0x79, 0xc8, 0xaa, 0x57, - 0xbb, 0xb5, 0xf4, 0x55, 0x25, 0x44, 0xf8, 0x65, 0xde, 0x6e, 0x5b, 0x4b, - 0xf0, 0x00, 0xeb, 0x43, 0x1c, 0x2d, 0x25, 0x49, 0x79, 0x55, 0x98, 0x0d, - 0xba, 0x6b, 0xab, 0x7a, 0x81, 0xea, 0x00, 0xf8, 0xc1, 0x1f, 0xb8, 0x9e, - 0x87, 0x21, 0x75, 0xb1, 0xc9, 0x3c, 0x39, 0x00, 0x44, 0xc9, 0x45, 0xb9, - 0x2d, 0x9a, 0x4a, 0x1e, 0xf2, 0x67, 0x5f, 0x43, 0x1f, 0x35, 0xae, 0x69, - 0xa7, 0x68, 0x18, 0x5e, 0x53, 0x83, 0x0c, 0x6b, 0x8e, 0x8c, 0xee, 0x23, - 0x0e, 0x93, 0xe1, 0x97, 0xd7, 0x9a, 0x40, 0x74, 0x0f, 0x00, 0x9c, 0x18, - 0xa7, 0xf7, 0xa1, 0xb8, 0x27, 0x54, 0x87, 0x3c, 0x82, 0xe2, 0x4f, 0xd9, - 0xd9, 0xd5, 0xd6, 0x3a, 0xbe, 0x35, 0x43, 0x47, 0xe2, 0xaa, 0x37, 0x92, - 0x17, 0x49, 0x1d, 0xac, 0x40, 0xf9, 0xe0, 0xd9, 0x3e, 0x54, 0x6f, 0xfa, - 0xab, 0xd9, 0x5a, 0x0b, 0xa1, 0x3f, 0xd2, 0xf8, 0xd4, 0xd0, 0xda, 0x65, - 0xd7, 0x5e, 0x06, 0x91, 0xba, 0x09, 0xcd, 0x25, 0x08, 0x90, 0x69, 0xd1, - 0x31, 0x81, 0x2e, 0x2a, 0x03, 0x92, 0x81, 0xb5, 0xcd, 0x66, 0x1c, 0x43, - 0x2e, 0xb2, 0x4a, 0x2f, 0xcb, 0xfc, 0x14, 0x99, 0x73, 0xc4, 0xae, 0x09, - 0x95, 0x01, 0x03, 0x72, 0x31, 0x5c, 0xbd, 0x9b, 0x36, 0x30, 0xd3, 0x2d, - 0x16, 0xda, 0x8e, 0x3e, 0xa7, 0xcf, 0xc1, 0xd6, 0x2e, 0x8d, 0x1e, 0x8c, - 0x21, 0xc5, 0x9f, 0xe3, 0xcf, 0xeb, 0x7f, 0xef, 0xb9, 0x67, 0xf1, 0xad, - 0xe2, 0x76, 0xa6, 0x19, 0x19, 0xa2, 0x6f, 0x65, 0xce, 0x98, 0x44, 0xec, - 0xf2, 0x3d, 0xaf, 0x92, 0x33, 0x03, 0x33, 0x0d, 0xc6, 0x4c, 0x1b, 0x53, - 0x33, 0x33, 0x73, 0xc0, 0x1f, 0x20, 0x8b, 0x86, 0x2d, 0x16, 0x8b, 0x84, - 0xf1, 0x27, 0xfd, 0x4c, 0xab, 0x44, 0x15, 0xcd, 0x7b, 0x29, 0xc9, 0x73, - 0x12, 0x62, 0x3b, 0xc4, 0xb4, 0x12, 0x04, 0x52, 0x45, 0x9c, 0xc1, 0xef, - 0xef, 0x77, 0x2b, 0x56, 0xa4, 0x16, 0x1a, 0x27, 0xa4, 0x88, 0x1d, 0x29, - 0xcb, 0xe7, 0x71, 0xe4, 0xa0, 0x74, 0x68, 0x30, 0x15, 0x17, 0x5c, 0xca, - 0x5c, 0xc2, 0xc3, 0xd8, 0x69, 0xa7, 0x54, 0x05, 0xf7, 0x29, 0xb9, 0x07, - 0x21, 0x68, 0xc4, 0x20, 0x0f, 0x52, 0xc7, 0x2c, 0x58, 0x8a, 0x4c, 0xdc, - 0xe2, 0xdf, 0xed, 0x8e, 0x31, 0x06, 0x70, 0x93, 0x1b, 0x2f, 0x0d, 0x96, - 0xef, 0x60, 0xa1, 0x3d, 0x9c, 0x45, 0xe6, 0x7a, 0x1f, 0x7f, 0x86, 0x07, - 0xa9, 0xb3, 0xe7, 0x6c, 0x0d, 0x36, 0x66, 0x3a, 0xc0, 0x28, 0xd9, 0x9e, - 0x89, 0x87, 0xe8, 0x3f, 0x31, 0x3f, 0xf9, 0xd0, 0xeb, 0x3d, 0x32, 0xb3, - 0xa8, 0xdd, 0xda, 0x5c, 0x17, 0x6e, 0xe0, 0xab, 0x13, 0x5a, 0xf1, 0xb9, - 0x62, 0xc2, 0xee, 0x82, 0x5b, 0xca, 0x06, 0x88, 0x86, 0x05, 0xc5, 0x6d, - 0x73, 0xb5, 0x0c, 0x49, 0x96, 0x3f, 0xae, 0xfd, 0x7f, 0x47, 0xce, 0x4c, - 0x31, 0xa9, 0xb9, 0x15, 0x04, 0x68, 0x78, 0x4f, 0xe2, 0xf6, 0x8c, 0xe5, - 0x33, 0x99, 0xfa, 0x7a, 0x8d, 0x3a, 0x17, 0x93, 0xb8, 0xce, 0x07, 0x23, - 0x02, 0xdf, 0xd0, 0xab, 0x98, 0x73, 0xb2, 0xb2, 0x4c, 0xe9, 0x12, 0xae, - 0xb8, 0x16, 0xee, 0x90, 0x4b, 0xe9, 0xb2, 0xdb, 0xbb, 0xec, 0x35, 0xe7, - 0xbe, 0x80, 0x0c, 0x8c, 0xdf, 0xc4, 0x07, 0x50, 0xe5, 0xf7, 0xf5, 0xd1, - 0x9d, 0xe3, 0x81, 0x3a, 0x6e, 0xb5, 0x6f, 0xa8, 0xe2, 0xb9, 0x99, 0xa4, - 0x9d, 0xf9, 0xc2, 0xae, 0x0c, 0x4f, 0x90, 0x69, 0xf4, 0xd9, 0x3d, 0x4b, - 0x48, 0x33, 0x79, 0xf4, 0x6e, 0xad, 0x73, 0x9e, 0x08, 0x62, 0xd8, 0x9f, - 0x76, 0x72, 0xc0, 0x8a, 0xf8, 0x82, 0x3e, 0x4a, 0xa4, 0xc5, 0x24, 0x1e, - 0x04, 0x8f, 0xfa, 0x29, 0x43, 0x65, 0xa3, 0x2e, 0xc3, 0xf4, 0x2f, 0x0c, - 0x6e, 0x3e, 0x04, 0x91, 0x4e, 0x87, 0x88, 0x78, 0x5a, 0xac, 0x78, 0x5a, - 0xb8, 0xf2, 0xc0, 0x37, 0x45, 0xf1, 0x90, 0x53, 0x57, 0x5d, 0xe0, 0xaf, - 0x24, 0x90, 0x07, 0x04, 0xa5, 0x66, 0xa9, 0x71, 0xcc, 0x41, 0x32, 0xc1, - 0xbb, 0xfa, 0xb2, 0x14, 0xb2, 0x79, 0x4f, 0xbd, 0x93, 0x4a, 0x63, 0x2a, - 0xb7, 0x60, 0x24, 0x56, 0x70, 0x0f, 0x50, 0x7c, 0xda, 0xbd, 0x93, 0x72, - 0x3f, 0xa3, 0xd2, 0x7d, 0xd8, 0x64, 0x78, 0x2d, 0xf2, 0xbe, 0x2b, 0x00, - 0xef, 0xcb, 0x53, 0xd6, 0x26, 0xfb, 0x11, 0x96, 0xbd, 0x51, 0x3d, 0xe2, - 0xdd, 0x8d, 0x5d, 0x70, 0x80, 0x68, 0x21, 0x98, 0xf8, 0xb8, 0x3c, 0x68, - 0x62, 0x27, 0x15, 0xae, 0x75, 0x72, 0x5d, 0x4f, 0xcb, 0x14, 0x6b, 0x18, - 0x2f, 0xcf, 0x47, 0x8c, 0x7c, 0x67, 0x63, 0xd5, 0x45, 0xd5, 0x0b, 0x33, - 0xac, 0xe8, 0x25, 0xa5, 0x7b, 0x5f, 0x32, 0x3f, 0x5c, 0x9b, 0x72, 0x73, - 0x0f, 0x56, 0x35, 0x69, 0x5a, 0x4e, 0x80, 0x09, 0x54, 0xe9, 0x73, 0x4c, - 0xa2, 0x11, 0xca, 0xb0, 0xf7, 0x64, 0xc3, 0xd5, 0xd0, 0x66, 0x85, 0xbd, - 0x5e, 0x0e, 0x57, 0x83, 0x55, 0x3d, 0x5f, 0x9b, 0x25, 0x01, 0x8f, 0x0c, - 0xad, 0x99, 0xb3, 0x2a, 0xf1, 0xf9, 0x62, 0x6e, 0x26, 0x61, 0x74, 0x00, - 0x0c, 0x61, 0xbb, 0xc8, 0xf6, 0x08, 0x58, 0x44, 0xdf, 0x55, 0xd0, 0x4a, - 0xf2, 0xea, 0x7d, 0x79, 0x00, 0xa5, 0x7d, 0x50, 0x86, 0x6f, 0x9f, 0xae, - 0x61, 0xcf, 0xf0, 0x46, 0xa7, 0x4f, 0x30, 0x3b, 0xef, 0x14, 0xc4, 0x7d, - 0x0b, 0x38, 0x98, 0x8d, 0xa4, 0x27, 0x28, 0xec, 0x75, 0x15, 0x4d, 0x0e, - 0xc0, 0x59, 0xed, 0x63, 0x0b, 0x93, 0xcd, 0x92, 0xb1, 0x01, 0x44, 0x44, - 0x15, 0x6b, 0x1c, 0x15, 0x16, 0x0d, 0x88, 0xfc, 0x35, 0x58, 0x53, 0xed, - 0x00, 0x56, 0xfb, 0x96, 0xb7, 0x74, 0x11, 0x2e, 0x7a, 0xae, 0xda, 0xa9, - 0x6b, 0xd0, 0x2e, 0xc9, 0xe1, 0xf6, 0x84, 0x43, 0x69, 0x14, 0xcb, 0xd6, - 0xf5, 0x7d, 0xd2, 0x2c, 0xdc, 0x5d, 0x36, 0x38, 0xae, 0x70, 0xf9, 0x1f, - 0x7d, 0x49, 0xd9, 0xaf, 0x0a, 0xe3, 0x2a, 0x3c, 0xba, 0xb6, 0xd3, 0xac, - 0x09, 0x86, 0x8d, 0x48, 0xe9, 0x42, 0x13, 0x97, 0xf4, 0x40, 0x66, 0x0a, - 0x3f, 0xb9, 0x2d, 0x68, 0x47, 0x3b, 0x80, 0xa0, 0xb3, 0xe1, 0x88, 0x3a, - 0xac, 0xa5, 0x66, 0x20, 0x4f, 0xcf, 0xe0, 0x61, 0xae, 0xd4, 0x7d, 0xfd, - 0x25, 0x92, 0x9f, 0xaa, 0x52, 0xce, 0x03, 0x13, 0x21, 0xd7, 0xa3, 0x22, - 0x2f, 0x50, 0x28, 0x4d, 0xdf, 0x2b, 0x9b, 0x07, 0xd8, 0x72, 0x0b, 0xea, - 0xb5, 0xf4, 0xdc, 0x72, 0xce, 0x7b, 0x2f, 0xc2, 0xfa, 0xf9, 0x9b, 0xfe, - 0xa9, 0x81, 0xbe, 0xa2, 0x71, 0x97, 0x96, 0xef, 0x98, 0xd7, 0x04, 0xf6, - 0x45, 0x6c, 0xa9, 0xf8, 0x42, 0xcc, 0xb2, 0xd5, 0xbd, 0x89, 0x2a, 0xf3, - 0x43, 0xd8, 0xd5, 0xce, 0xca, 0x1b, 0xdd, 0xd1, 0x80, 0x2f, 0xb7, 0x94, - 0xf4, 0x71, 0x0d, 0x96, 0x8c, 0xb1, 0x92, 0xfa, 0x34, 0xbe, 0x69, 0x4d, - 0xf3, 0x1c, 0xba, 0x84, 0xad, 0x45, 0xa8, 0x6a, 0xf0, 0x7a, 0x28, 0xbf, - 0xd0, 0x55, 0x5e, 0x23, 0x51, 0x96, 0x73, 0x69, 0x23, 0xab, 0x1e, 0x34, - 0xfe, 0x22, 0x2d, 0x51, 0xbc, 0x41, 0x89, 0x8f, 0x8f, 0xc7, 0xd0, 0x72, - 0xd8, 0xd5, 0x86, 0xa9, 0xdd, 0x81, 0xe8, 0x62, 0x58, 0x77, 0xd9, 0x8d, - 0xa0, 0xe2, 0xfd, 0xa2, 0xd6, 0xa0, 0x0d, 0xc2, 0x0a, 0x53, 0xc9, 0x23, - 0x1a, 0x14, 0xa9, 0x21, 0x07, 0x54, 0x53, 0xa2, 0xa1, 0xc3, 0x0a, 0x20, - 0xed, 0x63, 0x35, 0xb8, 0x4d, 0xdc, 0x26, 0xf0, 0x30, 0x58, 0x66, 0x7a, - 0x09, 0xf6, 0x9b, 0xce, 0xb3, 0xf3, 0x65, 0xfe, 0xdb, 0x33, 0x11, 0xd4, - 0xb8, 0x21, 0xd4, 0x76, 0xeb, 0x5b, 0xe2, 0x59, 0x4e, 0xf2, 0x54, 0xb8, - 0xdc, 0x34, 0x9c, 0x70, 0x7e, 0xba, 0x63, 0x8e, 0x69, 0xeb, 0x3c, 0xe8, - 0x4f, 0x2e, 0x03, 0xf9, 0xf3, 0xf2, 0x09, 0x78, 0xbd, 0x8d, 0x59, 0xf2, - 0x40, 0xc1, 0x7e, 0xb0, 0xe2, 0xc5, 0x62, 0xf9, 0x7b, 0x80, 0x1b, 0x7b, - 0xb7, 0x5b, 0x80, 0x8f, 0x4d, 0x01, 0x01, 0x80, 0xe6, 0x57, 0x94, 0xa4, - 0xa6, 0x5c, 0xc5, 0x56, 0x9c, 0xb1, 0xab, 0xe3, 0x99, 0x44, 0x22, 0xce, - 0x1d, 0x06, 0x0c, 0xb5, 0x68, 0x23, 0xfe, 0xe3, 0x88, 0x6b, 0xc2, 0xc2, - 0x7d, 0x17, 0xc0, 0x28, 0x1d, 0xb3, 0x1b, 0xb4, 0x63, 0x81, 0x56, 0xb9, - 0xed, 0xed, 0xc4, 0x7d, 0xa4, 0x98, 0x4b, 0x63, 0x6a, 0x32, 0xfc, 0x1a, - 0xfc, 0xf9, 0x53, 0xad, 0x36, 0x67, 0xa6, 0xae, 0x42, 0xcc, 0xb7, 0xaa, - 0xf9, 0x74, 0x18, 0x99, 0xdb, 0xed, 0xb2, 0xfd, 0x7a, 0xce, 0xc9, 0x5a, - 0x9a, 0x4b, 0xdd, 0x76, 0x8b, 0x10, 0x76, 0x77, 0x7d, 0x60, 0x6a, 0x3d, - 0x5a, 0x64, 0xd1, 0x44, 0x85, 0x0c, 0xd5, 0xde, 0x71, 0x9c, 0x31, 0x28, - 0x7d, 0xb1, 0x4c, 0x20, 0xfe, 0xda, 0x1a, 0x64, 0xb0, 0xdb, 0x7e, 0x70, - 0x5e, 0x23, 0x75, 0xf4, 0xcc, 0x71, 0x79, 0xde, 0x6c, 0x05, 0xdb, 0xb7, - 0x40, 0xd1, 0xc0, 0xcb, 0x79, 0x8a, 0x64, 0x0f, 0x58, 0x5f, 0x12, 0x8a, - 0xa6, 0x20, 0x00, 0x31, 0xcb, 0x36, 0x9e, 0x96, 0xc3, 0x60, 0xad, 0x01, - 0xd2, 0xe3, 0xbd, 0x45, 0xbd, 0x2d, 0x69, 0xb8, 0x0a, 0xf0, 0xe5, 0x24, - 0x44, 0x5b, 0x7b, 0x64, 0xe3, 0x83, 0x9e, 0x74, 0x05, 0xff, 0x85, 0xd5, - 0xa6, 0x20, 0xd2, 0x65, 0xfe, 0x39, 0x46, 0x0c, 0x9e, 0x1c, 0x6e, 0x3d, - 0x0f, 0x6b, 0x48, 0xe2, 0xe0, 0xb2, 0x19, 0xba, 0x73, 0x07, 0x70, 0xd9, - 0x0a, 0x8f, 0x92, 0xa7, 0xef, 0x3e, 0x3e, 0xec, 0xc6, 0x83, 0xd7, 0x01, - 0x68, 0x03, 0x2d, 0x49, 0x0d, 0xe3, 0x61, 0xb9, 0x1c, 0xe5, 0x9b, 0x9b, - 0xee, 0x53, 0x15, 0xed, 0x52, 0x67, 0x54, 0x31, 0xcc, 0xba, 0xf9, 0x1a, - 0xe4, 0xf6, 0x1d, 0xd9, 0xbc, 0x13, 0x11, 0x46, 0x34, 0xfd, 0x5c, 0xb0, - 0xaf, 0x6c, 0x13, 0x14, 0xab, 0xe8, 0xae, 0x91, 0x0a, 0x8c, 0x83, 0x38, - 0xd1, 0x5d, 0x06, 0x54, 0x93, 0x79, 0x96, 0x91, 0x23, 0x89, 0x67, 0x97, - 0x22, 0xb9, 0x26, 0xfb, 0xbf, 0x38, 0x72, 0xa9, 0x8b, 0xb0, 0x3a, 0xde, - 0xdb, 0xa1, 0x08, 0x23, 0x3d, 0xaf, 0x4a, 0x7c, 0x34, 0x5c, 0x94, 0xaa, - 0xa6, 0x42, 0x50, 0x51, 0xb5, 0x29, 0x91, 0xf0, 0x12, 0xd8, 0xf1, 0x6c, - 0x51, 0xf9, 0x97, 0xc6, 0xcd, 0xb8, 0xb8, 0x77, 0xd5, 0xb2, 0xe4, 0xea, - 0x71, 0xef, 0x99, 0x7f, 0xe6, 0x27, 0x4d, 0xff, 0x3c, 0xf7, 0xc9, 0xd5, - 0xd0, 0x4f, 0x52, 0x1e, 0x36, 0x3c, 0xa0, 0xc8, 0x96, 0xad, 0xa5, 0xcb, - 0x2f, 0xcc, 0x73, 0x02, 0x41, 0x2f, 0x1c, 0x75, 0x0a, 0x67, 0x68, 0x07, - 0x36, 0x6e, 0xb8, 0x3c, 0x16, 0xe6, 0xac, 0x16, 0x43, 0x29, 0xe1, 0xc6, - 0xbf, 0x56, 0x78, 0x12, 0x3c, 0x09, 0x7c, 0x85, 0x6c, 0x87, 0x3f, 0x77, - 0x0a, 0xf7, 0xcf, 0xbc, 0xce, 0x94, 0xef, 0x4f, 0x13, 0x64, 0xf5, 0x6c, - 0xb7, 0x75, 0xdb, 0x83, 0x3f, 0x39, 0xc3, 0xba, 0xc0, 0x6a, 0xad, 0x43, - 0xdc, 0x6d, 0xa2, 0x62, 0x3b, 0xe7, 0xc2, 0xb0, 0xf1, 0x3e, 0x19, 0xae, - 0x83, 0x79, 0x36, 0x4a, 0xcc, 0xcf, 0x14, 0xdc, 0x0a, 0x20, 0x74, 0xd4, - 0x1a, 0x3a, 0x3b, 0x9a, 0x19, 0x51, 0x81, 0x8f, 0x3d, 0xa9, 0xe6, 0xaa, - 0x81, 0x5c, 0xcb, 0xee, 0x84, 0x45, 0x16, 0x40, 0xe7, 0xb3, 0x65, 0x01, - 0x29, 0xab, 0x08, 0x05, 0xa4, 0x38, 0x09, 0x97, 0x31, 0x78, 0x06, 0x69, - 0xb6, 0xfc, 0x47, 0x3f, 0x97, 0x55, 0x93, 0x5b, 0x4d, 0x28, 0x37, 0xde, - 0xfe, 0x19, 0xf1, 0xbf, 0xda, 0x32, 0xe2, 0x35, 0x2d, 0x25, 0xa2, 0xc9, - 0x56, 0x58, 0x7d, 0x11, 0xb7, 0x67, 0x79, 0xf7, 0x67, 0xc1, 0x1b, 0xf3, - 0x23, 0xe0, 0x86, 0x95, 0xbd, 0x71, 0x7a, 0xd5, 0x23, 0x2c, 0x9b, 0xfc, - 0x60, 0x4f, 0xa7, 0x38, 0xc6, 0xec, 0xfc, 0x43, 0x13, 0xf4, 0x62, 0xa4, - 0x1d, 0xb0, 0x05, 0x87, 0x11, 0xfe, 0x94, 0x90, 0x8d, 0xea, 0x8a, 0x95, - 0xb1, 0x98, 0xbd, 0x04, 0xcd, 0x84, 0xc8, 0xb6, 0x4b, 0x73, 0x4f, 0x4a, - 0xed, 0xda, 0xcc, 0x92, 0xbc, 0x07, 0xed, 0x74, 0x4e, 0xe0, 0x06, 0x08, - 0xe2, 0xec, 0xbe, 0x1c, 0x8d, 0xbb, 0x4c, 0x35, 0xe8, 0xa7, 0xde, 0x87, - 0x20, 0xcf, 0xd7, 0xf7, 0x95, 0xa2, 0x7e, 0x65, 0xc2, 0xcc, 0xeb, 0xdf, - 0x49, 0x02, 0x47, 0x86, 0x54, 0xf5, 0x6d, 0xc7, 0xec, 0xa9, 0xb4, 0x8d, - 0xc5, 0x67, 0xe9, 0xcb, 0x41, 0x07, 0x03, 0x74, 0x9c, 0xff, 0xc2, 0x1c, - 0x31, 0xb4, 0x22, 0x3e, 0x87, 0x9a, 0xdf, 0xa5, 0xc1, 0x3e, 0x5f, 0xb4, - 0xe7, 0x00, 0x44, 0xa3, 0x80, 0xd6, 0x39, 0x72, 0x54, 0x9a, 0x4e, 0xd9, - 0xe1, 0x82, 0x09, 0x3b, 0x47, 0x0d, 0x30, 0xd2, 0x3e, 0xd0, 0x63, 0x50, - 0x52, 0xf4, 0x73, 0xf8, 0xb1, 0x17, 0x61, 0x2c, 0x9a, 0x40, 0x7f, 0x54, - 0x7a, 0xfd, 0x55, 0x16, 0xd0, 0xb5, 0xdb, 0x6e, 0xf7, 0xcf, 0xac, 0x4e, - 0xb7, 0x7a, 0x2c, 0x9c, 0x3e, 0x9f, 0xc8, 0x91, 0x62, 0xfd, 0xda, 0xa0, - 0xfb, 0x4a, 0x46, 0xa0, 0xef, 0x6e, 0x49, 0x86, 0x9e, 0x4a, 0xb8, 0x94, - 0x2a, 0xa2, 0xbc, 0x4b, 0x8e, 0x5a, 0x32, 0xfd, 0x1b, 0x24, 0x64, 0x72, - 0xe0, 0x12, 0xb5, 0x25, 0xc1, 0x44, 0xbe, 0x4c, 0x68, 0x2a, 0xc9, 0x9f, - 0xc2, 0x62, 0x32, 0xbe, 0xd5, 0xcb, 0x3c, 0xa7, 0x06, 0x20, 0xeb, 0xea, - 0x38, 0x07, 0x07, 0xe6, 0xf3, 0xef, 0x7a, 0xbc, 0x28, 0x7d, 0x42, 0xde, - 0xd3, 0x45, 0x26, 0xfd, 0x83, 0x4c, 0xcc, 0xea, 0xd1, 0x70, 0xa6, 0x33, - 0xca, 0x34, 0x76, 0x74, 0x28, 0x2a, 0xf9, 0xc5, 0x6c, 0x87, 0xae, 0x70, - 0xd5, 0xcf, 0x82, 0xba, 0xf2, 0x5d, 0xcf, 0x73, 0xe8, 0xba, 0x77, 0x76, - 0x65, 0x40, 0xdd, 0x44, 0x5d, 0x24, 0xff, 0x4b, 0x2e, 0x98, 0xc1, 0x9b, - 0x97, 0xb1, 0x41, 0x7e, 0x48, 0xf9, 0x46, 0x08, 0x38, 0x6d, 0x8d, 0xdc, - 0xe7, 0x53, 0x96, 0x71, 0xab, 0x66, 0xd4, 0x00, 0xfe, 0xf4, 0x8d, 0xbb, - 0xb6, 0x32, 0xab, 0x4b, 0x79, 0xda, 0xc3, 0x97, 0xd8, 0x48, 0x72, 0x8c, - 0xee, 0x94, 0x74, 0xcc, 0x81, 0xef, 0x4f, 0xdd, 0xcc, 0x95, 0x8c, 0x6d, - 0x43, 0x02, 0x35, 0x79, 0x4f, 0xff, 0x96, 0x27, 0xaf, 0xcc, 0x37, 0xde, - 0xa5, 0xc4, 0x54, 0xb2, 0xd7, 0x73, 0x9b, 0xc2, 0x43, 0xb9, 0x07, 0xa4, - 0x71, 0x33, 0x0d, 0x9d, 0xfd, 0xf0, 0x23, 0xf0, 0xff, 0xd3, 0x86, 0x81, - 0x41, 0xb7, 0x04, 0x64, 0xcf, 0xe4, 0x32, 0x92, 0xc5, 0x80, 0xe4, 0xe0, - 0x4b, 0x3c, 0xd6, 0x9a, 0x77, 0x1a, 0x77, 0x5b, 0x95, 0x86, 0x63, 0x01, - 0x9e, 0xc7, 0xe9, 0x06, 0xee, 0x0a, 0x69, 0xee, 0x41, 0xf2, 0xa8, 0xb5, - 0x76, 0x83, 0xb9, 0xa7, 0x7d, 0xb2, 0x23, 0xe4, 0xbf, 0x5d, 0x22, 0xb5, - 0x24, 0xe7, 0x3b, 0x42, 0xa5, 0x25, 0xb2, 0x3f, 0x4a, 0xac, 0x5b, 0x40, - 0xe0, 0x5e, 0x39, 0xa1, 0x3c, 0xa8, 0x18, 0x7d, 0x7a, 0xa8, 0xf5, 0xd0, - 0x46, 0xb3, 0x6e, 0x82, 0x4e, 0x9d, 0x84, 0x03, 0xf5, 0x2a, 0x2d, 0x66, - 0x41, 0x71, 0xd2, 0x1f, 0x71, 0xa5, 0xab, 0xa9, 0xf6, 0xf9, 0x28, 0x12, - 0xe2, 0xcd, 0x62, 0x9f, 0xdc, 0x21, 0xce, 0xeb, 0xdc, 0x1c, 0x8f, 0x97, - 0xf5, 0xcb, 0x75, 0xe6, 0x35, 0x3c, 0x43, 0x43, 0xa2, 0xc5, 0x18, 0xc2, - 0x6c, 0xfc, 0xe7, 0xb2, 0x59, 0x10, 0x4c, 0x0c, 0xb7, 0x2c, 0x5a, 0xcb, - 0x14, 0x01, 0x66, 0x33, 0x4a, 0xa5, 0xe1, 0x25, 0xde, 0xcc, 0x19, 0x86, - 0xf4, 0xd4, 0xc8, 0x1e, 0xdd, 0x29, 0x7f, 0xd1, 0x86, 0x43, 0xa4, 0xab, - 0x39, 0x7b, 0x1f, 0x84, 0x5d, 0xf7, 0x2c, 0x12, 0xc6, 0xb4, 0x94, 0x4b, - 0x38, 0xe6, 0x18, 0xfb, 0x2b, 0x7a, 0xea, 0xcf, 0x38, 0x24, 0x52, 0x18, - 0x15, 0x0c, 0xf9, 0x57, 0x99, 0xff, 0x7f, 0xc2, 0x39, 0xe2, 0xa6, 0x42, - 0x71, 0x35, 0xeb, 0x7c, 0x13, 0x20, 0x20, 0x21, 0xc4, 0x51, 0x87, 0x63, - 0xf9, 0x69, 0x97, 0x65, 0x35, 0x37, 0xba, 0xb6, 0xf2, 0x43, 0xdd, 0xb4, - 0x44, 0x15, 0x4c, 0xe6, 0x22, 0xfe, 0x0a, 0x09, 0x7a, 0xfd, 0xde, 0x76, - 0x58, 0xd2, 0xac, 0x9e, 0x57, 0xc0, 0x46, 0x02, 0x62, 0x39, 0xd0, 0xb0, - 0x97, 0xf5, 0xaa, 0x1b, 0xfb, 0xc6, 0x2c, 0x92, 0x78, 0xc7, 0x61, 0x9a, - 0xca, 0xd1, 0xbb, 0x45, 0x3f, 0x5f, 0xcb, 0xf1, 0x4c, 0x16, 0x6b, 0x07, - 0x18, 0x2b, 0x46, 0x9d, 0x3c, 0x3b, 0xf9, 0xd1, 0x75, 0x09, 0x04, 0xc1, - 0x80, 0xc8, 0x9a, 0x5f, 0x5a, 0x50, 0xe7, 0x7c, 0xd5, 0x2d, 0x54, 0x76, - 0xbb, 0x8a, 0xc5, 0xc2, 0x9f, 0xad, 0x27, 0x88, 0x90, 0x90, 0x34, 0xb0, - 0xdc, 0x8d, 0xdd, 0x26, 0x97, 0x4c, 0x0c, 0xe4, 0x24, 0x7d, 0x24, 0xad, - 0x29, 0xd7, 0x2d, 0xd9, 0x14, 0x7b, 0xde, 0x29, 0xb1, 0x31, 0xde, 0xb3, - 0xa4, 0x6f, 0xc0, 0x15, 0x9e, 0xd0, 0xc4, 0xe2, 0x3b, 0x57, 0x13, 0x45, - 0xde, 0xd1, 0x70, 0x96, 0x05, 0xd7, 0xdc, 0x00, 0x28, 0x19, 0x16, 0xee, - 0x97, 0xa7, 0xc9, 0x54, 0x71, 0x9f, 0x74, 0x1b, 0x6c, 0x80, 0x6d, 0x43, - 0xf7, 0xa1, 0x42, 0x66, 0xa5, 0x2f, 0x4c, 0xb1, 0x16, 0x33, 0xbe, 0x46, - 0x6a, 0x4c, 0x58, 0x98, 0x2b, 0xa8, 0x47, 0xe2, 0xf4, 0xcb, 0x39, 0x8a, - 0x80, 0x2f, 0x9c, 0x0a, 0x6c, 0xaa, 0x1a, 0x4f, 0xa1, 0x1f, 0x95, 0x34, - 0x6d, 0x95, 0x31, 0xd3, 0xf8, 0x56, 0xc5, 0xf7, 0xf8, 0xfd, 0x7d, 0x32, - 0xab, 0xeb, 0x52, 0x06, 0x0d, 0x9f, 0x50, 0x51, 0xfb, 0x49, 0x76, 0x02, - 0xb6, 0xdc, 0x41, 0x86, 0xa1, 0x05, 0xd3, 0x6c, 0x7a, 0x0c, 0xce, 0x68, - 0x22, 0xe2, 0x7c, 0xc1, 0x45, 0x04, 0x93, 0xdd, 0x1c, 0xe5, 0x0f, 0xe1, - 0x52, 0x87, 0xb3, 0xe7, 0x00, 0xfb, 0xc3, 0x58, 0xa6, 0xc0, 0xd5, 0x12, - 0x0c, 0x1c, 0x22, 0x2c, 0x83, 0xa7, 0x02, 0x67, 0x96, 0x54, 0x90, 0x63, - 0x48, 0x99, 0xb1, 0x57, 0xab, 0x20, 0x88, 0x49, 0x5c, 0xdb, 0xa4, 0xc8, - 0x70, 0x23, 0x11, 0xb0, 0xe9, 0x69, 0x0b, 0x6d, 0xa9, 0xd0, 0x07, 0x87, - 0xd5, 0x3c, 0x3d, 0xf6, 0x85, 0x66, 0x28, 0xe3, 0x72, 0xca, 0xc3, 0x50, - 0x73, 0x40, 0x8b, 0xb1, 0xf1, 0x4d, 0x83, 0xc1, 0x3c, 0xd6, 0x7f, 0x77, - 0x1a, 0xf4, 0xd4, 0x7b, 0x46, 0x4f, 0x1c, 0x65, 0x72, 0x2b, 0x3a, 0xe0, - 0xa6, 0x9f, 0xfa, 0x27, 0x07, 0xec, 0xda, 0xb4, 0xe2, 0x5b, 0xcb, 0x32, - 0x03, 0x0b, 0x80, 0xbf, 0xe1, 0xa0, 0x6c, 0xca, 0x41, 0x42, 0xa4, 0xfb, - 0x86, 0x98, 0xaa, 0x2f, 0xc6, 0x76, 0x79, 0xbc, 0x2f, 0xe0, 0x07, 0xaf, - 0xed, 0x3a, 0x28, 0xd6, 0x01, 0x51, 0x54, 0x2d, 0xbc, 0x42, 0x79, 0x7b, - 0xdc, 0x15, 0x31, 0x4b, 0x6b, 0x42, 0x14, 0xe3, 0xda, 0xb5, 0x0e, 0xb0, - 0x40, 0xd0, 0x13, 0xcc, 0x17, 0xbe, 0x54, 0x0c, 0x8a, 0x05, 0x31, 0x6c, - 0x5f, 0xdf, 0x71, 0xc5, 0xa8, 0xf3, 0xea, 0xbc, 0xd3, 0x8f, 0x33, 0x0a, - 0x20, 0xcb, 0xd5, 0xfb, 0x11, 0x00, 0x6d, 0xf2, 0x84, 0xf2, 0x46, 0x25, - 0x1c, 0x5e, 0xe3, 0xdc, 0x1e, 0x37, 0x04, 0x48, 0xae, 0x5d, 0x0a, 0x01, - 0x66, 0xa8, 0xf1, 0x1b, 0x49, 0xb7, 0xb3, 0x7b, 0x37, 0xb4, 0xdf, 0xd8, - 0xd5, 0xf6, 0x73, 0x3d, 0xa4, 0x8c, 0x33, 0x5e, 0xeb, 0xcf, 0xcb, 0xfa, - 0x56, 0xa4, 0xd8, 0x24, 0x76, 0x8f, 0x09, 0x23, 0x9c, 0xa5, 0x9e, 0x8a, - 0x0b, 0x23, 0x6d, 0xd8, 0xf3, 0xf8, 0xcc, 0x59, 0xde, 0x0e, 0x96, 0x5e, - 0x96, 0xfb, 0xed, 0x02, 0x20, 0x18, 0x40, 0xcf, 0xfd, 0x67, 0xe9, 0xcf, - 0xa9, 0xff, 0x89, 0xc4, 0x61, 0x79, 0x88, 0x82, 0x22, 0xa1, 0x0a, 0x31, - 0xae, 0x53, 0x79, 0x1a, 0x6d, 0x31, 0xfe, 0x67, 0x83, 0x89, 0x4a, 0x37, - 0x77, 0x7d, 0x58, 0x0b, 0xc9, 0xdf, 0x4d, 0x94, 0xfa, 0x1d, 0xdd, 0x5b, - 0xfc, 0x48, 0xd7, 0xef, 0x3f, 0xc8, 0x9f, 0x87, 0x67, 0xfc, 0xdb, 0xc7, - 0xd3, 0x18, 0x7a, 0x50, 0x7d, 0x30, 0x18, 0x46, 0xf1, 0x55, 0x5d, 0x9c, - 0x70, 0x50, 0xe6, 0xa8, 0x6f, 0xc9, 0xbf, 0x7f, 0xf4, 0xee, 0xfd, 0x79, - 0xd3, 0xb8, 0x6b, 0x06, 0x26, 0x76, 0x38, 0x6a, 0x4a, 0x82, 0xea, 0x75, - 0x77, 0x2f, 0x52, 0x5c, 0x23, 0xf7, 0x7e, 0x39, 0xf0, 0xb1, 0xc7, 0x17, - 0x5e, 0xde, 0x06, 0xcb, 0xca, 0x24, 0xac, 0xf9, 0x71, 0xc2, 0xb8, 0x2b, - 0x95, 0xe9, 0xc8, 0x2e, 0x8a, 0x68, 0xed, 0xfd, 0xb7, 0xfa, 0xe8, 0xd9, - 0x79, 0x72, 0x81, 0x5b, 0x37, 0x55, 0xcf, 0xb2, 0xed, 0x2b, 0x5a, 0xa5, - 0x26, 0xbe, 0x80, 0x6e, 0xfe, 0xb4, 0xf9, 0x88, 0xbd, 0x62, 0xf9, 0x9c, - 0xe7, 0x2c, 0x47, 0x51, 0x8d, 0xe1, 0xbf, 0x89, 0x09, 0xfb, 0x8f, 0x74, - 0xee, 0x44, 0xbe, 0x39, 0x0f, 0xa6, 0x36, 0xd9, 0x8c, 0xe6, 0xf5, 0x2e, - 0x3b, 0xd9, 0x89, 0x7f, 0x40, 0x39, 0x4a, 0xc3, 0xce, 0xf4, 0x5c, 0x67, - 0x0c, 0x8a, 0xba, 0x9f, 0xf7, 0xe6, 0x3b, 0x14, 0x4e, 0xdd, 0x56, 0x87, - 0x7a, 0x4c, 0x13, 0x55, 0x9f, 0xc5, 0x3a, 0xdd, 0x19, 0x84, 0x28, 0xb3, - 0xb8, 0x2c, 0x3f, 0x1e, 0x3f, 0x45, 0xa3, 0x3b, 0x97, 0x8c, 0x16, 0xcd, - 0xc8, 0xe0, 0x8c, 0xa4, 0xc2, 0x80, 0x2a, 0xef, 0xb5, 0x9f, 0x61, 0x2f, - 0x6b, 0xaa, 0xce, 0xe7, 0xf8, 0xa8, 0xe3, 0x1b, 0xbb, 0x1d, 0x87, 0x8e, - 0x31, 0x8e, 0xcf, 0x88, 0x89, 0x0f, 0x65, 0x30, 0xcb, 0x0c, 0xb4, 0x1d, - 0xbd, 0xed, 0xee, 0x84, 0x03, 0x81, 0xbf, 0xa2, 0x22, 0x13, 0x6e, 0x21, - 0xe7, 0xc4, 0x08, 0xdc, 0x90, 0xd8, 0x9d, 0xb0, 0x43, 0x05, 0xfa, 0xd3, - 0x4e, 0x45, 0xf3, 0x42, 0x94, 0x44, 0x42, 0xf9, 0xbd, 0x4f, 0x33, 0x25, - 0x97, 0x97, 0x2a, 0x44, 0x5b, 0x55, 0x1c, 0xdd, 0xae, 0xd6, 0xc5, 0x4f, - 0x99, 0x24, 0x12, 0x23, 0x97, 0x6c, 0x2e, 0x17, 0x11, 0xf4, 0x8c, 0xbe, - 0x61, 0x5c, 0xf8, 0xa1, 0xae, 0x19, 0xaf, 0x0f, 0x0c, 0xd8, 0x6a, 0x67, - 0x8b, 0x7f, 0xf3, 0xdd, 0xbe, 0xdb, 0x3f, 0x58, 0x2e, 0xda, 0xab, 0x46, - 0x53, 0x68, 0x44, 0x7b, 0xc9, 0x1f, 0xe8, 0x77, 0x8c, 0x3e, 0x04, 0xbd, - 0xf7, 0x2c, 0x9d, 0x98, 0xa0, 0x22, 0x3b, 0xd3, 0xc1, 0x63, 0xe8, 0xdc, - 0x4a, 0x17, 0x17, 0x54, 0xd9, 0x62, 0xbd, 0xc9, 0xd9, 0xc7, 0xda, 0x02, - 0x65, 0x7c, 0xfa, 0xe7, 0xad, 0x99, 0xef, 0xa5, 0x94, 0x75, 0x08, 0x78, - 0x92, 0x6e, 0x0c, 0x7e, 0x37, 0x4c, 0x0d, 0xc6, 0x3b, 0x51, 0xbf, 0x64, - 0x6b, 0xcb, 0x96, 0x19, 0x5a, 0x41, 0xf5, 0x33, 0xb7, 0x23, 0x1a, 0xdf, - 0x36, 0x2c, 0xa1, 0xa5, 0x11, 0xeb, 0x89, 0x7e, 0x29, 0x52, 0x46, 0x73, - 0x65, 0x3d, 0x37, 0x5d, 0xc2, 0xcd, 0x89, 0xbe, 0xac, 0x10, 0x75, 0x3c, - 0x76, 0x40, 0x9f, 0x53, 0xbb, 0x6a, 0x89, 0xf0, 0xd9, 0x7a, 0x3f, 0x22, - 0x32, 0x4d, 0xb9, 0x90, 0xd2, 0x36, 0xf9, 0x1a, 0xc2, 0xf6, 0x83, 0xc0, - 0x47, 0x62, 0xd7, 0x4f, 0x86, 0x1a, 0xe1, 0xc0, 0x9f, 0xe7, 0x2c, 0x3c, - 0x9b, 0xbf, 0xbf, 0x8c, 0x34, 0x8a, 0x8f, 0x44, 0x25, 0xaa, 0xde, 0xbe, - 0x13, 0x36, 0x3f, 0x44, 0x5f, 0xfe, 0x32, 0xd0, 0x91, 0x11, 0xd9, 0x5b, - 0xe5, 0xc8, 0x13, 0x2d, 0xe8, 0xb3, 0x78, 0xbc, 0x01, 0xc3, 0x94, 0xbe, - 0xae, 0x62, 0xb3, 0xd8, 0x08, 0x83, 0x39, 0x7f, 0x22, 0xb8, 0xdf, 0xf0, - 0x8e, 0x81, 0x6d, 0xad, 0xf9, 0xbb, 0x84, 0x5f, 0x33, 0xe8, 0x4c, 0xb9, - 0x93, 0xd3, 0xd7, 0x64, 0x20, 0x77, 0xef, 0x17, 0x75, 0x20, 0xe2, 0x3d, - 0xab, 0x5b, 0xa7, 0x38, 0xc7, 0x52, 0xb1, 0xcf, 0xb9, 0x27, 0x20, 0x66, - 0x10, 0x30, 0x17, 0x7f, 0x83, 0xc4, 0xe9, 0x09, 0xd5, 0x57, 0xfe, 0x09, - 0x0d, 0x34, 0xf8, 0x63, 0xe5, 0xcb, 0x8d, 0x35, 0x64, 0xa6, 0xc9, 0xf4, - 0x2c, 0xcd, 0xea, 0xf7, 0x82, 0x01, 0xe6, 0xf8, 0xed, 0x1b, 0x1f, 0x2a, - 0x18, 0x09, 0xad, 0xb7, 0xff, 0x4d, 0xf0, 0xe1, 0x71, 0x61, 0xf1, 0x67, - 0xb5, 0x7c, 0xd5, 0x9c, 0xd6, 0xb4, 0xe3, 0x03, 0x15, 0x7a, 0xe4, 0x6b, - 0xc0, 0xd8, 0xbf, 0x33, 0x70, 0x30, 0x92, 0xfe, 0x4e, 0x4c, 0xef, 0x9d, - 0x51, 0x97, 0x4f, 0x03, 0x78, 0xfa, 0x7b, 0xe4, 0xb1, 0x7f, 0x05, 0xa7, - 0xca, 0x8f, 0x3a, 0x6e, 0x61, 0x3c, 0x17, 0xad, 0x90, 0xcc, 0x3a, 0x63, - 0x57, 0x62, 0xcb, 0x06, 0x01, 0x83, 0xb5, 0x98, 0x0e, 0x5c, 0x8f, 0xfc, - 0xbc, 0x97, 0xbf, 0x71, 0xc0, 0xaa, 0x0c, 0x61, 0x99, 0x7f, 0x3b, 0x4f, - 0x70, 0x4b, 0x70, 0x19, 0x08, 0xfc, 0x94, 0x9b, 0xf2, 0x42, 0x36, 0x3f, - 0xfe, 0x68, 0x43, 0xea, 0x74, 0xd9, 0x34, 0x90, 0x25, 0x71, 0xb3, 0xe3, - 0x42, 0x5b, 0xae, 0x40, 0xe8, 0x44, 0x5e, 0x1f, 0x6a, 0xda, 0xe2, 0x56, - 0x37, 0x9a, 0xa5, 0x94, 0xe7, 0x61, 0xc6, 0x74, 0x84, 0x8b, 0xae, 0xf0, - 0x33, 0x18, 0xd0, 0xaf, 0xa4, 0x02, 0x55, 0xa5, 0xa7, 0xd8, 0x0c, 0x77, - 0x27, 0x83, 0xdd, 0x57, 0x48, 0x53, 0x6d, 0xa3, 0xbf, 0x4f, 0x7a, 0x72, - 0x2b, 0xd1, 0x01, 0x3b, 0x36, 0x33, 0x1d, 0x75, 0x90, 0x6c, 0xca, 0x66, - 0xab, 0x8a, 0x05, 0x7a, 0xca, 0x99, 0xf3, 0x0b, 0xf3, 0xb1, 0xc8, 0xed, - 0x27, 0x18, 0xa9, 0xb6, 0x90, 0x08, 0x2d, 0xc5, 0x68, 0x2e, 0x9c, 0x31, - 0xeb, 0x61, 0xdd, 0x73, 0x9d, 0x56, 0xf0, 0x5b, 0x08, 0x99, 0x3c, 0x2d, - 0x29, 0x21, 0x48, 0xc7, 0xf9, 0x8c, 0x4c, 0x72, 0x47, 0x8c, 0x04, 0x42, - 0x64, 0x6b, 0x05, 0xf2, 0xcb, 0x40, 0x71, 0x6b, 0x1f, 0xd5, 0x4a, 0xee, - 0x3e, 0x02, 0x73, 0x7c, 0xce, 0x67, 0xfc, 0x89, 0x7d, 0x27, 0x4d, 0xf3, - 0x59, 0xcb, 0xd1, 0x36, 0xee, 0x82, 0x26, 0x9a, 0x7a, 0x2c, 0x64, 0xc1, - 0x4e, 0x17, 0x1d, 0xa9, 0x93, 0x48, 0xda, 0x68, 0x42, 0x05, 0x33, 0x71, - 0x8a, 0x8d, 0x06, 0xac, 0x64, 0xba, 0x20, 0x9e, 0x66, 0xc8, 0xc9, 0x56, - 0x63, 0x89, 0x67, 0xc6, 0x8e, 0xc1, 0x7f, 0x04, 0x05, 0x41, 0xb5, 0xe6, - 0xf9, 0xe5, 0x30, 0x69, 0x47, 0xbc, 0x52, 0xe1, 0x2f, 0xb8, 0x36, 0x05, - 0x45, 0x10, 0xad, 0x87, 0x28, 0xf2, 0xf1, 0xf9, 0x1c, 0x51, 0x30, 0x59, - 0x31, 0xca, 0x6f, 0x55, 0xc9, 0xfd, 0x87, 0x84, 0xa2, 0x3c, 0xe4, 0x9b, - 0x4d, 0x30, 0xc2, 0x38, 0x4b, 0x5a, 0x13, 0xfc, 0x72, 0x56, 0x7f, 0xe5, - 0x11, 0x2e, 0x6a, 0xf2, 0xa9, 0x41, 0xeb, 0x03, 0x23, 0xa9, 0xa2, 0x8d, - 0x4f, 0xb3, 0xba, 0xf3, 0x19, 0x27, 0x2e, 0x0b, 0xf0, 0x17, 0x05, 0x4d, - 0xbe, 0x8b, 0xb5, 0x1e, 0x18, 0xfc, 0x1b, 0x15, 0xb2, 0xd1, 0xa6, 0x5e, - 0xd9, 0xe5, 0xb1, 0x36, 0xe0, 0x83, 0x06, 0x1c, 0x22, 0x85, 0x7f, 0x30, - 0x39, 0x5e, 0xe9, 0x70, 0x56, 0x3a, 0x02, 0x35, 0xe7, 0xde, 0x60, 0x96, - 0x58, 0xfc, 0x32, 0xae, 0x13, 0xe7, 0x29, 0x5d, 0x8d, 0xb7, 0x60, 0x72, - 0x2d, 0x24, 0x22, 0xab, 0x6f, 0x5c, 0x20, 0x4c, 0x79, 0xf2, 0x89, 0xc2, - 0x21, 0x9a, 0x41, 0x91, 0x6c, 0x6a, 0xbf, 0xc1, 0xf8, 0x9f, 0x78, 0x27, - 0x1d, 0x72, 0xea, 0xb0, 0x9e, 0x02, 0x8f, 0xfc, 0x6e, 0x15, 0x51, 0xc7, - 0x10, 0xf9, 0x62, 0x7d, 0xe5, 0xcc, 0xb5, 0x2f, 0x0c, 0x8f, 0xe6, 0x66, - 0x94, 0xdb, 0x1d, 0x53, 0x23, 0xaf, 0xa8, 0xf5, 0xd3, 0x98, 0x9b, 0x28, - 0x5d, 0xbc, 0x6d, 0xf4, 0x80, 0x70, 0x24, 0x30, 0x9e, 0xd4, 0x71, 0xb3, - 0xe8, 0xa1, 0x1c, 0xac, 0xc6, 0xa4, 0x2a, 0x77, 0xd9, 0x27, 0x4e, 0x7c, - 0x52, 0x55, 0xa8, 0x01, 0x36, 0x98, 0xb8, 0x1e, 0xb2, 0x27, 0x03, 0xb8, - 0x32, 0x12, 0x41, 0xa7, 0x2e, 0xf5, 0x2f, 0x90, 0x0d, 0x2d, 0xb9, 0x3a, - 0x09, 0x3b, 0xb9, 0x86, 0x0e, 0xb5, 0x43, 0xc5, 0x80, 0x27, 0xca, 0xb1, - 0xa6, 0xab, 0x11, 0x45, 0xe8, 0xff, 0xd4, 0x58, 0x63, 0xec, 0xb5, 0x4c, - 0xe9, 0x3e, 0x57, 0x3d, 0xfd, 0xf4, 0x03, 0x6d, 0xd8, 0xf0, 0xcb, 0xd3, - 0xfd, 0x57, 0xdb, 0x21, 0x35, 0x8a, 0xa3, 0x2b, 0x8a, 0xa3, 0xfa, 0x07, - 0xeb, 0x3e, 0x72, 0xf6, 0x26, 0x64, 0x96, 0x7c, 0x42, 0x96, 0x1a, 0x92, - 0x4d, 0x35, 0x43, 0x68, 0x0e, 0x82, 0xf2, 0x58, 0x37, 0xb6, 0xc3, 0xc5, - 0x2c, 0xb9, 0x1a, 0x3d, 0xa6, 0x6c, 0x0f, 0xc5, 0x58, 0x8f, 0x7e, 0x4c, - 0xd7, 0x72, 0x7c, 0x06, 0xd0, 0x85, 0x8e, 0x76, 0x9d, 0x31, 0x2e, 0x80, - 0xcc, 0xcc, 0xaa, 0x85, 0x79, 0x0a, 0xf6, 0xc8, 0x13, 0xdc, 0x4a, 0x9a, - 0x46, 0x72, 0xb9, 0x22, 0x63, 0xe8, 0x29, 0x12, 0x04, 0xde, 0x94, 0x87, - 0x5b, 0xd4, 0xd5, 0x5c, 0x00, 0x03, 0x9a, 0x92, 0x13, 0x97, 0x22, 0x05, - 0x2e, 0xea, 0x4e, 0xb8, 0xa8, 0x9c, 0xa7, 0xc5, 0x50, 0x78, 0x02, 0xdd, - 0x3d, 0xb6, 0x68, 0x0a, 0x93, 0xe6, 0x01, 0x2c, 0x96, 0x7f, 0x19, 0x3c, - 0x23, 0xc9, 0x68, 0x00, 0xfa, 0x44, 0xeb, 0xe8, 0x19, 0xe9, 0xd1, 0x58, - 0x4a, 0x88, 0xa3, 0xdf, 0xa8, 0x8e, 0xa4, 0x2e, 0x46, 0xe1, 0xf0, 0x1f, - 0x6c, 0xe9, 0x38, 0x8f, 0x8f, 0x67, 0xc1, 0xc4, 0x0a, 0x44, 0x63, 0x0b, - 0x2c, 0xad, 0x01, 0x93, 0x66, 0x7c, 0x73, 0x1b, 0x94, 0x89, 0x21, 0x79, - 0xd5, 0x44, 0x57, 0x72, 0xcb, 0x8f, 0x95, 0x1a, 0x46, 0x87, 0x6c, 0x0e, - 0xd1, 0x91, 0xbe, 0xee, 0xc8, 0x7e, 0xfa, 0x2a, 0xe9, 0x49, 0xfe, 0x73, - 0x21, 0xb4, 0x96, 0x10, 0x8b, 0x9a, 0x49, 0xbc, 0x56, 0x2d, 0x55, 0xf3, - 0xe6, 0x8f, 0xd8, 0xfe, 0xd1, 0x32, 0x05, 0xb0, 0x30, 0xce, 0x70, 0x71, - 0x33, 0x46, 0x56, 0xcb, 0xd7, 0xa6, 0xa6, 0xad, 0x10, 0x3a, 0x37, 0x11, - 0x1d, 0xb5, 0xd1, 0xe4, 0x6d, 0x65, 0x45, 0xb3, 0x82, 0x00, 0x99, 0xff, - 0xc8, 0xe6, 0x7b, 0xd3, 0x73, 0x63, 0x1a, 0x62, 0x55, 0xd5, 0x15, 0x6d, - 0x37, 0xa2, 0x9f, 0x04, 0x7f, 0x10, 0x62, 0x50, 0xb5, 0x58, 0xae, 0x32, - 0xe8, 0xfa, 0x3c, 0x05, 0xf3, 0x50, 0x5f, 0x8d, 0x48, 0xa8, 0x23, 0xcd, - 0x8b, 0xfe, 0x66, 0xce, 0x09, 0xb5, 0xf4, 0x1f, 0x2a, 0x21, 0xf8, 0x0d, - 0x4b, 0x99, 0xdf, 0xac, 0xdf, 0x2b, 0xff, 0x59, 0xbd, 0xcb, 0x60, 0xd3, - 0x72, 0xe8, 0x25, 0xc4, 0x44, 0x92, 0xfb, 0x73, 0x0e, 0x90, 0x18, 0xe6, - 0x2e, 0x4c, 0x58, 0xe0, 0x11, 0x59, 0x69, 0x44, 0xda, 0x4f, 0xda, 0x91, - 0xc2, 0xdd, 0xcd, 0x0c, 0x1f, 0xf6, 0x96, 0x7c, 0x58, 0x62, 0xe9, 0x6b, - 0x62, 0x3d, 0xf1, 0x63, 0xe8, 0x53, 0xc7, 0x80, 0x92, 0xf6, 0x3b, 0xce, - 0x46, 0xbc, 0xe0, 0xd6, 0x03, 0xd0, 0xdd, 0xa1, 0x4c, 0xb0, 0x0a, 0xf2, - 0x26, 0xe8, 0x60, 0xf5, 0xbc, 0x32, 0xc0, 0xd5, 0x41, 0x3f, 0xfe, 0x1e, - 0xfa, 0xcb, 0xc5, 0x3a, 0xb7, 0x4b, 0xff, 0xa7, 0xe7, 0xbf, 0x8e, 0x1b, - 0xa4, 0x10, 0xa8, 0xe7, 0x9d, 0xa2, 0x3c, 0x9a, 0xcb, 0x53, 0xb5, 0x45, - 0xab, 0x4f, 0xeb, 0xe2, 0x18, 0x94, 0xfc, 0x7b, 0x1a, 0x7b, 0xaf, 0x05, - 0xfe, 0x94, 0xdb, 0xa4, 0x8b, 0xc3, 0x61, 0xb1, 0xa8, 0xab, 0xea, 0xef, - 0x99, 0x37, 0x07, 0xb7, 0xba, 0x4b, 0x1a, 0xa9, 0x43, 0x89, 0x3e, 0xff, - 0x71, 0xfd, 0x5b, 0x1a, 0xeb, 0x7d, 0x86, 0x55, 0x5a, 0x06, 0x98, 0x93, - 0x43, 0xba, 0x6c, 0xac, 0xb8, 0x8c, 0xba, 0x54, 0xc9, 0xbb, 0xe8, 0x12, - 0xcc, 0xa8, 0x80, 0x77, 0xaf, 0x00, 0xcd, 0x4b, 0xb2, 0x00, 0x1a, 0x96, - 0x7d, 0x80, 0xe6, 0x1b, 0xd0, 0x25, 0x60, 0x85, 0xc5, 0xc3, 0x5d, 0xa5, - 0xaa, 0xf8, 0xcd, 0xf6, 0xd6, 0x7f, 0xa5, 0xf5, 0x72, 0xb8, 0x42, 0xbe, - 0x5f, 0xa1, 0x76, 0xef, 0xa2, 0xda, 0xef, 0xad, 0x13, 0x3f, 0xdc, 0x77, - 0x23, 0x2b, 0x2f, 0xe1, 0x8b, 0xa0, 0x9c, 0x7b, 0x2a, 0x3a, 0xf8, 0x6b, - 0x6c, 0x53, 0x7f, 0x35, 0x7d, 0xbe, 0x59, 0xeb, 0xbe, 0x3c, 0x02, 0x09, - 0x92, 0xfb, 0x3e, 0x94, 0x21, 0x3b, 0x83, 0xef, 0x78, 0x89, 0xbd, 0x95, - 0xb6, 0x60, 0x59, 0x1c, 0xdf, 0xdc, 0x5d, 0x2d, 0x31, 0x05, 0x6a, 0x64, - 0x2f, 0xf3, 0x16, 0xf6, 0x40, 0x0b, 0xbf, 0x24, 0xba, 0x50, 0x26, 0x00, - 0x95, 0x7b, 0xf0, 0x27, 0xf2, 0xea, 0x5b, 0xac, 0x72, 0x70, 0xeb, 0x83, - 0x00, 0x52, 0xe8, 0xe5, 0xc7, 0x07, 0xcf, 0xf6, 0xb6, 0xb4, 0xc1, 0xc0, - 0x23, 0x63, 0x9f, 0xca, 0xf1, 0xce, 0x39, 0xc6, 0x54, 0x5b, 0xce, 0xa3, - 0x15, 0x79, 0x08, 0xe9, 0x87, 0x7c, 0x15, 0x2c, 0xf2, 0x2c, 0x52, 0x1d, - 0xa7, 0x1e, 0xdb, 0xd0, 0x2f, 0xe6, 0xf1, 0x01, 0x56, 0x93, 0x5a, 0x26, - 0xac, 0x5e, 0x5b, 0x82, 0xbc, 0x97, 0x62, 0xdd, 0xa9, 0x2b, 0x7d, 0xc2, - 0x31, 0xc2, 0xb8, 0x64, 0x9a, 0x79, 0x66, 0x4b, 0x02, 0x62, 0xbb, 0xff, - 0xa5, 0xc8, 0xdc, 0xa8, 0x79, 0xe7, 0x32, 0xb3, 0x43, 0xd5, 0x61, 0x3a, - 0x04, 0x95, 0xf1, 0x2c, 0xe6, 0x8b, 0xf0, 0xdd, 0x9d, 0x2b, 0x18, 0x2f, - 0x24, 0x7d, 0x3c, 0x55, 0x57, 0x66, 0xa9, 0x21, 0x34, 0x2a, 0xa9, 0x7c, - 0x4e, 0x30, 0x1a, 0x99, 0x05, 0x3e, 0x41, 0x1f, 0x08, 0xf4, 0x76, 0xef, - 0xbe, 0x52, 0xcf, 0xa6, 0x3a, 0xdd, 0xac, 0x7f, 0x5d, 0xf5, 0xfe, 0x03, - 0x31, 0x88, 0x13, 0x1b, 0x96, 0xde, 0x19, 0x07, 0x59, 0x8e, 0x84, 0xf5, - 0xc1, 0x36, 0xb8, 0xef, 0x1d, 0x2c, 0xaa, 0x82, 0xa1, 0xb0, 0xca, 0x71, - 0xf6, 0x07, 0xda, 0xff, 0x7d, 0x73, 0x50, 0x1b, 0x5f, 0x4c, 0x74, 0x2a, - 0x8e, 0xe1, 0xf6, 0x4f, 0x59, 0x77, 0x12, 0x59, 0xa1, 0x72, 0x23, 0xcd, - 0x51, 0x22, 0xa2, 0x74, 0xfc, 0x5d, 0xd8, 0xaa, 0x4f, 0xc5, 0xa4, 0xcb, - 0x14, 0xc8, 0x21, 0x1a, 0x19, 0xe9, 0x8b, 0xf8, 0x0b, 0x7d, 0x5a, 0x62, - 0xd8, 0x97, 0xdb, 0x0d, 0x9d, 0xb8, 0x96, 0x9f, 0xb6, 0x50, 0xb8, 0x88, - 0xd6, 0x10, 0xd2, 0x88, 0xc2, 0x2f, 0xe0, 0x8b, 0xd9, 0xd0, 0xd8, 0xa7, - 0x50, 0xc0, 0x62, 0x9f, 0xec, 0x28, 0xb1, 0xab, 0xd5, 0x46, 0x85, 0x27, - 0x84, 0x0a, 0x89, 0xa2, 0xf0, 0x87, 0xee, 0x0b, 0x22, 0x0a, 0xd4, 0xcb, - 0x53, 0xb9, 0xcd, 0x5c, 0x6d, 0xee, 0xc5, 0xc7, 0x6f, 0xb0, 0xbb, 0x05, - 0xc9, 0x4a, 0xa4, 0xbc, 0x96, 0xeb, 0x2b, 0x90, 0xbe, 0x96, 0xa2, 0xc1, - 0x02, 0x57, 0x06, 0xcf, 0xa0, 0x2f, 0xfd, 0xa8, 0xf6, 0x41, 0xd6, 0x20, - 0x4e, 0x08, 0xf2, 0x9a, 0x9b, 0x0f, 0x93, 0x88, 0xd1, 0x8f, 0xf8, 0xe5, - 0x3b, 0xf6, 0xcf, 0x4b, 0x09, 0x50, 0x2a, 0x76, 0x83, 0x60, 0x24, 0xa4, - 0xf9, 0x2c, 0xe1, 0x01, 0xea, 0xd2, 0x55, 0xb9, 0xb4, 0xf0, 0x98, 0x9b, - 0x3c, 0x21, 0x79, 0xe8, 0x01, 0x28, 0xff, 0xf6, 0x12, 0x4b, 0xb9, 0x8c, - 0xe1, 0x40, 0x9f, 0xa2, 0xe5, 0xbf, 0x10, 0xab, 0x2f, 0x53, 0x87, 0x0b, - 0x6e, 0xda, 0x98, 0xe6, 0xf6, 0x1b, 0x62, 0x26, 0x88, 0x96, 0x5b, 0x48, - 0x37, 0xbb, 0x48, 0x60, 0xe3, 0xb5, 0x47, 0xb9, 0x78, 0x26, 0xd8, 0x90, - 0x7c, 0x78, 0x9e, 0xbb, 0x41, 0xbb, 0x6b, 0xa5, 0xbb, 0x0e, 0x04, 0xc6, - 0xc0, 0xcd, 0x2e, 0x23, 0xa3, 0xbc, 0x28, 0x5c, 0x4c, 0x57, 0xc4, 0xab, - 0x7c, 0x91, 0xdc, 0x9e, 0xf1, 0x50, 0x8b, 0xd3, 0x34, 0xb8, 0xfd, 0x54, - 0x5a, 0x59, 0xfa, 0x3c, 0xb6, 0xe0, 0x61, 0x96, 0xb2, 0x59, 0x6e, 0x8c, - 0xae, 0x0b, 0x76, 0x35, 0x22, 0x1b, 0x8f, 0xbc, 0x90, 0xb9, 0xd7, 0x61, - 0xd2, 0xb0, 0xa0, 0xfd, 0x7c, 0xfa, 0xab, 0xa6, 0xc0, 0x77, 0xd0, 0xba, - 0x99, 0x64, 0x91, 0xd9, 0x43, 0xe0, 0xc1, 0x12, 0x8d, 0x87, 0xa0, 0x76, - 0x30, 0x83, 0x53, 0x9d, 0x8c, 0x2a, 0xd2, 0x15, 0xe3, 0xb0, 0xe3, 0x12, - 0x9c, 0x4a, 0x8e, 0x32, 0xb7, 0x83, 0x31, 0xe5, 0x2b, 0xc2, 0x9e, 0x7c, - 0x67, 0x9d, 0xc9, 0x52, 0x9c, 0x88, 0xdd, 0x9a, 0x14, 0x81, 0xf6, 0x0b, - 0x4a, 0x8b, 0x4b, 0x53, 0x41, 0x6f, 0x69, 0xe0, 0x04, 0xf6, 0xf3, 0xbc, - 0x55, 0xf9, 0xca, 0x47, 0xcd, 0xc0, 0x62, 0x27, 0xa5, 0x3f, 0x98, 0xa2, - 0x20, 0xad, 0x52, 0xde, 0xee, 0x80, 0x88, 0xf2, 0xa7, 0xe0, 0xe5, 0xec, - 0x5f, 0x0e, 0x54, 0x76, 0xec, 0x9f, 0x9d, 0xff, 0x38, 0xd8, 0x28, 0xb2, - 0xdd, 0x62, 0xa8, 0x80, 0xfb, 0x7b, 0xb9, 0x25, 0x4a, 0x25, 0xb8, 0x31, - 0x44, 0x0e, 0x7a, 0x71, 0xb1, 0xc7, 0xdc, 0xdb, 0xb8, 0x4e, 0x0f, 0x43, - 0x8e, 0xa5, 0xed, 0xd5, 0xcb, 0xca, 0xe3, 0x0f, 0xa2, 0xf5, 0xf3, 0x49, - 0x89, 0x44, 0x63, 0x38, 0xc0, 0x88, 0x94, 0x1f, 0xa3, 0x2c, 0x47, 0xa1, - 0x47, 0x51, 0x1a, 0xb4, 0xa2, 0xa7, 0x97, 0x78, 0x1a, 0x0e, 0x23, 0xc5, - 0xe4, 0x5b, 0x51, 0x41, 0x7a, 0x8b, 0xb2, 0xa5, 0x59, 0xab, 0x0b, 0xa9, - 0x0b, 0xea, 0xe2, 0x88, 0xcf, 0x93, 0xae, 0x07, 0x86, 0xa5, 0x15, 0x0c, - 0x2b, 0x5f, 0x6f, 0xaf, 0x2f, 0x20, 0x56, 0xe5, 0x02, 0xee, 0x13, 0xd5, - 0x9b, 0x51, 0x1c, 0x9e, 0xce, 0x78, 0x4f, 0xab, 0xd1, 0xf5, 0x48, 0x41, - 0x93, 0x65, 0xa5, 0x0b, 0x3a, 0xf9, 0x4f, 0xd0, 0x27, 0x5a, 0x06, 0xd4, - 0x85, 0xac, 0x10, 0xad, 0xad, 0xe4, 0xa0, 0x54, 0x8b, 0xfd, 0xdc, 0xaf, - 0x02, 0xfe, 0xff, 0xd3, 0xfb, 0x64, 0xb0, 0x25, 0xf6, 0xdc, 0x23, 0xaa, - 0xe2, 0x09, 0xaa, 0x0f, 0x08, 0x9f, 0x41, 0xbb, 0xb1, 0x41, 0x0f, 0x21, - 0x67, 0xb5, 0x66, 0xf2, 0xcc, 0x14, 0xdf, 0x33, 0x8f, 0x6b, 0x88, 0xd8, - 0xb0, 0x3a, 0x0f, 0xe8, 0x75, 0x49, 0x25, 0x71, 0x4e, 0xea, 0xd7, 0xf6, - 0x72, 0x05, 0xeb, 0x3d, 0xce, 0x28, 0xdc, 0x67, 0xca, 0x89, 0x8c, 0x6c, - 0xf2, 0xe2, 0x46, 0x1b, 0xf9, 0x97, 0xde, 0x6e, 0x09, 0xe9, 0xc7, 0x05, - 0x0d, 0xbc, 0x51, 0x1f, 0x61, 0x4b, 0x7d, 0x71, 0x6d, 0xaf, 0x06, 0x37, - 0x40, 0xcf, 0x98, 0xf7, 0x8c, 0x87, 0x23, 0xb3, 0x35, 0xfe, 0xff, 0xb8, - 0xe9, 0xba, 0x95, 0x08, 0xb4, 0x38, 0x2e, 0xe3, 0xa0, 0x7a, 0x95, 0xce, - 0xfc, 0x0b, 0xc4, 0x46, 0x70, 0x98, 0xad, 0xae, 0x1e, 0xb8, 0x6a, 0xf2, - 0x2d, 0x29, 0xdd, 0xff, 0xe8, 0xf4, 0xe0, 0x5d, 0x4b, 0xf1, 0x7a, 0x66, - 0xa8, 0x5b, 0xe5, 0x51, 0x21, 0x03, 0x8e, 0xb0, 0x55, 0x88, 0xec, 0x45, - 0xda, 0x22, 0xa1, 0xd7, 0xa6, 0x03, 0x24, 0xba, 0x7b, 0xee, 0xb0, 0xa5, - 0xd9, 0x58, 0x74, 0x09, 0x78, 0x7a, 0x51, 0x0e, 0x68, 0xad, 0x67, 0x8d, - 0xd9, 0x70, 0x95, 0x3c, 0x20, 0xa4, 0xce, 0x30, 0xb8, 0xa5, 0x47, 0x7e, - 0x89, 0x53, 0xbe, 0x99, 0x57, 0x7f, 0x06, 0x09, 0xda, 0x6f, 0x18, 0x5a, - 0x95, 0xfe, 0x92, 0x7a, 0x2e, 0x8b, 0x5e, 0x1d, 0x62, 0xf8, 0xfd, 0x4d, - 0xd0, 0x86, 0x75, 0xf1, 0x31, 0x70, 0x3c, 0xf4, 0x25, 0x55, 0x54, 0x7c, - 0xc2, 0x6f, 0x47, 0xb1, 0xeb, 0x22, 0x5a, 0x0d, 0x64, 0xaa, 0x3d, 0xf8, - 0xc5, 0x0f, 0xd4, 0x2d, 0x78, 0x48, 0x80, 0x21, 0xd5, 0x4b, 0x43, 0xbd, - 0xdc, 0xcc, 0xba, 0x5c, 0xaa, 0x80, 0xd5, 0xa4, 0xee, 0x5f, 0xaa, 0x05, - 0x16, 0x98, 0x19, 0xec, 0x37, 0x8f, 0x0e, 0x1e, 0xa5, 0x77, 0x1b, 0x42, - 0x8f, 0x43, 0x1c, 0x4c, 0xa0, 0x2d, 0x50, 0x61, 0xe8, 0x31, 0x4d, 0xd4, - 0x48, 0x57, 0x70, 0xa2, 0xc8, 0x1a, 0xb3, 0x28, 0x05, 0x1f, 0xb9, 0x4e, - 0x2c, 0xed, 0x93, 0x73, 0x08, 0xf2, 0xc3, 0x3a, 0x86, 0x34, 0x06, 0xf0, - 0x0d, 0x2a, 0x30, 0xec, 0xe2, 0xb9, 0x41, 0xec, 0xf0, 0xd7, 0x07, 0xc5, - 0x48, 0x8a, 0xcb, 0xb9, 0xa9, 0x16, 0xf2, 0xf5, 0xc5, 0xa5, 0x3b, 0x12, - 0x8a, 0x97, 0xe8, 0x60, 0x07, 0x57, 0x93, 0xbc, 0x91, 0x97, 0x4f, 0x48, - 0xad, 0x59, 0x12, 0xc7, 0x8f, 0x2b, 0xd4, 0x29, 0x22, 0xde, 0x23, 0x05, - 0x46, 0x58, 0xa0, 0xc2, 0xd2, 0x33, 0x91, 0x6e, 0x8e, 0x28, 0x75, 0xe5, - 0x38, 0x78, 0x6c, 0xb8, 0xe7, 0xeb, 0x53, 0xb9, 0x08, 0x16, 0x1d, 0xfc, - 0x12, 0x99, 0x18, 0x53, 0x14, 0xe9, 0x23, 0xf5, 0xe8, 0x98, 0xcf, 0x66, - 0xe6, 0x55, 0xb8, 0xc8, 0xe1, 0xcf, 0xb6, 0x48, 0xaa, 0x49, 0xee, 0x00, - 0x52, 0xa4, 0xe0, 0xe2, 0x66, 0x23, 0x41, 0xff, 0x1d, 0x69, 0xac, 0x0e, - 0xfa, 0x4c, 0x2a, 0x3f, 0x24, 0x90, 0xfa, 0xde, 0x2e, 0xbc, 0x93, 0x09, - 0xf1, 0x18, 0x3a, 0xc9, 0xb7, 0x7d, 0x81, 0xe5, 0xe6, 0xfe, 0x6d, 0x3a, - 0xb8, 0x28, 0xb3, 0xbd, 0x50, 0x82, 0x44, 0x40, 0x8c, 0x9c, 0x30, 0xe5, - 0x43, 0x3a, 0x9e, 0x94, 0x16, 0xf7, 0xbc, 0x16, 0xe8, 0x34, 0x4d, 0xa4, - 0x62, 0x2e, 0x52, 0xc5, 0x0e, 0x83, 0xef, 0x18, 0x5f, 0x79, 0xd7, 0x1e, - 0x02, 0x4d, 0x89, 0x9a, 0x6e, 0xe1, 0x22, 0x66, 0x43, 0xcf, 0x5d, 0x2e, - 0xea, 0x47, 0x21, 0xc4, 0x94, 0xf4, 0xb2, 0x20, 0xbf, 0xd7, 0x5f, 0xcc, - 0x79, 0x4b, 0x76, 0x00, 0x63, 0x5a, 0xdf, 0x43, 0xde, 0x5e, 0x7f, 0x59, - 0x8c, 0xc4, 0x6e, 0x28, 0x8b, 0x08, 0xac, 0xaa, 0xfb, 0xaa, 0x55, 0x4d, - 0xce, 0xa2, 0x4a, 0xa2, 0xf7, 0x45, 0x09, 0x54, 0xcf, 0x90, 0x53, 0xbe, - 0xa1, 0xe9, 0xe1, 0x49, 0x10, 0xcf, 0x72, 0xa5, 0xd3, 0xe7, 0x47, 0xab, - 0x7f, 0xa7, 0x4c, 0x81, 0x82, 0x9b, 0xd1, 0xdf, 0x00, 0x12, 0x95, 0x18, - 0xe3, 0xa4, 0x19, 0xf7, 0x5f, 0x56, 0x04, 0xa0, 0x5c, 0xdd, 0xd2, 0xdc, - 0xd2, 0x1c, 0xf4, 0x7f, 0x43, 0x05, 0x93, 0x06, 0x78, 0x49, 0x82, 0x24, - 0x83, 0x41, 0x0e, 0xad, 0x31, 0x88, 0xee, 0x99, 0x5c, 0x6b, 0xbd, 0xd6, - 0x35, 0x42, 0x98, 0xb5, 0x03, 0x19, 0xba, 0xd1, 0x83, 0x71, 0xfa, 0x0d, - 0x2d, 0x4e, 0x04, 0xb3, 0x73, 0xae, 0x75, 0x61, 0x56, 0xad, 0xe3, 0x95, - 0xe7, 0x68, 0x36, 0x65, 0xc5, 0x00, 0x33, 0x5d, 0xdd, 0xff, 0xbe, 0xe8, - 0xb2, 0x9e, 0xfe, 0xd5, 0xf9, 0xbf, 0x81, 0x2c, 0xf7, 0x64, 0x2e, 0x53, - 0x88, 0x85, 0x23, 0xb8, 0x44, 0x43, 0x1e, 0xe1, 0x99, 0xd7, 0x41, 0x67, - 0x51, 0xed, 0xa7, 0x1d, 0xcb, 0x8f, 0x9e, 0xcf, 0x7c, 0x9f, 0xbe, 0x01, - 0xf6, 0x59, 0x52, 0xfe, 0xf8, 0xc1, 0x1c, 0x52, 0x91, 0xe9, 0x02, 0x26, - 0x23, 0x30, 0x72, 0x8a, 0x99, 0x3b, 0xe3, 0xad, 0xce, 0x5f, 0x01, 0xf2, - 0x80, 0xf2, 0x97, 0xbe, 0x28, 0x8c, 0x98, 0x07, 0xa6, 0xf2, 0xcf, 0xaa, - 0x7e, 0x16, 0x41, 0x5c, 0x90, 0x58, 0x62, 0xa0, 0x51, 0xb1, 0x4c, 0x80, - 0xbb, 0xe3, 0x07, 0x5e, 0x74, 0xbf, 0x7a, 0x62, 0x5a, 0x6c, 0xce, 0x20, - 0x74, 0x67, 0x2a, 0xe3, 0x89, 0xeb, 0xe8, 0xc5, 0xcf, 0xdc, 0x7c, 0xfe, - 0x33, 0x51, 0x9d, 0x5d, 0x2b, 0x20, 0x25, 0x88, 0x70, 0xec, 0xa1, 0x7b, - 0x77, 0x37, 0x2d, 0xaf, 0x7e, 0x58, 0xf7, 0x5f, 0x00, 0xce, 0x0f, 0x0e, - 0x23, 0x47, 0xd2, 0x78, 0xeb, 0xa5, 0x14, 0x2d, 0x26, 0x25, 0x36, 0x6a, - 0xd4, 0x1a, 0x77, 0x4c, 0xc0, 0x93, 0x96, 0x07, 0x6b, 0x63, 0x0f, 0x53, - 0x09, 0x44, 0xfe, 0x37, 0xcb, 0x87, 0xb5, 0x5e, 0xd7, 0x71, 0xe5, 0x9a, - 0xe5, 0x92, 0x7a, 0x9f, 0xe2, 0x0c, 0x78, 0x5f, 0xa6, 0x11, 0x7f, 0x79, - 0x7b, 0xbe, 0x91, 0xe9, 0xdf, 0xf0, 0x0f, 0x0d, 0x51, 0x50, 0x42, 0x78, - 0x6e, 0xfe, 0x48, 0x4a, 0xf9, 0xf1, 0xfd, 0x6c, 0x8e, 0xec, 0x93, 0xf0, - 0x90, 0x5a, 0xce, 0x79, 0xa6, 0x06, 0x34, 0x0b, 0x5a, 0x6f, 0x78, 0x45, - 0x62, 0x65, 0x7b, 0x83, 0xfd, 0xc7, 0x0b, 0x21, 0x91, 0x8f, 0x4c, 0xa3, - 0x56, 0xae, 0xb1, 0xf8, 0x2f, 0x7b, 0x26, 0xb8, 0x28, 0xef, 0x1a, 0xee, - 0xf2, 0xba, 0xc6, 0x00, 0x39, 0xf4, 0x04, 0xc5, 0xeb, 0xde, 0x12, 0xc2, - 0x1d, 0x08, 0x0c, 0xcf, 0x2c, 0x7b, 0x16, 0xdc, 0x38, 0xf2, 0x5d, 0x5a, - 0x70, 0x35, 0x00, 0x21, 0x7d, 0x1d, 0xa3, 0x26, 0x6a, 0x3b, 0xa8, 0xf1, - 0x19, 0x30, 0x23, 0xa4, 0x97, 0x52, 0xe5, 0xf2, 0x79, 0x5a, 0x9b, 0xd0, - 0x3d, 0x01, 0xc9, 0xcb, 0x9c, 0x89, 0xb6, 0x3b, 0xc5, 0x7a, 0x06, 0x2e, - 0x88, 0xf2, 0x51, 0x3c, 0xe6, 0xb9, 0x1e, 0xb8, 0x9f, 0xcb, 0xf0, 0x6f, - 0x38, 0x9d, 0x19, 0x92, 0x7e, 0x81, 0x0d, 0x68, 0x0a, 0xbc, 0xf1, 0xe2, - 0x93, 0x4e, 0x6f, 0x1f, 0x06, 0xf7, 0x29, 0xa8, 0x02, 0x2e, 0xf9, 0xae, - 0x46, 0xa8, 0x74, 0x87, 0x51, 0x40, 0x58, 0xc1, 0x5b, 0x0b, 0xb9, 0xb4, - 0x79, 0x73, 0x15, 0x8f, 0x90, 0x9d, 0x0f, 0xf7, 0x27, 0xbb, 0x25, 0x81, - 0x96, 0xe2, 0x39, 0x2f, 0x73, 0x5a, 0x7d, 0xfc, 0x8e, 0x96, 0xb2, 0x84, - 0xf5, 0x9d, 0x0f, 0x2a, 0x8c, 0x61, 0xb1, 0x6a, 0x9f, 0xa0, 0x09, 0x0b, - 0xfb, 0x2f, 0x9b, 0x1c, 0xf0, 0x8a, 0x68, 0xca, 0xae, 0x29, 0x4b, 0x44, - 0xc5, 0xfa, 0x84, 0x6f, 0x3d, 0x04, 0x51, 0x40, 0xaf, 0x07, 0x6e, 0xeb, - 0x75, 0xb2, 0xc8, 0x08, 0xd4, 0x6b, 0x66, 0xb3, 0xf2, 0x4c, 0x31, 0x15, - 0x8b, 0x9c, 0x2c, 0xc5, 0xe0, 0x8d, 0x23, 0x3b, 0x93, 0xef, 0xfb, 0x55, - 0x4b, 0x66, 0x49, 0xfd, 0x03, 0x73, 0x44, 0xda, 0x2c, 0x9e, 0x3e, 0x1f, - 0xce, 0x29, 0xd7, 0x5d, 0x36, 0xc3, 0x7a, 0x9e, 0x67, 0x1d, 0xe0, 0x27, - 0x69, 0x5d, 0x25, 0xfb, 0x46, 0x83, 0x0e, 0x0c, 0x8c, 0xa4, 0x4a, 0x3b, - 0x63, 0x75, 0x10, 0x28, 0x1b, 0x56, 0xce, 0xff, 0xeb, 0x63, 0x85, 0xc9, - 0xcf, 0xfa, 0xe0, 0x6c, 0xfe, 0x2d, 0xb1, 0x52, 0xd8, 0xf7, 0xb8, 0xcf, - 0x62, 0x3f, 0x24, 0x63, 0x4a, 0xa9, 0x8c, 0x97, 0x0a, 0xc4, 0x62, 0xcb, - 0x6e, 0x75, 0x4c, 0xc3, 0x12, 0xee, 0x9d, 0x48, 0xc4, 0xb6, 0xb2, 0x86, - 0xaa, 0xee, 0x4e, 0xb6, 0x52, 0xb1, 0x14, 0x00, 0x31, 0xfb, 0x22, 0x65, - 0x8d, 0xf8, 0xc5, 0x53, 0x89, 0xfc, 0x85, 0xad, 0xb0, 0xb7, 0x96, 0x4e, - 0xee, 0x39, 0x0f, 0xea, 0x6b, 0xbc, 0x36, 0x29, 0x0a, 0x9e, 0xcd, 0x09, - 0x47, 0x5f, 0x89, 0x1b, 0x84, 0x2f, 0xed, 0x67, 0xe4, 0x9f, 0x1e, 0xb3, - 0x06, 0xc1, 0x61, 0x8d, 0xe0, 0x70, 0x11, 0x8d, 0xc0, 0x39, 0x76, 0x40, - 0x63, 0xf9, 0x8c, 0x35, 0x78, 0xea, 0x0b, 0xae, 0xc2, 0x0e, 0x22, 0x73, - 0x48, 0x1c, 0xc9, 0x4b, 0x80, 0x1e, 0xa3, 0x5e, 0x41, 0x70, 0xb1, 0x6a, - 0x77, 0xb5, 0x43, 0xb0, 0x20, 0xc1, 0xd1, 0x79, 0x19, 0xdf, 0xe5, 0xf6, - 0xc6, 0xbf, 0x2d, 0xdf, 0x5f, 0x26, 0x27, 0x83, 0xa5, 0x22, 0xc1, 0x30, - 0x46, 0xf3, 0xa6, 0x6b, 0xde, 0xee, 0x66, 0xb8, 0xf9, 0x9a, 0xe6, 0x29, - 0xdf, 0xa1, 0x45, 0xbd, 0xa1, 0x11, 0x7e, 0x4a, 0x26, 0x62, 0x5a, 0xe1, - 0x25, 0x48, 0x12, 0x61, 0xe8, 0xf2, 0xac, 0xc0, 0xe7, 0x15, 0x03, 0xd9, - 0x38, 0x40, 0xd1, 0x55, 0x7d, 0xcf, 0xf9, 0xac, 0xd6, 0x76, 0x14, 0xc4, - 0x01, 0xd5, 0x5a, 0xb4, 0xbd, 0x9a, 0xae, 0x59, 0x9f, 0x16, 0x36, 0x72, - 0xcb, 0x94, 0x21, 0x89, 0x64, 0xbd, 0xe2, 0x87, 0x46, 0x15, 0x13, 0x54, - 0xa5, 0xae, 0x5b, 0x74, 0x91, 0x62, 0x38, 0xd4, 0x02, 0xa9, 0x26, 0x25, - 0xcb, 0xc2, 0x12, 0xba, 0x64, 0x76, 0x79, 0x00, 0x6c, 0x3d, 0x63, 0xdb, - 0x31, 0x2c, 0x7a, 0x4c, 0x5f, 0x48, 0xff, 0x7c, 0x07, 0x05, 0xd8, 0xd3, - 0x45, 0xf4, 0x46, 0x19, 0x7f, 0xc8, 0xff, 0xb6, 0xa4, 0x51, 0x40, 0xd5, - 0x00, 0xb5, 0x94, 0xb9, 0x6f, 0xef, 0xf1, 0x4b, 0x03, 0xd8, 0x34, 0xc1, - 0x70, 0x76, 0x70, 0x6c, 0xe0, 0x54, 0xd7, 0x7f, 0xd1, 0xf1, 0x65, 0xee, - 0xd1, 0x49, 0x02, 0x0d, 0x9b, 0x22, 0xef, 0x37, 0x21, 0x9e, 0x5f, 0xf0, - 0xab, 0x05, 0x13, 0xa6, 0xaf, 0xc0, 0x7e, 0xa1, 0x17, 0x99, 0x01, 0xda, - 0xba, 0xf0, 0x5a, 0x8f, 0x95, 0xf2, 0x85, 0x34, 0x94, 0x38, 0xfe, 0xb4, - 0x43, 0x40, 0xad, 0xe3, 0x4e, 0x9d, 0x87, 0x77, 0x44, 0xb2, 0x6c, 0x64, - 0xc8, 0xc8, 0xa9, 0x87, 0x2a, 0x73, 0x6d, 0xad, 0x40, 0x57, 0x37, 0x50, - 0x71, 0x4e, 0x9d, 0x0f, 0x42, 0x65, 0x56, 0x64, 0xeb, 0xc6, 0x7f, 0x69, - 0xa4, 0x41, 0x16, 0x4e, 0xf2, 0xdf, 0x3b, 0xc0, 0x0b, 0xbf, 0x91, 0xcb, - 0xee, 0x38, 0x17, 0x5e, 0xa7, 0x76, 0x03, 0xef, 0x93, 0x4b, 0x99, 0x29, - 0x28, 0xe1, 0x2d, 0xe3, 0x85, 0xf7, 0xab, 0xd1, 0x4f, 0x7e, 0x1d, 0xde, - 0x13, 0x8d, 0x22, 0x60, 0x29, 0x75, 0xfe, 0x73, 0x52, 0x2d, 0x48, 0xb4, - 0x1b, 0xd7, 0x3e, 0x61, 0x25, 0x91, 0x8e, 0x50, 0xab, 0xbf, 0xe9, 0x72, - 0x15, 0xbf, 0x61, 0x97, 0x2d, 0x8f, 0x0e, 0xf0, 0x3f, 0x41, 0xc0, 0x9b, - 0xa9, 0x8d, 0xba, 0x3c, 0xe4, 0x97, 0xc2, 0xa9, 0xb6, 0xf1, 0xbc, 0xaa, - 0xd3, 0x3c, 0x13, 0x36, 0x31, 0x94, 0x36, 0xa3, 0xab, 0x4b, 0x4a, 0x22, - 0x6a, 0x5d, 0x69, 0x34, 0x54, 0x20, 0x87, 0x0f, 0xd8, 0x33, 0x6f, 0x5a, - 0x3d, 0xff, 0xec, 0x62, 0x82, 0xf6, 0xf4, 0x4b, 0x74, 0x31, 0x17, 0x5a, - 0x52, 0x47, 0x04, 0x1b, 0xc5, 0xf1, 0x94, 0x57, 0xe6, 0x4d, 0xe4, 0x5a, - 0x6c, 0xdd, 0x58, 0xc2, 0x46, 0xe2, 0xb9, 0x0f, 0xe6, 0x1c, 0x23, 0x64, - 0x34, 0x5c, 0x8c, 0x3a, 0xe4, 0x7c, 0x4c, 0x4d, 0xaf, 0x09, 0x22, 0xdf, - 0x63, 0xaf, 0x09, 0xf6, 0x54, 0xa8, 0x47, 0xbc, 0x01, 0x18, 0x76, 0x1f, - 0x5f, 0x71, 0x00, 0x4e, 0xb9, 0x49, 0xeb, 0x91, 0xff, 0x00, 0xd6, 0x5c, - 0x74, 0x83, 0xbd, 0xf3, 0xca, 0x8c, 0x2c, 0x81, 0x48, 0xc5, 0xea, 0xf6, - 0x03, 0xa2, 0x9f, 0xc6, 0x88, 0xd9, 0x41, 0xda, 0x82, 0x01, 0x72, 0x31, - 0xed, 0xc9, 0xec, 0xa1, 0xb2, 0x42, 0x3d, 0x82, 0xf3, 0x92, 0x2c, 0xa9, - 0xed, 0xcd, 0xfa, 0x3d, 0x8d, 0xf9, 0xcf, 0x5f, 0x28, 0x50, 0x7e, 0x20, - 0x4a, 0x8b, 0x19, 0x98, 0x1a, 0xca, 0x99, 0xa3, 0xb4, 0xd9, 0xa4, 0xf1, - 0x11, 0xcd, 0xa9, 0x99, 0xe4, 0xcc, 0xb7, 0x09, 0xb4, 0x2e, 0xd5, 0xfc, - 0x24, 0x3c, 0x6d, 0x0c, 0xab, 0xec, 0x0c, 0x64, 0x10, 0x7c, 0x41, 0x85, - 0xff, 0x27, 0x88, 0x9c, 0xa0, 0x8c, 0xfe, 0xec, 0xc9, 0x85, 0xaa, 0x9e, - 0xb0, 0xf2, 0xc4, 0x61, 0x2e, 0xca, 0xd8, 0x86, 0x54, 0xeb, 0x1f, 0xad, - 0x04, 0xe9, 0x67, 0x4a, 0xb2, 0x65, 0x88, 0x93, 0x2c, 0x33, 0x31, 0x3e, - 0x0b, 0x5a, 0xdf, 0x9f, 0xd4, 0xd0, 0x09, 0xab, 0xd4, 0xd2, 0xf2, 0x80, - 0x37, 0x06, 0x8e, 0x28, 0x8c, 0x05, 0x59, 0x06, 0xa8, 0x6f, 0xf8, 0x45, - 0x5a, 0xaa, 0xd9, 0x6c, 0xd1, 0x35, 0x08, 0xc7, 0xcf, 0x77, 0x8a, 0x92, - 0x47, 0xf0, 0x3c, 0x9b, 0x2e, 0xf4, 0x05, 0x77, 0xd8, 0x82, 0xfe, 0x8e, - 0xb6, 0x93, 0x3a, 0x72, 0xbe, 0x28, 0x9e, 0x3a, 0x26, 0x1b, 0x99, 0x28, - 0xa0, 0x37, 0x74, 0xe6, 0xdb, 0xb2, 0xa8, 0x99, 0xe8, 0xe9, 0x72, 0x38, - 0x86, 0xf7, 0x7e, 0x6a, 0xbc, 0xd7, 0xdf, 0x0a, 0xba, 0x18, 0x7d, 0xa7, - 0x66, 0x53, 0x93, 0x8f, 0x66, 0x1b, 0x41, 0x2b, 0x9f, 0x86, 0x5a, 0x7f, - 0x0b, 0x90, 0x6f, 0x5a, 0xe0, 0x97, 0x7f, 0x37, 0x42, 0xe1, 0x1d, 0xfa, - 0x3e, 0x57, 0x9c, 0xeb, 0xe7, 0x04, 0xb0, 0x01, 0x7e, 0xa8, 0x6c, 0xcb, - 0xdf, 0xd0, 0x1b, 0x20, 0xf4, 0x8b, 0x56, 0x33, 0xc2, 0xe4, 0xf3, 0xe8, - 0x6a, 0x64, 0xaf, 0x50, 0x5b, 0x00, 0x9a, 0x4e, 0x97, 0x8d, 0x4d, 0xb5, - 0xe6, 0xcb, 0x49, 0x2b, 0x71, 0x37, 0x8e, 0xbf, 0x17, 0xed, 0xa0, 0xa1, - 0xdc, 0xd4, 0xc1, 0xe6, 0xc1, 0x2e, 0xf4, 0x80, 0x56, 0x77, 0xc6, 0xf7, - 0x12, 0x1e, 0xcc, 0x67, 0xc5, 0xb8, 0xe0, 0x46, 0xbe, 0xd7, 0x28, 0x99, - 0x9e, 0x4e, 0x7d, 0x3a, 0x35, 0x13, 0x31, 0x44, 0xc0, 0x62, 0x19, 0x4d, - 0x50, 0xac, 0xa5, 0xc3, 0x30, 0x9d, 0xf5, 0xfb, 0xfa, 0x8f, 0x92, 0xbd, - 0x87, 0xbd, 0x68, 0x3b, 0x8d, 0x0e, 0xd3, 0x03, 0xcb, 0xc7, 0x4c, 0xc9, - 0xe2, 0x0c, 0x31, 0x51, 0xa4, 0xe9, 0x8e, 0xda, 0x57, 0xc6, 0x45, 0xab, - 0x04, 0xb9, 0xb6, 0x1b, 0x76, 0x4b, 0x99, 0x0d, 0xe2, 0xa6, 0xe2, 0x2f, - 0x1a, 0xbb, 0x32, 0x93, 0xd9, 0x75, 0xfd, 0xe9, 0xd5, 0xf5, 0xcf, 0xfb, - 0x39, 0x08, 0xb9, 0x4a, 0xd1, 0x4a, 0x7b, 0x94, 0x61, 0x43, 0x87, 0x93, - 0xa8, 0x20, 0xbc, 0xae, 0x8c, 0x97, 0xbf, 0x3a, 0x79, 0x53, 0x0e, 0x6f, - 0x35, 0xc3, 0x3b, 0xa1, 0xa5, 0xee, 0xa9, 0xb1, 0xfd, 0xeb, 0xe8, 0xa0, - 0x2b, 0x56, 0x09, 0x3a, 0x93, 0x5a, 0x0c, 0xdc, 0x32, 0x64, 0x6e, 0x4c, - 0x6e, 0x26, 0x09, 0x22, 0x2f, 0x82, 0x78, 0xb6, 0xad, 0xff, 0xc2, 0xb5, - 0x78, 0x3a, 0x5b, 0x0d, 0x63, 0x0c, 0x86, 0x68, 0xcd, 0x49, 0x65, 0x28, - 0x16, 0xa6, 0x3a, 0xa8, 0xab, 0xd7, 0x4f, 0xb6, 0x33, 0x26, 0x37, 0xf0, - 0x91, 0x63, 0x63, 0x93, 0x67, 0x99, 0xa8, 0x1b, 0xe4, 0x49, 0x34, 0x2f, - 0xbf, 0x22, 0xb0, 0x05, 0x13, 0x67, 0x97, 0xdf, 0xc2, 0x51, 0x35, 0xae, - 0xa5, 0xe9, 0xe2, 0x10, 0xdc, 0x9e, 0xdc, 0x26, 0xde, 0x3b, 0x54, 0x2d, - 0xef, 0x23, 0x27, 0xf2, 0x7b, 0xf6, 0x68, 0xa1, 0xe0, 0x67, 0xe0, 0xe6, - 0xa5, 0xaf, 0x07, 0x9d, 0xa9, 0xdc, 0xfb, 0xef, 0xb9, 0x8a, 0xde, 0x3e, - 0x9b, 0x61, 0x36, 0x5a, 0x86, 0x7e, 0xd4, 0x8b, 0x42, 0x8a, 0x19, 0x71, - 0x6a, 0xc2, 0xb1, 0xd1, 0x40, 0xd3, 0xeb, 0x00, 0xce, 0x78, 0xd7, 0x08, - 0x4b, 0xea, 0x54, 0x36, 0x30, 0x92, 0x0f, 0x1a, 0x41, 0xc0, 0x32, 0x8d, - 0x9e, 0x48, 0x82, 0x0b, 0xad, 0x76, 0x68, 0xe3, 0xb0, 0x57, 0xc3, 0x33, - 0xb2, 0xcc, 0x3c, 0x75, 0x92, 0x9b, 0x9d, 0xe0, 0x27, 0x32, 0xff, 0xe9, - 0x26, 0x85, 0xf5, 0xd1, 0x82, 0xa4, 0xc9, 0xf2, 0xf2, 0x66, 0xf1, 0xf2, - 0xc2, 0x4e, 0x19, 0x85, 0xd5, 0xc6, 0xb8, 0x74, 0x54, 0xd9, 0x61, 0x6b, - 0x8d, 0x4e, 0x19, 0x3c, 0x7e, 0x75, 0x10, 0x85, 0xc5, 0xaf, 0x9e, 0x4d, - 0x07, 0xee, 0x96, 0xf7, 0xec, 0x16, 0xe4, 0x78, 0x5e, 0x3f, 0x1f, 0xb0, - 0x17, 0x7e, 0x90, 0xb5, 0xb4, 0xda, 0xcf, 0xab, 0xca, 0xc6, 0xb5, 0xcf, - 0xbd, 0x11, 0xac, 0x13, 0xec, 0x2e, 0xd3, 0x0b, 0x89, 0x11, 0x10, 0x44, - 0x6b, 0xea, 0x0e, 0xec, 0x58, 0x7c, 0x38, 0x99, 0xca, 0xaf, 0xc9, 0xec, - 0x00, 0x10, 0x0e, 0x41, 0xce, 0xa1, 0x77, 0xf3, 0xfc, 0xe9, 0x7d, 0x09, - 0xd5, 0x4a, 0x35, 0x89, 0x3f, 0x05, 0xfc, 0x19, 0xac, 0x9b, 0x7f, 0xb6, - 0x29, 0x02, 0x29, 0x1a, 0x59, 0x11, 0x75, 0xcc, 0x17, 0xb9, 0xb0, 0x0d, - 0x0d, 0x66, 0x87, 0x1d, 0xd2, 0x83, 0xa4, 0x47, 0x86, 0x30, 0x0e, 0xe6, - 0xbf, 0x0f, 0xba, 0x59, 0xa6, 0x8d, 0x9e, 0x36, 0xa1, 0xe6, 0xd6, 0xc1, - 0x5a, 0xe7, 0xe0, 0x2f, 0x25, 0x3b, 0xd2, 0xab, 0x1c, 0xa5, 0xde, 0x3d, - 0x96, 0x05, 0x8c, 0x8b, 0xce, 0x01, 0xef, 0x9c, 0x4a, 0x01, 0x5d, 0x8e, - 0x6a, 0x29, 0x75, 0xab, 0x70, 0xd2, 0xd1, 0x3f, 0x7e, 0x16, 0xd6, 0xda, - 0xcf, 0x1e, 0x6c, 0x91, 0x27, 0xe8, 0x40, 0x5e, 0x77, 0xf1, 0x95, 0x3b, - 0x3a, 0x56, 0x86, 0xdb, 0x60, 0xea, 0x2a, 0xf5, 0x12, 0x53, 0x71, 0xbc, - 0xb9, 0xef, 0x12, 0x8a, 0x39, 0xa9, 0x40, 0x4a, 0x60, 0x8d, 0x96, 0x9c, - 0xb8, 0x1b, 0x30, 0x0a, 0xcf, 0xb0, 0xed, 0x72, 0xb3, 0x03, 0x67, 0x31, - 0x09, 0x75, 0x2f, 0x9a, 0x13, 0x40, 0xa1, 0x97, 0xb1, 0xc8, 0x20, 0x03, - 0x47, 0xf8, 0x36, 0x9b, 0x16, 0x55, 0xa2, 0xed, 0x56, 0x77, 0x54, 0xe4, - 0x0b, 0x72, 0xed, 0x3f, 0x66, 0x0d, 0xb4, 0x2f, 0x99, 0xfd, 0x68, 0xab, - 0x2d, 0xa9, 0xee, 0x99, 0x37, 0xb7, 0x81, 0x69, 0x19, 0xb8, 0xdb, 0x99, - 0x43, 0x16, 0xf4, 0x4c, 0x10, 0x54, 0x89, 0x22, 0x30, 0xb0, 0xe1, 0xf2, - 0x0a, 0x15, 0xe7, 0xf0, 0x95, 0x6b, 0xc4, 0x6b, 0xb9, 0x6a, 0xee, 0x50, - 0xc0, 0xec, 0xd8, 0x9d, 0xde, 0xa2, 0x8b, 0x80, 0x6e, 0xe3, 0x5a, 0x9d, - 0xb3, 0xcf, 0x45, 0x96, 0xa2, 0x02, 0x8a, 0x58, 0xd8, 0x7c, 0xbd, 0xfa, - 0xa9, 0x0f, 0x0e, 0xcb, 0x3c, 0x9f, 0x16, 0x3d, 0x1c, 0x12, 0x3e, 0x0b, - 0xd6, 0xa0, 0x2f, 0x47, 0x02, 0x6a, 0x04, 0x1b, 0xd6, 0xea, 0x2f, 0x4f, - 0xdf, 0x5e, 0x7a, 0xc5, 0x25, 0x6d, 0xf6, 0x31, 0x02, 0xbd, 0x99, 0x91, - 0x1c, 0x49, 0xaf, 0x4b, 0xf1, 0x95, 0x35, 0x52, 0x94, 0x70, 0x77, 0x6e, - 0x8d, 0x34, 0x9b, 0x06, 0x0d, 0x9b, 0x3d, 0x85, 0xd2, 0x75, 0x96, 0x5d, - 0xfe, 0x2a, 0xab, 0x07, 0x07, 0xda, 0xbd, 0xb9, 0xad, 0x72, 0xc6, 0x7a, - 0x0a, 0x28, 0x20, 0x69, 0x0d, 0x07, 0x09, 0xed, 0x7a, 0x18, 0x79, 0x47, - 0xde, 0x5f, 0xca, 0x8b, 0x06, 0xc5, 0x04, 0x6a, 0x2b, 0x3e, 0xc7, 0x64, - 0x50, 0x21, 0xb9, 0x70, 0xfd, 0x42, 0x80, 0x02, 0x59, 0x48, 0x0c, 0x6e, - 0x5b, 0xd8, 0x39, 0xe0, 0x66, 0xc4, 0xe0, 0xd6, 0x9c, 0x7b, 0xc4, 0xf1, - 0x98, 0xa6, 0xda, 0x05, 0x77, 0x50, 0x00, 0x39, 0xc5, 0x3c, 0xaf, 0xb5, - 0xcd, 0x08, 0xb0, 0xff, 0x29, 0x03, 0x66, 0x70, 0x13, 0x79, 0x8f, 0x18, - 0x39, 0x72, 0x6e, 0x8f, 0x14, 0xb3, 0x3e, 0x5b, 0xd3, 0x23, 0x62, 0xb6, - 0x8e, 0x02, 0x91, 0x82, 0x72, 0x3d, 0xb0, 0x96, 0xea, 0x6e, 0xaf, 0x4e, - 0x02, 0x30, 0xb1, 0x4a, 0xbe, 0xa5, 0x15, 0x4f, 0xef, 0x50, 0x64, 0x08, - 0xc7, 0x3b, 0x2b, 0x2e, 0xd8, 0x95, 0x60, 0x04, 0x2b, 0xc2, 0x71, 0x57, - 0xc9, 0x44, 0x84, 0x09, 0x1d, 0xba, 0xef, 0x27, 0xe2, 0xe2, 0xd3, 0x26, - 0xae, 0x8f, 0xa6, 0x17, 0x45, 0xe3, 0x9d, 0xb7, 0x29, 0xa9, 0x7a, 0x23, - 0x3c, 0x31, 0x8f, 0x07, 0x91, 0x4d, 0x13, 0x43, 0xeb, 0xd8, 0x86, 0x1e, - 0xd6, 0x6e, 0x9f, 0xde, 0x83, 0x79, 0x76, 0x3c, 0x4c, 0x06, 0x3e, 0x7f, - 0x66, 0xc2, 0x16, 0x4f, 0xcc, 0x5c, 0xf3, 0xb6, 0xe4, 0x5b, 0x79, 0x0a, - 0xc1, 0x7d, 0x2c, 0xce, 0x9d, 0xfc, 0x31, 0xe9, 0xdb, 0x4d, 0xbd, 0xb5, - 0xfb, 0x30, 0xdb, 0xa4, 0xdb, 0xd1, 0xf3, 0x2d, 0x68, 0x34, 0x37, 0x41, - 0xab, 0x1e, 0x73, 0x3a, 0x80, 0xac, 0xb4, 0x1f, 0xbb, 0xb7, 0x8f, 0x85, - 0x57, 0x16, 0xa9, 0x77, 0xa0, 0x90, 0x9d, 0x2e, 0x30, 0x70, 0x10, 0x4d, - 0xfb, 0x0a, 0x3d, 0xa3, 0xcc, 0xa3, 0xf7, 0xbf, 0xc3, 0x16, 0xf7, 0x3b, - 0x18, 0x1b, 0xea, 0x09 -}; -unsigned int dummy_firmware_bin_len = 16384; diff --git a/tools/self-header-verify/generated/test_pubkey.h b/tools/self-header-verify/generated/test_pubkey.h deleted file mode 100644 index 321feb093a..0000000000 --- a/tools/self-header-verify/generated/test_pubkey.h +++ /dev/null @@ -1,49 +0,0 @@ -unsigned char test_signing_key_pub_der[] = { - 0x30, 0x82, 0x02, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, - 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0f, 0x00, - 0x30, 0x82, 0x02, 0x0a, 0x02, 0x82, 0x02, 0x01, 0x00, 0x9d, 0xe7, 0x94, - 0xe8, 0x5e, 0x2b, 0x17, 0x47, 0x18, 0xfa, 0xc2, 0x52, 0x6a, 0x4b, 0x2e, - 0xa6, 0xd0, 0x11, 0xd5, 0x91, 0xbe, 0x7e, 0x06, 0x31, 0x07, 0x0e, 0xd6, - 0x8a, 0x77, 0x29, 0x71, 0xe9, 0xdc, 0xea, 0x4e, 0x93, 0x41, 0xbf, 0xe6, - 0x1a, 0x61, 0x0a, 0x69, 0xbd, 0x50, 0x02, 0xce, 0x1d, 0x3e, 0xe5, 0x8b, - 0x1e, 0x1a, 0x6a, 0xbb, 0xdb, 0x40, 0xe8, 0x73, 0x2c, 0x5b, 0x09, 0x34, - 0xcf, 0x93, 0x38, 0xa7, 0x4a, 0xce, 0xd6, 0x81, 0x7d, 0x33, 0x86, 0x6d, - 0xf8, 0x4a, 0xa5, 0xa9, 0xa0, 0x51, 0xb1, 0xb5, 0x54, 0x66, 0x21, 0xa8, - 0x8a, 0x6f, 0x62, 0x8f, 0xe8, 0xa0, 0x35, 0x55, 0x61, 0x08, 0xdb, 0x1c, - 0x79, 0x31, 0x14, 0x40, 0xf8, 0x59, 0x09, 0xef, 0xf0, 0x58, 0x74, 0x31, - 0x1b, 0x96, 0x46, 0x85, 0xf2, 0xd9, 0xd6, 0x26, 0xa8, 0xa4, 0x26, 0x43, - 0x43, 0x84, 0xdb, 0x54, 0x90, 0xdb, 0x30, 0x03, 0x5d, 0x8e, 0xd7, 0x39, - 0x1b, 0x44, 0xc0, 0x13, 0x05, 0x73, 0x8f, 0x27, 0x24, 0xec, 0xc8, 0x60, - 0x74, 0x8e, 0xd9, 0x95, 0x62, 0x1b, 0x85, 0xd9, 0x8a, 0xc3, 0x14, 0xe5, - 0x83, 0x81, 0xdf, 0x35, 0xa7, 0x16, 0xcb, 0xd5, 0x40, 0x41, 0xd7, 0x0a, - 0xf0, 0x94, 0x83, 0x92, 0xa8, 0xf8, 0xe4, 0xe8, 0x28, 0x63, 0x9e, 0xbe, - 0x95, 0xf5, 0xe4, 0x8e, 0xb6, 0x0d, 0x44, 0x41, 0x3f, 0xb8, 0x91, 0xb9, - 0xfe, 0xbe, 0xe3, 0x0a, 0xed, 0xf9, 0x1c, 0x3a, 0x92, 0x44, 0xff, 0x8f, - 0xe3, 0xf4, 0xcd, 0x24, 0xfb, 0x3f, 0xe9, 0x86, 0x81, 0x5f, 0xb7, 0x54, - 0x2c, 0x2a, 0xd3, 0xac, 0x23, 0x47, 0x60, 0x7b, 0x3e, 0xde, 0x5f, 0x52, - 0x39, 0xa9, 0x49, 0x2a, 0xb7, 0xf6, 0xa8, 0x07, 0x3d, 0xbf, 0x15, 0x79, - 0x61, 0x97, 0x3c, 0xf8, 0xd9, 0x9b, 0xef, 0x58, 0xb8, 0xb7, 0xd0, 0x95, - 0x8f, 0xa6, 0x97, 0x4d, 0x70, 0x84, 0x55, 0xc0, 0x77, 0x4b, 0xde, 0x55, - 0xc2, 0xef, 0x8d, 0xfd, 0x3d, 0x32, 0xd2, 0x86, 0x53, 0x1c, 0x3a, 0x41, - 0x0e, 0x30, 0x71, 0xd1, 0x9d, 0x22, 0x8d, 0xba, 0xcd, 0xed, 0x01, 0xd8, - 0xd5, 0xe7, 0xd0, 0xda, 0xb1, 0x33, 0x17, 0xe9, 0x15, 0x0b, 0x06, 0x58, - 0x99, 0x9c, 0x15, 0x82, 0x3c, 0xad, 0x24, 0x33, 0x90, 0x89, 0x02, 0x79, - 0x06, 0x3c, 0x38, 0xe7, 0xfd, 0xb9, 0x65, 0x25, 0x85, 0xb7, 0xa5, 0xfb, - 0x51, 0x19, 0xe5, 0x77, 0x33, 0xd0, 0xdd, 0xbe, 0xa9, 0x22, 0x34, 0xac, - 0x84, 0x5d, 0x0c, 0x47, 0xdd, 0xd5, 0x1b, 0x82, 0xf0, 0x7f, 0xc9, 0x3a, - 0xf7, 0xcb, 0x3b, 0x3d, 0x9a, 0x37, 0xed, 0x7c, 0x19, 0xaa, 0x1b, 0x42, - 0x00, 0xb3, 0x3d, 0xdf, 0x65, 0x23, 0xdd, 0xce, 0x83, 0x26, 0xc5, 0x7b, - 0xd1, 0x00, 0xea, 0x51, 0x7e, 0x36, 0x29, 0x4e, 0x35, 0x1e, 0xe3, 0x92, - 0x9a, 0xc7, 0x48, 0xef, 0x96, 0x62, 0x10, 0xa5, 0xce, 0x6e, 0xe8, 0xa7, - 0x73, 0x2b, 0x04, 0x83, 0xa7, 0x71, 0x7a, 0xbb, 0xc6, 0x8c, 0x42, 0xed, - 0x5d, 0x76, 0xb1, 0xaf, 0x21, 0xc8, 0x2f, 0xaf, 0xc6, 0x4a, 0xdc, 0x78, - 0x92, 0xf3, 0x0d, 0x69, 0xf0, 0x39, 0x39, 0x2b, 0xf5, 0xae, 0xbe, 0xa6, - 0x06, 0x6b, 0xe6, 0xfc, 0x2b, 0xac, 0xc2, 0x78, 0xe8, 0xf8, 0x0b, 0xa5, - 0xcb, 0xda, 0x2c, 0x46, 0xb5, 0x27, 0x28, 0x55, 0xb0, 0x58, 0x5a, 0x24, - 0x93, 0xf2, 0x6e, 0xce, 0xb4, 0xa7, 0xdd, 0x30, 0xcc, 0x1c, 0x4b, 0xb1, - 0x2c, 0x79, 0x38, 0x7f, 0x9c, 0x80, 0x96, 0x41, 0x77, 0x45, 0x5a, 0x65, - 0x5b, 0x0c, 0x18, 0xad, 0x1f, 0x12, 0x4c, 0xbc, 0x77, 0xd2, 0x4b, 0x53, - 0xf8, 0x9b, 0x2c, 0xd5, 0x0f, 0x26, 0x4a, 0x13, 0x70, 0x2d, 0xf5, 0x25, - 0x00, 0xcf, 0x9c, 0x6b, 0x9b, 0x02, 0x03, 0x01, 0x00, 0x01 -}; -unsigned int test_signing_key_pub_der_len = 550; diff --git a/tools/self-header-verify/test-self-header-verify b/tools/self-header-verify/test-self-header-verify deleted file mode 100755 index 94c1e8b53e87ce80840f419739c1c378008603f6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 43608 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