From: slontis Date: Tue, 3 Dec 2024 04:03:09 +0000 (+1100) Subject: Add ML-DSA Keygen support X-Git-Tag: openssl-3.5.0-alpha1~608 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=d3a7ae64b337b494981a8868a63762db6a934fcf;p=thirdparty%2Fopenssl.git Add ML-DSA Keygen support The key generation algorithm requires a significant portion of the many algorithms present in FIPS 204. This work is derived from the BoringSSL code located at https://boringssl.googlesource.com/boringssl/+/refs/heads/master/crypto/mldsa/mldsa.cc Instead of c++ templates it uses an ML_DSA_PARAMS object to store constants such as k & l. To perform hash operations a temporary EVP_MD_CTX object is used, which is supplied with a prefetched EVP_MD shake128 or shake256 object that reside in the ML_DSA_KEY object. The ML_DSA_KEY object stores the encoded public and/or private key whenever a key is loaded or generated. A public key is always present if the private key component exists. Reviewed-by: Viktor Dukhovni Reviewed-by: Tim Hudson Reviewed-by: Matt Caswell (Merged from https://github.com/openssl/openssl/pull/26127) --- diff --git a/Configure b/Configure index 2dd6234d1cc..b090f0ad364 100755 --- a/Configure +++ b/Configure @@ -486,6 +486,7 @@ my @disablables = ( "md2", "md4", "mdc2", + "ml-dsa", "module", "msan", "multiblock", diff --git a/INSTALL.md b/INSTALL.md index 0f686532d3d..7426204106f 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -885,6 +885,11 @@ Disabling this also disables the legacy algorithms: MD2 (already disabled by def Don't generate dependencies. +### no-ml-dsa + +Disable Module-Lattice-Based Digital Signature Standard (ML-DSA) Support. +(ML-DSA is based on CRYSTALS-DILITHIUM. See NIST.FIPS.204) + ### no-module Don't build any dynamically loadable engines. diff --git a/crypto/build.info b/crypto/build.info index 2642d30754b..e476b678da3 100644 --- a/crypto/build.info +++ b/crypto/build.info @@ -6,7 +6,7 @@ SUBDIRS=objects buffer bio stack lhash hashtable rand evp asn1 pem x509 conf \ siphash sm3 des aes rc2 rc4 rc5 idea aria bf cast camellia \ seed sm4 chacha modes bn ec rsa dsa dh sm2 dso engine \ err comp http ocsp cms ts srp cmac ct async ess crmf cmp encode_decode \ - ffc hpke thread + ffc hpke thread ml_dsa LIBS=../libcrypto diff --git a/crypto/ml_dsa/build.info b/crypto/ml_dsa/build.info new file mode 100644 index 00000000000..f972fed51c6 --- /dev/null +++ b/crypto/ml_dsa/build.info @@ -0,0 +1,8 @@ +LIBS=../../libcrypto + +$COMMON=ml_dsa_ctx.c ml_dsa_encoders.c ml_dsa_key_compress.c ml_dsa_key.c \ + ml_dsa_matrix.c ml_dsa_ntt.c ml_dsa_params.c ml_dsa_sample.c + +IF[{- !$disabled{'ml_dsa'} -}] + SOURCE[../../libcrypto]=$COMMON +ENDIF diff --git a/crypto/ml_dsa/ml_dsa_ctx.c b/crypto/ml_dsa/ml_dsa_ctx.c new file mode 100644 index 00000000000..7689384951a --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_ctx.c @@ -0,0 +1,81 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include +#include "ml_dsa_local.h" +#include "ml_dsa_params.h" + +static EVP_MD_CTX *md_ctx_new(EVP_MD *md) +{ + EVP_MD_CTX *ctx = EVP_MD_CTX_new(); + + if (ctx == NULL) + return NULL; + + if (EVP_DigestInit_ex2(ctx, md, NULL) != 1) { + EVP_MD_CTX_free(ctx); + ctx = NULL; + } + return ctx; +} + +/** + * @brief Create a ML_DSA_CTX that contains parameters, and pre-fetched hash + * related objects for a ML-DSA algorithm. This context is passed + * to many ML-DSA related functions. + * + * @param alg An ML-DSA algorithm name such as "ML-DSA-65" + * @param lib_ctx A library context used for fetching. Can be NULL + * @param propq A property query to use for algorithm fetching. Can be NULL. + * + * @returns The created ML_DSA_CTX object or NULL on failure. + */ +ML_DSA_CTX *ossl_ml_dsa_ctx_new(const char *alg, + OSSL_LIB_CTX *lib_ctx, const char *propq) +{ + ML_DSA_CTX *ret; + EVP_MD *shake128_md = NULL; + EVP_MD *shake256_md = NULL; + const ML_DSA_PARAMS *params = ossl_ml_dsa_params_get(alg); + + if (params == NULL) + return NULL; + + ret = OPENSSL_zalloc(sizeof(*ret)); + if (ret == NULL) + return NULL; + + shake128_md = EVP_MD_fetch(lib_ctx, "SHAKE-128", propq); + shake256_md = EVP_MD_fetch(lib_ctx, "SHAKE-256", propq); + if (shake128_md == NULL || shake256_md == NULL) + goto err; + ret->g_ctx = md_ctx_new(shake128_md); + ret->h_ctx = md_ctx_new(shake256_md); + EVP_MD_free(shake128_md); + EVP_MD_free(shake256_md); + if (ret->h_ctx == NULL || ret->g_ctx == NULL) + goto err; + ret->params = params; + return ret; +err: + ossl_ml_dsa_ctx_free(ret); + return NULL; +} + +/** + * @brief Destroy a ML_DSA_CTX + * + * @param ctx The ML_DSA_CTX object to destroy. + */ +void ossl_ml_dsa_ctx_free(ML_DSA_CTX *ctx) +{ + EVP_MD_CTX_free(ctx->g_ctx); + EVP_MD_CTX_free(ctx->h_ctx); + OPENSSL_free(ctx); +} diff --git a/crypto/ml_dsa/ml_dsa_encoders.c b/crypto/ml_dsa/ml_dsa_encoders.c new file mode 100644 index 00000000000..844a1e97928 --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_encoders.c @@ -0,0 +1,541 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include "ml_dsa_local.h" +#include "ml_dsa_key.h" +#include "ml_dsa_params.h" +#include "internal/packet.h" + +typedef int (PRIV_ENCODE_FN)(WPACKET *pkt, const POLY *s); +typedef int (PRIV_DECODE_FN)(PACKET *pkt, POLY *s); + +static PRIV_ENCODE_FN poly_encode_signed_2; +static PRIV_ENCODE_FN poly_encode_signed_4; +static PRIV_DECODE_FN poly_decode_signed_2; +static PRIV_DECODE_FN poly_decode_signed_4; + +static ossl_inline int constant_time_declassify_int(int v) +{ + return value_barrier_32(v); +} + +/* Bit packing Algorithms */ + +/* + * Encodes a polynomial into a byte string, assuming that all coefficients are + * 10 bits. + * + * See FIPS 204, Algorithm 16, SimpleBitPack(w, b) where b = 10 bits + * + * i.e. Use 10 bits from each coefficient and pack them into bytes + * So every 4 coefficients (c0..c3) fit into 5 bytes. + * |c0||c1||c2||c3| + * |\ |\ |\ |\ + * |8|2 6|4 4|6 2|8| + * + * This is used to save t1 (the high part of public key polynomial t) + * + * @param p A polynomial with coefficients all in the range (0..1023) + * @param pkt A packet object to write 320 bytes to. + * + * @returns 1 on success, or 0 on error. + */ +static int poly_encode_10_bits(WPACKET *pkt, const POLY *p) +{ + uint8_t *out; + const uint32_t *in = p->coeff, *end = in + 256; + + if (!WPACKET_allocate_bytes(pkt, 5 * (256 / 4), &out)) + return 0; + + while (in < end) { + uint32_t c0 = *in++; + uint32_t c1 = *in++; + uint32_t c2 = *in++; + uint32_t c3 = *in++; + + *out++ = (uint8_t)c0; + *out++ = (uint8_t)((c0 >> 8) | (c1 << 2)); + *out++ = (uint8_t)((c1 >> 6) | (c2 << 4)); + *out++ = (uint8_t)((c2 >> 4) | (c3 << 6)); + *out++ = (uint8_t)(c3 >> 2); + } + return 1; +} + +/* + * @brief Reverses the procedure of poly_encode_10_bits(). + * See FIPS 204, Algorithm 18, SimpleBitUnpack(v, b) where b = 10. + * + * @param pkt A packet object to read 320 bytes from. + * @param p A polynomial to write coefficients to. + * + * @returns 1 on success, or 0 on error. + */ +static int poly_decode_10_bits(PACKET *pkt, POLY *p) +{ + int i, ret = 0; + const uint8_t *in = NULL; + uint32_t v, *out = p->coeff; + + for (i = 0; i < (ML_DSA_NUM_POLY_COEFFICIENTS / 4); i++) { + if (!PACKET_get_bytes(pkt, &in, 5)) + goto err; + memcpy(&v, in, sizeof(v)); + *out++ = v & 0x3ff; + *out++ = (v >> 10) & 0x3ff; + *out++ = (v >> 20) & 0x3ff; + *out++ = (v >> 30) | (((uint32_t)in[4]) << 2); + } + ret = 1; +err: + return ret; +} + +/* + * @brief Encodes a polynomial into a byte string, assuming that all + * coefficients are in the range -4..4. + * See FIPS 204, Algorithm 17, BitPack(w, a, b). (a = 4, b = 4) + * + * It uses a nibble from each coefficient and packs them into bytes + * So every 2 coefficients fit into 1 byte. + * + * This is used to encode the private key polynomial elements of s1 and s2 + * for ML-DSA-65 (i.e. eta = 4) + * + * @param pkt A packet to write 128 bytes of encoded polynomial coefficients to. + * @param p An array of 256 coefficients all in the range -4..4 + * + * @returns 1 on success, or 0 on error. + */ +static int poly_encode_signed_4(WPACKET *pkt, const POLY *p) +{ + uint8_t *out; + const uint32_t *in = p->coeff, *end = in + 256; + + if (!WPACKET_allocate_bytes(pkt, 32 * 4, &out)) + return 0; + + while (in < end) { + uint32_t z0 = mod_sub(4, *in++); /* 0..8 */ + uint32_t z1 = mod_sub(4, *in++); /* 0..8 */ + + *out++ = z0 | (z1 << 4); + } + return 1; +} + +/* + * @brief Reverses the procedure of poly_encode_signed_4(). + * See FIPS 204, Algorithm 19, BitUnpack(v, a, b) where a = b = 4. + * + * @param pkt A packet object to read 128 bytes from. + * @param p A polynomial to write coefficients to. + * + * @returns 1 on success, or 0 on error. An error will occur if any of the + * coefficients are not in the correct range. + */ +static int poly_decode_signed_4(PACKET *pkt, POLY *s) +{ + int i, ret = 0; + uint32_t v, *out = s->coeff; + const uint8_t *in; + uint32_t msbs, mask; + + for (i = 0; i < (ML_DSA_NUM_POLY_COEFFICIENTS / 8); i++) { + if (!PACKET_get_bytes(pkt, &in, 4)) + goto err; + memcpy(&v, &in, 4); + + /* + * None of the nibbles may be >= 9. So if the MSB of any nibble is set, + * none of the other bits may be set. First, select all the MSBs. + */ + msbs = v & 0x88888888u; + /* For each nibble where the MSB is set, form a mask of all the other bits. */ + mask = (msbs >> 1) | (msbs >> 2) | (msbs >> 3); + /* + * A nibble is only out of range in the case of invalid input, in which case + * it is okay to leak the value. + */ + if (constant_time_declassify_int((mask & v) != 0)) + goto err; + + *out++ = mod_sub(4, v & 15); + *out++ = mod_sub(4, (v >> 4) & 15); + *out++ = mod_sub(4, (v >> 8) & 15); + *out++ = mod_sub(4, (v >> 12) & 15); + *out++ = mod_sub(4, (v >> 16) & 15); + *out++ = mod_sub(4, (v >> 20) & 15); + *out++ = mod_sub(4, (v >> 24) & 15); + *out++ = mod_sub(4, v >> 28); + } + ret = 1; + err: + return ret; +} + +/* + * @brief Encodes a polynomial into a byte string, assuming that all + * coefficients are in the range -2..2. + * See FIPS 204, Algorithm 17, BitPack(w, a, b). where a = b = 2. + * + * This is used to encode the private key polynomial elements of s1 and s2 + * for ML-DSA-44 and ML-DSA-87 (i.e. eta = 2) + * + * @param pkt A packet to write 128 bytes of encoded polynomial coefficients to. + * @param p An array of 256 coefficients all in the range -2..2 + * + * Use 3 bits from each coefficient and pack them into bytes + * So every 8 coefficients fit into 3 bytes. + * |c0 c1 c2 c3 c4 c5 c6 c7| + * | / / | | / / | | / + * |3 3 2| 1 3 3 1| 2 3 3| + * + * @param pkt A packet to write 64 bytes of encoded polynomial coefficients to. + * @param p An array of 256 coefficients all in the range -2..2 + * + * @returns 1 on success, or 0 on error. + */ +static int poly_encode_signed_2(WPACKET *pkt, const POLY *s) +{ + uint8_t *out; + const uint32_t *in = s->coeff, *end = in + 256; + + if (!WPACKET_allocate_bytes(pkt, 32 * 3, &out)) + return 0; + + while (in < end) { + uint32_t z0 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z1 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z2 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z3 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z4 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z5 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z6 = mod_sub(2, *in++); /* 0..7 */ + uint32_t z7 = mod_sub(2, *in++); /* 0..7 */ + + *out++ = (uint8_t)z0 | (uint8_t)(z1 << 3) | (uint8_t)(z2 << 6); + *out++ = (uint8_t)(z2 >> 2) | (uint8_t)(z3 << 1) | (uint8_t)(z4 << 4) | (uint8_t)(z5 << 7); + *out++ = (uint8_t)(z5 >> 1) | (uint8_t)(z6 << 2) | (uint8_t)(z7 << 5); + } + return 1; +} + +/* + * @brief Reverses the procedure of poly_encode_signed_2(). + * See FIPS 204, Algorithm 19, BitUnpack(v, a, b) where a = b = 2. + * + * @param pkt A packet object to read 64 encoded bytes from. + * @param p A polynomial to write coefficients to. + * + * @returns 1 on success, or 0 on error. An error will occur if any of the + * coefficients are not in the correct range. + */ +static int poly_decode_signed_2(PACKET *pkt, POLY *p) +{ + int i, ret = 0; + uint32_t v = 0, *out = p->coeff; + uint32_t msbs, mask; + const uint8_t *in; + + for (i = 0; i < (ML_DSA_NUM_POLY_COEFFICIENTS / 8); i++) { + if (!PACKET_get_bytes(pkt, &in, 3)) + goto err; + memcpy(&v, &in, 3); + /* + * Each octal value (3 bits) must be <= 4, So if the MSB is set then the + * bottom 2 bits must not be set. + * First, select all the MSBs (Use octal representation for the mask) + */ + msbs = v & 044444444; + /* For each octal value where the MSB is set, form a mask of the 2 other bits. */ + mask = (msbs >> 1) | (msbs >> 2); + /* + * A nibble is only out of range in the case of invalid input, in which + * case it is okay to leak the value. + */ + if (constant_time_declassify_int((mask & v) != 0)) + goto err; + + *out++ = mod_sub(2, v & 7); + *out++ = mod_sub(2, (v >> 3) & 7); + *out++ = mod_sub(2, (v >> 6) & 7); + *out++ = mod_sub(2, (v >> 9) & 7); + *out++ = mod_sub(2, (v >> 12) & 7); + *out++ = mod_sub(2, (v >> 15) & 7); + *out++ = mod_sub(2, (v >> 18) & 7); + *out++ = mod_sub(2, (v >> 21) & 7); + } + ret = 1; + err: + return ret; +} + +/* + * @brief Encodes a polynomial into a byte string, assuming that all + * coefficients are in the range (-2^12 + 1)..2^12. + * See FIPS 204, Algorithm 17, BitPack(w, a, b). where a = 2^12 - 1, b = 2^12. + * + * This is used to encode the LSB of the public key polynomial elements of t0 + * (which are encoded as part of the encoded private key). + * + * Use 13 bits from each coefficient and pack them into bytes + * + * The code below packs them into 2 64 bits blocks by doing.. + * z0 z1 z2 z3 z4 z5 z6 z7 0 + * | | | | / \ | | | | + * |13 13 13 13 12 |1 13 13 13 24 + * + * @param pkt A packet to write 416 (13 * 256 / 8) bytes of encoded polynomial + * coefficients to. + * @param p An array of 256 coefficients all in the range -2^12+1..2^12 + * + * @returns 1 on success, or 0 on error. + */ +static int poly_encode_signed_two_to_power_12(WPACKET *pkt, const POLY *p) +{ + static const uint32_t range = 1u << 12; + const uint32_t *in = p->coeff, *end = in + 256; + + while (in < end) { + uint64_t z0 = mod_sub(range, *in++); /* < 2^13 */ + uint64_t z1 = mod_sub(range, *in++); + uint64_t z2 = mod_sub(range, *in++); + uint64_t z3 = mod_sub(range, *in++); + uint64_t z4 = mod_sub(range, *in++); + uint64_t z5 = mod_sub(range, *in++); + uint64_t z6 = mod_sub(range, *in++); + uint64_t z7 = mod_sub(range, *in++); + uint64_t a1 = (z0) | (z1 << 13) | (z2 << 26) | (z3 << 39) | (z4 << 52); + uint64_t a2 = (z4 >> 12) | (z5 << 1) | (z6 << 14) | (z7 << 27); + + if (!WPACKET_memcpy(pkt, &a1, 8) + || !WPACKET_memcpy(pkt, &a2, 5)) + return 0; + } + return 1; +} + +/* + * @brief Reverses the procedure of poly_encode_signed_two_to_power_12(). + * See FIPS 204, Algorithm 19, BitUnpack(v, a, b) where a = 2^12 - 1, b = 2^12. + * + * @param pkt A packet object to read 416 encoded bytes from. + * @param p A polynomial to write coefficients to. + * + * @returns 1 on success, or 0 on error. + */ +static int poly_decode_signed_two_to_power_12(PACKET *pkt, POLY *p) +{ + int i, ret = 0; + uint64_t a1 = 0, a2 = 0; + uint32_t *out = p->coeff; + const uint8_t *in; + static const uint32_t range = 1u << 12; + static const uint32_t mask_13_bits = (1u << 13) - 1; + + for (i = 0; i < (ML_DSA_NUM_POLY_COEFFICIENTS / 8); i++) { + if (!PACKET_get_bytes(pkt, &in, 13)) + goto err; + memcpy(&a1, in, 8); + memcpy(&a2, in + 8, 5); + + /* + * It is not possible for a 13-bit number to be out of range when the + * max is 2^12. + */ + *out++ = mod_sub(range, a1 & mask_13_bits); + *out++ = mod_sub(range, (a1 >> 13) & mask_13_bits); + *out++ = mod_sub(range, (a1 >> 26) & mask_13_bits); + *out++ = mod_sub(range, (a1 >> 39) & mask_13_bits); + *out++ = mod_sub(range, (a1 >> 52) | ((a2 << 12) & mask_13_bits)); + *out++ = mod_sub(range, (a2 >> 1) & mask_13_bits); + *out++ = mod_sub(range, (a2 >> 14) & mask_13_bits); + *out++ = mod_sub(range, (a2 >> 27) & mask_13_bits); + } + ret = 1; + err: + return ret; +} + +/* + * @brief Encode the public key as an array of bytes. + * See FIPS 204, Algorithm 22, pkEncode(). + * + * @param key A key object containing public key values. The encoded public + * key data is stored in this key. + * @returns 1 if the public key was encoded successfully or 0 otherwise. + */ +int ossl_ml_dsa_pk_encode(ML_DSA_KEY *key) +{ + int ret = 0; + size_t i; + const POLY *t1 = key->t1.poly; + size_t t1_len = key->t1.num_poly; + size_t enc_len = key->params->pk_len; + uint8_t *enc = OPENSSL_zalloc(enc_len); + WPACKET pkt; + + if (enc == NULL) + return 0; + + if (!WPACKET_init_static_len(&pkt, enc, enc_len, 0) + || !WPACKET_memcpy(&pkt, key->rho, sizeof(key->rho))) + goto err; + for (i = 0; i < t1_len; i++) + if (!poly_encode_10_bits(&pkt, t1 + i)) + goto err; + OPENSSL_free(key->pub_encoding); + key->pub_encoding = enc; + ret = 1; +err: + WPACKET_finish(&pkt); + if (ret == 0) + OPENSSL_free(enc); + return ret; +} + +/* + * @brief The reverse of ossl_ml_dsa_pk_encode(). + * See FIPS 204, Algorithm 23, pkDecode(). + * + * @param in An encoded public key. + * @param in_len The size of |in| + * @param key A key object to store the decoded public key into. + * + * @returns 1 if the public key was decoded successfully or 0 otherwise. + */ +int ossl_ml_dsa_pk_decode(const uint8_t *in, size_t in_len, ML_DSA_KEY *key) +{ + int ret = 0; + size_t i; + PACKET pkt; + + if (in_len != key->params->pk_len) + return 0; + + if (!PACKET_buf_init(&pkt, in, in_len) + || PACKET_copy_bytes(&pkt, key->rho, sizeof(key->rho))) + goto err; + for (i = 0; i < key->t1.num_poly; i++) + if (!poly_decode_10_bits(&pkt, &key->t1.poly[i])) + goto err; + memcpy(key->pub_encoding, in, in_len); + ret = 1; +err: + return ret; +} + +/* + * @brief Encode the private key as an array of bytes. + * See FIPS 204, Algorithm 24, skEncode(). + * + * @param key A key object containing private key values. The encoded private + * key data is stored in this key. + * @returns 1 if the private key was encoded successfully or 0 otherwise. + */ +int ossl_ml_dsa_sk_encode(ML_DSA_KEY *key) +{ + int ret = 0; + const ML_DSA_PARAMS *params = key->params; + size_t i, k = params->k, l = params->l; + PRIV_ENCODE_FN *encode_fn; + size_t enc_len = params->sk_len; + const POLY *t0 = key->t0.poly; + WPACKET pkt; + uint8_t *enc = OPENSSL_zalloc(enc_len); + + if (enc == NULL) + return 0; + + /* eta is the range of private key coefficients (-eta...eta) */ + if (params->eta == 4) + encode_fn = poly_encode_signed_4; + else + encode_fn = poly_encode_signed_2; + + if (!WPACKET_init_static_len(&pkt, enc, enc_len, 0) + || !WPACKET_memcpy(&pkt, key->rho, sizeof(key->rho)) + || !WPACKET_memcpy(&pkt, key->K, sizeof(key->K)) + || !WPACKET_memcpy(&pkt, key->tr, sizeof(key->tr))) + goto err; + for (i = 0; i < l; ++i) + if (!encode_fn(&pkt, &key->s1.poly[i])) + goto err; + for (i = 0; i < k; ++i) + if (!encode_fn(&pkt, &key->s2.poly[i])) + goto err; + for (i = 0; i < k; ++i, t0++) + if (!poly_encode_signed_two_to_power_12(&pkt, t0)) + goto err; + OPENSSL_clear_free(key->priv_encoding, enc_len); + key->priv_encoding = enc; + ret = 1; +err: + WPACKET_finish(&pkt); + if (ret == 0) + OPENSSL_clear_free(enc, enc_len); + return ret; +} + +/* + * @brief The reverse of ossl_ml_dsa_sk_encode(). + * See FIPS 204, Algorithm 24, skDecode(). + * + * @param in An encoded private key. + * @param in_len The size of |in| + * @param key A key object to store the decoded private key into. + * + * @returns 1 if the private key was decoded successfully or 0 otherwise. + */ +int ossl_ml_dsa_sk_decode(const uint8_t *in, size_t in_len, ML_DSA_KEY *key) +{ + int ret = 0; + uint8_t *enc = NULL; + PRIV_DECODE_FN *decode_fn; + const ML_DSA_PARAMS *params = key->params; + size_t i, k = params->k, l = params->l; + PACKET pkt; + + if (in_len != key->params->sk_len) + return 0; + enc = OPENSSL_memdup(in, in_len); + if (enc == NULL) + return 0; + + /* eta is the range of private key coefficients (-eta...eta) */ + if (params->eta == 4) + decode_fn = poly_decode_signed_4; + else + decode_fn = poly_decode_signed_2; + + if (!PACKET_buf_init(&pkt, in, in_len) + || !PACKET_copy_bytes(&pkt, key->rho, sizeof(key->rho)) + || !PACKET_copy_bytes(&pkt, key->K, sizeof(key->K)) + || !PACKET_copy_bytes(&pkt, key->tr, sizeof(key->tr))) + goto err; + + for (i = 0; i < l; ++i) + if (!decode_fn(&pkt, key->s1.poly + i)) + goto err; + for (i = 0; i < k; ++i) + if (!decode_fn(&pkt, key->s2.poly + i)) + goto err; + for (i = 0; i < k; ++i) + if (!poly_decode_signed_two_to_power_12(&pkt, key->t0.poly + i)) + goto err; + if (PACKET_remaining(&pkt) != 0) + goto err; + OPENSSL_clear_free(key->priv_encoding, in_len); + key->priv_encoding = enc; + ret = 1; +err: + return ret; +} diff --git a/crypto/ml_dsa/ml_dsa_key.c b/crypto/ml_dsa/ml_dsa_key.c new file mode 100644 index 00000000000..9ab46ab1b5d --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_key.c @@ -0,0 +1,380 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include +#include +#include +#include +#include "ml_dsa_local.h" +#include "ml_dsa_key.h" +#include "ml_dsa_params.h" +#include "ml_dsa_matrix.h" + +/** + * @brief Create a new ML_DSA_KEY object + * + * @param libctx A OSSL_LIB_CTX object used for fetching algorithms. + * @param alg The algorithm name associated with the key type + * @returns The new ML_DSA_KEY object on success, or NULL on malloc failure + */ +ML_DSA_KEY *ossl_ml_dsa_key_new(OSSL_LIB_CTX *libctx, const char *alg) +{ + ML_DSA_KEY *ret; + const ML_DSA_PARAMS *params = ossl_ml_dsa_params_get(alg); + + if (params == NULL) + return NULL; + + ret = OPENSSL_zalloc(sizeof(*ret)); + if (ret != NULL) { + if (!CRYPTO_NEW_REF(&ret->references, 1)) { + OPENSSL_free(ret); + return NULL; + } + ret->libctx = libctx; + ret->params = params; + vector_init(&ret->t0, params->k); + vector_init(&ret->t1, params->k); + vector_init(&ret->s2, params->k); + vector_init(&ret->s1, params->l); + } + return ret; +} + +/** + * @brief Destroy a ML_DSA_KEY object + */ +void ossl_ml_dsa_key_free(ML_DSA_KEY *key) +{ + int i; + + if (key == NULL) + return; + + CRYPTO_DOWN_REF(&key->references, &i); + REF_PRINT_COUNT("ML_DSA_KEY", key); + if (i > 0) + return; + REF_ASSERT_ISNT(i < 0); + + OPENSSL_free(key->pub_encoding); + OPENSSL_free(key->priv_encoding); + OPENSSL_free(key->propq); + CRYPTO_FREE_REF(&key->references); + OPENSSL_free(key); +} + +/* + * @brief Increase the reference count for a ML_DSA_KEY object. + * @returns 1 on success or 0 otherwise. + */ +int ossl_ml_dsa_key_up_ref(ML_DSA_KEY *key) +{ + int i; + + if (CRYPTO_UP_REF(&key->references, &i) <= 0) + return 0; + + REF_PRINT_COUNT("ML_DSA_KEY", key); + REF_ASSERT_ISNT(i < 2); + return ((i > 1) ? 1 : 0); +} + +/** + * @brief Are 2 keys equal? + * + * To be equal the keys must have the same key data and algorithm name. + * + * @param key1 A ML_DSA_KEY object + * @param key2 A ML_DSA_KEY object + * @param selection to select public and/or private component comparison. + * @returns 1 if the keys are equal otherwise it returns 0. + */ +int ossl_ml_dsa_key_equal(const ML_DSA_KEY *key1, const ML_DSA_KEY *key2, + int selection) +{ + if (key1->params != key2->params) + return 0; + if (key1->pub_encoding != NULL) { + if (key2->pub_encoding == NULL + || memcmp(key1->pub_encoding, key1->pub_encoding, + key1->params->pk_len) != 0) + return 0; + } else if (key2->pub_encoding != NULL) { + return 0; + } + if (key1->priv_encoding != NULL) { + if (key2->priv_encoding == NULL + || memcmp(key1->priv_encoding, key1->priv_encoding, + key1->params->sk_len) != 0) + return 0; + } else if (key2->priv_encoding != NULL) { + return 0; + } + return 1; +} + +int ossl_ml_dsa_key_has(const ML_DSA_KEY *key, int selection) +{ + if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0) { + if (key->pub_encoding == NULL) + return 0; /* No public key */ + if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0 + && key->priv_encoding == 0) + return 0; /* No private key */ + return 1; + } + return 0; +} + +/** + * @brief Load a ML_DSA key from raw data. + * + * @param key An ML_DSA key to load into + * @param params An array of parameters containing key data. + * @param include_private Set to 1 to optionally include the private key data + * if it exists. + * @returns 1 on success, or 0 on failure. + */ +int ossl_ml_dsa_key_fromdata(ML_DSA_KEY *key, const OSSL_PARAM params[], + int include_private) +{ + const OSSL_PARAM *p = NULL; + + /* Private key is optional */ + if (include_private) { + p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY); + if (p != NULL) { + if (p->data_type != OSSL_PARAM_OCTET_STRING + || !ossl_ml_dsa_sk_decode(p->data, p->data_size, key)) + return 0; + } + } + p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY); + if (p != NULL) { + if (p->data_type != OSSL_PARAM_OCTET_STRING + || !ossl_ml_dsa_pk_decode(p->data, p->data_size, key)) + return 0; + } + return 1; +} + +/* + * @brief Given a key containing private key values for rho, s1 & s2 + * generate the public value t and return the compressed values t1, t0. + * + * @param ctx A Object containing algorithm specific constants and hash contexts. + * @param key A private key containing rh0, s1 & s2. + * @param t1 The returned polynomial encoding of the 10 MSB of each coefficient + * of the uncompressed public key polynomial t. + * @param t0 The returned polynomial encoding of the 13 LSB of each coefficient + * of the uncompressed public key polynomial t. + * @returns 1 on success, or 0 on failure. + */ +static int public_from_private(ML_DSA_CTX *ctx, const ML_DSA_KEY *key, + VECTOR *t1, VECTOR *t0) +{ + MATRIX a_ntt; + VECTOR s1_ntt; + VECTOR t; + const ML_DSA_PARAMS *params = ctx->params; + + matrix_init(&a_ntt, params->k, params->l); + vector_init(&s1_ntt, params->l); + vector_init(&t, params->k); + + /* Using rho generate A' = A in NTT form */ + if (!ossl_ml_dsa_sample_expandA(ctx->g_ctx, key->rho, &a_ntt)) + return 0; + + /* t = NTT_inv(A' * NTT(s1)) + s2 */ + vector_copy(&s1_ntt, &key->s1); + vector_ntt(&s1_ntt); + + ossl_ml_dsa_matrix_mult_vector(&a_ntt, &s1_ntt, &t); + vector_ntt_inverse(&t); + vector_add(&t, &key->s2, &t); + + /* Compress t */ + vector_power2_round(&t, t1, t0); + + /* Zeroize secret */ + vector_zero(&s1_ntt); + return 1; +} + +int ossl_ml_dsa_key_pairwise_check(const ML_DSA_KEY *key) +{ + int ret = 0; + ML_DSA_CTX *ctx = NULL; + VECTOR t1, t0; + + if (key->pub_encoding == NULL || key->priv_encoding == 0) + return 0; + + ctx = ossl_ml_dsa_ctx_new(key->params->alg, key->libctx, key->propq); + if (ctx == NULL) + return 0; + + vector_init(&t1, key->params->k); + vector_init(&t0, key->params->k); + if (!public_from_private(ctx, key, &t1, &t0)) + goto err; + + ret = vector_equal(&t1, &key->t1) && vector_equal(&t0, &key->t0); +err: + ossl_ml_dsa_ctx_free(ctx); + return ret; +} + +static int shake_xof(EVP_MD_CTX *ctx, const uint8_t *in, size_t in_len, + uint8_t *out, size_t out_len) +{ + return (EVP_DigestInit_ex2(ctx, NULL, NULL) == 1 + && EVP_DigestUpdate(ctx, in, in_len) == 1 + && EVP_DigestFinalXOF(ctx, out, out_len) == 1); +} + +/* + * @brief Generate a public-private key pair from a seed. + * See FIPS 204, Algorithm 6 ML-DSA.KeyGen_internal(). + * + * @param entropy The input seed + * @param entropy_len The size of entropy (Should be 32 bytes) + * + * + * @returns 1 on success or 0 on failure. + */ +static int keygen_internal(ML_DSA_CTX *ctx, const uint8_t *seed, size_t seed_len, + ML_DSA_KEY *out) +{ + int ret = 0; + uint8_t augmented_seed[ML_DSA_SEED_BYTES + 2]; + uint8_t expanded_seed[ML_DSA_RHO_BYTES + ML_DSA_PRIV_SEED_BYTES + ML_DSA_K_BYTES]; + const uint8_t *const rho = expanded_seed; /* p = Public Random Seed */ + const uint8_t *const priv_seed = expanded_seed + ML_DSA_RHO_BYTES; + const uint8_t *const K = priv_seed + ML_DSA_PRIV_SEED_BYTES; + const ML_DSA_PARAMS *params = ctx->params; + + /* augmented_seed = seed || k || l */ + memcpy(augmented_seed, seed, seed_len); + augmented_seed[ML_DSA_SEED_BYTES] = (uint8_t)params->k; + augmented_seed[ML_DSA_SEED_BYTES + 1] = (uint8_t)params->l; + /* Expand the seed into p[32], p'[64], K[32] */ + if (!shake_xof(ctx->h_ctx, augmented_seed, sizeof(augmented_seed), + expanded_seed, sizeof(expanded_seed))) + goto err; + + memcpy(out->rho, rho, sizeof(out->rho)); + memcpy(out->K, K, sizeof(out->K)); + + ret = ossl_ml_dsa_sample_expandS(ctx->h_ctx, params->eta, priv_seed, + &out->s1, &out->s2) + && public_from_private(ctx, out, &out->t1, &out->t0) + && ossl_ml_dsa_pk_encode(out) + && shake_xof(ctx->h_ctx, out->pub_encoding, out->params->pk_len, + out->tr, sizeof(out->tr)) + && ossl_ml_dsa_sk_encode(out); +err: + OPENSSL_cleanse(augmented_seed, sizeof(augmented_seed)); + OPENSSL_cleanse(expanded_seed, sizeof(expanded_seed)); + return ret; +} + +int ossl_ml_dsa_generate_key(ML_DSA_CTX *ctx, OSSL_LIB_CTX *lib_ctx, + const uint8_t *entropy, size_t entropy_len, + ML_DSA_KEY *out) +{ + int ret = 0; + uint8_t seed[32]; + size_t seed_len = sizeof(seed); + + if (ctx->params != out->params) + return 0; + + if (entropy != NULL && entropy_len != 0) { + if (entropy_len < seed_len) + goto err; + memcpy(seed, entropy, seed_len); + } else { + if (RAND_priv_bytes_ex(lib_ctx, seed, seed_len, 0) <= 0) + goto err; + } + ret = keygen_internal(ctx, seed, seed_len, out); +err: + OPENSSL_cleanse(seed, seed_len); + return ret; +} + +/** + * @brief This is used when a ML DSA key is used for an operation. + * This checks that the algorithm is the same (i.e. uses the same parameters) + * + * @param ctx Contains ML_DSA algorithm functions and constants to be used for + * an operation. + * @param key A ML_DSA key to use for an operation. + * + * @returns 1 if the algorithm matches, or 0 otherwise. + */ +int ossl_ml_dsa_key_type_matches(ML_DSA_CTX *ctx, const ML_DSA_KEY *key) +{ + return (key->params == ctx->params); +} + +/* Returns the public key data or NULL if there is no public key */ +const uint8_t *ossl_ml_dsa_key_get_pub(const ML_DSA_KEY *key) +{ + return key->pub_encoding; +} + +/* Returns the constant 2 * |n| which is the size of PK_SEED + PK_ROOT */ +size_t ossl_ml_dsa_key_get_pub_len(const ML_DSA_KEY *key) +{ + return key->params->pk_len; +} + +size_t ossl_ml_dsa_key_get_collision_strength_bits(const ML_DSA_KEY *key) +{ + return key->params->strength; +} + +/* Returns the private key data or NULL if there is no private key */ +const uint8_t *ossl_ml_dsa_key_get_priv(const ML_DSA_KEY *key) +{ + return key->priv_encoding; +} + +size_t ossl_ml_dsa_key_get_priv_len(const ML_DSA_KEY *key) +{ + return key->params->sk_len; +} + +size_t ossl_ml_dsa_key_get_sig_len(const ML_DSA_KEY *key) +{ + return key->params->sig_len; +} +void ossl_ml_dsa_key_set0_libctx(ML_DSA_KEY *key, OSSL_LIB_CTX *lib_ctx) +{ + key->libctx = lib_ctx; +} + +const char *ossl_ml_dsa_key_get_name(const ML_DSA_KEY *key) +{ + return key->params->alg; +} + +int ossl_ml_dsa_set_priv(ML_DSA_KEY *key, const uint8_t *priv, size_t priv_len) +{ + return 0; +} + +int ossl_ml_dsa_set_pub(ML_DSA_KEY *key, const uint8_t *pub, size_t pub_len) +{ + return 0; +} diff --git a/crypto/ml_dsa/ml_dsa_key.h b/crypto/ml_dsa/ml_dsa_key.h new file mode 100644 index 00000000000..c841da0987d --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_key.h @@ -0,0 +1,47 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include +#include "crypto/types.h" +#include "internal/refcount.h" +#include "ml_dsa_vector.h" + +struct ml_dsa_key_st { + + CRYPTO_REF_COUNT references; + OSSL_LIB_CTX *libctx; + const ML_DSA_PARAMS *params; + char *propq; + + uint8_t rho[ML_DSA_RHO_BYTES]; /* public random seed */ + uint8_t tr[ML_DSA_TR_BYTES]; /* Pre-cached public key Hash */ + uint8_t K[ML_DSA_K_BYTES]; /* Private random seed for signing */ + /* + * t0 is the Polynomial encoding of the 13 LSB of each coefficient of the + * uncompressed public key polynomial t. This is saved as part of the + * private key. It is column vector of K polynomials. + */ + VECTOR t0; + /* + * t1 is the Polynomial encoding of the 10 MSB of each coefficient of the + * uncompressed public key polynomial t. This is saved as part of the + * public key. It is column vector of K polynomials. + * (There are 23 bits in q-modulus.. i.e 10 bits = 23 - 13) + */ + VECTOR t1; + VECTOR s1; /* private secret of size L with short coefficients (-4..4) or (-2..2) */ + VECTOR s2; /* private secret of size K with short coefficients (-4..4) or (-2..2) */ + + /* + * The encoded public and private keys, these are non NULL if the key + * components are generated or loaded. + */ + uint8_t *pub_encoding; + uint8_t *priv_encoding; +}; diff --git a/crypto/ml_dsa/ml_dsa_key_compress.c b/crypto/ml_dsa/ml_dsa_key_compress.c new file mode 100644 index 00000000000..035475b885a --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_key_compress.c @@ -0,0 +1,149 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include "ml_dsa_local.h" + +/* Key Compression related functions (Rounding & hints) */ + +/** + * @brief Decompose r into (r1, r0) such that r == r1 * 2^13 + r0 mod q + * See FIPS 204, Algorithm 35, Power2Round() + * + * Note: that this code is more complex than the FIPS 204 spec since it keeps + * r0 as a positive number + * + * r mod +- 2^13 is defined as having a range of -4095..4096 + * + * i.e for r = 0..4096 r1 = 0 and r0 = 0..4096 + * at r = 4097..8191 r1 = 1 and r0 = -4095..0 + * (but since r0 is kept positive it effectively adds q and then reduces by q if needed) + * Similarly for the range r = 8192..8192+4096 r1=1 and r0=0..4096 + * & 12289..16383 r1=2 and r0=-4095..0 + * + * @param r is in the range 0..q-1 + * @param r1 The returned top 10 MSB (i.e it ranges from 0..1023) + * @param r0 The remainder in the range (0..4096 or q-4095..q-1) + * So r0 has an effective range of 8192 (i.e. 13 bits). + */ +void ossl_ml_dsa_key_compress_power2_round(uint32_t r, uint32_t *r1, uint32_t *r0) +{ + unsigned int mask; + uint32_t r0_adjusted, r1_adjusted; + + *r1 = r >> ML_DSA_D_BITS; /* top 13 bits */ + *r0 = r - (*r1 << ML_DSA_D_BITS); /* The remainder mod q */ + + r0_adjusted = mod_sub(*r0, 1 << ML_DSA_D_BITS); + r1_adjusted = *r1 + 1; + + /* Mask is set iff r0 > (2^(dropped_bits))/2. */ + mask = constant_time_lt((uint32_t)(1 << (ML_DSA_D_BITS - 1)), *r0); + /* r0 = mask ? r0_adjusted : r0 */ + *r0 = constant_time_select_int(mask, r0_adjusted, *r0); + /* r1 = mask ? r1_adjusted : r1 */ + *r1 = constant_time_select_int(mask, r1_adjusted, *r1); +} + +/* + * @brief return the r1 component of Decomposing r into (r1, r0) such that + * r == r1 * (2 & gamma) + r0 mod q + * See FIPS 204, Algorithm 37, HighBits() + * + * @param r A value to decompose in the range (0..q-1) + * @param gamma2 Depending on the algorithm gamma2 is either (q-1)/32 or (q-1)/88 + * @returns r1 + */ +uint32_t ossl_ml_dsa_key_compress_high_bits(uint32_t r, uint32_t gamma2) +{ + uint32_t r1 = (r + 127) >> 7; + + /* TODO - figure out what this is doing */ + if (gamma2 == ML_DSA_Q_MINUS1_DIV32) { + r1 = (r1 * 1025 + (1 << 21)) >> 22; + r1 &= 15; /* mod 16 */ + return r1; + } else { + r1 = (r1 * 11275 + (1 << 23)) >> 24; + r1 ^= ((43 - r1) >> 31) & r1; + return r1; + } +} + +/** + * TODO - document this + * See FIPS 204, Algorithm 36, Decompose() + */ +void ossl_ml_dsa_key_compress_decompose(uint32_t r, uint32_t gamma2, + uint32_t *r1, int32_t *r0) +{ + *r1 = ossl_ml_dsa_key_compress_high_bits(r, gamma2); + + *r0 = r - *r1 * 2 * (int32_t)gamma2; + *r0 -= (((int32_t)ML_DSA_Q_MINUS1_DIV2 - *r0) >> 31) & (int32_t)ML_DSA_Q; +} + +/** + * TODO - document this + * See FIPS 204, Algorithm 38, LowBits() + */ +int32_t ossl_ml_dsa_key_compress_low_bits(uint32_t r, uint32_t gamma2) +{ + uint32_t r1; + int32_t r0; + + ossl_ml_dsa_key_compress_decompose(r, gamma2, &r1, &r0); + return r0; +} + +/* + * See FIPS 204, Algorithm 39 (`MakeHint`). + * + * In the spec this takes two arguments, z and r, and is called with + * z = -ct0 + * r = w - cs2 + ct0 + * + * It then computes HighBits (algorithm 37) of z and z+r. + * But z+r is just w - cs2, so this takes three arguments and saves an addition. + */ +int32_t ossl_ml_dsa_key_compress_make_hint(uint32_t ct0, uint32_t cs2, + uint32_t gamma2, uint32_t w) +{ + uint32_t r_plus_z = mod_sub(w, cs2); + uint32_t r = reduce_once(r_plus_z + ct0); + + return ossl_ml_dsa_key_compress_high_bits(r, gamma2) + != ossl_ml_dsa_key_compress_high_bits(r_plus_z, gamma2); +} + +/* + * FIPS 204, Algorithm 40 (`UseHint`). + * This is not constant time + */ +uint32_t ossl_ml_dsa_key_compress_use_hint(uint32_t hint, uint32_t r, + uint32_t gamma2) +{ + uint32_t r1; + int32_t r0; + + ossl_ml_dsa_key_compress_decompose(r, gamma2, &r1, &r0); + + if (hint == 0) + return r1; + + if (gamma2 == ((ML_DSA_Q - 1) / 32)) { + /* m = 16, thus |mod m| in the spec turns into |& 15| */ + return r0 > 0 ? (r1 + 1) & 15 : (r1 - 1) & 15; + } else { + /* m = 44 if gamma2 = ((q - 1) / 88) */ + if (r1 > 0) + return (r1 == 43) ? 0 : r1 + 1; + else + return (r1 == 0) ? 43 : r1 - 1; + } +} diff --git a/crypto/ml_dsa/ml_dsa_local.h b/crypto/ml_dsa/ml_dsa_local.h new file mode 100644 index 00000000000..54e1d3b35a7 --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_local.h @@ -0,0 +1,110 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#ifndef OSSL_CRYPTO_ML_DSA_LOCAL_H +# define OSSL_CRYPTO_ML_DSA_LOCAL_H + +# include "crypto/ml_dsa.h" +# include "internal/constant_time.h" + +/* Maximimum size of the 'A' matrix */ +# define ML_DSA_K_MAX 8 +# define ML_DSA_L_MAX 7 + +# define ML_DSA_SEED_BYTES 32 +# define ML_DSA_Q 8380417 /* The modulus is 23 bits (2^23 - 2^13 + 1) */ +# define ML_DSA_Q_MINUS1_DIV2 ((ML_DSA_Q - 1) / 2) +# define ML_DSA_Q_MINUS1_DIV32 ((ML_DSA_Q - 1) / 32) +# define ML_DSA_Q_BITS 23 +# define ML_DSA_Q_INV 58728449 /* q^-1 satisfies: q^-1 * q = 1 mod 2^32 */ +# define ML_DSA_Q_NEG_INV 4236238847 /* Inverse of -q modulo 2^32 */ +# define ML_DSA_DEGREE_INV_MONTGOMERY 41978 /* Inverse of 256 mod q, in Montgomery form. */ + +# define ML_DSA_D_BITS 13 /* The number of bits dropped from t */ +# define ML_DSA_NUM_POLY_COEFFICIENTS 256 /* The number of coefficients in the polynomials */ +# define ML_DSA_RHO_BYTES 32 /* p = Public Random Seed */ +# define ML_DSA_PRIV_SEED_BYTES 64 /* p' = Private random seed */ +# define ML_DSA_K_BYTES 32 /* K = Private random seed for signing */ +# define ML_DSA_TR_BYTES 64 /* Hash of public key used for signing */ +# define ML_DSA_MU_BYTES 64 +# define ML_DSA_RHO_PRIME_BYTES 64 + +typedef struct ml_dsa_params_st ML_DSA_PARAMS; +typedef struct poly_st POLY; +typedef struct vector_st VECTOR; +typedef struct matrix_st MATRIX; + +/* + * FIPS 204 ML-DSA algorithms have different parameters which includes: + * - A set of constants (Section 4. contains 3 parameter sets) + * + * - OpenSSL also uses pre-fetched EVP_MD_CTX objects for Hashing purposes. + * + * ML_DSA_CTX is a container to hold all these objects. This object is + * resolved early and is then passed to most ML-DSA related functions. + */ +struct ml_dsa_ctx_st { + const ML_DSA_PARAMS *params; + EVP_MD_CTX *h_ctx; /* SHAKE-256 */ + EVP_MD_CTX *g_ctx; /* SHAKE-128 */ +}; + +int ossl_ml_dsa_sample_expandA(EVP_MD_CTX *g_ctx, const uint8_t *rho, MATRIX *out); +int ossl_ml_dsa_sample_expandS(EVP_MD_CTX *h_ctx, int eta, const uint8_t *seed, + VECTOR *s1, VECTOR *s2); +void ossl_ml_dsa_poly_ntt(POLY *s); +void ossl_ml_dsa_poly_ntt_inverse(POLY *s); +void ossl_ml_dsa_poly_ntt_mult(const POLY *lhs, const POLY *rhs, POLY *out); + +void ossl_ml_dsa_key_compress_power2_round(uint32_t r, uint32_t *r1, uint32_t *r0); +uint32_t ossl_ml_dsa_key_compress_high_bits(uint32_t r, uint32_t gamma2); +void ossl_ml_dsa_key_compress_decompose(uint32_t r, uint32_t gamma2, + uint32_t *r1, int32_t *r0); +void ossl_ml_dsa_key_compress_decompose(uint32_t r, uint32_t gamma2, + uint32_t *r1, int32_t *r0); +int32_t ossl_ml_dsa_key_compress_low_bits(uint32_t r, uint32_t gamma2); +int32_t ossl_ml_dsa_key_compress_make_hint(uint32_t ct0, uint32_t cs2, + uint32_t gamma2, uint32_t w); +uint32_t ossl_ml_dsa_key_compress_use_hint(uint32_t hint, uint32_t r, + uint32_t gamma2); + +int ossl_ml_dsa_pk_encode(ML_DSA_KEY *key); +int ossl_ml_dsa_pk_decode(const uint8_t *in, size_t in_len, ML_DSA_KEY *key); +int ossl_ml_dsa_sk_encode(ML_DSA_KEY *key); +int ossl_ml_dsa_sk_decode(const uint8_t *in, size_t in_len, ML_DSA_KEY *key); + +/* + * @brief Reduces x mod q in constant time + * i.e. return x < q ? x : x - q; + * + * @param x Where x is assumed to be in the range 0 <= x < 2*q + * @returns the difference in the range 0..q-1 + */ +static ossl_inline ossl_unused uint32_t reduce_once(uint32_t x) +{ + return constant_time_select_32(constant_time_lt(x, ML_DSA_Q), x, x - ML_DSA_Q); +} + +/* + * @brief Calculate The positive value of (a-b) mod q in constant time. + * + * a - b mod q gives a value in the range -(q-1)..(q-1) + * By adding q we get a range of 1..(2q-1). + * Reducing this once then gives the range 0..q-1 + * + * @param a The minuend assumed to be in the range 0..q-1 + * @param b The subtracthend assumed to be in the range 0..q-1. + * @returns The value (q + a - b) mod q + */ +static ossl_inline ossl_unused uint32_t mod_sub(uint32_t a, uint32_t b) +{ + return reduce_once(ML_DSA_Q + a - b); +} + +#endif /* OSSL_CRYPTO_ML_DSA_LOCAL_H */ diff --git a/crypto/ml_dsa/ml_dsa_matrix.c b/crypto/ml_dsa/ml_dsa_matrix.c new file mode 100644 index 00000000000..88c6be3bbb1 --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_matrix.c @@ -0,0 +1,38 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include "ml_dsa_local.h" +#include "ml_dsa_vector.h" +#include "ml_dsa_matrix.h" + +/* + * Matrix multiply of a k*l matrix of polynomials by a 1 * l vector of + * polynomials to produce a 1 * k vector of polynomial results. + * i.e. t = a * s + * + * @param a A k * l matrix of polynomials in NTT form + * @param s A 1 * l vector of polynomials in NTT form + * @param t 1 * k vector of polynomial results in NTT form + */ +void ossl_ml_dsa_matrix_mult_vector(const MATRIX *a, const VECTOR *s, + VECTOR *t) +{ + size_t i, j; + + vector_zero(t); + + for (i = 0; i < a->k; i++) { + for (j = 0; j < a->l; j++) { + POLY product; + + ossl_ml_dsa_poly_ntt_mult(&a->m_poly[i][j], &s->poly[j], &product); + poly_add(&product, &t->poly[i], &t->poly[i]); + } + } +} diff --git a/crypto/ml_dsa/ml_dsa_matrix.h b/crypto/ml_dsa/ml_dsa_matrix.h new file mode 100644 index 00000000000..759a69bc71f --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_matrix.h @@ -0,0 +1,24 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +/* A 'k' by 'l' Matrix object ('k' rows and 'l' columns) containing polynomial entries */ +struct matrix_st { + POLY m_poly[ML_DSA_K_MAX][ML_DSA_L_MAX]; + size_t k, l; +}; + +static ossl_inline ossl_unused void +matrix_init(MATRIX *m, size_t k, size_t l) +{ + m->k = k; + m->l = l; +} + +void ossl_ml_dsa_matrix_mult_vector(const MATRIX *matrix_kl, const VECTOR *vl, + VECTOR *vk); diff --git a/crypto/ml_dsa/ml_dsa_ntt.c b/crypto/ml_dsa/ml_dsa_ntt.c new file mode 100644 index 00000000000..a79b058906d --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_ntt.c @@ -0,0 +1,197 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include "ml_dsa_local.h" +#include "ml_dsa_poly.h" + +/* + * This file has multiple parts required for fast matrix multiplication, + * 1) NTT (See https://eprint.iacr.org/2024/585.pdf) + * NTT and NTT inverse transformations are Discrete Fourier Transforms in a + * polynomial ring. Fast-Fourier Transformations can then be applied to make + * multiplications n log(n). This uses the symmetry of the transformation to + * reduce computations. + * + * 2) Montgomery multiplication + * The multiplication of a.b mod q requires division by q which is a slow operation. + * + * When many multiplications mod q are required montgomery multiplication + * can be used. This requires a number R > N such that R & N are coprime + * (i.e. GCD(N, R) = 1), so that division happens using R instead of q. + * If r is a power of 2 then this division can be done as a bit shift. + * + * Given that q = 2^23 - 2^13 + 1 + * We can chose a Montgomery multiplier of R = 2^32. + * + * To transform a into montgomery form m + * m = a mod q * ((2^32)*(2^32) mod q) + */ + +/* + * The table in FIPS 204 Appendix B uses the following formula + * zeta[k]= 1753^bitrev(k) mod q for (k = 1..255) (The first value is not used). + * + * As this implementation uses montgomery form with a multiplier of 2^32. + * The values need to be transformed i.e. + * + * zetasMontgomery[k] = reduce_montgomery(zeta[k] * (2^32 * 2^32 mod(q))) + * reduce_montgomery() is defined below.. + */ +static const uint32_t zetas_montgomery[256] = { + 4193792, 25847, 5771523, 7861508, 237124, 7602457, 7504169, 466468, + 1826347, 2353451, 8021166, 6288512, 3119733, 5495562, 3111497, 2680103, + 2725464, 1024112, 7300517, 3585928, 7830929, 7260833, 2619752, 6271868, + 6262231, 4520680, 6980856, 5102745, 1757237, 8360995, 4010497, 280005, + 2706023, 95776, 3077325, 3530437, 6718724, 4788269, 5842901, 3915439, + 4519302, 5336701, 3574422, 5512770, 3539968, 8079950, 2348700, 7841118, + 6681150, 6736599, 3505694, 4558682, 3507263, 6239768, 6779997, 3699596, + 811944, 531354, 954230, 3881043, 3900724, 5823537, 2071892, 5582638, + 4450022, 6851714, 4702672, 5339162, 6927966, 3475950, 2176455, 6795196, + 7122806, 1939314, 4296819, 7380215, 5190273, 5223087, 4747489, 126922, + 3412210, 7396998, 2147896, 2715295, 5412772, 4686924, 7969390, 5903370, + 7709315, 7151892, 8357436, 7072248, 7998430, 1349076, 1852771, 6949987, + 5037034, 264944, 508951, 3097992, 44288, 7280319, 904516, 3958618, + 4656075, 8371839, 1653064, 5130689, 2389356, 8169440, 759969, 7063561, + 189548, 4827145, 3159746, 6529015, 5971092, 8202977, 1315589, 1341330, + 1285669, 6795489, 7567685, 6940675, 5361315, 4499357, 4751448, 3839961, + 2091667, 3407706, 2316500, 3817976, 5037939, 2244091, 5933984, 4817955, + 266997, 2434439, 7144689, 3513181, 4860065, 4621053, 7183191, 5187039, + 900702, 1859098, 909542, 819034, 495491, 6767243, 8337157, 7857917, + 7725090, 5257975, 2031748, 3207046, 4823422, 7855319, 7611795, 4784579, + 342297, 286988, 5942594, 4108315, 3437287, 5038140, 1735879, 203044, + 2842341, 2691481, 5790267, 1265009, 4055324, 1247620, 2486353, 1595974, + 4613401, 1250494, 2635921, 4832145, 5386378, 1869119, 1903435, 7329447, + 7047359, 1237275, 5062207, 6950192, 7929317, 1312455, 3306115, 6417775, + 7100756, 1917081, 5834105, 7005614, 1500165, 777191, 2235880, 3406031, + 7838005, 5548557, 6709241, 6533464, 5796124, 4656147, 594136, 4603424, + 6366809, 2432395, 2454455, 8215696, 1957272, 3369112, 185531, 7173032, + 5196991, 162844, 1616392, 3014001, 810149, 1652634, 4686184, 6581310, + 5341501, 3523897, 3866901, 269760, 2213111, 7404533, 1717735, 472078, + 7953734, 1723600, 6577327, 1910376, 6712985, 7276084, 8119771, 4546524, + 5441381, 6144432, 7959518, 6094090, 183443, 7403526, 1612842, 4834730, + 7826001, 3919660, 8332111, 7018208, 3937738, 1400424, 7534263, 1976782 +}; + +/* + * @brief When multiplying 2 numbers mod q that are in montgomery form, the + * product mod q needs to be multiplied by 2^-32 to be in montgomery form. + * See FIPS 204, Algorithm 49, MontgomeryReduce() + * Note it is slightly different due to the input range being positive + * + * @param a is the result of a multiply of 2 numbers in montgomery form, + * in the range 0...(2^32)*q + * @returns The Montgomery form of 'a' with multiplier 2^32 in the range 0..q-1 + * The result is congruent to x * 2^-32 mod q + */ +static uint32_t reduce_montgomery(uint64_t a) +{ + uint64_t t = (uint32_t)a * (uint32_t)ML_DSA_Q_NEG_INV; /* a * -qinv */ + uint64_t b = a + t * ML_DSA_Q; /* a - t * q */ + uint32_t c = b >> 32; /* /2^32 = 0..2q */ + + return reduce_once(c); /* 0..q */ +} + +/* + * @brief Multiply two polynomials in the number theoretically transformed state. + * See FIPS 204, Algorithm 45, MultiplyNTT() + * This function has been modified to use montgomery multiplication + * + * @param lhs A polynomial multiplicand + * @param rhs A polynomial multiplier + * @param out The returned result of the polynomial multiply + */ +void ossl_ml_dsa_poly_ntt_mult(const POLY *lhs, const POLY *rhs, POLY *out) +{ + int i; + + for (i = 0; i < ML_DSA_NUM_POLY_COEFFICIENTS; i++) + out->coeff[i] = + reduce_montgomery((uint64_t)lhs->coeff[i] * (uint64_t)rhs->coeff[i]); +} + +/* + * In place number theoretic transform of a given polynomial. + * + * See FIPS 204, Algorithm 41, NTT() + * This function uses montgomery multiplication. + * + * @param p a polynomial that is used as the input, that is replaced with + * the NTT of the polynomial + */ +void ossl_ml_dsa_poly_ntt(POLY *p) +{ + int i, j, k; + int step; + int offset = ML_DSA_NUM_POLY_COEFFICIENTS; + + /* Step: 1, 2, 4, 8, ..., 128 */ + for (step = 1; step < ML_DSA_NUM_POLY_COEFFICIENTS; step <<= 1) { + k = 0; + offset >>= 1; /* Offset: 128, 64, 32, 16, ..., 1 */ + for (i = 0; i < step; i++) { + const uint32_t z_step_root = zetas_montgomery[step + i]; + + for (j = k; j < k + offset; j++) { + uint32_t w_even = p->coeff[j]; + uint32_t t_odd = + reduce_montgomery((uint64_t)z_step_root + * (uint64_t)p->coeff[j + offset]); + + p->coeff[j] = reduce_once(w_even + t_odd); + p->coeff[j + offset] = mod_sub(w_even, t_odd); + } + k += 2 * offset; + } + } +} + +/* + * @brief In place inverse number theoretic transform of a given polynomial. + * See FIPS 204, Algorithm 42, NTT^-1() + * + * @param p a polynomial that is used as the input, that is overwritten with + * the inverse of the NTT. + */ +void ossl_ml_dsa_poly_ntt_inverse(POLY *p) +{ + /* + * Step: 128, 64, 32, 16, ..., 1 + * Offset: 1, 2, 4, 8, ..., 128 + */ + int i, j, k, offset, step = ML_DSA_NUM_POLY_COEFFICIENTS; + /* + * The multiplicative inverse of 256 mod q, in Montgomery form is + * ((256^-1 mod q) * ((2^32 * 2^32) mod q)) mod q = (8347681 * 2365951) mod 8380417 + */ + static const uint32_t inverse_degree_montgomery = 41978; + + for (offset = 1; offset < ML_DSA_NUM_POLY_COEFFICIENTS; offset <<= 1) { + step >>= 1; + k = 0; + for (i = 0; i < step; i++) { + const uint32_t step_root = + ML_DSA_Q - zetas_montgomery[step + (step - 1 - i)]; + + for (j = k; j < k + offset; j++) { + uint32_t even = p->coeff[j]; + uint32_t odd = p->coeff[j + offset]; + + p->coeff[j] = reduce_once(odd + even); + p->coeff[j + offset] = + reduce_montgomery((uint64_t)step_root + * (uint64_t)(ML_DSA_Q + even - odd)); + } + k += 2 * offset; + } + } + for (i = 0; i < ML_DSA_NUM_POLY_COEFFICIENTS; i++) + p->coeff[i] = reduce_montgomery((uint64_t)p->coeff[i] * + (uint64_t)inverse_degree_montgomery); +} diff --git a/crypto/ml_dsa/ml_dsa_params.c b/crypto/ml_dsa/ml_dsa_params.c new file mode 100644 index 00000000000..63b50c6d2cf --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_params.c @@ -0,0 +1,39 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ +#include +#include +#include "ml_dsa_local.h" +#include "ml_dsa_params.h" + +/* + * See FIPS 204 Section 4 Table 1 & Table 2 + * tau strength gamma1 k l eta beta omega sc sklen pklen siglen + */ +#define OSSL_ML_DSA_65 49, 192, 1 << 19, 6, 5, 4, 196, 55, 3, 4032, 1952, 3309 + +static const ML_DSA_PARAMS ml_dsa_params[] = { + {"ML-DSA-65", OSSL_ML_DSA_65}, + {NULL}, +}; + +/** + * @brief A getter to convert an algorithm name into a ML_DSA_PARAMS object + */ +const ML_DSA_PARAMS *ossl_ml_dsa_params_get(const char *alg) +{ + const ML_DSA_PARAMS *p; + + if (alg == NULL) + return NULL; + for (p = ml_dsa_params; p->alg != NULL; ++p) { + if (strcmp(p->alg, alg) == 0) + return p; + } + return NULL; +} diff --git a/crypto/ml_dsa/ml_dsa_params.h b/crypto/ml_dsa/ml_dsa_params.h new file mode 100644 index 00000000000..1645735ef00 --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_params.h @@ -0,0 +1,31 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include + +/* + * Refer to FIPS 204 Section 4 Parameter sets. + * Fields that are shared between all algorithms (such as q & d) have been omitted. + */ +struct ml_dsa_params_st { + const char *alg; + int tau; /* Number of +/-1's in polynomial c */ + int strength; /* The collision strength */ + int gamma1; /* coefficient range of y */ + size_t k, l; /* matrix dimensions of 'A' */ + int eta; /* Private key range */ + int beta; /* tau * eta */ + int omega; /* Number of 1's in the hint 'h' */ + int security_category; /* Category is related to Security strength */ + size_t sk_len; /* private key size */ + size_t pk_len; /* public key size */ + size_t sig_len; /* signature size */ +}; + +const struct ml_dsa_params_st *ossl_ml_dsa_params_get(const char *alg); diff --git a/crypto/ml_dsa/ml_dsa_poly.h b/crypto/ml_dsa/ml_dsa_poly.h new file mode 100644 index 00000000000..734bfb9b1e4 --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_poly.h @@ -0,0 +1,80 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ +#include + +#define ML_DSA_NUM_POLY_COEFFICIENTS 256 + +/* Polynomial object with 256 coefficients. The coefficients are unsigned 32 bits */ +struct poly_st { + uint32_t coeff[ML_DSA_NUM_POLY_COEFFICIENTS]; +}; + +/** + * @brief Polynomial addition. + * + * @param lhs A polynomial with coefficients in the range (0..q-1) + * @param rhs A polynomial with coefficients in the range (0..q-1) to add + * to the 'lhs'. + * @param out The returned addition result with the coefficients all in the + * range 0..q-1 + */ +static ossl_inline ossl_unused void +poly_add(const POLY *lhs, const POLY *rhs, POLY *out) +{ + int i; + + for (i = 0; i < ML_DSA_NUM_POLY_COEFFICIENTS; i++) + out->coeff[i] = reduce_once(lhs->coeff[i] + rhs->coeff[i]); +} + +/** + * @brief Polynomial subtraction. + * + * @param lhs A polynomial with coefficients in the range (0..q-1) + * @param rhs A polynomial with coefficients in the range (0..q-1) to subtract + * from the 'lhs'. + * @param out The returned subtraction result with the coefficients all in the + * range 0..q-1 + */ +static ossl_inline ossl_unused void +poly_sub(const POLY *lhs, const POLY *rhs, POLY *out) +{ + int i; + + for (i = 0; i < ML_DSA_NUM_POLY_COEFFICIENTS; i++) + out->coeff[i] = mod_sub(lhs->coeff[i], rhs->coeff[i]); +} + +/* @returns 1 if the polynomials are equal, or 0 otherwise */ +static ossl_inline ossl_unused int +poly_equal(const POLY *a, const POLY *b) +{ + return CRYPTO_memcmp(a, b, sizeof(*a)) == 0; +} + +/** + * @brief Decompose the coefficients of a polynomial into (r1, r0) such that + * coeff[i] == t1[i] * 2^13 + t0[i] mod q + * See FIPS 204, Algorithm 35, Power2Round() + * + * @param t A polynomial containing coefficients in the range 0..q-1 + * @param t1 The returned polynomial containing coefficients that represent + * the top 10 MSB of each coefficient in t (i.e each ranging from 0..1023) + * @param t0 The remainder coefficients of t in the range (0..4096 or q-4095..q-1) + * Each t0 coefficient has an effective range of 8192 (i.e. 13 bits). + */ +static ossl_inline ossl_unused void +poly_power2_round(const POLY *t, POLY *t1, POLY *t0) +{ + int i; + + for (i = 0; i < ML_DSA_NUM_POLY_COEFFICIENTS; i++) + ossl_ml_dsa_key_compress_power2_round(t->coeff[i], + &t1->coeff[i], &t0->coeff[i]); +} diff --git a/crypto/ml_dsa/ml_dsa_sample.c b/crypto/ml_dsa/ml_dsa_sample.c new file mode 100644 index 00000000000..74abdd5d67a --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_sample.c @@ -0,0 +1,262 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include +#include "ml_dsa_local.h" +#include "ml_dsa_vector.h" +#include "ml_dsa_matrix.h" + +#define SHAKE128_BLOCKSIZE 168 +#define SHAKE256_BLOCKSIZE 136 + +typedef int (COEFF_FROM_NIBBLE_FUNC)(uint32_t nibble, uint32_t *out); + +static COEFF_FROM_NIBBLE_FUNC coeff_from_nibble_4; +static COEFF_FROM_NIBBLE_FUNC coeff_from_nibble_2; + +/** + * @brief Combine 3 bytes to form an coefficient. + * See FIPS 204, Algorithm 14, CoeffFromThreeBytes() + * + * This is not constant time as it is used to generate the matrix A which is public. + * + * @param s A byte array of 3 uniformly distributed bytes. + * @param out The returned coefficient in the range 0..q-1. + * @returns 1 if the value is less than q or 0 otherwise. + * This is used for rejection sampling. + */ +static ossl_inline int coeff_from_three_bytes(const uint8_t *s, uint32_t *out) +{ + /* Zero out the top bit of the 3rd byte to get a value in the range 0..2^23-1) */ + *out = (uint32_t)s[0] | ((uint32_t)s[1] << 8) | (((uint32_t)s[2] & 0x7f) << 16); + return *out < ML_DSA_Q; +} + +/** + * @brief Generate a value in the range (q-4..0..4) + * See FIPS 204, Algorithm 15, CoeffFromHalfByte() where eta = 4 + * Note the FIPS 204 code uses the range -4..4 (whereas this code adds q to the + * negative numbers). + * + * @param nibble A value in the range 0..15 + * @param out The returned value if the range (q-4)..0..4 if nibble is < 9 + * @returns 1 nibble was in range, or 0 if the nibble was rejected. + */ +static ossl_inline int coeff_from_nibble_4(uint32_t nibble, uint32_t *out) +{ + /* + * This is not constant time but will not leak any important info since + * the value is either chosen or thrown away. + */ + if (value_barrier_32(nibble < 9)) { + *out = mod_sub(4, nibble); + return 1; + } + return 0; +} + +/** + * @brief Generate a value in the range (q-2..0..2) + * See FIPS 204, Algorithm 15, CoeffFromHalfByte() where eta = 2 + * Note the FIPS 204 code uses the range -2..2 (whereas this code adds q to the + * negative numbers). + * + * @param nibble A value in the range 0..15 + * @param out The returned value if the range (q-2)..0..2 if nibble is < 15 + * @returns 1 nibble was in range, or 0 if the nibble was rejected. + */ +static ossl_inline int coeff_from_nibble_2(uint32_t nibble, uint32_t *out) +{ + if (value_barrier_32(nibble < 15)) { + *out = mod_sub(2, nibble % 5); + return 1; + } + return 0; +} + +/** + * @brief Use a seed value to generate a polynomial with coefficients in the + * range of 0..q-1 using rejection sampling. + * SHAKE128 is used to absorb the seed, and then sequences of 3 sample bytes are + * squeezed to try to produce coefficients. + * The SHAKE128 stream is used to get uniformly distributed elements. + * This algorithm is used for matrix expansion and only operates on public inputs. + * + * See FIPS 204, Algorithm 30, RejNTTPoly() + * + * @param g_ctx A pre-fetched SHAKE128 context used for sampling the seed. + * @param seed The seed to use for sampling. + * @param seed_len The size of |seed| + * @param out The returned polynomial with coefficients in the range of + * 0..q-1. This range is required for NTT. + * @returns 1 if the polynomial was successfully generated, or 0 if any of the + * digest operations failed. + */ +static int rej_ntt_poly(EVP_MD_CTX *g_ctx, + const uint8_t *seed, size_t seed_len, POLY *out) +{ + int j = 0; + uint8_t blocks[SHAKE128_BLOCKSIZE], *b, *end = blocks + sizeof(blocks); + + if (EVP_DigestInit_ex2(g_ctx, NULL, NULL) != 1 + || EVP_DigestUpdate(g_ctx, seed, seed_len) != 1) + return 0; + + while (1) { + /* + * Instead of just squeezing 3 bytes at a time, we grab a whole block + * Note that the shake128 blocksize of 168 is divisible by 3. + */ + if (!EVP_DigestSqueeze(g_ctx, blocks, sizeof(blocks))) + return 0; + for (b = blocks; b < end; b += 3) { + if (coeff_from_three_bytes(b, &(out->coeff[j]))) { + if (++j >= ML_DSA_NUM_POLY_COEFFICIENTS) + return 1; /* finished */ + } + } + } +} + +/** + * @brief Use a seed value to generate a polynomial with coefficients in the + * range of ((q-eta)..0..eta) using rejection sampling. eta is either 2 or 4. + * SHAKE256 is used to absorb the seed, and then samples are squeezed. + * See FIPS 204, Algorithm 31, RejBoundedPoly() + * + * @param h_ctx A pre-fetched SHAKE256 context used for sampling the seed. + * @param coef_from_nibble A function that is dependent on eta, which takes a + * nibble and tries to see if it is in the correct range. + * @param seed The seed to use for sampling. + * @param seed_len The size of |seed| + * @param out The returned polynomial with coefficients in the range of + * ((q-eta)..0..eta) + * @returns 1 if the polynomial was successfully generated, or 0 if any of the + * digest operations failed. + */ +static int rej_bounded_poly(EVP_MD_CTX *h_ctx, + COEFF_FROM_NIBBLE_FUNC *coef_from_nibble, + const uint8_t *seed, size_t seed_len, POLY *out) +{ + int j = 0; + uint32_t z0, z1; + uint8_t blocks[SHAKE256_BLOCKSIZE], *b, *end = blocks + sizeof(blocks); + + if (EVP_DigestInit_ex2(h_ctx, NULL, NULL) != 1 + || EVP_DigestUpdate(h_ctx, seed, seed_len) != 1) + return 0; + + while (1) { + /* Instead of just squeezing 1 byte at a time, we grab a whole block */ + if (!EVP_DigestSqueeze(h_ctx, blocks, sizeof(blocks))) + return 0; + for (b = blocks; b < end; b++) { + z0 = *b & 0x0F; /* lower nibble of byte */ + z1 = *b >> 4; /* high nibble of byte */ + + if (coef_from_nibble(z0, &out->coeff[j]) + && ++j >= ML_DSA_NUM_POLY_COEFFICIENTS) + return 1; + if (coef_from_nibble(z1, &out->coeff[j]) + && ++j >= ML_DSA_NUM_POLY_COEFFICIENTS) + return 1; + } + } +} + +/** + * @brief Generate a k * l matrix that has uniformly distributed polynomial + * elements using rejection sampling. + * See FIPS 204, Algorithm 32, ExpandA() + * + * @param g_ctx A pre-fetched SHAKE128 context used for rejection sampling + * seed values generated from the seed rho. + * @param rho A 32 byte seed to generated the matrix from. + * @param out The generated k * l matrix of polynomials with coefficients + * in the range of 0..q-1. + * @returns 1 if the matrix was generated, or 0 on error. + */ +int ossl_ml_dsa_sample_expandA(EVP_MD_CTX *g_ctx, const uint8_t *rho, + MATRIX *out) +{ + int ret = 0; + size_t i, j; + uint8_t derived_seed[ML_DSA_RHO_BYTES + 2]; + + /* The seed used for each matrix element is rho + column_index + row_index */ + memcpy(derived_seed, rho, ML_DSA_RHO_BYTES); + + for (i = 0; i < out->k; i++) { + for (j = 0; j < out->l; j++) { + derived_seed[ML_DSA_RHO_BYTES + 1] = (uint8_t)i; + derived_seed[ML_DSA_RHO_BYTES] = (uint8_t)j; + /* Generate the polynomial for each matrix element using a unique seed */ + if (!rej_ntt_poly(g_ctx, derived_seed, sizeof(derived_seed), + &out->m_poly[i][j])) + goto err; + } + } + ret = 1; +err: + return ret; +} + +/** + * @brief Generates 2 vectors using rejection sampling whose polynomial + * coefficients are in the interval [q-eta..0..eta] + * + * See FIPS 204, Algorithm 33, ExpandS(). + * Note that in FIPS 204 the range -eta..eta is used. + * + * @param h_ctx A pre-fetched SHAKE256 context used for sampling the seed. + * @param eta Is either 2 or 4, and determines the range of the coefficients for + * s1 and s2. + * @param seed A 64 byte seed to use for sampling. + * @param s1 A 1 * l column vector containing polynomials with coefficients in + * the range (q-eta)..0..eta + * @param s2 A 1 * k column vector containing polynomials with coefficients in + * the range (q-eta)..0..eta + * @returns 1 if s1 and s2 were successfully generated, or 0 otherwise. + */ +int ossl_ml_dsa_sample_expandS(EVP_MD_CTX *h_ctx, int eta, const uint8_t *seed, + VECTOR *s1, VECTOR *s2) +{ + int ret = 0; + size_t i; + size_t l = s1->num_poly; + size_t k = s2->num_poly; + uint8_t derived_seed[ML_DSA_PRIV_SEED_BYTES + 2]; + COEFF_FROM_NIBBLE_FUNC *coef_from_nibble_fn; + + coef_from_nibble_fn = (eta == 4) ? coeff_from_nibble_4 : coeff_from_nibble_2; + + /* + * Each polynomial generated uses a unique seed that consists of + * seed + counter (where the counter is 2 bytes starting at 0) + */ + memcpy(derived_seed, seed, ML_DSA_PRIV_SEED_BYTES); + derived_seed[ML_DSA_PRIV_SEED_BYTES] = 0; + derived_seed[ML_DSA_PRIV_SEED_BYTES + 1] = 0; + + for (i = 0; i < l; i++) { + if (!rej_bounded_poly(h_ctx, coef_from_nibble_fn, + derived_seed, sizeof(derived_seed), &s1->poly[i])) + goto err; + ++derived_seed[ML_DSA_PRIV_SEED_BYTES]; + } + for (i = 0; i < k; i++) { + if (!rej_bounded_poly(h_ctx, coef_from_nibble_fn, + derived_seed, sizeof(derived_seed), &s2->poly[i])) + goto err; + ++derived_seed[ML_DSA_PRIV_SEED_BYTES]; + } + ret = 1; +err: + return ret; +} diff --git a/crypto/ml_dsa/ml_dsa_vector.h b/crypto/ml_dsa/ml_dsa_vector.h new file mode 100644 index 00000000000..c21122add18 --- /dev/null +++ b/crypto/ml_dsa/ml_dsa_vector.h @@ -0,0 +1,117 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include "ml_dsa_poly.h" + +/* Either a 1 * l column vector or a k * 1 row vector of polynomial entries */ +struct vector_st { + POLY poly[ML_DSA_K_MAX]; + size_t num_poly; /* Either k or l */ +}; + +/* @brief Set the number of polynomial elements that will be present in the vector */ +static ossl_inline ossl_unused +void vector_init(VECTOR *v, size_t num_polys) +{ + v->num_poly = num_polys; +} + +/* @brief zeroize a vectors polynomial coefficients */ +static ossl_inline ossl_unused +void vector_zero(VECTOR *va) +{ + memset(va->poly, 0, va->num_poly * sizeof(va->poly[0])); +} + +/* @brief add 2 vectors */ +static ossl_inline ossl_unused void +vector_add(const VECTOR *lhs, const VECTOR *rhs, VECTOR *out) +{ + size_t i; + + for (i = 0; i < lhs->num_poly; i++) + poly_add(&lhs->poly[i], &rhs->poly[i], &out->poly[i]); +} + +/* @brief subtract 2 vectors */ +static ossl_inline ossl_unused void +vector_sub(const VECTOR *lhs, const VECTOR *rhs, VECTOR *out) +{ + size_t i; + + for (i = 0; i < lhs->num_poly; i++) + poly_sub(&lhs->poly[i], &rhs->poly[i], &out->poly[i]); +} + +/* @brief multiply a vector by a polynomial */ +static ossl_inline ossl_unused void +vector_ntt_mult_poly(const VECTOR *lhs, const POLY *rhs, VECTOR *out) +{ + size_t i; + + for (i = 0; i < lhs->num_poly; i++) + ossl_ml_dsa_poly_ntt_mult(&lhs->poly[i], rhs, &out->poly[i]); +} + +/* @brief copy a vector */ +static ossl_inline ossl_unused void +vector_copy(VECTOR *dst, const VECTOR *src) +{ + dst->num_poly = src->num_poly; + memcpy(dst->poly, src->poly, sizeof(src->poly)); +} + +/* @brief return 1 if 2 vectors are equal, or 0 otherwise */ +static ossl_inline ossl_unused int +vector_equal(const VECTOR *a, const VECTOR *b) +{ + size_t i; + + if (a->num_poly != b->num_poly) + return 0; + for (i = 0; i < a->num_poly; ++i) { + if (!poly_equal(a->poly + i, b->poly + i)) + return 0; + } + return 1; +} + +/* @brief convert a vector in place into NTT form */ +static ossl_inline ossl_unused void +vector_ntt(VECTOR *va) +{ + size_t i; + + for (i = 0; i < va->num_poly; i++) + ossl_ml_dsa_poly_ntt(&va->poly[i]); +} + +/* @brief convert a vector in place into inverse NTT form */ +static ossl_inline ossl_unused void +vector_ntt_inverse(VECTOR *va) +{ + size_t i; + + for (i = 0; i < va->num_poly; i++) + ossl_ml_dsa_poly_ntt_inverse(&va->poly[i]); +} + +/* + * @brief Decompose all polynomial coefficients of a vector into (t1, t0) such + * that coeff[i] == t1[i] * 2^13 + t0[i] mod q. + * See FIPS 204, Algorithm 35, Power2Round() + */ +static ossl_inline ossl_unused void +vector_power2_round(const VECTOR *t, VECTOR *t1, VECTOR *t0) +{ + size_t i; + + for (i = 0; i < t->num_poly; i++) + poly_power2_round(&t->poly[i], &t1->poly[i], &t0->poly[i]); +} diff --git a/include/crypto/ml_dsa.h b/include/crypto/ml_dsa.h new file mode 100644 index 00000000000..124e65441d0 --- /dev/null +++ b/include/crypto/ml_dsa.h @@ -0,0 +1,55 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +/* Internal ML_DSA functions for other submodules, not for application use */ + +#ifndef OSSL_CRYPTO_ML_DSA_H +# define OSSL_CRYPTO_ML_DSA_H + +# pragma once +# include +# include +# include "crypto/types.h" + +# define ML_DSA_MAX_CONTEXT_STRING_LEN 255 + +typedef struct ml_dsa_ctx_st ML_DSA_CTX; + +__owur ML_DSA_KEY *ossl_ml_dsa_key_new(OSSL_LIB_CTX *libctx, const char *alg); +void ossl_ml_dsa_key_free(ML_DSA_KEY *key); +__owur int ossl_ml_dsa_key_up_ref(ML_DSA_KEY *key); +__owur int ossl_ml_dsa_key_equal(const ML_DSA_KEY *key1, const ML_DSA_KEY *key2, + int selection); +__owur int ossl_ml_dsa_key_has(const ML_DSA_KEY *key, int selection); +__owur int ossl_ml_dsa_key_pairwise_check(const ML_DSA_KEY *key); +__owur int ossl_ml_dsa_key_fromdata(ML_DSA_KEY *key, const OSSL_PARAM *params, + int include_private); +__owur int ossl_ml_dsa_generate_key(ML_DSA_CTX *ctx, OSSL_LIB_CTX *libctx, + const uint8_t *entropy, size_t entropy_len, + ML_DSA_KEY *out); +__owur const uint8_t *ossl_ml_dsa_key_get_pub(const ML_DSA_KEY *key); +__owur const uint8_t *ossl_ml_dsa_key_get_priv(const ML_DSA_KEY *key); +__owur size_t ossl_ml_dsa_key_get_pub_len(const ML_DSA_KEY *key); +__owur size_t ossl_ml_dsa_key_get_collision_strength_bits(const ML_DSA_KEY *key); +__owur int ossl_ml_dsa_set_priv(ML_DSA_KEY *key, const uint8_t *priv, + size_t priv_len); +__owur int ossl_ml_dsa_set_pub(ML_DSA_KEY *key, const uint8_t *pub, + size_t pub_len); +__owur size_t ossl_ml_dsa_key_get_priv_len(const ML_DSA_KEY *key); +__owur size_t ossl_ml_dsa_key_get_sig_len(const ML_DSA_KEY *key); +__owur const char *ossl_ml_dsa_key_get_name(const ML_DSA_KEY *key); +__owur int ossl_ml_dsa_key_type_matches(ML_DSA_CTX *ctx, const ML_DSA_KEY *key); +__owur int ossl_ml_dsa_key_to_text(BIO *out, const ML_DSA_KEY *key, int selection); +void ossl_ml_dsa_key_set0_libctx(ML_DSA_KEY *key, OSSL_LIB_CTX *lib_ctx); + +__owur ML_DSA_CTX *ossl_ml_dsa_ctx_new(const char *alg, + OSSL_LIB_CTX *lib_ctx, const char *propq); +void ossl_ml_dsa_ctx_free(ML_DSA_CTX *ctx); + +#endif /* OSSL_CRYPTO_SLH_DSA_H */ diff --git a/include/crypto/types.h b/include/crypto/types.h index ad17f052e45..8f60ed81e00 100644 --- a/include/crypto/types.h +++ b/include/crypto/types.h @@ -28,5 +28,8 @@ typedef struct dsa_st DSA; # ifndef OPENSSL_NO_EC typedef struct ecx_key_st ECX_KEY; # endif +# ifndef OPENSSL_NO_ML_DSA +typedef struct ml_dsa_key_st ML_DSA_KEY; +# endif #endif diff --git a/providers/defltprov.c b/providers/defltprov.c index e30256cbaa4..48618641306 100644 --- a/providers/defltprov.c +++ b/providers/defltprov.c @@ -509,6 +509,10 @@ static const OSSL_ALGORITHM deflt_keymgmt[] = { PROV_DESCS_ED448 }, # endif #endif +#ifndef OPENSSL_NO_ML_DSA + { PROV_NAMES_ML_DSA_65, "provider=default", ossl_ml_dsa_65_keymgmt_functions, + PROV_DESCS_ML_DSA_65 }, +#endif /* OPENSSL_NO_ML_DSA */ { PROV_NAMES_TLS1_PRF, "provider=default", ossl_kdf_keymgmt_functions, PROV_DESCS_TLS1_PRF_SIGN }, { PROV_NAMES_HKDF, "provider=default", ossl_kdf_keymgmt_functions, diff --git a/providers/implementations/include/prov/implementations.h b/providers/implementations/include/prov/implementations.h index 5b919056577..cfafbf48873 100644 --- a/providers/implementations/include/prov/implementations.h +++ b/providers/implementations/include/prov/implementations.h @@ -321,6 +321,7 @@ extern const OSSL_DISPATCH ossl_cmac_legacy_keymgmt_functions[]; #ifndef OPENSSL_NO_SM2 extern const OSSL_DISPATCH ossl_sm2_keymgmt_functions[]; #endif +extern const OSSL_DISPATCH ossl_ml_dsa_65_keymgmt_functions[]; /* Key Exchange */ extern const OSSL_DISPATCH ossl_dh_keyexch_functions[]; diff --git a/providers/implementations/include/prov/names.h b/providers/implementations/include/prov/names.h index d422dbac296..4728fe903f0 100644 --- a/providers/implementations/include/prov/names.h +++ b/providers/implementations/include/prov/names.h @@ -384,3 +384,5 @@ #define PROV_DESCS_RSA_PSS "OpenSSL RSA-PSS implementation" #define PROV_NAMES_SM2 "SM2:1.2.156.10197.1.301" #define PROV_DESCS_SM2 "OpenSSL SM2 implementation" +#define PROV_NAMES_ML_DSA_65 "ML-DSA-65:2.16.840.1.101.3.4.3.18" +#define PROV_DESCS_ML_DSA_65 "OpenSSL ML-DSA-65 implementation" diff --git a/providers/implementations/keymgmt/build.info b/providers/implementations/keymgmt/build.info index f2cbb3dfe8d..852d9dc7d2e 100644 --- a/providers/implementations/keymgmt/build.info +++ b/providers/implementations/keymgmt/build.info @@ -9,6 +9,7 @@ $KDF_GOAL=../../libdefault.a ../../libfips.a $MAC_GOAL=../../libdefault.a ../../libfips.a $RSA_GOAL=../../libdefault.a ../../libfips.a $TEMPLATE_GOAL=../../libtemplate.a +$ML_DSA_GOAL=../../libdefault.a IF[{- !$disabled{dh} -}] SOURCE[$DH_GOAL]=dh_kmgmt.c @@ -44,3 +45,7 @@ SOURCE[$KDF_GOAL]=kdf_legacy_kmgmt.c SOURCE[$MAC_GOAL]=mac_legacy_kmgmt.c SOURCE[$TEMPLATE_GOAL]=template_kmgmt.c + +IF[{- !$disabled{ml-dsa} -}] + SOURCE[$ML_DSA_GOAL]=ml_dsa_kmgmt.c +ENDIF diff --git a/providers/implementations/keymgmt/ml_dsa_kmgmt.c b/providers/implementations/keymgmt/ml_dsa_kmgmt.c new file mode 100644 index 00000000000..079e67d8ce9 --- /dev/null +++ b/providers/implementations/keymgmt/ml_dsa_kmgmt.c @@ -0,0 +1,375 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include +#include +#include +#include +#include "crypto/ml_dsa.h" +#include "internal/param_build_set.h" +#include "prov/implementations.h" +#include "prov/providercommon.h" +#include "prov/provider_ctx.h" + +static OSSL_FUNC_keymgmt_free_fn ml_dsa_free_key; +static OSSL_FUNC_keymgmt_has_fn ml_dsa_has; +static OSSL_FUNC_keymgmt_match_fn ml_dsa_match; +static OSSL_FUNC_keymgmt_import_fn ml_dsa_import; +static OSSL_FUNC_keymgmt_export_fn ml_dsa_export; +static OSSL_FUNC_keymgmt_import_types_fn ml_dsa_imexport_types; +static OSSL_FUNC_keymgmt_export_types_fn ml_dsa_imexport_types; +static OSSL_FUNC_keymgmt_load_fn ml_dsa_load; +static OSSL_FUNC_keymgmt_get_params_fn ml_dsa_get_params; +static OSSL_FUNC_keymgmt_gettable_params_fn ml_dsa_gettable_params; +static OSSL_FUNC_keymgmt_validate_fn ml_dsa_validate; +static OSSL_FUNC_keymgmt_gen_init_fn ml_dsa_gen_init; +static OSSL_FUNC_keymgmt_gen_cleanup_fn ml_dsa_gen_cleanup; +static OSSL_FUNC_keymgmt_gen_set_params_fn ml_dsa_gen_set_params; +static OSSL_FUNC_keymgmt_gen_settable_params_fn ml_dsa_gen_settable_params; + +#define ML_DSA_POSSIBLE_SELECTIONS (OSSL_KEYMGMT_SELECT_KEYPAIR) + +struct ml_dsa_gen_ctx { + ML_DSA_CTX *ctx; + OSSL_LIB_CTX *libctx; + char *propq; + uint8_t entropy[32]; + size_t entropy_len; +}; + +static void *ml_dsa_new_key(void *provctx, const char *alg) +{ + if (!ossl_prov_is_running()) + return 0; + + return ossl_ml_dsa_key_new(PROV_LIBCTX_OF(provctx), alg); +} + +static void ml_dsa_free_key(void *keydata) +{ + ossl_ml_dsa_key_free((ML_DSA_KEY *)keydata); +} + +static int ml_dsa_has(const void *keydata, int selection) +{ + const ML_DSA_KEY *key = keydata; + + if (!ossl_prov_is_running() || key == NULL) + return 0; + if ((selection & ML_DSA_POSSIBLE_SELECTIONS) == 0) + return 1; /* the selection is not missing */ + + return ossl_ml_dsa_key_has(key, selection); +} + +static int ml_dsa_match(const void *keydata1, const void *keydata2, int selection) +{ + const ML_DSA_KEY *key1 = keydata1; + const ML_DSA_KEY *key2 = keydata2; + + if (!ossl_prov_is_running()) + return 0; + if (key1 == NULL || key2 == NULL) + return 0; + return ossl_ml_dsa_key_equal(key1, key2, selection); +} + +static int ml_dsa_validate(const void *key_data, int selection, int check_type) +{ + const ML_DSA_KEY *key = key_data; + + if (!ml_dsa_has(key, selection)) + return 0; + + if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == OSSL_KEYMGMT_SELECT_KEYPAIR) + return ossl_ml_dsa_key_pairwise_check(key); + return 1; +} + +static int ml_dsa_import(void *keydata, int selection, const OSSL_PARAM params[]) +{ + ML_DSA_KEY *key = keydata; + int include_priv; + + if (!ossl_prov_is_running() || key == NULL) + return 0; + + if ((selection & ML_DSA_POSSIBLE_SELECTIONS) == 0) + return 0; + + include_priv = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0); + return ossl_ml_dsa_key_fromdata(key, params, include_priv); +} + +#define ML_DSA_IMEXPORTABLE_PARAMETERS \ + OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0), \ + OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0) + +static const OSSL_PARAM ml_dsa_key_types[] = { + ML_DSA_IMEXPORTABLE_PARAMETERS, + OSSL_PARAM_END +}; +static const OSSL_PARAM *ml_dsa_imexport_types(int selection) +{ + if ((selection & ML_DSA_POSSIBLE_SELECTIONS) == 0) + return NULL; + return ml_dsa_key_types; +} + +static const OSSL_PARAM ml_dsa_params[] = { + OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL), + OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL), + OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL), + ML_DSA_IMEXPORTABLE_PARAMETERS, + OSSL_PARAM_END +}; +static const OSSL_PARAM *ml_dsa_gettable_params(void *provctx) +{ + return ml_dsa_params; +} + +static int key_to_params(ML_DSA_KEY *key, OSSL_PARAM_BLD *tmpl, + int include_private) +{ + /* Error if there is no key or public key */ + if (key == NULL || ossl_ml_dsa_key_get_pub(key) == NULL) + return 0; + /* + * Note that the private key always contains the public key elements so we + * just save the one blob and return. + */ + if (include_private && ossl_ml_dsa_key_get_priv(key) != NULL) + return ossl_param_build_set_octet_string(tmpl, NULL, + OSSL_PKEY_PARAM_PRIV_KEY, + ossl_ml_dsa_key_get_priv(key), + ossl_ml_dsa_key_get_priv_len(key)); + /* Otherwise write out the public key element */ + return ossl_param_build_set_octet_string(tmpl, NULL, + OSSL_PKEY_PARAM_PUB_KEY, + ossl_ml_dsa_key_get_pub(key), + ossl_ml_dsa_key_get_pub_len(key)); +} + +static int ml_dsa_get_params(void *keydata, OSSL_PARAM params[]) +{ + ML_DSA_KEY *key = keydata; + OSSL_PARAM *p; + const uint8_t *pub, *priv; + + if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL + && !OSSL_PARAM_set_int(p, 8 * ossl_ml_dsa_key_get_pub_len(key))) + return 0; + if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL + && !OSSL_PARAM_set_int(p, 8 * ossl_ml_dsa_key_get_collision_strength_bits(key))) + return 0; + if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL + && !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_sig_len(key))) + return 0; + + pub = ossl_ml_dsa_key_get_pub(key); + priv = ossl_ml_dsa_key_get_priv(key); + + /* This just gets the private elements */ + p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY); + if (p != NULL) { + if (priv == NULL + || !OSSL_PARAM_set_octet_string(p, priv, + ossl_ml_dsa_key_get_priv_len(key))) + return 0; + } + p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY); + if (p != NULL) { + if (pub == NULL + || !OSSL_PARAM_set_octet_string(p, pub, + ossl_ml_dsa_key_get_pub_len(key))) + return 0; + } + return 1; +} + +static int ml_dsa_export(void *keydata, int selection, + OSSL_CALLBACK *param_cb, void *cbarg) +{ + ML_DSA_KEY *key = keydata; + OSSL_PARAM_BLD *tmpl; + OSSL_PARAM *params = NULL; + int ret = 0, include_private; + + if (!ossl_prov_is_running() || key == NULL) + return 0; + + if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0) + return 0; + /* The public key is required for private keys */ + if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0) + return 0; + + tmpl = OSSL_PARAM_BLD_new(); + if (tmpl == NULL) + return 0; + + include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0); + if (!key_to_params(key, tmpl, include_private)) + goto err; + + params = OSSL_PARAM_BLD_to_param(tmpl); + if (params == NULL) + goto err; + + ret = param_cb(params, cbarg); + OSSL_PARAM_free(params); +err: + OSSL_PARAM_BLD_free(tmpl); + return ret; +} + +static void *ml_dsa_load(const void *reference, size_t reference_sz) +{ + ML_DSA_KEY *key = NULL; + + if (ossl_prov_is_running() && reference_sz == sizeof(key)) { + /* The contents of the reference is the address to our object */ + key = *(ML_DSA_KEY **)reference; + /* We grabbed, so we detach it */ + *(ML_DSA_KEY **)reference = NULL; + return key; + } + return NULL; +} + +static void *ml_dsa_gen_init(void *provctx, int selection, + const OSSL_PARAM params[]) +{ + OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(provctx); + struct ml_dsa_gen_ctx *gctx = NULL; + + if (!ossl_prov_is_running()) + return NULL; + + if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) { + gctx->libctx = libctx; + if (!ml_dsa_gen_set_params(gctx, params)) { + OPENSSL_free(gctx); + gctx = NULL; + } + } + return gctx; +} + +static void *ml_dsa_gen(void *genctx, const char *alg) +{ + struct ml_dsa_gen_ctx *gctx = genctx; + ML_DSA_KEY *key = NULL; + ML_DSA_CTX *ctx = NULL; + + if (!ossl_prov_is_running()) + return NULL; + ctx = ossl_ml_dsa_ctx_new(alg, gctx->libctx, gctx->propq); + if (ctx == NULL) + return NULL; + key = ossl_ml_dsa_key_new(gctx->libctx, alg); + if (key == NULL) + return NULL; + if (!ossl_ml_dsa_generate_key(ctx, gctx->libctx, + gctx->entropy, gctx->entropy_len, key)) + goto err; + ossl_ml_dsa_ctx_free(ctx); + return key; + err: + ossl_ml_dsa_ctx_free(ctx); + ossl_ml_dsa_key_free(key); + return NULL; +} + +static int ml_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[]) +{ + struct ml_dsa_gen_ctx *gctx = genctx; + const OSSL_PARAM *p; + + if (gctx == NULL) + return 0; + + p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED); + if (p != NULL) { + void *vp = gctx->entropy; + size_t len = sizeof(gctx->entropy); + + if (!OSSL_PARAM_get_octet_string(p, &vp, len, &(gctx->entropy_len))) { + gctx->entropy_len = 0; + return 0; + } + } + + p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PROPERTIES); + if (p != NULL) { + if (p->data_type != OSSL_PARAM_UTF8_STRING) + return 0; + OPENSSL_free(gctx->propq); + gctx->propq = OPENSSL_strdup(p->data); + if (gctx->propq == NULL) + return 0; + } + return 1; +} + +static const OSSL_PARAM *ml_dsa_gen_settable_params(ossl_unused void *genctx, + ossl_unused void *provctx) +{ + static OSSL_PARAM settable[] = { + OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0), + OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0), + OSSL_PARAM_END + }; + return settable; +} + +static void ml_dsa_gen_cleanup(void *genctx) +{ + struct ml_dsa_gen_ctx *gctx = genctx; + + OPENSSL_cleanse(gctx->entropy, gctx->entropy_len); + OPENSSL_free(gctx->propq); + OPENSSL_free(gctx); +} + +#define MAKE_KEYMGMT_FUNCTIONS(alg, fn) \ + static OSSL_FUNC_keymgmt_new_fn ml_dsa_##fn##_new_key; \ + static OSSL_FUNC_keymgmt_gen_fn ml_dsa_##fn##_gen; \ + static void *ml_dsa_##fn##_new_key(void *provctx) \ + { \ + return ml_dsa_new_key(provctx, alg); \ + } \ + static void *ml_dsa_##fn##_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)\ + { \ + return ml_dsa_gen(genctx, alg); \ + } \ + const OSSL_DISPATCH ossl_ml_dsa_##fn##_keymgmt_functions[] = { \ + { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))ml_dsa_##fn##_new_key }, \ + { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ml_dsa_free_key }, \ + { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ml_dsa_has }, \ + { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))ml_dsa_match }, \ + { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ml_dsa_import }, \ + { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\ + { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ml_dsa_export }, \ + { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\ + { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))ml_dsa_load }, \ + { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))ml_dsa_get_params }, \ + { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ml_dsa_gettable_params },\ + { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))ml_dsa_validate }, \ + { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))ml_dsa_gen_init }, \ + { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))ml_dsa_##fn##_gen }, \ + { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))ml_dsa_gen_cleanup }, \ + { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, \ + (void (*)(void))ml_dsa_gen_set_params }, \ + { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS, \ + (void (*)(void))ml_dsa_gen_settable_params }, \ + OSSL_DISPATCH_END \ + } + +MAKE_KEYMGMT_FUNCTIONS("ML-DSA-65", 65); diff --git a/test/build.info b/test/build.info index 13431580d13..5e511590d34 100644 --- a/test/build.info +++ b/test/build.info @@ -284,6 +284,13 @@ IF[{- !$disabled{tests} -}] DEPEND[casttest]=../libcrypto libtestutil.a ENDIF + IF[{- !$disabled{'ml-dsa'} -}] + PROGRAMS{noinst}=ml_dsa_test + SOURCE[ml_dsa_test]=ml_dsa_test.c + INCLUDE[ml_dsa_test]=../include ../apps/include + DEPEND[ml_dsa_test]=../libcrypto.a libtestutil.a + ENDIF + SOURCE[v3nametest]=v3nametest.c INCLUDE[v3nametest]=../include ../apps/include DEPEND[v3nametest]=../libcrypto libtestutil.a diff --git a/test/ml_dsa.inc b/test/ml_dsa.inc new file mode 100644 index 00000000000..273ac7f6741 --- /dev/null +++ b/test/ml_dsa.inc @@ -0,0 +1,2183 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#define ML_DSA_SIG_TEST_DET_ITEM(alg, name) { \ + alg, \ + name##_sig_priv, sizeof(name##_sig_priv), \ + name##_sig_msg, sizeof(name##_sig_msg), \ + name##_sig_digest, sizeof(name##_sig_digest), \ +} + +#define ML_DSA_SIG_TEST_ITEM(alg, name) { \ + alg, \ + name##_sig_priv, sizeof(name##_sig_priv), \ + name##_sig_msg, sizeof(name##_sig_msg), \ + name##_sig_digest, sizeof(name##_sig_digest), \ + name##_sig_add_random, sizeof(name##_sig_add_random), \ +} + +#define ML_DSA_KEYGEN_TEST_ITEM(alg, name) { \ + alg, \ + name##_keygen_seed, sizeof(name##_keygen_seed), \ + name##_keygen_pub, sizeof(name##_keygen_pub), \ + name##_keygen_priv, sizeof(name##_keygen_priv), \ +} + +typedef struct slh_dsa_sig_test_data_st { + const char *alg; + const unsigned char *priv; + size_t priv_len; + const unsigned char *msg; + size_t msg_len; + /* This is the sha256 digest of the signature, to reduce its size */ + const unsigned char *sig_digest; + size_t sig_digest_len; + const unsigned char *add_random; + size_t add_random_len; +} ML_DSA_SIG_TEST_DATA; + +typedef struct slh_dsa_keygen_test_data_st { + const char *name; + const uint8_t *seed; + size_t seed_len; + const uint8_t *pub; + size_t pub_len; + const uint8_t *priv; + size_t priv_len; +} ML_DSA_KEYGEN_TEST_DATA; + +#if 0 + +static const uint8_t ml_dsa_65_0_sig_priv[] = { + 0x3e, 0x93, 0x5d, 0x3b, 0x7d, 0xb7, 0xee, 0x99, 0x1c, 0xe7, 0x74, 0xfa, 0x5b, 0x93, 0xd9, 0xbe, + 0x0d, 0x10, 0x8b, 0xe3, 0x97, 0xee, 0x17, 0x65, 0x68, 0x29, 0x6e, 0xe7, 0xf2, 0x87, 0x86, 0x00, + 0x7c, 0xaf, 0x11, 0x56, 0x28, 0x0d, 0x77, 0x02, 0x45, 0x61, 0x1b, 0x2d, 0x34, 0x6a, 0x65, 0xff, + 0xc7, 0x35, 0xa3, 0xa2, 0xe1, 0x5b, 0xb2, 0x0c, 0x05, 0x14, 0x3d, 0x92, 0x56, 0x69, 0x1b, 0x2a, + 0xb4, 0x1d, 0x75, 0xa9, 0x0b, 0xc5, 0xe8, 0xf3, 0xb3, 0x0b, 0x6f, 0x5c, 0xd0, 0x5f, 0xd1, 0x89, + 0x92, 0x92, 0x4a, 0x5b, 0x59, 0xa6, 0x5a, 0xf0, 0x6c, 0x0f, 0x00, 0x0e, 0x74, 0xa2, 0x19, 0xdd, + 0x3e, 0x76, 0x04, 0xb5, 0x83, 0x31, 0xdb, 0x0a, 0x0a, 0xe9, 0x01, 0xc2, 0x93, 0x91, 0x79, 0x44, + 0x17, 0xdd, 0x11, 0x0b, 0xc8, 0xaa, 0xf7, 0xf6, 0x2c, 0xfe, 0xfb, 0x34, 0xe0, 0x0e, 0x1d, 0x12, + 0x73, 0x22, 0x46, 0x08, 0x14, 0x03, 0x52, 0x20, 0x33, 0x74, 0x00, 0x78, 0x75, 0x25, 0x61, 0x71, + 0x86, 0x47, 0x15, 0x36, 0x14, 0x76, 0x15, 0x04, 0x43, 0x07, 0x61, 0x35, 0x10, 0x76, 0x82, 0x41, + 0x75, 0x65, 0x75, 0x45, 0x53, 0x62, 0x35, 0x86, 0x60, 0x63, 0x81, 0x22, 0x08, 0x42, 0x16, 0x62, + 0x73, 0x34, 0x13, 0x13, 0x62, 0x65, 0x71, 0x12, 0x77, 0x38, 0x33, 0x60, 0x04, 0x60, 0x33, 0x26, + 0x03, 0x34, 0x70, 0x80, 0x17, 0x50, 0x14, 0x26, 0x13, 0x46, 0x43, 0x76, 0x06, 0x43, 0x42, 0x02, + 0x03, 0x45, 0x04, 0x42, 0x24, 0x04, 0x00, 0x84, 0x30, 0x31, 0x14, 0x57, 0x08, 0x20, 0x78, 0x38, + 0x67, 0x26, 0x76, 0x16, 0x51, 0x13, 0x00, 0x68, 0x85, 0x05, 0x78, 0x01, 0x60, 0x36, 0x48, 0x78, + 0x83, 0x01, 0x03, 0x71, 0x10, 0x55, 0x61, 0x80, 0x08, 0x11, 0x17, 0x45, 0x15, 0x13, 0x75, 0x37, + 0x57, 0x68, 0x60, 0x07, 0x43, 0x81, 0x21, 0x37, 0x55, 0x73, 0x62, 0x36, 0x57, 0x33, 0x33, 0x16, + 0x14, 0x32, 0x31, 0x20, 0x36, 0x61, 0x35, 0x55, 0x42, 0x51, 0x74, 0x65, 0x66, 0x18, 0x51, 0x86, + 0x84, 0x41, 0x42, 0x40, 0x50, 0x08, 0x81, 0x27, 0x16, 0x20, 0x32, 0x87, 0x60, 0x10, 0x83, 0x14, + 0x37, 0x16, 0x20, 0x05, 0x64, 0x57, 0x66, 0x35, 0x04, 0x75, 0x20, 0x17, 0x70, 0x22, 0x18, 0x00, + 0x63, 0x75, 0x25, 0x20, 0x16, 0x46, 0x42, 0x71, 0x44, 0x15, 0x32, 0x77, 0x78, 0x15, 0x10, 0x52, + 0x00, 0x86, 0x42, 0x80, 0x85, 0x73, 0x38, 0x00, 0x26, 0x88, 0x34, 0x57, 0x43, 0x60, 0x64, 0x23, + 0x41, 0x22, 0x61, 0x82, 0x36, 0x02, 0x55, 0x63, 0x05, 0x85, 0x41, 0x67, 0x42, 0x01, 0x72, 0x30, + 0x48, 0x78, 0x86, 0x40, 0x11, 0x28, 0x13, 0x15, 0x06, 0x54, 0x40, 0x37, 0x74, 0x84, 0x14, 0x24, + 0x45, 0x33, 0x05, 0x30, 0x32, 0x21, 0x14, 0x87, 0x53, 0x00, 0x86, 0x88, 0x03, 0x13, 0x32, 0x25, + 0x40, 0x82, 0x07, 0x82, 0x42, 0x58, 0x48, 0x40, 0x28, 0x61, 0x77, 0x30, 0x16, 0x07, 0x17, 0x67, + 0x88, 0x01, 0x71, 0x21, 0x68, 0x44, 0x33, 0x04, 0x01, 0x73, 0x75, 0x55, 0x55, 0x75, 0x06, 0x83, + 0x65, 0x18, 0x13, 0x04, 0x15, 0x66, 0x08, 0x43, 0x54, 0x58, 0x86, 0x62, 0x41, 0x86, 0x42, 0x25, + 0x00, 0x64, 0x74, 0x74, 0x73, 0x03, 0x18, 0x12, 0x37, 0x40, 0x21, 0x67, 0x32, 0x82, 0x48, 0x68, + 0x27, 0x60, 0x50, 0x38, 0x05, 0x53, 0x24, 0x71, 0x02, 0x54, 0x45, 0x58, 0x17, 0x62, 0x61, 0x00, + 0x00, 0x02, 0x30, 0x66, 0x48, 0x26, 0x10, 0x31, 0x72, 0x48, 0x81, 0x76, 0x53, 0x11, 0x34, 0x30, + 0x68, 0x46, 0x02, 0x47, 0x23, 0x44, 0x83, 0x11, 0x74, 0x02, 0x30, 0x68, 0x00, 0x42, 0x14, 0x88, + 0x50, 0x53, 0x68, 0x37, 0x73, 0x05, 0x52, 0x57, 0x13, 0x45, 0x64, 0x33, 0x70, 0x46, 0x15, 0x44, + 0x61, 0x07, 0x80, 0x18, 0x37, 0x73, 0x45, 0x10, 0x78, 0x17, 0x11, 0x80, 0x10, 0x45, 0x82, 0x14, + 0x78, 0x07, 0x55, 0x68, 0x73, 0x67, 0x00, 0x47, 0x48, 0x85, 0x18, 0x65, 0x43, 0x85, 0x28, 0x48, + 0x74, 0x45, 0x13, 0x81, 0x58, 0x06, 0x20, 0x11, 0x37, 0x57, 0x11, 0x28, 0x03, 0x08, 0x30, 0x74, + 0x31, 0x46, 0x84, 0x32, 0x02, 0x37, 0x10, 0x00, 0x37, 0x47, 0x77, 0x66, 0x10, 0x57, 0x12, 0x11, + 0x82, 0x41, 0x16, 0x14, 0x56, 0x21, 0x22, 0x45, 0x65, 0x60, 0x34, 0x18, 0x61, 0x54, 0x01, 0x70, + 0x04, 0x46, 0x41, 0x76, 0x33, 0x43, 0x26, 0x74, 0x04, 0x02, 0x83, 0x27, 0x64, 0x30, 0x87, 0x66, + 0x44, 0x58, 0x51, 0x50, 0x40, 0x60, 0x64, 0x05, 0x76, 0x12, 0x44, 0x00, 0x28, 0x13, 0x53, 0x64, + 0x73, 0x23, 0x21, 0x48, 0x21, 0x03, 0x38, 0x57, 0x54, 0x55, 0x23, 0x61, 0x07, 0x74, 0x62, 0x50, + 0x68, 0x10, 0x61, 0x22, 0x68, 0x31, 0x80, 0x22, 0x16, 0x78, 0x26, 0x03, 0x62, 0x52, 0x12, 0x01, + 0x30, 0x28, 0x63, 0x40, 0x67, 0x12, 0x35, 0x06, 0x82, 0x47, 0x52, 0x71, 0x63, 0x58, 0x57, 0x22, + 0x05, 0x71, 0x52, 0x53, 0x43, 0x25, 0x88, 0x36, 0x27, 0x50, 0x54, 0x82, 0x77, 0x41, 0x87, 0x76, + 0x21, 0x32, 0x64, 0x32, 0x02, 0x05, 0x80, 0x78, 0x47, 0x10, 0x35, 0x38, 0x75, 0x77, 0x28, 0x68, + 0x34, 0x18, 0x78, 0x36, 0x30, 0x51, 0x85, 0x61, 0x58, 0x44, 0x30, 0x44, 0x54, 0x88, 0x40, 0x05, + 0x31, 0x68, 0x83, 0x87, 0x28, 0x70, 0x44, 0x86, 0x52, 0x12, 0x68, 0x77, 0x24, 0x77, 0x03, 0x10, + 0x31, 0x71, 0x56, 0x32, 0x77, 0x01, 0x25, 0x82, 0x18, 0x27, 0x46, 0x82, 0x81, 0x54, 0x51, 0x48, + 0x68, 0x64, 0x12, 0x46, 0x73, 0x56, 0x36, 0x01, 0x06, 0x47, 0x87, 0x86, 0x42, 0x75, 0x17, 0x18, + 0x28, 0x48, 0x46, 0x63, 0x86, 0x61, 0x64, 0x60, 0x70, 0x73, 0x11, 0x67, 0x56, 0x54, 0x32, 0x71, + 0x02, 0x52, 0x86, 0x46, 0x24, 0x85, 0x52, 0x17, 0x50, 0x50, 0x55, 0x43, 0x80, 0x13, 0x31, 0x30, + 0x60, 0x54, 0x83, 0x62, 0x71, 0x38, 0x56, 0x84, 0x43, 0x07, 0x40, 0x22, 0x18, 0x70, 0x57, 0x48, + 0x42, 0x32, 0x37, 0x54, 0x61, 0x55, 0x01, 0x20, 0x57, 0x74, 0x63, 0x00, 0x28, 0x14, 0x01, 0x30, + 0x83, 0x53, 0x40, 0x21, 0x23, 0x74, 0x75, 0x85, 0x03, 0x08, 0x46, 0x70, 0x47, 0x43, 0x52, 0x62, + 0x47, 0x12, 0x36, 0x26, 0x63, 0x05, 0x06, 0x34, 0x08, 0x11, 0x52, 0x74, 0x53, 0x55, 0x42, 0x16, + 0x44, 0x20, 0x05, 0x35, 0x44, 0x84, 0x28, 0x43, 0x63, 0x23, 0x28, 0x23, 0x27, 0x63, 0x50, 0x34, + 0x05, 0x30, 0x68, 0x65, 0x14, 0x50, 0x32, 0x68, 0x84, 0x02, 0x01, 0x88, 0x82, 0x07, 0x30, 0x27, + 0x57, 0x17, 0x68, 0x37, 0x06, 0x05, 0x42, 0x44, 0x27, 0x64, 0x37, 0x18, 0x68, 0x82, 0x64, 0x80, + 0x15, 0x31, 0x46, 0x06, 0x82, 0x25, 0x43, 0x20, 0x65, 0x84, 0x41, 0x48, 0x04, 0x17, 0x08, 0x14, + 0x80, 0x17, 0x32, 0x21, 0x04, 0x83, 0x03, 0x52, 0x67, 0x15, 0x88, 0x25, 0x27, 0x87, 0x05, 0x43, + 0x27, 0x04, 0x88, 0x73, 0x32, 0x75, 0x48, 0x83, 0x44, 0x41, 0x48, 0x28, 0x02, 0x17, 0x60, 0x80, + 0x18, 0x15, 0x57, 0x12, 0x12, 0x20, 0x18, 0x13, 0x87, 0x43, 0x40, 0x35, 0x65, 0x43, 0x31, 0x04, + 0x86, 0x02, 0x64, 0x22, 0x08, 0x68, 0x26, 0x30, 0x12, 0x13, 0x86, 0x54, 0x60, 0x57, 0x45, 0x51, + 0x54, 0x71, 0x65, 0x83, 0x34, 0x64, 0x57, 0x13, 0x31, 0x34, 0x23, 0x33, 0x32, 0x43, 0x61, 0x54, + 0x17, 0x70, 0x18, 0x81, 0x54, 0x25, 0x67, 0x76, 0x00, 0x25, 0x70, 0x45, 0x28, 0x22, 0x67, 0x10, + 0x53, 0x62, 0x22, 0x86, 0x15, 0x15, 0x72, 0x58, 0x88, 0x71, 0x37, 0x86, 0x18, 0x20, 0x38, 0x62, + 0x70, 0x86, 0x70, 0x03, 0x28, 0x72, 0x33, 0x17, 0x27, 0x75, 0x11, 0x30, 0x05, 0x61, 0x33, 0x83, + 0x88, 0x55, 0x58, 0x56, 0x07, 0x87, 0x60, 0x11, 0x01, 0x06, 0x76, 0x27, 0x56, 0x32, 0x62, 0x52, + 0x03, 0x12, 0x11, 0x58, 0x64, 0x13, 0x26, 0x87, 0x58, 0x54, 0x12, 0x81, 0x31, 0x67, 0x23, 0x82, + 0x38, 0x10, 0x20, 0x35, 0x31, 0x85, 0x78, 0x00, 0x15, 0x70, 0x51, 0x12, 0x32, 0x60, 0x25, 0x80, + 0x02, 0x26, 0x56, 0x30, 0x74, 0x58, 0x04, 0x44, 0x60, 0x47, 0x00, 0x20, 0x76, 0x00, 0x18, 0x36, + 0x43, 0x03, 0x17, 0x76, 0x08, 0x26, 0x61, 0x22, 0x08, 0x66, 0x11, 0x16, 0x32, 0x10, 0x31, 0x07, + 0x37, 0x21, 0x46, 0x82, 0x30, 0x46, 0x82, 0x02, 0x44, 0x45, 0x54, 0x12, 0x42, 0x15, 0x80, 0x87, + 0x50, 0x43, 0x25, 0x71, 0x54, 0x23, 0x13, 0x87, 0x81, 0x73, 0x56, 0x10, 0x08, 0x82, 0x74, 0x74, + 0x32, 0x50, 0x11, 0x52, 0x56, 0x53, 0x07, 0x26, 0x71, 0x61, 0x43, 0x01, 0x20, 0x11, 0x85, 0x07, + 0x74, 0x43, 0x08, 0x57, 0x48, 0x66, 0x23, 0x37, 0x00, 0x32, 0x68, 0x27, 0x55, 0x23, 0x38, 0x46, + 0x60, 0x67, 0x21, 0x14, 0x65, 0x54, 0x62, 0x57, 0x66, 0x07, 0x01, 0x67, 0x42, 0x21, 0x14, 0x82, + 0x84, 0x15, 0x33, 0x10, 0x84, 0x42, 0x42, 0x63, 0x47, 0x35, 0x38, 0x21, 0x44, 0x18, 0x32, 0x25, + 0x24, 0x10, 0x03, 0x47, 0x15, 0x75, 0x54, 0x37, 0x15, 0x56, 0x18, 0x43, 0x71, 0x61, 0x68, 0x71, + 0x58, 0x56, 0x04, 0x20, 0x71, 0x10, 0x83, 0x01, 0x01, 0x28, 0x01, 0x65, 0x23, 0x45, 0x04, 0x52, + 0x55, 0x01, 0x67, 0x35, 0x80, 0x56, 0x65, 0x61, 0x22, 0x03, 0x23, 0x80, 0x88, 0x22, 0x55, 0x55, + 0x23, 0x52, 0x53, 0x07, 0x11, 0x16, 0x30, 0x68, 0x08, 0x17, 0x34, 0x33, 0x03, 0x16, 0x10, 0x57, + 0x28, 0x82, 0x37, 0x21, 0x84, 0x86, 0x01, 0x54, 0x86, 0x31, 0x35, 0x21, 0x26, 0x81, 0x74, 0x57, + 0x72, 0x53, 0x83, 0x11, 0x18, 0x31, 0x31, 0x35, 0x85, 0x41, 0x04, 0x05, 0x58, 0x57, 0x47, 0x35, + 0x41, 0x04, 0x88, 0x45, 0x44, 0x26, 0x06, 0x58, 0x81, 0x44, 0x64, 0x70, 0x86, 0x46, 0x80, 0x18, + 0x80, 0x26, 0x24, 0x62, 0x87, 0x81, 0x56, 0x64, 0x52, 0x00, 0x33, 0x26, 0x82, 0x07, 0x53, 0x08, + 0x52, 0x64, 0x47, 0x20, 0x76, 0x47, 0x14, 0x77, 0x07, 0x41, 0x54, 0x01, 0x41, 0x06, 0x57, 0x54, + 0x17, 0x12, 0x22, 0x38, 0x54, 0x08, 0x03, 0x55, 0x58, 0x63, 0x76, 0x84, 0x37, 0x66, 0x20, 0x48, + 0x77, 0x44, 0x58, 0x47, 0x45, 0x73, 0x65, 0x33, 0x38, 0x74, 0x25, 0x47, 0x34, 0x34, 0x28, 0x07, + 0x35, 0x54, 0x67, 0x66, 0x51, 0x50, 0x87, 0x15, 0x03, 0x06, 0x38, 0x83, 0x83, 0x87, 0x37, 0x63, + 0x03, 0x07, 0x20, 0x28, 0x62, 0x31, 0x05, 0x07, 0x77, 0x65, 0x82, 0x56, 0x53, 0x60, 0x78, 0x01, + 0x33, 0x73, 0x57, 0x37, 0x31, 0x54, 0x30, 0x08, 0x08, 0x05, 0x40, 0x83, 0x75, 0x32, 0x05, 0x42, + 0x65, 0x73, 0x27, 0x25, 0x30, 0x14, 0x03, 0x18, 0x56, 0x81, 0x58, 0x03, 0x40, 0x55, 0x61, 0x82, + 0x75, 0x15, 0x34, 0x15, 0x22, 0x16, 0x78, 0x00, 0x45, 0x27, 0x27, 0x61, 0x13, 0x62, 0x56, 0x55, + 0x68, 0x58, 0x46, 0x11, 0x50, 0x18, 0x67, 0x53, 0x28, 0x00, 0x04, 0x48, 0x88, 0x20, 0x17, 0x23, + 0x21, 0x26, 0x54, 0x30, 0x42, 0x82, 0x78, 0x87, 0x67, 0x41, 0x15, 0x28, 0x05, 0x30, 0x42, 0x54, + 0xef, 0x2d, 0x2b, 0x23, 0x51, 0x89, 0x6f, 0xa8, 0x81, 0xa5, 0xf6, 0x02, 0x2a, 0x2b, 0xd4, 0x20, + 0xa3, 0xd3, 0x9b, 0x3b, 0x3c, 0x4a, 0x13, 0x8a, 0x6f, 0x29, 0x9a, 0x62, 0x19, 0x79, 0x03, 0x11, + 0x11, 0x51, 0x5b, 0x40, 0x2d, 0x90, 0x40, 0x36, 0x1d, 0x5c, 0x6e, 0x2d, 0xb1, 0x87, 0x20, 0x4f, + 0xad, 0xc4, 0x7a, 0x8a, 0xf0, 0x73, 0x82, 0xc4, 0x37, 0xe8, 0x55, 0x36, 0xea, 0xbd, 0x12, 0xb6, + 0x1f, 0x0e, 0x50, 0x67, 0x9a, 0x42, 0xeb, 0x88, 0x6f, 0xdd, 0x3a, 0xbf, 0x04, 0xbb, 0x7c, 0x16, + 0xfe, 0x94, 0x9a, 0xeb, 0x66, 0xb3, 0x0b, 0x68, 0x5a, 0x0c, 0xbe, 0xcb, 0xa9, 0x0e, 0xc1, 0x34, + 0x0c, 0xbb, 0x5f, 0xe2, 0x38, 0x2a, 0x53, 0x4b, 0xa5, 0x8a, 0xfe, 0x4a, 0x8a, 0x29, 0x30, 0x79, + 0xd5, 0x1d, 0x7e, 0xc7, 0xc9, 0xec, 0x51, 0x56, 0x97, 0x72, 0x6c, 0x23, 0xaa, 0xb9, 0x81, 0x5d, + 0xac, 0x18, 0x46, 0x96, 0xff, 0x52, 0xae, 0x3c, 0x02, 0xff, 0x71, 0x60, 0x81, 0xfd, 0x07, 0xab, + 0x10, 0xb6, 0x53, 0xc3, 0xd4, 0xb4, 0x7c, 0x32, 0xbf, 0xb5, 0x39, 0x2d, 0x0c, 0xd2, 0x2d, 0x5b, + 0x99, 0x26, 0x4c, 0x5b, 0x58, 0xf6, 0x5a, 0x5e, 0x52, 0xc8, 0xd7, 0x99, 0xc1, 0x7a, 0x04, 0x73, + 0xa9, 0x62, 0xa6, 0x84, 0x2c, 0xfd, 0x25, 0x5c, 0xeb, 0xc0, 0xf2, 0x0e, 0x9a, 0xcd, 0x7e, 0xfb, + 0xc8, 0xa7, 0x22, 0x6e, 0xa9, 0x98, 0xf0, 0x14, 0xc3, 0xe7, 0x15, 0x35, 0xa6, 0xd8, 0xab, 0xbe, + 0xa5, 0xe8, 0x48, 0x7e, 0xf2, 0xa4, 0x51, 0x6a, 0x4b, 0x83, 0x54, 0xb1, 0x9c, 0x03, 0xb9, 0x71, + 0x23, 0x0b, 0xfa, 0xda, 0xe6, 0xc8, 0x0d, 0xd3, 0xd2, 0x34, 0x56, 0x45, 0x53, 0xe2, 0x49, 0x31, + 0x53, 0xfd, 0x09, 0xaa, 0xfb, 0x5f, 0x06, 0xdb, 0x57, 0xb3, 0x88, 0xe0, 0x00, 0xd1, 0x49, 0xc8, + 0xae, 0x52, 0xcb, 0x42, 0x88, 0x61, 0x41, 0x31, 0x6a, 0xa5, 0x7f, 0xbd, 0xce, 0xb7, 0x8f, 0x81, + 0x5e, 0x31, 0x63, 0x0c, 0x8a, 0x55, 0x7f, 0xc5, 0xf5, 0x4c, 0xce, 0x95, 0xe1, 0xcb, 0x5f, 0x25, + 0xae, 0x1b, 0x62, 0xd2, 0xa1, 0xf3, 0x90, 0x44, 0x4f, 0xcd, 0x77, 0xeb, 0x74, 0x57, 0x85, 0xf5, + 0xb3, 0x6c, 0xbe, 0x14, 0x33, 0xe5, 0x55, 0x21, 0x16, 0x5b, 0xac, 0x3b, 0x2b, 0x00, 0x46, 0x22, + 0x4e, 0xba, 0xfb, 0x4c, 0x9e, 0x74, 0xe6, 0x34, 0x3a, 0xd9, 0x4a, 0xa3, 0x7a, 0xe9, 0x32, 0xbf, + 0xc7, 0x70, 0x80, 0x37, 0x86, 0x68, 0x73, 0x92, 0xb2, 0x6c, 0xa7, 0xc4, 0x71, 0x24, 0xe8, 0x8b, + 0x8b, 0x99, 0x71, 0x34, 0x53, 0xfb, 0x22, 0xc2, 0x10, 0xeb, 0x6e, 0xfa, 0xbb, 0xf4, 0xf0, 0x7d, + 0x47, 0xc0, 0x15, 0x43, 0x56, 0x4f, 0x6d, 0x3c, 0x62, 0x33, 0xb9, 0x13, 0xec, 0x45, 0x53, 0xe8, + 0x07, 0x5c, 0x97, 0xa6, 0xde, 0xe1, 0xcf, 0x8c, 0xfe, 0xa5, 0xc1, 0x67, 0xdd, 0xa8, 0x25, 0x8c, + 0xa6, 0x9f, 0xee, 0xdd, 0x8d, 0x46, 0xc5, 0x2f, 0x3a, 0x51, 0x05, 0x5e, 0x89, 0x0b, 0x23, 0x51, + 0xcc, 0x3a, 0x18, 0x98, 0xcf, 0x6f, 0xdf, 0x51, 0xf8, 0x5f, 0x01, 0x45, 0x3e, 0x64, 0xb1, 0xe6, + 0xcc, 0x83, 0xe2, 0x8a, 0x6c, 0x22, 0xc8, 0xbe, 0xd8, 0x0f, 0xb7, 0xb4, 0xd2, 0x7d, 0x47, 0x5b, + 0xa4, 0x1b, 0x9d, 0xf5, 0x6e, 0xfd, 0xf8, 0xfc, 0x4e, 0xdd, 0xcb, 0x45, 0x3f, 0x65, 0xd8, 0x36, + 0xf3, 0xbc, 0x96, 0xe4, 0x3f, 0x0a, 0xc0, 0xb5, 0x64, 0x5b, 0x4f, 0x8d, 0x30, 0x6d, 0x72, 0x72, + 0xd5, 0x4f, 0x86, 0xc9, 0x0f, 0xbb, 0xe4, 0xca, 0x89, 0x7d, 0xf1, 0xf5, 0x67, 0x48, 0xae, 0x6d, + 0x0b, 0x0d, 0xb3, 0x27, 0x7a, 0x73, 0x85, 0xee, 0x75, 0x61, 0xb5, 0x70, 0xd2, 0x70, 0xc9, 0xac, + 0xe0, 0x6d, 0x2a, 0x00, 0x44, 0xbe, 0x7c, 0x8b, 0xd0, 0x1f, 0x3c, 0xe0, 0x8e, 0xc3, 0x65, 0x61, + 0x91, 0x1f, 0x01, 0x55, 0x92, 0x24, 0x32, 0xe9, 0x04, 0x54, 0x86, 0xa6, 0x02, 0xaa, 0x4f, 0x06, + 0xa0, 0x2c, 0x30, 0x0f, 0x8a, 0x71, 0x50, 0x4a, 0x13, 0x4e, 0xaf, 0xff, 0xc0, 0x51, 0xf1, 0xd4, + 0xd4, 0x2d, 0x88, 0x1e, 0x30, 0xfd, 0xd5, 0xdf, 0xaa, 0xfb, 0xf9, 0xe9, 0xbf, 0x74, 0x5a, 0xe0, + 0xf7, 0x0f, 0xc2, 0x6f, 0xd4, 0x04, 0xfa, 0x79, 0x7d, 0x9e, 0xaa, 0x76, 0xd9, 0x06, 0x5c, 0x64, + 0x97, 0x85, 0xf5, 0xfb, 0xc1, 0x34, 0x69, 0x0c, 0x7d, 0x8b, 0xd6, 0x39, 0x2d, 0x4e, 0xe9, 0x9c, + 0x48, 0x8b, 0x9e, 0xe1, 0x5d, 0xef, 0x92, 0x27, 0x86, 0x8a, 0x19, 0x9e, 0xf3, 0x58, 0xbf, 0x08, + 0xef, 0x8d, 0xdc, 0x5e, 0x45, 0x36, 0x52, 0x17, 0xa4, 0xad, 0xe0, 0xd3, 0x6a, 0xf7, 0xb0, 0xd3, + 0xd7, 0x44, 0xc3, 0xea, 0x3b, 0xb2, 0x6b, 0x56, 0xb9, 0xce, 0xb3, 0x74, 0x71, 0x0f, 0x75, 0x8b, + 0xc7, 0xaa, 0x68, 0xbb, 0x34, 0x6e, 0xc2, 0xdb, 0x5b, 0x5e, 0x7f, 0xfd, 0xd5, 0xf0, 0xb4, 0xce, + 0x9f, 0x25, 0xf0, 0x3e, 0x72, 0xa9, 0xe2, 0xf5, 0xdb, 0x15, 0xe3, 0xb4, 0xe9, 0x22, 0xce, 0x09, + 0xa5, 0x7e, 0x25, 0x80, 0xcb, 0xc2, 0x87, 0x90, 0x37, 0x03, 0xe1, 0x65, 0xbd, 0x7f, 0x42, 0xd4, + 0x27, 0x4a, 0xab, 0x82, 0x0e, 0xb7, 0x1e, 0x84, 0x20, 0xcd, 0x47, 0xf8, 0x76, 0x24, 0x72, 0x7e, + 0x79, 0xac, 0x50, 0x7b, 0x09, 0x3d, 0x22, 0xc9, 0xe6, 0xe7, 0x61, 0xdf, 0x4a, 0x30, 0x82, 0xae, + 0xce, 0x10, 0x95, 0xd3, 0xa5, 0xf1, 0x01, 0xec, 0x01, 0x9f, 0x2b, 0x84, 0xac, 0xd4, 0xbd, 0xd1, + 0xf5, 0x37, 0x9c, 0xac, 0x8d, 0x7b, 0x88, 0x08, 0x48, 0x5c, 0x6e, 0xd1, 0xac, 0xd5, 0xb1, 0xa2, + 0x45, 0x59, 0x51, 0x08, 0xb4, 0x83, 0x60, 0x04, 0xd6, 0xa6, 0xd6, 0x12, 0x94, 0xc1, 0xc8, 0xeb, + 0xad, 0x65, 0xa0, 0xe7, 0x42, 0xb9, 0x8c, 0xcc, 0x7d, 0x1d, 0x27, 0x60, 0x53, 0x6b, 0x6e, 0xbd, + 0x19, 0xa8, 0x8d, 0x17, 0xc3, 0x59, 0x8e, 0x86, 0xe5, 0xa2, 0x2c, 0x0e, 0xa0, 0x7b, 0xe6, 0x71, + 0xde, 0x3a, 0xef, 0x09, 0x6a, 0xae, 0x6d, 0x3b, 0x71, 0xaa, 0xdb, 0x38, 0x83, 0x9a, 0xcf, 0xa5, + 0x59, 0x81, 0x8e, 0xb4, 0x3a, 0x34, 0x18, 0x57, 0x6f, 0x3b, 0x42, 0xdc, 0xd0, 0xe1, 0x28, 0xaa, + 0x02, 0x22, 0x34, 0x21, 0x8e, 0x61, 0x61, 0x69, 0xf0, 0xba, 0x38, 0x47, 0xf0, 0xef, 0x62, 0xff, + 0xf4, 0xef, 0x7d, 0x4d, 0xe8, 0x03, 0x68, 0x2d, 0x40, 0xa5, 0xc3, 0xb7, 0xd8, 0xf4, 0xd5, 0xfa, + 0x14, 0x44, 0x47, 0x0f, 0x1b, 0x66, 0xde, 0x18, 0x7b, 0x50, 0xfe, 0x42, 0x69, 0x81, 0x28, 0xaa, + 0x93, 0x35, 0x0c, 0x20, 0xe7, 0xd3, 0x7f, 0x61, 0x95, 0x37, 0xc2, 0x20, 0xd7, 0x8c, 0x5e, 0xbe, + 0xf8, 0x9c, 0xa0, 0xf1, 0x1c, 0x7c, 0x7a, 0x93, 0xd8, 0x3f, 0x28, 0xd8, 0x3a, 0x17, 0x21, 0x6a, + 0xdc, 0x45, 0x0e, 0x25, 0xf3, 0xeb, 0x00, 0xd9, 0xf3, 0x65, 0xc9, 0xf5, 0xed, 0x69, 0xdd, 0x08, + 0xb6, 0x8e, 0x0b, 0xc9, 0x78, 0x0f, 0x34, 0xd1, 0x50, 0x32, 0x9e, 0x49, 0x06, 0xd3, 0x0a, 0x04, + 0xe4, 0x7b, 0x6b, 0x6d, 0x50, 0x8d, 0xf9, 0xa9, 0x45, 0xed, 0x83, 0xe3, 0x9d, 0xbf, 0xf9, 0xb0, + 0xc1, 0x36, 0x48, 0x6d, 0x01, 0xa9, 0x1d, 0x11, 0xd3, 0x7b, 0x5a, 0xdb, 0x8a, 0x23, 0xd3, 0x05, + 0xb7, 0x06, 0x09, 0xf1, 0x26, 0x58, 0x8c, 0x8f, 0x77, 0xb6, 0xd0, 0x61, 0x4d, 0xb5, 0x36, 0x4c, + 0xf3, 0x6e, 0xbb, 0xe9, 0xac, 0x59, 0xd4, 0xaf, 0xa1, 0x8d, 0xf5, 0x30, 0xac, 0x5e, 0xd8, 0xb5, + 0x8d, 0x68, 0xd0, 0xcb, 0x7b, 0xf9, 0x1d, 0x65, 0xb0, 0xf3, 0x92, 0xad, 0x4b, 0x40, 0x89, 0x92, + 0x54, 0x9f, 0x8a, 0x8f, 0xbe, 0xca, 0xf2, 0x56, 0x52, 0xf0, 0xf6, 0xc4, 0xab, 0x6f, 0x32, 0xd5, + 0xb1, 0x47, 0xe8, 0xd8, 0x52, 0x86, 0xeb, 0xf9, 0x6a, 0x5d, 0x57, 0xb1, 0x7a, 0x98, 0x99, 0xe8, + 0x54, 0xeb, 0x45, 0x44, 0xbf, 0xce, 0x30, 0x36, 0x2f, 0x7b, 0xba, 0x0d, 0x2f, 0xe4, 0x01, 0x02, + 0xed, 0xe0, 0x8e, 0xe9, 0xf4, 0x3d, 0x07, 0x09, 0xcf, 0xc8, 0x9b, 0x8e, 0x33, 0xfd, 0x5f, 0x38, + 0x15, 0xa7, 0x71, 0xc5, 0x6d, 0xb8, 0xd7, 0xc7, 0x88, 0xc4, 0x9e, 0xef, 0xf5, 0x3a, 0xab, 0xc5, + 0xe3, 0x41, 0xf1, 0x84, 0xf9, 0x2a, 0xda, 0xa2, 0x25, 0x12, 0x2d, 0x2d, 0x95, 0xe3, 0xbf, 0x03, + 0xa2, 0x7d, 0xa0, 0xc1, 0x04, 0xc6, 0xf4, 0x4a, 0x3e, 0x6e, 0xac, 0x0c, 0xbc, 0x2f, 0x20, 0x66, + 0xd1, 0x7a, 0xa7, 0x4a, 0x58, 0x46, 0x44, 0xea, 0xe6, 0xe2, 0xb6, 0x9c, 0x32, 0xea, 0x11, 0x6c, + 0x91, 0xd8, 0xd6, 0xd5, 0x9c, 0x97, 0x44, 0xfc, 0x22, 0xd3, 0x8e, 0xe5, 0xcf, 0xd0, 0x91, 0x0d, + 0xd3, 0x05, 0x78, 0x8b, 0xca, 0x66, 0x14, 0x63, 0xaf, 0x04, 0x09, 0x0b, 0x57, 0x21, 0x5e, 0x70, + 0x28, 0x50, 0xe8, 0x5a, 0xa1, 0xc6, 0x60, 0x75, 0xb1, 0x5b, 0x9c, 0x9d, 0x6e, 0x93, 0x25, 0xa6, + 0x34, 0xcb, 0x04, 0xa6, 0xc7, 0x27, 0x1c, 0xef, 0xd9, 0xde, 0xfd, 0xa2, 0xd4, 0x29, 0x2e, 0xf1, + 0x53, 0x59, 0x98, 0xe5, 0xa6, 0xe6, 0x5c, 0x4e, 0x51, 0xdb, 0x49, 0xe2, 0x7f, 0xe2, 0x98, 0x6a, + 0xf0, 0x2f, 0x4b, 0xea, 0xfb, 0xe1, 0x74, 0xbd, 0x75, 0xe8, 0x99, 0x86, 0x51, 0xe6, 0x10, 0x95, + 0x81, 0x88, 0x82, 0x08, 0x45, 0xaa, 0xeb, 0x23, 0x9d, 0x2d, 0x15, 0x2b, 0x2c, 0x25, 0x97, 0xd0, + 0x4d, 0x76, 0x14, 0xa4, 0x43, 0x9f, 0x60, 0x48, 0xd2, 0xb3, 0x61, 0xfd, 0x9c, 0x55, 0x8f, 0x40, + 0xce, 0x0d, 0x2d, 0x86, 0xd7, 0xf7, 0x68, 0x46, 0xeb, 0x81, 0xdf, 0xb4, 0xe8, 0x33, 0x12, 0x7c, + 0x87, 0x09, 0x5d, 0xc2, 0xaa, 0xd0, 0xd7, 0xca, 0x4f, 0xfd, 0x18, 0x9c, 0x5e, 0x24, 0xa0, 0xf9, + 0xcd, 0xad, 0x4a, 0x55, 0x98, 0xf3, 0x27, 0x35, 0x14, 0x70, 0x3a, 0xdb, 0x5d, 0x12, 0xe7, 0x96, + 0x6e, 0x51, 0xa8, 0x56, 0xa6, 0x88, 0xcb, 0x6e, 0x25, 0xcf, 0x8c, 0x72, 0x4b, 0xd9, 0xed, 0xdc, + 0xf5, 0x55, 0xb9, 0x0c, 0x65, 0xe2, 0x8e, 0x07, 0x02, 0x2b, 0xdb, 0x2d, 0x75, 0x69, 0xcc, 0x46, + 0xdf, 0x61, 0x3e, 0xa1, 0xe7, 0xfc, 0x1d, 0x88, 0xb0, 0x25, 0x94, 0xa4, 0x64, 0x38, 0x7d, 0xae, + 0xbd, 0x04, 0x62, 0xa5, 0xf9, 0xc8, 0xbb, 0x46, 0xd5, 0x25, 0xf9, 0xbf, 0x8b, 0x3a, 0xf7, 0xfc, + 0x0d, 0x0b, 0x84, 0xdf, 0x55, 0xb2, 0xaf, 0x9e, 0x3e, 0x82, 0xa1, 0x30, 0x57, 0x26, 0xb1, 0xc6, + 0xd6, 0x03, 0x96, 0xfd, 0x08, 0x6b, 0x01, 0xbe, 0x69, 0xf9, 0x1c, 0x75, 0x2c, 0x5d, 0x0a, 0x58, + 0x75, 0x40, 0xc9, 0x19, 0xfa, 0x8e, 0xae, 0x2f, 0x5d, 0x3d, 0x72, 0xa1, 0x4a, 0xe9, 0xd5, 0xe0, + 0xb4, 0xdd, 0x4c, 0x8e, 0xe8, 0x08, 0x43, 0x42, 0x03, 0x3c, 0x93, 0xa8, 0x60, 0x52, 0xad, 0xe3, + 0xa2, 0xa6, 0x8e, 0x4c, 0x7b, 0x5d, 0xd5, 0x99, 0xc5, 0x68, 0xc9, 0x93, 0x5b, 0xe5, 0x9a, 0xb3, + 0x8a, 0xbe, 0x35, 0x56, 0xfe, 0x81, 0x30, 0x63, 0x58, 0xd5, 0xf1, 0x3c, 0x1c, 0x50, 0xc8, 0xe5, + 0xd3, 0x2f, 0x23, 0x02, 0x42, 0xcf, 0x52, 0xe3, 0x0c, 0x43, 0xd8, 0x8c, 0x50, 0xfa, 0x03, 0x0c, + 0xa5, 0xfd, 0xfa, 0x88, 0xda, 0x86, 0x9f, 0x31, 0xb2, 0x9a, 0x95, 0x29, 0x9e, 0xce, 0x1e, 0x4c, + 0xe8, 0x57, 0x5b, 0x6a, 0x63, 0x31, 0x20, 0xea, 0x76, 0xb4, 0x3f, 0x30, 0xe9, 0x51, 0x77, 0x28, + 0x70, 0x8d, 0xe1, 0xe7, 0x3a, 0x27, 0x69, 0x9d, 0x45, 0x1c, 0x14, 0x3d, 0xbf, 0x33, 0x56, 0x84, + 0xa6, 0x43, 0xf5, 0x44, 0x75, 0x6b, 0x94, 0xc5, 0x46, 0x59, 0x39, 0x72, 0xc3, 0x54, 0x3e, 0xc6, + 0x5e, 0xf6, 0x87, 0xca, 0x3f, 0x07, 0x30, 0x2e, 0x67, 0x5f, 0xe0, 0x06, 0x5c, 0x15, 0x26, 0xd1, + 0x35, 0x3d, 0x02, 0x77, 0x78, 0xe2, 0xbd, 0x04, 0xee, 0xa3, 0x1d, 0x40, 0x09, 0x70, 0x1a, 0xe7, + 0xb2, 0x24, 0x1e, 0x32, 0xe1, 0xf9, 0x42, 0x7b, 0xf8, 0x20, 0xcf, 0x55, 0xa4, 0x65, 0x24, 0x89, + 0x93, 0x11, 0x4a, 0x71, 0x45, 0x61, 0x53, 0x84, 0xcf, 0xb4, 0xa2, 0x37, 0xc0, 0xc3, 0x7f, 0x5c, + 0x2c, 0x1b, 0x3a, 0xf7, 0xa6, 0x28, 0x67, 0xf0, 0xda, 0x8e, 0x46, 0x14, 0xde, 0x7b, 0xff, 0x6f, + 0x00, 0x03, 0x4a, 0xe6, 0x28, 0xe6, 0x4d, 0xb9, 0xfd, 0x96, 0x52, 0x8a, 0x78, 0x8d, 0x98, 0xfb, + 0xe6, 0x12, 0x11, 0xd1, 0xf2, 0x2e, 0x37, 0xb9, 0x78, 0x87, 0x3e, 0xe7, 0x8a, 0x6e, 0x87, 0x1c, + 0x52, 0x65, 0x3d, 0x1e, 0xe0, 0xe0, 0x17, 0x46, 0x99, 0xff, 0x71, 0xb0, 0x78, 0x8e, 0x75, 0x61, + 0x93, 0x1a, 0xa7, 0x09, 0x39, 0xfe, 0x1d, 0x58, 0x5d, 0x73, 0x35, 0x09, 0x30, 0x35, 0x07, 0x80, + 0x1b, 0x87, 0x18, 0x9c, 0xa1, 0x7b, 0xa3, 0x06, 0x0a, 0x4b, 0xe8, 0x5f, 0x9a, 0xbe, 0x6c, 0xce, + 0x14, 0x2f, 0x8e, 0x16, 0x45, 0x1e, 0xb3, 0xc5, 0x1a, 0x43, 0x33, 0x82, 0x76, 0x41, 0xa9, 0x36, + 0x1b, 0xf6, 0x79, 0xe6, 0x65, 0xf0, 0xe0, 0xe1, 0x1f, 0x65, 0x7a, 0xb9, 0x27, 0x7d, 0x5e, 0x3a, + 0x9e, 0xbb, 0x8d, 0xa3, 0x3b, 0xca, 0x8d, 0x37, 0x25, 0x91, 0x66, 0xdc, 0x8c, 0x68, 0xa7, 0xa6, + 0x92, 0xb5, 0x70, 0x88, 0x32, 0x76, 0x45, 0x0a, 0x56, 0xd9, 0x84, 0xb7, 0x74, 0xa1, 0x0a, 0xf0, + 0xba, 0x76, 0x69, 0x71, 0xdb, 0x37, 0x55, 0xab, 0x5e, 0xde, 0x5b, 0xb8, 0xcd, 0x62, 0x92, 0x55, + 0x52, 0x08, 0xb3, 0x78, 0x72, 0xef, 0xa2, 0xe7, 0xe4, 0x27, 0x46, 0x57, 0x6f, 0x72, 0x5c, 0xa9, + 0xe9, 0xff, 0x5a, 0x69, 0x03, 0x94, 0x5c, 0xb0, 0x8e, 0x71, 0x5d, 0x4b, 0xf4, 0x68, 0xab, 0x84, + 0x72, 0x10, 0xe3, 0x0c, 0xd8, 0xb2, 0x89, 0xd2, 0xfb, 0x74, 0x57, 0x26, 0xd7, 0x6a, 0x58, 0x02, + 0xa4, 0xc7, 0x4d, 0xf5, 0x44, 0xe8, 0x35, 0xd6, 0x1d, 0xfe, 0xf6, 0x80, 0x84, 0x6e, 0xbc, 0x5f, + 0x71, 0x5f, 0x07, 0x1f, 0xa0, 0xcf, 0x2b, 0xc3, 0xad, 0x0b, 0x0f, 0x01, 0x6c, 0x9a, 0x67, 0x16, + 0x2b, 0x4f, 0x92, 0x6c, 0x32, 0xea, 0x6d, 0xc7, 0xc5, 0x48, 0xe8, 0x59, 0xb7, 0x2a, 0xb7, 0x3c, + 0x7a, 0x29, 0xc4, 0xf0, 0x6d, 0x60, 0x9c, 0x32, 0x84, 0xc7, 0x84, 0xe4, 0x0c, 0xd4, 0x60, 0xec, + 0x14, 0x9b, 0xdc, 0x17, 0xe6, 0x14, 0x60, 0x3f, 0x26, 0xbe, 0xb2, 0xe8, 0xae, 0x8a, 0x0c, 0xe2, + 0x1e, 0x00, 0xea, 0x3d, 0x18, 0xce, 0x18, 0x65, 0xbe, 0x6e, 0xb0, 0xb9, 0xe9, 0xc7, 0x9c, 0x17, + 0x00, 0x49, 0x49, 0x24, 0x18, 0xce, 0x00, 0x9b, 0xaf, 0xba, 0xcd, 0x4b, 0x8a, 0xe5, 0x55, 0x37, + 0xd8, 0xcd, 0x88, 0x39, 0xeb, 0x42, 0xfa, 0x69, 0x21, 0x28, 0x2b, 0x32, 0xef, 0xd2, 0xa7, 0x6b, + 0x1a, 0x96, 0x5d, 0xe1, 0xbe, 0x3c, 0xb0, 0x00, 0x10, 0x69, 0xd4, 0xd8, 0x0d, 0x67, 0x15, 0xf8, + 0xe1, 0x73, 0xbc, 0x8b, 0xb9, 0x72, 0xf2, 0x30, 0x20, 0xe0, 0xba, 0x2d, 0xdf, 0x3a, 0x2d, 0x39, + 0x0f, 0x11, 0xf1, 0xf5, 0xbe, 0x9f, 0x61, 0x34, 0xf4, 0x27, 0x6c, 0xf6, 0x3c, 0x5d, 0xd6, 0xa1, + 0x54, 0xe1, 0x33, 0xd9, 0xe1, 0x12, 0x6f, 0xe5, 0x5c, 0x51, 0x13, 0xf5, 0xe3, 0x48, 0x5a, 0xd0, + 0x51, 0xb4, 0xc6, 0x13, 0xe3, 0x2a, 0xd3, 0xbc, 0x07, 0x93, 0xb0, 0xd9, 0x55, 0xfe, 0xe7, 0x9b, + 0x13, 0x92, 0xae, 0x2e, 0xdf, 0x04, 0x87, 0x53, 0xba, 0xf8, 0x2e, 0xb4, 0xb7, 0x39, 0x74, 0x6c, + 0x07, 0x5c, 0xf8, 0x47, 0x29, 0xa9, 0x0e, 0xf6, 0x06, 0x85, 0xc3, 0xf7, 0x83, 0x3b, 0xb0, 0xd0, + 0x08, 0x95, 0x92, 0x4e, 0x5a, 0x8b, 0xcb, 0xcb, 0x7b, 0xaf, 0x41, 0xc7, 0x8c, 0x37, 0x05, 0xc4, + 0x8c, 0x28, 0x55, 0x99, 0x68, 0xc9, 0x47, 0xbc, 0x6f, 0xba, 0x0e, 0x96, 0x40, 0xf8, 0x84, 0x5a, + 0x45, 0xc5, 0xaa, 0xa0, 0x18, 0x84, 0x2f, 0xca, 0x46, 0xa2, 0x5d, 0x68, 0xdc, 0xcb, 0xde, 0x8b, + 0xad, 0xeb, 0xa3, 0x41, 0xf8, 0x96, 0x9a, 0x3c, 0x83, 0x33, 0x7e, 0xf3, 0xa6, 0x38, 0x3c, 0xfa, + 0x4c, 0xf9, 0xb0, 0x93, 0xf7, 0xc8, 0x1c, 0xd8, 0x94, 0x70, 0x59, 0xcc, 0x6d, 0xb3, 0x50, 0xbe, + 0x20, 0xe8, 0x08, 0x0a, 0x32, 0xc3, 0x56, 0xbb, 0x81, 0x3a, 0x71, 0x45, 0x57, 0xae, 0x66, 0xe6, + 0xdf, 0x11, 0x0a, 0xff, 0xb7, 0xb1, 0x1d, 0x95, 0xa8, 0x2f, 0x47, 0x14, 0xd0, 0x9c, 0x94, 0x55, + 0x54, 0xdc, 0xee, 0x53, 0xb3, 0xa0, 0x6f, 0x08, 0x60, 0xbe, 0x89, 0xe7, 0xb1, 0x94, 0x59, 0xcd, + 0x06, 0x11, 0x54, 0xb9, 0xf8, 0x6e, 0xd7, 0x70, 0xac, 0x27, 0x1d, 0x72, 0x72, 0xa8, 0xd0, 0xf4, + 0x0b, 0xac, 0x2b, 0xe0, 0xf9, 0x50, 0x64, 0xdf, 0x20, 0x24, 0x6f, 0xf3, 0xaa, 0xf3, 0x10, 0x0d, + 0xaa, 0x75, 0xf6, 0x8c, 0xaa, 0x6c, 0x53, 0x2e, 0x11, 0x81, 0xd6, 0x70, 0xd9, 0x4a, 0x68, 0x63, + 0x9a, 0x45, 0x57, 0xd5, 0xfa, 0x10, 0xab, 0x8a, 0x01, 0x6e, 0xbb, 0x94, 0xb3, 0xb3, 0x67, 0x05, + 0x8a, 0xf4, 0x05, 0x41, 0xfe, 0xf8, 0x8f, 0x49, 0x7e, 0xda, 0x04, 0x0b, 0x6d, 0x92, 0x7a, 0x3c, + 0x1f, 0x03, 0x4d, 0x6c, 0x24, 0x72, 0xf8, 0xa9, 0x0e, 0xac, 0xaf, 0xb6, 0x12, 0x42, 0xe9, 0x6f, + 0xfa, 0x47, 0xd1, 0x59, 0x8d, 0x61, 0x07, 0xc1, 0xb4, 0xb6, 0x70, 0x3e, 0x83, 0x06, 0x7a, 0x81, + 0x7e, 0xfa, 0x96, 0x40, 0xa6, 0xa1, 0x27, 0x7e, 0x59, 0xfd, 0xad, 0x28, 0xde, 0xb2, 0x9a, 0x70, + 0xe3, 0x1e, 0xc8, 0x2b, 0xfd, 0xdf, 0x96, 0xdf, 0xbf, 0x77, 0x56, 0xfb, 0x6d, 0x83, 0x68, 0xf9, + 0xe3, 0x40, 0x06, 0x59, 0x97, 0xb5, 0x5b, 0x00, 0xb2, 0x20, 0x57, 0xe7, 0x01, 0x4c, 0xa5, 0x55, + 0xfb, 0xe5, 0x56, 0x3e, 0xee, 0xdd, 0x4b, 0x03, 0x98, 0x35, 0xf6, 0x0f, 0x75, 0x3e, 0x98, 0x10, + 0xb5, 0x41, 0x0a, 0xdf, 0x69, 0x95, 0x15, 0x08, 0x01, 0x04, 0xae, 0xc8, 0x12, 0xc3, 0xec, 0x29, + 0x99, 0x28, 0xc6, 0x6c, 0x49, 0x8b, 0x0e, 0x26, 0xb1, 0x71, 0x9c, 0x69, 0x0b, 0xf5, 0xa4, 0x24, + 0x15, 0xa6, 0xf6, 0x3a, 0x92, 0x78, 0xdf, 0xa4, 0x30, 0x38, 0x0a, 0x82, 0x1b, 0xad, 0x0a, 0x2f, + 0x83, 0x77, 0x23, 0x5a, 0x26, 0x0a, 0x0b, 0xc9, 0xb3, 0x3e, 0x49, 0xfb, 0x98, 0x0e, 0xfd, 0x77, + 0x0b, 0xa9, 0x7f, 0xfe, 0x16, 0x18, 0x3d, 0x6b, 0x1c, 0x24, 0xd0, 0xd1, 0xc3, 0xf4, 0x37, 0xa1, +}; +static const uint8_t ml_dsa_65_0_sig_msg[] = { + 0xe3, 0xd5, 0x4d, 0xba, 0x67, 0x5d, 0xe7, 0x53, 0x0d, 0x38, 0x54, 0xc8, 0xcd, 0xbd, 0x58, 0x1c, + 0x6e, 0x39, 0x2f, 0x69, 0xcf, 0x97, 0x93, 0xd8, 0xc0, 0xbb, 0xaf, 0xee, 0x73, 0x34, 0xc5, 0x87, + 0x8b, 0xf1, 0x3b, 0x3b, 0xdc, 0xf1, 0xd9, 0x93, 0xa4, 0x7a, 0x7e, 0x8e, 0xdd, 0x4b, 0x6c, 0x3e, + 0xc9, 0x15, 0xa5, 0xe8, 0xfb, 0xf2, 0x07, 0x1f, 0x11, 0x2a, 0xac, 0x41, 0xf0, 0x8c, 0xcd, 0x8c, + 0xc7, 0x31, 0x14, 0x3a, 0xfc, 0x22, 0x32, 0x13, 0x21, 0x2a, 0x5b, 0xd6, 0xb6, 0xa4, 0x02, 0x6c, + 0xfc, 0x9f, 0x7a, 0x41, 0xc0, 0x8c, 0xb9, 0x9f, 0x2b, 0x37, 0x5d, 0x0e, 0x04, 0xfb, 0xbe, 0x00, + 0x50, 0x35, 0x33, 0xdf, 0xb8, 0x69, 0xde, 0x43, 0x56, 0x65, 0x74, 0xb4, 0x92, 0x32, 0x56, 0x6e, + 0x38, 0xb1, 0x3c, 0xaf, 0x8c, 0x1e, 0xc1, 0xfa, 0x11, 0xcc, 0xa3, 0xdb, 0x66, 0x88, 0x79, 0x96, + 0xdf, 0xee, 0x09, 0x0d, 0x13, 0x3b, 0x1d, 0x39, 0x4f, 0x07, 0x5f, 0x82, 0x86, 0xca, 0x6c, 0xce, + 0x13, 0xc3, 0x97, 0x7d, 0x92, 0x9d, 0xef, 0x59, 0x43, 0x46, 0x1b, 0xd5, 0xa2, 0x2d, 0x4b, 0xb5, + 0xe8, 0xfb, 0x7e, 0xfe, 0x01, 0x69, 0x32, 0xd0, 0x2e, 0xcf, 0x4d, 0x7b, 0x77, 0x05, 0x41, 0x2c, + 0xa1, 0x45, 0x08, 0xb1, 0x3e, 0x61, 0x92, 0x5e, 0xec, 0x0b, 0x77, 0x46, 0x0c, 0x4c, 0x08, 0x9c, + 0x83, 0xd6, 0x87, 0xc8, 0xf7, 0x0d, 0x14, 0x1c, 0x75, 0xd6, 0xdf, 0x24, 0xfc, 0xdb, 0x64, 0xbb, + 0x8c, 0x27, 0x21, 0xaa, 0xc9, 0xce, 0x8c, 0x6f, 0xc4, 0x75, 0x0c, 0x16, 0x86, 0xa7, 0xa7, 0x0d, + 0xf3, 0x49, 0x57, 0xdc, 0xc0, 0xce, 0x53, 0xc3, 0xf0, 0xd2, 0x80, 0xcb, 0xd0, 0x56, 0xd4, 0xf9, + 0x21, 0xfd, 0xed, 0xb3, 0x5a, 0xfc, 0xe5, 0xdb, 0xb3, 0x48, 0x96, 0x4a, 0xd1, 0x05, 0xee, 0xf5, + 0xa1, 0xb0, 0x7b, 0xd0, 0xd5, 0x86, 0xb8, 0x7a, 0xda, 0x7c, 0xa7, 0xaf, 0xa9, 0x3f, 0xb7, 0x5a, + 0xc0, 0xde, 0x1c, 0x74, 0x9c, 0x48, 0xbd, 0x6f, 0x19, 0x2d, 0x62, 0x79, 0x48, 0x2d, 0x3f, 0x97, + 0x81, 0x29, 0x0b, 0x88, 0xb0, 0x95, 0xd7, 0x3e, 0x72, 0x8a, 0xfc, 0x18, 0x6b, 0xff, 0x08, 0x16, + 0xc1, 0xde, 0x78, 0x11, 0x9d, 0x70, 0x1f, 0xad, 0x38, 0x2c, 0x65, 0xac, 0xc4, 0x2b, 0x04, 0xd6, + 0x94, 0x12, 0xae, 0xb2, 0x55, 0x79, 0x38, 0x39, 0xef, 0xb9, 0xe5, 0xbb, 0xf6, 0xf6, 0x9b, 0x7f, + 0xda, 0x27, 0xa4, 0x4c, 0x04, 0xd3, 0xaa, 0x2f, 0xdc, 0x61, 0x01, 0xe9, 0xce, 0xc6, 0xf7, 0x57, + 0x45, 0xf2, 0x0e, 0x07, 0x7e, 0xe2, 0x3d, 0x65, 0x2b, 0x7d, 0xe5, 0x47, 0xa0, 0xfb, 0x0e, 0x3a, + 0x15, 0x34, 0x73, 0xbc, 0x82, 0x4a, 0xc8, 0xa3, 0x1a, 0x2c, 0x94, 0x93, 0xde, 0x64, 0xb6, 0xd4, + 0x01, 0x85, 0xb6, 0x04, 0x31, 0xb1, 0xb3, 0x4e, 0xe3, 0x27, 0x97, 0xcc, 0x77, 0xc4, 0x5c, 0x71, + 0xf4, 0xe0, 0x4e, 0x84, 0x9b, 0xf8, 0xdd, 0xfc, 0xf6, 0x40, 0xb8, 0x31, 0x30, 0x20, 0x8d, 0xc2, + 0x49, 0x5c, 0x0c, 0xfc, 0x6c, 0x03, 0x1b, 0x63, 0xb8, 0x0f, 0xb4, 0x5f, 0x47, 0xbf, 0xe3, 0xd2, + 0x5e, 0xc5, 0xb3, 0x6c, 0x27, 0x00, 0x30, 0x0d, 0x82, 0x23, 0x07, 0x4c, 0x15, 0x6c, 0x5d, 0x98, + 0x87, 0xde, 0x8c, 0x5a, 0x97, 0xba, 0x36, 0xa8, 0x4d, 0x75, 0x85, 0xcc, 0x06, 0x5f, 0x20, 0xfe, + 0x8d, 0xce, 0x9e, 0x8e, 0xb8, 0x14, 0xa1, 0xd5, 0xb7, 0xa3, 0xb7, 0xa3, 0xab, 0x68, 0xd9, 0x3e, + 0xdb, 0xbb, 0xbf, 0x67, 0xbd, 0x70, 0xa0, 0xfc, 0x53, 0x6c, 0x81, 0xc8, 0xd6, 0xe8, 0xb1, 0x39, + 0xc6, 0xb3, 0xb5, 0xee, 0xaa, 0x39, 0x53, 0x46, 0x45, 0x49, 0xcb, 0x38, 0xb7, 0x8a, 0x15, 0xce, + 0x3d, 0x5b, 0xb4, 0xb7, 0x98, 0xe6, 0xb1, 0x42, 0xbc, 0x48, 0xc7, 0x0c, 0x5b, 0xe6, 0x1f, 0x82, + 0xdb, 0x6e, 0x2e, 0xc0, 0x36, 0x16, 0x99, 0x90, 0x73, 0x57, 0x4e, 0x6f, 0xb3, 0x5d, 0x44, 0x1b, + 0x78, 0xdc, 0xaf, 0xf5, 0x6b, 0x8c, 0xa8, 0xf4, 0x73, 0xec, 0x05, 0x43, 0xc9, 0xc6, 0x9e, 0x93, + 0xb9, 0x7f, 0x95, 0xfc, 0xa5, 0x8d, 0xaa, 0xed, 0x51, 0x1f, 0x44, 0x40, 0xdb, 0x25, 0x2e, 0xc1, + 0x8c, 0x90, 0xd2, 0xf9, 0x7a, 0xd9, 0x01, 0x71, 0x6a, 0xd3, 0x4e, 0xe1, 0x03, 0xea, 0xb0, 0xb7, + 0x98, 0x29, 0x94, 0xe2, 0x1e, 0xd1, 0xac, 0x4b, 0xd6, 0x2a, 0xce, 0x6d, 0xfe, 0x12, 0xc8, 0xc2, + 0xcd, 0x09, 0x2e, 0x7a, 0x7e, 0x37, 0xbd, 0x4e, 0x61, 0xb4, 0xcd, 0x51, 0xd9, 0x80, 0x17, 0x1f, + 0x8d, 0x42, 0x53, 0xa4, 0xe7, 0xfc, 0xca, 0xba, 0x0a, 0x51, 0x30, 0x38, 0x27, 0x63, 0x25, 0x37, + 0x25, 0x27, 0x62, 0x1b, 0x0a, 0x3d, 0xfa, 0xec, 0xcd, 0x7c, 0xdf, 0xe9, 0x8c, 0xb7, 0x9c, 0x06, + 0x62, 0xf5, 0xd0, 0x23, 0x4a, 0xee, 0xe9, 0x30, 0x24, 0x38, 0xb7, 0x78, 0x23, 0x8b, 0xca, 0x40, + 0x9d, 0x59, 0x08, 0x76, 0x87, 0x79, 0x15, 0x5d, 0x65, 0x9e, 0x92, 0xd1, 0x2c, 0xee, 0xf3, 0xc2, + 0xc9, 0x54, 0xc3, 0xf1, 0xa4, 0xc2, 0x91, 0x2e, 0x9e, 0xe9, 0x94, 0x20, 0x9b, 0x60, 0x8a, 0x60, + 0x4d, 0x0c, 0xd8, 0x7f, 0x79, 0x66, 0x5a, 0x25, 0xe7, 0x74, 0xe6, 0xdc, 0x1d, 0x88, 0x19, 0xb8, + 0x58, 0x52, 0xd9, 0xad, 0xeb, 0x17, 0x4c, 0x75, 0xd9, 0x82, 0xdc, 0xe2, 0x9f, 0xfd, 0xd2, 0x4b, + 0x7a, 0xaf, 0x59, 0x46, 0xa7, 0x4c, 0x14, 0xa3, 0x01, 0xae, 0x09, 0xf1, 0x38, 0x6a, 0xb1, 0x7a, + 0xcc, 0x34, 0x1d, 0x6d, 0xac, 0x04, 0x0f, 0xa6, 0x52, 0x7f, 0xcb, 0x8e, 0x09, 0x5c, 0xd4, 0xf1, + 0x65, 0x1e, 0x47, 0xce, 0x02, 0xe6, 0xed, 0x76, 0xc0, 0x85, 0xb2, 0xfa, 0xbe, 0x9f, 0xf5, 0xa5, + 0x10, 0xe6, 0x3e, 0x73, 0xee, 0x38, 0x6a, 0xc1, 0x7d, 0x5c, 0x2c, 0x94, 0xc2, 0xd5, 0x28, 0xb3, + 0xa9, 0xc8, 0x90, 0x2d, 0x10, 0xc1, 0x61, 0x0b, 0xa7, 0x0b, 0xa6, 0x16, 0xc5, 0x8d, 0x03, 0x7f, + 0x14, 0x8e, 0x63, 0x32, 0x10, 0x7d, 0xb9, 0xf6, 0x4c, 0x57, 0x90, 0x64, 0xf1, 0x94, 0x81, 0x66, + 0x9c, 0x78, 0x88, 0xc2, 0x1f, 0x0a, 0x33, 0x74, 0x19, 0x4f, 0xf1, 0xa7, 0x2f, 0xb6, 0x18, 0x0d, + 0xc0, 0x1d, 0x29, 0x44, 0x3b, 0xc5, 0x2c, 0x31, 0x8a, 0xb0, 0x38, 0x43, 0x35, 0x7a, 0x5a, 0x98, + 0xb3, 0xd5, 0xcd, 0xde, 0x9b, 0xc4, 0x9d, 0x3e, 0xd2, 0x9e, 0xf7, 0x3c, 0xaf, 0x44, 0xa7, 0x84, + 0x9a, 0xc6, 0xdf, 0x4b, 0x2d, 0x35, 0x3b, 0x6a, 0x56, 0x23, 0x86, 0xbd, 0x48, 0x05, 0x12, 0x10, + 0x8c, 0xa0, 0xec, 0xd6, 0x3b, 0xb3, 0xd3, 0xa0, 0x69, 0x56, 0x79, 0x76, 0x2f, 0x82, 0x54, 0x11, + 0x6d, 0x80, 0x49, 0x48, 0x8b, 0xe6, 0x38, 0x9f, 0xac, 0x08, 0x91, 0x6e, 0x64, 0x07, 0x94, 0x4b, + 0x15, 0x26, 0xbf, 0x03, 0x55, 0x15, 0x04, 0xe4, 0x0e, 0x6a, 0x32, 0x66, 0xd4, 0xe7, 0x73, 0xe8, + 0x92, 0xea, 0xc4, 0xdd, 0x51, 0x28, 0x37, 0x4b, 0xa3, 0x41, 0xeb, 0x40, 0x97, 0xe2, 0x0a, 0x9b, + 0xbd, 0x4e, 0x5e, 0xa2, 0x6b, 0xe6, 0xfc, 0x32, 0x5d, 0x9b, 0x71, 0xc2, 0x32, 0xdc, 0xe1, 0x97, + 0x49, 0x28, 0x51, 0x6e, 0xa2, 0x51, 0x99, 0x74, 0xc8, 0x2a, 0xea, 0x52, 0x47, 0x62, 0x7f, 0x80, + 0x2c, 0x64, 0x42, 0xb6, 0x7f, 0xbc, 0x10, 0xe3, 0x59, 0x67, 0x2e, 0xeb, 0x9d, 0xff, 0x76, 0x8e, + 0x93, 0x33, 0xa2, 0x16, 0x63, 0x36, 0xff, 0x00, 0x04, 0xde, 0x5e, 0x7b, 0xca, 0x55, 0x99, 0x8c, + 0x86, 0x0f, 0xc1, 0xa8, 0x6b, 0x75, 0xcb, 0xeb, 0x3f, 0xb5, 0xa5, 0xa2, 0x51, 0x9d, 0x52, 0x27, + 0xa6, 0xb5, 0xa7, 0xe0, 0xee, 0x05, 0x8f, 0xee, 0x0c, 0xae, 0x2b, 0x4a, 0xa7, 0x50, 0x99, 0xff, + 0x09, 0x80, 0x89, 0xf0, 0x26, 0x1c, 0x44, 0x3b, 0x13, 0x91, 0x1c, 0xf3, 0x25, 0x0c, 0xae, 0x2f, + 0x29, 0x06, 0xcb, 0x64, 0x54, 0xa2, 0x0d, 0x0f, 0xff, 0xe8, 0xc5, 0xaf, 0xb1, 0xde, 0x7c, 0x5b, + 0xa8, 0xca, 0xae, 0x00, 0xcd, 0x7c, 0x2d, 0x72, 0x19, 0xfc, 0x83, 0xfb, 0x15, 0x8f, 0xd6, 0xd1, + 0x5e, 0xdc, 0x29, 0x24, 0xab, 0x41, 0xc9, 0xb8, 0x81, 0x56, 0x6c, 0x53, 0x8f, 0x5e, 0x38, 0x97, + 0x8c, 0x31, 0x82, 0xfb, 0xdd, 0x0c, 0x0c, 0x53, 0x2a, 0x77, 0xa6, 0x1e, 0x5b, 0x8e, 0x66, 0x6b, + 0x3c, 0x54, 0x0d, 0xe9, 0x76, 0x09, 0x8d, 0x2b, 0xc6, 0x8c, 0x0c, 0xda, 0xcf, 0x57, 0xe9, 0xbf, + 0x1b, 0xde, 0x8a, 0x7b, 0xfb, 0x13, 0x25, 0x6b, 0xc6, 0x9f, 0x2e, 0x38, 0x6d, 0x8f, 0x45, 0x8d, + 0x30, 0x3b, 0xab, 0x78, 0x1e, 0x53, 0x75, 0x17, 0xad, 0x7d, 0x0f, 0x03, 0x78, 0xd2, 0xf2, 0x58, + 0xb0, 0x13, 0xae, 0xa0, 0x1c, 0x97, 0xa7, 0xe8, 0xcd, 0x2c, 0x3d, 0xeb, 0x20, 0x3a, 0xa8, 0xd5, + 0x90, 0x84, 0xac, 0xc2, 0xb0, 0x9a, 0xd3, 0xc9, 0x7e, 0xa6, 0x13, 0xa2, 0xfb, 0xf2, 0x97, 0x03, + 0x8b, 0x4e, 0x72, 0x16, 0x65, 0xd5, 0x12, 0xdd, 0xfe, 0x5c, 0x13, 0xf1, 0x1d, 0xf4, 0xbd, 0xc0, + 0x20, 0x0b, 0xf6, 0x10, 0xd5, 0x7e, 0xa7, 0x23, 0x29, 0x14, 0x75, 0x2f, 0x75, 0xa5, 0x44, 0xe0, + 0x1d, 0x5a, 0xe0, 0xde, 0xfb, 0xc9, 0xe1, 0x86, 0x95, 0x82, 0x40, 0x58, 0xbd, 0xfc, 0xdd, 0xf4, + 0xd5, 0x88, 0x48, 0x40, 0xd2, 0xb5, 0x5d, 0x6c, 0x2d, 0x6e, 0xdf, 0x47, 0x5c, 0xa7, 0x5f, 0x3e, + 0xb4, 0xd0, 0xed, 0xfa, 0xe9, 0x93, 0x49, 0x68, 0x4b, 0xc9, 0xc5, 0x33, 0xea, 0xd5, 0x91, 0x08, + 0x5b, 0xd1, 0xd6, 0xd4, 0xe4, 0xf9, 0xb0, 0x0a, 0x54, 0xc9, 0x72, 0x44, 0x32, 0x2d, 0x50, 0x5a, + 0xb5, 0x2b, 0x2d, 0x4e, 0x04, 0x38, 0xc6, 0xac, 0x5d, 0x2c, 0x39, 0x83, 0xbf, 0xb2, 0x35, 0x9f, + 0xb2, 0x11, 0x74, 0xac, 0x02, 0x15, 0x6a, 0xe1, 0x1e, 0xf2, 0x33, 0xaf, 0x40, 0xa6, 0x95, 0x85, + 0x4c, 0x84, 0xe6, 0x20, 0x75, 0x44, 0x19, 0xcf, 0x7e, 0xd9, 0xea, 0x4f, 0xda, 0xce, 0xfc, 0x88, + 0x79, 0xb2, 0xeb, 0xc7, 0xb2, 0x9c, 0xdf, 0x9c, 0x4c, 0xa2, 0x92, 0x1e, 0x08, 0x44, 0x86, 0x47, + 0x7c, 0x14, 0x52, 0xbc, 0x3b, 0xaf, 0x52, 0x9d, 0xd9, 0x27, 0x48, 0xe2, 0xb1, 0xb6, 0x84, 0xb1, + 0x10, 0x3c, 0xf4, 0xc6, 0xee, 0x11, 0x99, 0x9e, 0x41, 0x21, 0xcf, 0xc7, 0xe2, 0xf3, 0xf6, 0xc7, + 0xbb, 0x9c, 0x05, 0x5f, 0x80, 0x0d, 0xc4, 0x6d, 0x78, 0xd9, 0xd9, 0x4c, 0x3b, 0x20, 0xbd, 0x1b, + 0x69, 0x74, 0x11, 0xff, 0x0b, 0x41, 0xe3, 0x81, 0x73, 0xd2, 0xc9, 0xff, 0x1c, 0xca, 0x77, 0xb2, + 0x73, 0x84, 0x02, 0x6e, 0xd2, 0xee, 0x25, 0x22, 0x3b, 0x00, 0x07, 0xd2, 0x93, 0x0d, 0x70, 0x0a, + 0x20, 0xec, 0x91, 0x59, 0xa6, 0x6a, 0x4b, 0xbe, 0x0b, 0xd8, 0x4d, 0xa5, 0x2f, 0x00, 0x6d, 0x7f, + 0xac, 0x6d, 0x59, 0xab, 0x2b, 0xde, 0x08, 0xfb, 0xce, 0xb7, 0x6a, 0x57, 0xff, 0xef, 0x59, 0xc0, + 0x77, 0xf9, 0x00, 0x8a, 0x4a, 0x23, 0x1f, 0xcc, 0x30, 0x2e, 0x4d, 0xda, 0xe9, 0xf3, 0xda, 0xa5, + 0x57, 0x07, 0xc1, 0xed, 0xcd, 0xe8, 0x04, 0x21, 0x76, 0xdc, 0x7d, 0xc6, 0x37, 0x7b, 0xec, 0x58, + 0xb2, 0x36, 0x99, 0x0a, 0xa6, 0xc5, 0x87, 0x6d, 0x5a, 0x27, 0x94, 0x2f, 0xff, 0x7f, 0xd7, 0x4b, + 0x7d, 0xa1, 0xd2, 0xec, 0x47, 0x0c, 0xf7, 0x11, 0x03, 0xa6, 0x4f, 0xd2, 0x91, 0x7a, 0xf4, 0xc4, + 0x5d, 0x4c, 0x59, 0xc1, 0x3f, 0x58, 0x47, 0x2a, 0xf4, 0x08, 0xf9, 0xc5, 0xf9, 0x07, 0xc7, 0xc6, + 0xae, 0x0f, 0x40, 0x2b, 0x40, 0x4a, 0xa4, 0x0c, 0xf8, 0xd9, 0x62, 0xed, 0xef, 0x7b, 0x76, 0x54, + 0xec, 0x8e, 0x36, 0xc6, 0x45, 0x85, 0x5b, 0xbe, 0xcc, 0x13, 0x37, 0xec, 0x18, 0xf0, 0xea, 0x65, + 0x93, 0x3f, 0x4d, 0x07, 0xce, 0xe1, 0x52, 0x94, 0x13, 0x9f, 0x47, 0x9a, 0x16, 0x13, 0x3d, 0x2b, + 0xf4, 0x12, 0xb5, 0xe4, 0x6d, 0x5b, 0x06, 0xfb, 0x17, 0x0f, 0x0c, 0x93, 0xdf, 0xb8, 0xac, 0x3f, + 0x74, 0x78, 0x00, 0x2c, 0xa7, 0x6b, 0x67, 0xa2, 0x72, 0xa3, 0x22, 0x4c, 0x81, 0x72, 0xcd, 0xd8, + 0xa6, 0x16, 0xa4, 0xc5, 0x2f, 0x5f, 0xde, 0x94, 0x6c, 0xf5, 0x73, 0x35, 0x83, 0xc5, 0x38, 0x35, + 0xeb, 0xc9, 0x0d, 0xe3, 0xec, 0xe3, 0x42, 0x99, 0xd7, 0xe5, 0x43, 0x4b, 0xf0, 0x72, 0xf0, 0x8a, + 0x44, 0x90, 0x58, 0x18, 0xee, 0x97, 0x08, 0x81, 0x5c, 0xed, 0x10, 0xe9, 0x04, 0x3e, 0x88, 0xb6, + 0xef, 0x12, 0xbe, 0x72, 0xfc, 0x11, 0x69, 0xff, 0x2f, 0x92, 0x5c, 0x38, 0xe0, 0x3b, 0x82, 0x7c, + 0xde, 0x77, 0x74, 0x0c, 0x7c, 0x28, 0x48, 0xaa, 0x3b, 0x09, 0xf5, 0x55, 0xe2, 0x71, 0x2b, 0x34, + 0x1e, 0x24, 0x87, 0x72, 0xef, 0xcf, 0x01, 0xb9, 0x9c, 0xd5, 0x40, 0x36, 0x42, 0x44, 0x8b, 0x52, + 0x43, 0xf3, 0x5a, 0x30, 0x73, 0xa6, 0xda, 0x76, 0x85, 0xad, 0x42, 0xfe, 0xcb, 0x05, 0xd4, 0x6f, + 0xc9, 0x9f, 0x7d, 0x6b, 0x8e, 0xc5, 0x6f, 0x39, 0xa7, 0xe7, 0xb3, 0x57, 0x9f, 0xcd, 0x58, 0x7e, + 0x07, 0xc0, 0x5b, 0xb7, 0xe1, 0xf5, 0xd4, 0x9b, 0x90, 0x15, 0x37, 0x5e, 0x09, 0xa9, 0xa1, 0x4f, + 0x2c, 0xdf, 0x04, 0x9a, 0xc3, 0x92, 0x13, 0x9e, 0xaa, 0x3c, 0x25, 0x47, 0x42, 0x6b, 0x8c, 0xbc, + 0x0c, 0x4b, 0xa7, 0x6c, 0x55, 0x01, 0x4f, 0xcd, 0x39, 0x40, 0xfe, 0xa2, 0x63, 0x1a, 0x75, 0xcd, + 0x2f, 0xf5, 0xc2, 0x2b, 0x8a, 0x65, 0xc9, 0xaf, 0x2d, 0xb1, 0xb8, 0x31, 0xc3, 0x0e, 0xdc, 0x8e, + 0xb7, 0x9b, 0x79, 0x7e, 0x76, 0xd0, 0x45, 0xef, 0x0b, 0x8e, 0xff, 0x8d, 0x41, 0x40, 0x4f, 0x62, + 0x6d, 0xe8, 0x55, 0x1f, 0xfa, 0x44, 0x58, 0x85, 0xca, 0x1e, 0x3c, 0x9b, 0xf0, 0x5b, 0x5c, 0x39, + 0xcd, 0x40, 0xe3, 0xb3, 0x7c, 0xe3, 0xb5, 0x85, 0x14, 0xbc, 0x70, 0xe2, 0xea, 0x94, 0xcd, 0x69, + 0x4c, 0xa8, 0x8c, 0x1f, 0x47, 0xaa, 0xcf, 0x9b, 0x4f, 0xf6, 0x62, 0x2c, 0x55, 0x5a, 0xab, 0x7c, + 0x71, 0xea, 0x21, 0x0f, 0xaa, 0x9c, 0x0b, 0xf9, 0x08, 0x9d, 0xc9, 0xc9, 0xdf, 0xa7, 0x7c, 0x2c, + 0x4a, 0x92, 0xf5, 0x9b, 0xd7, 0xcd, 0x24, 0xef, 0x4f, 0x8d, 0x50, 0x88, 0xdd, 0xbe, 0x22, 0xde, + 0x85, 0x4f, 0x89, 0x66, 0xc0, 0x17, 0xfb, 0x41, 0x44, 0x64, 0xed, 0x6b, 0x99, 0x1e, 0x28, 0x9f, + 0x7e, 0x3f, 0xea, 0x78, 0x38, 0x31, 0xcc, 0xfb, 0x51, 0xe2, 0x27, 0xa6, 0xdd, 0x4f, 0x5e, 0xf5, + 0x09, 0x63, 0xe8, 0x08, 0x47, 0xfa, 0x6b, 0x35, 0x0a, 0x2d, 0xcd, 0xa3, 0xc8, 0x75, 0xd1, 0x76, + 0x34, 0x2e, 0xd7, 0x3b, 0xb4, 0x2b, 0x41, 0x6e, 0x58, 0xd1, 0x61, 0x2c, 0x4d, 0x06, 0x6f, 0x12, + 0x07, 0xb6, 0xe1, 0x6a, 0x95, 0x5d, 0xcd, 0x55, 0x7a, 0x9e, 0xa3, 0x7a, 0x9f, 0x24, 0xcc, 0xb2, + 0x0e, 0x74, 0xac, 0x4d, 0x61, 0x66, 0xac, 0xeb, 0xcd, 0x7d, 0x65, 0x14, 0x50, 0xe5, 0xd4, 0xae, + 0xa8, 0x6d, 0xc8, 0x95, 0x28, 0xdf, 0xeb, 0xe0, 0x7b, 0x39, 0xa1, 0x60, 0x16, 0x0f, 0xeb, 0xbe, + 0xe5, 0xb1, 0x11, 0x22, 0xb4, 0x17, 0x7f, 0xd0, 0x4b, 0x0a, 0x49, 0x80, 0x3e, 0x49, 0x8f, 0x1b, + 0xff, 0xba, 0x89, 0x8b, 0xe3, 0xb2, 0x63, 0x20, 0x96, 0x61, 0x65, 0xe1, 0x36, 0xf7, 0xf5, 0x17, + 0xfe, 0xa3, 0x5e, 0xdf, 0x01, 0xd3, 0x68, 0x31, 0xf9, 0xab, 0x47, 0x8c, 0xff, 0x82, 0x41, 0xe0, + 0x1a, 0xd7, 0x57, 0x0c, 0x26, 0xea, 0x62, 0x43, 0x90, 0x13, 0xf6, 0x1d, 0x48, 0x79, 0x7b, 0x92, + 0x96, 0x49, 0x03, 0x80, 0x2a, 0xaa, 0xf3, 0x56, 0xc6, 0xaf, 0x76, 0x45, 0xf5, 0xf4, 0x33, 0x8c, + 0x7e, 0xad, 0x5a, 0xb2, 0x89, 0x8c, 0x60, 0x01, 0x23, 0x88, 0x8a, 0xf4, 0x2a, 0x2f, 0xe0, 0x6f, + 0xf0, 0x3d, 0x81, 0x32, 0x0f, 0xc0, 0x8e, 0x75, 0x89, 0xe1, 0x98, 0x87, 0xec, 0x86, 0xcc, 0x1b, + 0x08, 0x20, 0x4c, 0x29, 0xe8, 0x6c, 0xcf, 0x18, 0x7b, 0x12, 0x40, 0xb8, 0x1f, 0x7d, 0x37, 0x5f, + 0x37, 0x62, 0xcb, 0xc1, 0x0f, 0x3b, 0xad, 0xca, 0xd7, 0x43, 0x1e, 0x59, 0xa4, 0xdc, 0x13, 0x64, + 0x40, 0xaa, 0x72, 0x62, 0x8e, 0x17, 0xd2, 0xbc, 0xff, 0x91, 0x6d, 0xbc, 0x8a, 0x66, 0xb8, 0xa8, + 0x3a, 0x3c, 0x64, 0x00, 0xea, 0x0c, 0xc5, 0x7a, 0x82, 0xdb, 0x41, 0xbb, 0x28, 0xce, 0xa9, 0xe9, + 0xce, 0xca, 0x1e, 0xd8, 0x26, 0x71, 0x9b, 0x9b, 0x62, 0xb6, 0xce, 0xd5, 0xb5, 0x2f, 0xa5, 0x18, + 0xfe, 0x47, 0x27, 0x4d, 0xc6, 0xe2, 0x2e, 0x5f, 0x83, 0x98, 0xd4, 0x2a, 0xb2, 0x35, 0x72, 0xcd, + 0x66, 0x23, 0xec, 0x30, 0x7f, 0xb7, 0xef, 0x61, 0x89, 0x2a, 0xe3, 0x19, 0x6c, 0x48, 0x12, 0x56, + 0x05, 0xf4, 0xf0, 0x9b, 0x9c, 0x0f, 0x0d, 0xbb, 0xfb, 0x9d, 0x90, 0x15, 0xd3, 0x25, 0xc5, 0x46, + 0xcf, 0x3b, 0x1d, 0xc8, 0x86, 0xab, 0x0d, 0xef, 0xe2, 0xc3, 0x5c, 0xd3, 0x9e, 0x2a, 0xfd, 0x13, + 0xae, 0xa7, 0x4f, 0x78, 0x7b, 0x41, 0x08, 0x83, 0xeb, 0x72, 0xdb, 0x8c, 0xa7, 0xd2, 0x25, 0xe6, + 0xfe, 0x81, 0x43, 0x69, 0x5b, 0xc0, 0xfe, 0x55, 0x6c, 0x6c, 0xdd, 0xa4, 0x93, 0xf9, 0x2e, 0xd6, + 0x2a, 0x38, 0xe8, 0xf9, 0x0c, 0xc4, 0xc7, 0x13, 0xa4, 0x79, 0x89, 0x84, 0x00, 0x7a, 0x5c, 0xbf, + 0x68, 0xf0, 0xcd, 0xcc, 0x01, 0x27, 0x4c, 0x96, 0xa1, 0x5c, 0x3c, 0x43, 0x55, 0xad, 0xfc, 0x75, + 0xf7, 0xdb, 0x06, 0x03, 0x91, 0x8e, 0xd6, 0xcb, 0x4e, 0x44, 0x91, 0xa8, 0x56, 0x9f, 0xb1, 0xa9, + 0xaf, 0x32, 0x52, 0x8f, 0x6e, 0x26, 0xb2, 0x30, 0x3c, 0x79, 0x87, 0xe3, 0x90, 0x15, 0x57, 0x35, + 0x21, 0xe0, 0x24, 0xb2, 0x23, 0x0b, 0xf1, 0xbb, 0x80, 0x3b, 0xf2, 0xb3, 0x58, 0x88, 0x0f, 0x28, + 0x40, 0xcc, 0x58, 0xac, 0xe3, 0x1e, 0x55, 0x1c, 0x8e, 0x2a, 0x0f, 0x83, 0x49, 0x57, 0x07, 0x41, + 0xf8, 0xe9, 0x30, 0x66, 0xc8, 0xf1, 0x76, 0x08, 0xde, 0x35, 0xae, 0xc3, 0x42, 0x41, 0x5a, 0x4b, + 0xfd, 0xd1, 0x3a, 0x97, 0x57, 0x50, 0x1f, 0x52, 0x46, 0xec, 0xa4, 0x99, 0x13, 0xd0, 0xf0, 0x2e, + 0xff, 0x35, 0xf4, 0xb3, 0xd4, 0x0d, 0xf9, 0x7a, 0x64, 0xb0, 0xfd, 0x02, 0x70, 0x9c, 0x08, 0x32, + 0xc4, 0x23, 0x54, 0x3a, 0x85, 0x07, 0x76, 0xed, 0x9c, 0x05, 0x74, 0xc2, 0x6c, 0xda, 0xb8, 0xdb, + 0x37, 0x1f, 0x5f, 0x4b, 0x73, 0x1e, 0x6f, 0x51, 0x0b, 0xc0, 0x9f, 0xce, 0x3d, 0xbb, 0x58, 0xbb, + 0xae, 0x10, 0x74, 0xcc, 0xac, 0x28, 0x4d, 0x5f, 0x80, 0x68, 0xd2, 0x43, 0x5e, 0x05, 0x3a, 0x03, + 0x7e, 0x3a, 0xbd, 0xc9, 0x57, 0xb7, 0x43, 0x39, 0xef, 0x00, 0x63, 0xd3, 0x67, 0xf7, 0x55, 0x6e, + 0x49, 0xd2, 0xc7, 0xa7, 0xde, 0x36, 0x16, 0xf5, 0xe8, 0xb7, 0x03, 0xb7, 0x58, 0x5f, 0x52, 0x6e, + 0x93, 0x06, 0xc5, 0x93, 0x29, 0xa1, 0x8e, 0x76, 0xb8, 0x53, 0x03, 0xc3, 0x1e, 0x36, 0x16, 0x83, + 0x1f, 0x2a, 0xa2, 0xb1, 0x73, 0xcd, 0x0a, 0x43, 0xcd, 0xe7, 0x6a, 0xe5, 0x2e, 0xfb, 0x8c, 0xf3, + 0xc3, 0x81, 0x09, 0x7d, 0x7a, 0x75, 0x98, 0xec, 0x83, 0x3a, 0x75, 0xe9, 0x7a, 0xe4, 0xdd, 0x53, + 0x9c, 0x31, 0xb3, 0xe4, 0x52, 0x16, 0xef, 0x9c, 0x84, 0x40, 0x08, 0xc2, 0x8d, 0x12, 0xb1, 0x2d, + 0x3c, 0x7e, 0xa7, 0xfb, 0x89, 0xb3, 0xb5, 0xd2, 0x0e, 0xf5, 0xc7, 0x63, 0x6a, 0x8e, 0x83, 0xd6, + 0xa9, 0xf8, 0xf7, 0xdf, 0x29, 0xc9, 0x71, 0x6b, 0x7d, 0x92, 0x31, 0x30, 0x48, 0xa7, 0xe1, 0x4b, + 0x9e, 0xdf, 0x77, 0xfe, 0xba, 0x87, 0x4b, 0x94, 0x10, 0xdc, 0xae, 0xc4, 0x81, 0x6d, 0x2f, 0xb5, + 0x70, 0x50, 0x69, 0x6f, 0x5d, 0x4f, 0x0d, 0xb4, 0x7c, 0x61, 0x83, 0xd4, 0x47, 0xc5, 0xaf, 0xbc, + 0xb9, 0x48, 0xd0, 0x99, 0x44, 0xf4, 0x27, 0x13, 0x68, 0x54, 0x2e, 0x37, 0x7d, 0xee, 0xcd, 0x00, + 0x67, 0x79, 0xf6, 0xf7, 0x64, 0x9b, 0x94, 0x6e, 0x79, 0xbb, 0xf2, 0xe1, 0x9a, 0xb4, 0xe9, 0x3f, + 0x14, 0x2b, 0xb2, 0x4e, 0x6d, 0x96, 0x2f, 0x66, 0x48, 0xcd, 0x0b, 0xf1, 0xbe, 0x87, 0x6f, 0x6f, + 0x43, 0x1e, 0x88, 0x31, 0x05, 0xc3, 0xe8, 0x6b, 0x97, 0x3e, 0x30, 0x73, 0x5a, 0x6f, 0xe1, 0x73, + 0x46, 0xec, 0xbe, 0xed, 0x5d, 0x10, 0x1e, 0xf0, 0xaa, 0xfb, 0xbb, 0x4c, 0x07, 0x2b, 0xad, 0xaa, + 0x2f, 0x4d, 0x51, 0x7c, 0x27, 0x2f, 0x2b, 0xd2, 0x19, 0x0f, 0x5f, 0x8c, 0x87, 0xd9, 0x61, 0x04, + 0x1a, 0x12, 0x1d, 0x6b, 0x31, 0x9e, 0xbc, 0x95, 0x9a, 0xb0, 0x60, 0x30, 0x96, 0x01, 0x7b, 0xf7, + 0xcb, 0xb7, 0x4d, 0xbc, 0x74, 0xfb, 0x86, 0x63, 0x58, 0xef, 0x8c, 0x1a, 0xa5, 0xb9, 0xa1, 0x0b, + 0x2c, 0x52, 0x4e, 0x82, 0x22, 0x78, 0x62, 0x7c, 0x0a, 0xc5, 0x77, 0xae, 0x93, 0x83, 0xc2, 0xa5, + 0x29, 0x05, 0x45, 0x28, 0xe5, 0x8d, 0x56, 0x69, 0x95, 0x40, 0xe4, 0x93, 0x1b, 0xc6, 0x5a, 0x12, + 0x5e, 0xf4, 0xb4, 0x59, 0xa7, 0xa5, 0xfc, 0x10, 0xe0, 0x32, 0x4a, 0xcb, 0x64, 0x1b, 0xa3, 0x3c, + 0x83, 0xa7, 0xe1, 0x00, 0xcb, 0x00, 0xff, 0xe0, 0xab, 0xf6, 0x28, 0x1f, 0x89, 0x42, 0xae, 0x54, + 0x90, 0xdc, 0xca, 0x37, 0xbf, 0x46, 0x4d, 0x0b, 0x06, 0x10, 0x28, 0xe4, 0x6e, 0x02, 0x5f, 0xbd, + 0x5f, 0x6d, 0xd6, 0xca, 0x1b, 0xeb, 0xee, 0x28, 0x2b, 0x74, 0x9f, 0xf5, 0xb0, 0x02, 0x21, 0x09, + 0x16, 0xb9, 0xcd, 0xc4, 0xd9, 0x03, 0xa9, 0x59, 0x72, 0xfc, 0xec, 0xb9, 0x29, 0x2a, 0x55, 0x4a, + 0xeb, 0xd8, 0x21, 0xab, 0x4c, 0xc5, 0x0d, 0x5e, 0xa0, 0xa3, 0x3a, 0x69, 0x9f, 0xbf, 0x07, 0xf2, + 0xca, 0x52, 0x0f, 0xc4, 0x4d, 0x4a, 0x95, 0x81, 0x18, 0x22, 0x90, 0x29, 0x4a, 0x8f, 0xcc, 0x66, + 0xde, 0x3f, 0xb5, 0xb7, 0xf5, 0xec, 0x5b, 0x26, 0x7d, 0x1a, 0x0e, 0x6f, 0x84, 0xc2, 0x7c, 0x02, + 0x25, 0x36, 0x49, 0xf5, 0x90, 0x33, 0x89, 0xa0, 0x90, 0x17, 0x97, 0xa7, 0xec, 0x8b, 0x78, 0xaf, + 0x12, 0xbf, 0x2b, 0x1c, 0xc2, 0x2d, 0x29, 0x13, 0x47, 0xa0, 0xf8, 0xd6, 0xeb, 0x26, 0x98, 0xaf, + 0xca, 0x7c, 0xb4, 0xc2, 0x3e, 0xdf, 0x25, 0x0a, 0x5b, 0x77, 0xe5, 0x1e, 0xff, 0xa3, 0xc6, 0x75, + 0xf1, 0xfa, 0x95, 0x1d, 0x72, 0x46, 0x7e, 0xda, 0xf9, 0x87, 0xd5, 0xb6, 0x3d, 0xe4, 0x17, 0x75, + 0x35, 0x97, 0x4b, 0xb2, 0x00, 0x6a, 0xa9, 0xa8, 0xdd, 0x9e, 0x62, 0x41, 0x08, 0x22, 0x9b, 0x1c, + 0x57, 0x35, 0xbb, 0x03, 0x9c, 0xce, 0x47, 0x16, 0x2e, 0xb5, 0x2d, 0xe8, 0x87, 0x03, 0xa8, 0xbd, + 0xb8, 0xed, 0x40, 0x9b, 0xc0, 0x1d, 0xab, 0xad, 0xfd, 0x31, 0xeb, 0xb9, 0x5c, 0xad, 0x90, 0x26, + 0x70, 0x5d, 0xba, 0xe5, 0xa2, 0xd0, 0x63, 0x76, 0x32, 0x0b, 0xcf, 0xac, 0x17, 0xa7, 0xda, 0xc9, + 0x57, 0xbf, 0xee, 0x98, 0x48, 0x0c, 0x7a, 0x11, 0x1b, 0x5e, 0xd3, 0x00, 0x44, 0x7a, 0x21, 0xfe, + 0x62, 0x44, 0x8f, 0x62, 0xcc, 0xff, 0x7d, 0xa6, 0x86, 0x89, 0xa7, 0x3a, 0x2e, 0xc7, 0x0b, 0xd1, + 0x31, 0x30, 0x33, 0x7e, 0xab, 0xf2, 0x6a, 0x00, 0xbf, 0x86, 0xe5, 0x20, 0x77, 0xea, 0x00, 0xda, + 0x46, 0xfe, 0x73, 0x23, 0x78, 0x0c, 0xf9, 0x8b, 0x3e, 0x99, 0x8b, 0xb3, 0x0c, 0x39, 0x98, 0x01, + 0x7f, 0x4b, 0xea, 0x45, 0x55, 0x68, 0xfc, 0xd5, 0x67, 0x08, 0x6e, 0xc6, 0x8a, 0xbc, 0x40, 0x11, + 0x3d, 0xb4, 0x74, 0xc6, 0xc8, 0x8b, 0x1c, 0x1c, 0x75, 0x88, 0xe7, 0xa8, 0xc8, 0xd2, 0x08, 0x2d, + 0x4c, 0x70, 0xdc, 0xb8, 0xfc, 0x3d, 0x8f, 0xba, 0xc5, 0x3c, 0xae, 0x95, 0x28, 0x6f, 0x13, 0x25, + 0x42, 0x53, 0x86, 0x15, 0x67, 0xe4, 0x71, 0x5b, 0x03, 0xe6, 0x82, 0xe4, 0x22, 0xc1, 0x11, 0x16, + 0x9d, 0x96, 0x35, 0x9e, 0xe1, 0x82, 0x65, 0xc3, 0xca, 0xdb, 0xab, 0x3a, 0xe6, 0x1f, 0x03, 0xf8, + 0x6d, 0x09, 0x6a, 0xda, 0xe9, 0xa6, 0xc4, 0x82, 0x0e, 0xbe, 0x3b, 0x61, 0x01, 0x59, 0x95, 0x70, + 0x76, 0x95, 0xb4, 0x2b, 0x67, 0x80, 0x2f, 0xac, 0x2d, 0x6f, 0xbb, 0x2b, 0x67, 0x80, 0x1a, 0x3e, + 0x48, 0x84, 0x3e, 0xb8, 0x32, 0x88, 0xab, 0x52, 0xc2, 0x9c, 0x1f, 0x11, 0x2f, 0x92, 0x33, 0x86, + 0x06, 0x12, 0xba, 0x01, 0x5d, 0x4b, 0x7c, 0xab, 0xc1, 0x9c, 0x62, 0x94, 0xf8, 0x87, 0x1e, 0x2e, + 0xcf, 0x6a, 0xf3, 0x34, 0xdf, 0x9c, 0x83, 0x30, 0x97, 0x12, 0x77, 0xe3, 0x2c, 0xf1, 0x48, 0x8f, + 0x04, 0xb4, 0xb2, 0x85, 0xae, 0xea, 0xa8, 0x3b, 0xb8, 0x1d, 0x54, 0xb6, 0xb8, 0x42, 0x64, 0x39, + 0x80, 0x4b, 0x02, 0x78, 0x22, 0x37, 0x3a, 0xb9, 0x98, 0x68, 0xec, 0x06, 0x87, 0x35, 0xc8, 0x16, + 0x52, 0x1b, 0xd7, 0x5d, 0xc1, 0x9f, 0x79, 0xd2, 0xe2, 0x16, 0x6b, 0x1a, 0x55, 0x1c, 0x99, 0x83, + 0x18, 0xfe, 0x19, 0xf5, 0x07, 0x9b, 0xaa, 0xdb, 0x12, 0x73, 0x25, 0x28, 0xbc, 0x8b, 0x52, 0x24, + 0x38, 0xaa, 0xd2, 0x52, 0xc5, 0x7d, 0x38, 0x99, 0x40, 0x09, 0x13, 0xcd, 0x12, 0x4d, 0x2d, 0xbe, + 0x90, 0xa8, 0x91, 0xd9, 0x59, 0x00, 0xc0, 0x25, 0x6d, 0x9d, 0xdb, 0xf9, 0x39, 0xba, 0xdc, 0xf6, + 0xe3, 0x7e, 0x67, 0x83, 0xda, 0x2a, 0x2b, 0xaa, 0xd8, 0x72, 0xf6, 0xc8, 0xc1, 0x18, 0x78, 0xed, + 0x6d, 0x5e, 0xe2, 0x98, 0x81, 0x35, 0xa3, 0x9f, 0x2d, 0xac, 0x7c, 0xf1, 0x27, 0x10, 0x0c, 0x36, + 0xd2, 0xd4, 0xe5, 0x8b, 0x3a, 0x9b, 0x1d, 0x73, 0x41, 0x12, 0x0f, 0xfc, 0xa0, 0xee, 0xd2, 0xe9, + 0x8e, 0x02, 0x0a, 0x46, 0xf1, 0xae, 0xcb, 0xc8, 0x09, 0xa2, 0x1e, 0xf7, 0x9e, 0x6d, 0xbc, 0xe7, + 0x6f, 0x96, 0xb6, 0x93, 0x01, 0x07, 0xf0, 0x78, 0xa5, 0xd4, 0x46, 0x4c, 0xfe, 0xac, 0x41, 0x4c, + 0xa4, 0x1a, 0x5e, 0xe4, 0xf8, 0x7c, 0xcd, 0x88, 0x68, 0xe7, 0x92, 0x2a, 0x14, 0xc2, 0x47, 0x88, + 0x5f, 0x0d, 0xa9, 0xe2, 0x3a, 0x76, 0x04, 0xed, 0xe7, 0x03, 0xc2, 0xbe, 0x36, 0x33, 0xaf, 0x9c, + 0xcc, 0x32, 0xb9, 0xe5, 0xf5, 0x1c, 0xf5, 0x19, 0x78, 0xf1, 0x0a, 0x06, 0xf5, 0xd7, 0x7c, 0x67, + 0x92, 0x7d, 0x80, 0xae, 0x48, 0x0e, 0x7e, 0x5e, 0x00, 0x54, 0x01, 0xed, 0x95, 0x46, 0x79, 0x72, + 0xed, 0x87, 0x02, 0x90, 0x29, 0xda, 0x05, 0xdf, 0xbc, 0xf2, 0xf0, 0xb9, 0xd5, 0x04, 0x41, 0xe8, + 0xf1, 0x58, 0x04, 0xb0, 0xa5, 0x9d, 0x23, 0xcf, 0xc2, 0xe3, 0xc0, 0xfb, 0xfc, 0xb1, 0x0b, 0x69, + 0xaa, 0xdf, 0x0b, 0x37, 0xc0, 0x6d, 0xbf, 0x97, 0x2e, 0x26, 0x4c, 0x6c, 0xde, 0x41, 0x42, 0xc0, + 0x4f, 0xfd, 0x9f, 0xa0, 0xaf, 0x24, 0x51, 0xf8, 0xbe, 0xc3, 0xfd, 0xe9, 0x72, 0x33, 0x06, 0x08, + 0x5e, 0xce, 0xfb, 0x17, 0xc5, 0x91, 0xe6, 0x91, 0xf9, 0xb4, 0xd4, 0xf7, 0x96, 0xe2, 0x93, 0xc0, + 0xcd, 0x32, 0x2f, 0x02, 0xb9, 0x69, 0x38, 0xa5, 0xf7, 0xd1, 0xc8, 0xa7, 0xfe, 0xb9, 0x4c, 0x03, + 0x1d, 0xe2, 0x4e, 0x71, 0x02, 0x0f, 0xf3, 0x7e, 0x00, 0x59, 0x0a, 0xe7, 0xca, 0x48, 0xca, 0x87, + 0x6a, 0xfc, 0xa2, 0xbe, 0x37, 0x23, 0xea, 0xad, 0x40, 0xfd, 0x27, 0xb9, 0x0f, 0xe6, 0xea, 0x03, + 0x9c, 0x9f, 0x3f, 0x60, 0x69, 0xfd, 0xbc, 0x70, 0xf1, 0x66, 0x26, 0xa4, 0x16, 0x78, 0xa3, 0x1e, + 0x8a, 0xd8, 0x8d, 0xe9, 0xbc, 0xe8, 0xa2, 0x5d, 0x43, 0xb8, 0x6e, 0xbf, 0x80, 0xe5, 0xe4, 0x26, + 0xfe, 0x21, 0x60, 0x6e, 0x67, 0x54, 0x5f, 0xf8, 0xe5, 0x5f, 0xa7, 0xd9, 0x80, 0x2d, 0x65, 0xaf, + 0xbd, 0xa7, 0x9e, 0xf4, 0x0d, 0xe9, 0x24, 0xfd, 0x0d, 0xa7, 0xb5, 0xc8, 0xf6, 0xa2, 0xcf, 0x99, + 0x3f, 0xa6, 0xd2, 0x7b, 0x28, 0x61, 0xc6, 0x29, 0xcc, 0x9b, 0xd2, 0xe1, 0xe6, 0xaf, 0x04, 0xf8, + 0x80, 0x65, 0x61, 0x4f, 0x7e, 0x24, 0xcd, 0xd1, 0x9c, 0x88, 0xcf, 0x2d, 0x7d, 0x2b, 0x93, 0xb7, + 0x40, 0x8d, 0x89, 0x85, 0x25, 0xe5, 0x14, 0x1f, 0xf7, 0x1d, 0x18, 0xda, 0xba, 0xc1, 0x86, 0xdc, + 0xd4, 0x32, 0xf3, 0x89, 0x5a, 0x10, 0x27, 0xc9, 0x2c, 0xf8, 0x61, 0x3c, 0x80, 0xbd, 0x46, 0xe4, + 0x75, 0x8c, 0xa2, 0x6c, 0x8c, 0xd9, 0x2b, 0x74, 0xee, 0xbc, 0x5f, 0xa5, 0xed, 0xf9, 0xc9, 0xfe, + 0xc5, 0x4f, 0xea, 0xc4, 0x0f, 0x09, 0x44, 0xe3, 0xfa, 0x16, 0x5e, 0x51, 0x5a, 0x03, 0xdb, 0x57, + 0xc2, 0x05, 0xd3, 0x83, 0xc0, 0x4b, 0x2c, 0xbf, 0xf7, 0x03, 0x93, 0x9e, 0xf3, 0x21, 0xdf, 0x8a, + 0x49, 0xbc, 0x3f, 0x5b, 0x14, 0x09, 0xea, 0x49, 0x10, 0x62, 0xb7, 0xb9, 0x98, 0x22, 0x77, 0x82, + 0x5b, 0x52, 0xc6, 0xcc, 0x83, 0x13, 0xba, 0x05, 0xab, 0xff, 0xcd, 0xfa, 0x52, 0x54, 0x45, 0xb1, + 0xcf, 0xf7, 0x73, 0xd2, 0x85, 0x36, 0xa9, 0x89, 0xd2, 0x57, 0x96, 0x7b, 0x50, 0xd7, 0xbe, 0xc4, + 0xfd, 0xe5, 0xf3, 0x38, 0xd2, 0xae, 0x81, 0xbc, 0x8e, 0xc5, 0x92, 0xbe, 0x93, 0xbd, 0xa0, 0xa7, + 0xdd, 0x08, 0x90, 0x57, 0xe6, 0x75, 0x67, 0x4e, 0x8b, 0x99, 0x7b, 0x05, 0xd0, 0x49, 0xca, 0x3d, + 0xbd, 0x60, 0xb7, 0xf3, 0xfb, 0x23, 0xba, 0x5f, 0x4e, 0x5a, 0x48, 0xed, 0x85, 0x35, 0x23, 0x4e, + 0x5c, 0x66, 0xc4, 0x1b, 0x15, 0x7c, 0x25, 0xb5, 0xd9, 0xef, 0x5c, 0x8c, 0x0e, 0xd0, 0x16, 0xd6, + 0xb2, 0x17, 0xf4, 0xb6, 0x0b, 0xfd, 0x0d, 0xa2, 0x23, 0xa5, 0xd4, 0x0c, 0x2a, 0x40, 0x3d, 0xe8, + 0x26, 0x8a, 0xd5, 0xe6, 0x20, 0x7c, 0x54, 0xb2, 0x17, 0xc2, 0xf0, 0x09, 0xc5, 0xdd, 0x05, 0x22, + 0x66, 0x72, 0x2d, 0xc2, 0x1d, 0x4a, 0xd8, 0x31, 0x4d, 0xe4, 0x98, 0x69, 0x2e, 0x3c, 0x77, 0xc9, + 0xf8, 0x22, 0x6a, 0x14, 0xf2, 0x7d, 0x49, 0xe0, 0xda, 0x11, 0x01, 0xe3, 0x2e, 0x5b, 0x86, 0xbc, + 0x0f, 0x03, 0x48, 0xa2, 0x0a, 0x36, 0x0a, 0x91, 0x9e, 0xc8, 0x63, 0x69, 0x5d, 0x2e, 0xc3, 0x18, + 0xa6, 0x1f, 0x65, 0x4c, 0x9a, 0x15, 0x26, 0xaf, 0x15, 0x38, 0xf9, 0x28, 0xdb, 0x76, 0xf9, 0xb1, + 0x4e, 0xf5, 0x98, 0xf2, 0x55, 0x1e, 0xe8, 0x5d, 0x6e, 0x04, 0x29, 0x19, 0x2c, 0x5f, 0x18, 0xd3, + 0x39, 0xdd, 0x5a, 0x28, 0x0d, 0xd5, 0xb1, 0xa8, 0xf5, 0x9e, 0xc1, 0xf2, 0x94, 0x79, 0x96, 0xc7, + 0xe1, 0x90, 0xc8, 0x75, 0x02, 0xfd, 0xf5, 0x00, 0x47, 0x72, 0x22, 0x4b, 0xbd, 0x1c, 0x4d, 0xd6, + 0x2a, 0x8d, 0xa1, 0x72, 0x3e, 0xdb, 0x41, 0x17, 0x6a, 0x9a, 0xf0, 0x4b, 0x1f, 0x30, 0xd0, 0x90, + 0x50, 0xe7, 0x35, 0x79, 0x36, 0x43, 0x60, 0xdb, 0x4f, 0x98, 0x03, 0x4f, 0xec, 0x1b, 0x43, 0xe6, + 0xe9, 0xe0, 0x22, 0x64, 0x09, 0xe6, 0xaf, 0x16, 0x09, 0xfe, 0xb8, 0x62, 0xd8, 0x45, 0x99, 0x4b, + 0xc2, 0x0e, 0x67, 0x01, 0x02, 0x37, 0xb7, 0x4d, 0xf1, 0xab, 0x59, 0xed, 0xf1, 0x4b, 0x16, 0x23, + 0xfd, 0xc9, 0x90, 0xb8, 0x7b, 0x92, 0x9f, 0xb7, 0xe8, 0x37, 0xb1, 0xed, 0x90, 0x52, 0x86, 0xa8, + 0x86, 0xf5, 0x9b, 0x02, 0x3f, 0x40, 0xb0, 0x7a, 0x98, 0x9e, 0xf7, 0xa9, 0x9e, 0x97, 0x4e, 0xba, + 0xec, 0x49, 0xb4, 0x5f, 0xee, 0x1f, 0x40, 0x5d, 0x11, 0xa6, 0x41, 0xb2, 0xb1, 0x50, 0xeb, 0xe8, + 0x54, 0xf7, 0x85, 0x3f, 0x06, 0x02, 0x6c, 0xb1, 0x28, 0x7f, 0xd8, 0xbc, 0xef, 0xb1, 0x5d, 0x2a, + 0xea, 0x62, 0x3d, 0x7c, 0x3a, 0xda, 0xa0, 0x0b, 0x35, 0xa1, 0x05, 0xab, 0xf2, 0xd8, 0xf9, 0x71, + 0x5b, 0xe6, 0x5a, 0xfc, 0xc1, 0x38, 0x1d, 0x29, 0xc5, 0xef, 0x39, 0x8f, 0x2b, 0x76, 0xfe, 0x16, + 0x51, 0x34, 0x8b, 0xaa, 0xc1, 0x47, 0xcf, 0xaf, 0xf3, 0x47, 0x78, 0x24, 0x2b, 0x32, 0xa1, 0x62, + 0x0e, 0x03, 0x32, 0xee, 0xc7, 0xaf, 0x5e, 0x75, 0x0d, 0xfe, 0xc3, 0x0a, 0x89, 0x94, 0x52, 0xad, + 0xc5, 0x30, 0xdd, 0x93, 0x3a, 0x07, 0x74, 0x8d, 0xd5, 0x22, 0xac, 0x20, 0xae, 0x2b, 0x28, 0x89, + 0xfa, 0xc3, 0x23, 0x7d, 0x23, 0xc4, 0x47, 0x2f, 0xc8, 0xc6, 0xb2, 0x36, 0xd4, 0xa4, 0xd1, 0x9f, + 0x67, 0x26, 0x4f, 0x54, 0xbb, 0x9b, 0x25, 0x31, 0x81, 0x56, 0xb3, 0x0e, 0xdf, 0x27, 0x3b, 0xbf, + 0x35, 0x98, 0xaf, 0x5b, 0x34, 0xba, 0xd4, 0x15, 0x85, 0x98, 0x2f, 0x60, 0x39, 0xf6, 0xe4, 0x88, + 0x30, 0x8b, 0x47, 0xea, 0xea, 0x5d, 0x21, 0xa9, 0x1e, 0x58, 0x38, 0xf7, 0xd9, 0xcc, 0xc8, 0xf7, + 0x26, 0xeb, 0x2d, 0xb8, 0x2d, 0x02, 0x2b, 0xaf, 0x10, 0x3a, 0xb2, 0xdd, 0x44, 0x44, 0x89, 0xb9, + 0x4e, 0x8d, 0xdb, 0xa7, 0x1e, 0x62, 0xab, 0x62, 0x51, 0xdd, 0x5d, 0x5f, 0x69, 0xe4, 0x4f, 0x37, + 0x76, 0x74, 0xa5, 0xc2, 0xb0, 0x32, 0x15, 0x0c, 0x32, 0x66, 0x4c, 0x96, 0xc0, 0x72, 0x86, 0x7b, + 0xb7, 0xa2, 0xdc, 0x29, 0x03, 0x3e, 0x6b, 0xcc, 0xae, 0xdd, 0xea, 0x43, 0x0e, 0x5e, 0x15, 0x5d, + 0xd0, 0x72, 0x4f, 0xcb, 0xc0, 0x41, 0x5b, 0x2a, 0xb6, 0xdf, 0xe6, 0x8a, 0x2e, 0x59, 0x40, 0x3b, + 0x20, 0x6b, 0xbe, 0x7f, 0x42, 0x1f, 0xaa, 0xc5, 0x3f, 0x66, 0x04, 0x0c, 0x5c, 0xcc, 0xeb, 0x19, + 0xf1, 0x7b, 0xf0, 0x00, 0xae, 0xa7, 0xe7, 0x75, 0x21, 0x1e, 0x48, 0xae, 0x04, 0xab, 0x32, 0xb2, + 0xea, 0x47, 0x0f, 0xf9, 0x77, 0x07, 0xd9, 0xc0, 0x73, 0xfe, 0x72, 0xa7, 0xb7, 0x7d, 0x49, 0xff, + 0x8d, 0xea, 0x36, 0x61, 0x0c, 0x2a, 0x83, 0x30, 0x64, 0x35, 0x86, 0x1b, 0xe0, 0x1d, 0xc4, 0xb2, + 0x0d, 0xbb, 0x8a, 0xa6, 0xcb, 0x78, 0x03, 0x28, 0xdc, 0xfc, 0x2a, 0x32, 0xd7, 0x4c, 0xab, 0xa8, + 0x39, 0x29, 0xcb, 0xc8, 0x5e, 0x40, 0x6e, 0x74, 0xee, 0xdb, 0x72, 0x7a, 0x2f, 0xb5, 0xbd, 0x9d, + 0x30, 0x4a, 0xf4, 0x62, 0x25, 0x83, 0x28, 0x58, 0xb2, 0x95, 0xa1, 0x7b, 0x9e, 0x71, 0x0b, 0xd7, + 0xb0, 0xb5, 0xd1, 0x9d, 0xbb, 0xf4, 0xfd, 0x02, 0x1e, 0xaf, 0x29, 0xf4, 0xd1, 0xb6, 0xbd, 0x7e, + 0x78, 0xc8, 0xa3, 0xe3, 0x23, 0x5b, 0x5d, 0x0b, 0xc6, 0x87, 0xbd, 0x5b, 0x42, 0x8d, 0x23, 0x18, + 0xcf, 0x43, 0x30, 0xec, 0x34, 0x35, 0x66, 0xd4, 0x2d, 0x17, 0xbe, 0x83, 0x8e, 0xee, 0xdf, 0x70, + 0xf1, 0xe4, 0x09, 0xc1, 0x89, 0xdb, 0x1a, 0xe0, 0xa2, 0x05, 0xd2, 0x22, 0xc9, 0x2a, 0x1a, 0xdd, + 0x33, 0xb8, 0xe3, 0xb1, 0x26, 0xaf, 0x62, 0x81, 0x8a, 0x2d, 0xbe, 0x3e, 0x3c, 0x00, 0x10, 0x98, + 0xa9, 0x86, 0x86, 0x5c, 0x6b, 0x57, 0xd0, 0xb2, 0xf5, 0x57, 0x9b, 0x97, 0xb6, 0xf1, 0x01, 0xeb, + 0x56, 0xfa, 0x83, 0x9f, 0x87, 0x89, 0xf6, 0x77, 0x40, 0x74, 0x18, 0x5a, 0x8e, 0x0f, 0x38, 0x3e, + 0x9d, 0x88, 0x13, 0xca, 0x16, 0x70, 0xd8, 0xb7, 0x58, 0x6a, 0x3a, 0x1c, 0x27, 0xa3, 0xf5, 0xa3, + 0x87, 0x4c, 0x4e, 0x74, 0x3e, 0xae, 0x21, 0xbc, 0x51, 0x9d, 0xcc, 0x43, 0x0e, 0x28, 0x1d, 0x2f, + 0x73, 0xc2, 0x3b, 0xab, 0x94, 0x89, 0x38, 0xa4, 0x6f, 0xc2, 0x4d, 0xa9, 0x46, 0x47, 0x15, 0x0d, + 0xb7, 0x27, 0x83, 0xab, 0x3f, 0xac, 0x01, 0xd8, 0x34, 0xa8, 0x54, 0x4f, 0x14, 0x47, 0x79, 0xa5, + 0x14, 0x80, 0x64, 0x3c, 0xb1, 0xac, 0xca, 0x0b, 0xf8, 0x8d, 0x20, 0x3f, 0x86, 0x56, 0x64, 0xa5, + 0xec, 0xe1, 0x8a, 0x88, 0xce, 0x31, 0xb0, 0xd8, 0xfe, 0xec, 0x58, 0x5f, 0x95, 0x31, 0x32, 0x90, + 0x02, 0xd4, 0xff, 0xab, 0xed, 0x01, 0xef, 0x42, 0xaf, 0x52, 0xdd, 0xf0, 0x84, 0x00, 0xc5, 0x8d, + 0x07, 0xe9, 0x80, 0x46, 0xd7, 0x7c, 0x7a, 0x14, 0x2b, 0x51, 0x3d, 0xa0, 0xee, 0x79, 0x5d, 0xd5, + 0x7e, 0xa4, 0x3f, 0x4c, 0xe3, 0x6c, 0x8f, 0x6d, 0x28, 0x62, 0x04, 0x49, 0x45, 0xdc, 0x29, 0x3c, + 0x8d, 0x47, 0xd9, 0xf2, 0x07, 0xb0, 0x34, 0x42, 0x20, 0xe3, 0x17, 0x7d, 0x6e, 0x17, 0xa4, 0xb3, + 0x9b, 0x22, 0xcc, 0xae, 0x3c, 0x53, 0xd4, 0xe0, 0xdc, 0x87, 0xf7, 0x0c, 0xbe, 0x9b, 0xf7, 0x43, + 0xce, 0xac, 0xb8, 0x93, 0x2d, 0xf8, 0xf8, 0x4a, 0x52, 0x7c, 0x9f, 0xb8, 0x4c, 0x6c, 0xf5, 0x20, + 0x6e, 0xc2, 0xe4, 0x3d, 0x1f, 0xf8, 0xe8, 0x46, 0xda, 0x06, 0xeb, 0xff, 0xfb, 0x87, 0xbe, 0xc0, + 0x9c, 0x63, 0xe9, 0x63, 0x37, 0x13, 0x76, 0x80, 0x60, 0xec, 0xa6, 0x25, 0x9a, 0xaf, 0xe7, 0xc7, + 0x87, 0xf3, 0x94, 0x7d, 0x5b, 0x94, 0xa6, 0xb8, 0x0f, 0xf0, 0xa7, 0xa4, 0x78, 0x58, 0x36, 0xf9, + 0xa1, 0x39, 0x68, 0x33, 0x34, 0x7c, 0x13, 0x03, 0x40, 0x40, 0xd1, 0xc6, 0xb1, 0xf8, 0x37, 0x82, + 0xaa, 0x64, 0x58, 0x32, 0x81, 0x60, 0xfa, 0x04, 0x97, 0x1d, 0xe0, 0x4a, 0x16, 0xb6, 0xc0, 0x31, + 0xb2, 0x57, 0x1d, 0xd1, 0x31, 0x91, 0x2c, 0xdf, 0x25, 0x15, 0xdd, 0x56, 0x98, 0x3e, 0xd6, 0xef, + 0x3b, 0xbe, 0x5b, 0x39, 0x89, 0xe9, 0x51, 0xbf, 0x0b, 0x99, 0xc5, 0x60, 0x5c, 0x38, 0x18, 0x1e, + 0x96, 0x69, 0x04, 0x87, 0xe8, 0x72, 0x40, 0x05, 0x9d, 0xe2, 0x1b, 0xd2, 0x20, 0x05, 0x9e, 0x5d, + 0x7e, 0x3c, 0x83, 0x2f, 0xd4, 0x56, 0x9b, 0xb7, 0xdf, 0x06, 0x43, 0x71, 0x97, 0xca, 0xc1, 0x41, + 0xe8, 0xfe, 0x5b, 0x36, 0x9b, 0x54, 0x2c, 0xbe, 0xed, 0x2f, 0x90, 0x25, 0xa0, 0x30, 0xc5, 0x4f, + 0x0b, 0x5d, 0x2b, 0x1e, 0x79, 0x01, 0x1c, 0xf2, 0xa0, 0xa0, 0xdb, 0x14, 0x31, 0x2e, 0x35, 0x2d, + 0x07, 0xbc, 0x03, 0xe6, 0x54, 0xaa, 0xba, 0xa9, 0x5a, 0xfd, 0x30, 0xf1, 0x48, 0x3b, 0x57, 0xbb, + 0x1a, 0x74, 0xa0, 0xcd, 0xf8, 0xc9, 0xfd, 0xeb, 0xe4, 0xb0, 0xe1, 0x56, 0xfe, 0x86, 0xbb, 0x1e, + 0x21, 0xd8, 0x61, 0xf8, 0xeb, 0xe0, 0xc4, 0xab, 0x2b, 0x23, 0xe7, 0x76, 0xec, 0x01, 0xa2, 0x81, + 0xf6, 0xda, 0x9b, 0xec, 0x4c, 0x56, 0x06, 0x68, 0xb4, 0xee, 0xc7, 0x18, 0x56, 0xe6, 0xcc, 0x41, + 0x74, 0x1d, 0xf2, 0xeb, 0xbd, 0x4e, 0x95, 0xb6, 0x61, 0xec, 0x24, 0xfe, 0x31, 0xb1, 0xda, 0xab, + 0xc9, 0x37, 0x3c, 0xcb, 0xc8, 0x2f, 0x3c, 0x13, 0xc3, 0x1e, 0x47, 0x80, 0x97, 0x25, 0x98, 0x50, + 0x22, 0x19, 0x28, 0xc7, 0xac, 0x6b, 0xb9, 0x33, 0xa5, 0x63, 0x1c, 0x89, 0x6a, 0xca, 0x87, 0xfb, + 0x6f, 0x5e, 0x3e, 0xef, 0x36, 0xef, 0x5b, 0x9c, 0xe5, 0x9f, 0x56, 0x76, 0x81, 0x3a, 0x1a, 0x7e, + 0x76, 0x8f, 0xc9, 0xb8, 0xad, 0x4a, 0x0a, 0x07, 0x26, 0x72, 0xba, 0x23, 0xcc, 0x21, 0xb2, 0x1a, + 0x95, 0xc9, 0xbb, 0xb1, 0xa4, 0x0f, 0xdf, 0xeb, 0xd2, 0xd6, 0x11, 0xb7, 0x73, 0xdf, 0xa5, 0x5f, + 0x87, 0xe9, 0xab, 0x1c, 0xe5, 0x1c, 0xc4, 0x2b, 0x0f, 0xe2, 0xfe, 0x15, 0xda, 0x2d, 0x73, 0xf6, + 0x56, 0xca, 0x56, 0x27, 0x9a, 0xa1, 0x67, 0x22, 0xab, 0xae, 0xd5, 0x72, 0x75, 0x19, 0xea, 0x25, + 0x87, 0x94, 0x50, 0x3f, 0x18, 0x08, 0xe4, 0xeb, 0xf0, 0x56, 0x53, 0x0b, 0x31, 0x8b, 0x99, 0xa7, + 0x48, 0x86, 0xd0, 0x5d, 0x04, 0x2d, 0xf4, 0xd8, 0x29, 0xc4, 0x25, 0xc9, 0x08, 0xb5, 0x81, 0x62, + 0xee, 0x30, 0xa0, 0x73, 0xd4, 0xbb, 0x7d, 0x27, 0x27, 0x5b, 0x54, 0x8e, 0x7a, 0x90, 0xe6, 0xd1, + 0x78, 0xdd, 0x27, 0xf6, 0x7c, 0xd9, 0x55, 0x27, 0x08, 0x25, 0xfb, 0x96, 0x30, 0x0c, 0x46, 0x45, + 0xe4, 0xcd, 0x9c, 0x17, 0x5c, 0x11, 0x85, 0x70, 0x7d, 0x4d, 0x36, 0x59, 0x55, 0xfc, 0xfd, 0x24, + 0x5a, 0x55, 0xd6, 0x4e, 0xfb, 0x66, 0x30, 0x8a, 0x47, 0xfc, 0x85, 0x59, 0x2b, 0xfb, 0x75, 0x5e, + 0xb4, 0xaa, 0x8b, 0x78, 0xb5, 0x41, 0x27, 0x4e, 0x2c, 0x22, 0x5d, 0xad, 0x64, 0x9c, 0x24, 0x8e, + 0x7f, 0x27, 0x92, 0xa5, 0x6b, 0xfb, 0xef, 0x70, 0x45, 0x51, 0x58, 0x84, 0x60, 0xb1, 0x92, 0xda, + 0xfb, 0x9b, 0xf6, 0x79, 0x8b, 0x7d, 0x4c, 0xec, 0xfa, 0x42, 0x4a, 0xea, 0xd6, 0x75, 0xdc, 0xa0, + 0x81, 0xe6, 0x0b, 0xbe, 0xd6, 0x70, 0xf9, 0xab, 0x23, 0x16, 0xf5, 0x01, 0x2e, 0x22, 0x90, 0x77, + 0x0d, 0x33, 0x23, 0x40, 0x3d, 0xa5, 0x74, 0x8b, 0xe6, 0x68, 0x15, 0x65, 0xa7, 0x13, 0x87, 0x3a, + 0x53, 0x86, 0xa6, 0xf1, 0x29, 0x9f, 0x0e, 0x1e, 0xdb, 0x34, 0x1f, 0xff, 0x08, 0x32, 0x55, 0x10, + 0xa7, 0xf2, 0xfe, 0x5e, 0xb0, 0x30, 0x27, 0x27, 0xd7, 0x35, 0x5e, 0xe4, 0x8e, 0xd5, 0xdf, 0x43, + 0x16, 0xfd, 0x34, 0x83, 0x32, 0x38, 0x69, 0x0b, 0x91, 0xd4, 0x71, 0x65, 0xcd, 0x4c, 0xc0, 0x45, + 0x4d, 0xa3, 0x3b, 0x87, 0x56, 0x9d, 0x38, 0x88, 0x0a, 0xd9, 0x2a, 0x92, 0xab, 0xa0, 0xf2, 0x4d, + 0x99, 0xed, 0x4c, 0xc9, 0x77, 0xa2, 0xb4, 0xe3, 0x79, 0x54, 0xfb, 0xe9, 0xb9, 0x32, 0x01, 0x01, + 0xc8, 0x0a, 0x85, 0x81, 0x22, 0x79, 0x30, 0x62, 0xc7, 0xac, 0x26, 0xe7, 0x1b, 0xe2, 0x60, 0x8d, + 0xbd, 0x2a, 0x97, 0xcf, 0x4e, 0x88, 0x4f, 0xd3, 0x25, 0x5d, 0x00, 0x87, 0x00, 0xff, 0x35, 0x31, + 0xc0, 0x45, 0x75, 0x0b, 0x2e, 0xaf, 0x77, 0x30, 0xbc, 0x9a, 0x51, 0xc6, 0x75, 0xd9, 0x41, 0x79, + 0xdc, 0xfc, 0xe9, 0xee, 0x63, 0xc1, 0x47, 0x3d, 0x15, 0xb4, 0x31, 0x9a, 0xa9, 0xed, 0xfd, 0x19, + 0x73, 0x9c, 0xc0, 0x5c, 0x5c, 0x3c, 0x8a, 0xa6, 0x18, 0xfa, 0x90, 0x96, 0xc6, 0x64, 0x87, 0x56, + 0xf8, 0xaa, 0x74, 0xfd, 0x18, 0xa8, 0xcd, 0x81, 0xa2, 0xd2, 0x48, 0xb8, 0x56, 0x90, 0x2b, 0x4d, + 0x30, 0x18, 0x2b, 0xfc, 0x2f, 0x39, 0x24, 0x50, 0xf9, 0x02, 0x97, 0x30, 0x43, 0xea, 0x0f, 0x5e, + 0x6c, 0x87, 0x2a, 0xd4, 0x3a, 0x2d, 0x31, 0x9f, 0x99, 0xf0, 0x95, 0x80, 0x8d, 0x83, 0xa8, 0xb0, + 0x2b, 0xd3, 0x80, 0xd6, 0xc3, 0xf3, 0xdd, 0x22, 0x7e, 0xae, 0x2b, 0x4a, 0x48, 0x67, 0x71, 0x38, + 0x53, 0xd6, 0x3c, 0xff, 0x40, 0x56, 0x21, 0xb1, 0xee, 0xee, 0xf0, 0x0d, 0x5b, 0xa2, 0xff, 0x25, + 0x4c, 0xdf, 0x97, 0xb4, 0x22, 0x63, 0x34, 0xa9, 0x86, 0x6a, 0x2b, 0x5b, 0xdf, 0x1f, 0x8e, 0x8a, + 0xfd, 0xf1, 0x23, 0x8d, 0xa9, 0xf4, 0x8f, 0xc3, 0x88, 0xa3, 0x39, 0xf7, 0x9d, 0x64, 0x8c, 0xaa, + 0x0a, 0x0a, 0x69, 0xd6, 0xf1, 0x6e, 0x29, 0x76, 0x63, 0xe5, 0xf4, 0xcf, 0x1a, 0xa9, 0x54, 0x27, + 0xe6, 0x8d, 0x71, 0xe7, 0x4c, 0x0a, 0x2f, 0xb6, 0xb6, 0x89, 0x22, 0x4b, 0xd9, 0x97, 0x8f, 0x7a, + 0x3a, 0x45, 0x05, 0x33, 0x47, 0x74, 0x17, 0x6f, 0xd8, 0x70, 0x97, 0xd8, 0xab, 0x45, 0x4c, 0xab, + 0xee, 0x13, 0x8f, 0x2c, 0xdf, 0xc6, 0xef, 0x0f, 0x3d, 0xb1, 0x4b, 0x09, 0xdd, 0x02, 0xe7, 0xfa, + 0xbe, 0x9f, 0x15, 0x66, 0x54, 0x43, 0x3b, 0x75, 0xb9, 0x51, 0xae, 0x3c, 0x19, 0x6d, 0x67, 0x01, + 0x92, 0x00, 0x4d, 0xc1, 0x92, 0x4d, 0x19, 0x50, 0xac, 0x59, 0x76, 0x82, 0xea, 0xd1, 0xc0, 0x87, + 0xac, 0xb1, 0x46, 0x12, 0x47, 0xdf, 0xab, 0x3c, 0xd4, 0x22, 0x79, 0xf9, 0x16, 0x9b, 0x69, 0xb3, + 0x34, 0x35, 0xdb, 0x9d, 0x89, 0x94, 0xac, 0x04, 0xb1, 0x5d, 0x45, 0x00, 0x7f, 0x0f, 0x98, 0x33, + 0x4a, 0xc5, 0xd7, 0x83, 0x21, 0x9b, 0x37, 0x6d, 0x9e, 0xd7, 0x55, 0x3f, 0x52, 0xcb, 0xad, 0xf1, + 0x59, 0xf6, 0x92, 0x82, 0x05, 0x0a, 0x4c, 0x84, 0x34, 0x67, 0xae, 0x7e, 0x4c, 0x4a, 0x14, 0x2a, + 0x61, 0xcc, 0xc4, 0xc4, 0x8d, 0xc3, 0xaa, 0xc6, 0xb8, 0xe0, 0xa8, 0xd6, 0x18, 0xe0, 0x6c, 0x60, + 0xdc, 0x92, 0x4a, 0x94, 0x3a, 0xf9, 0x00, 0x0f, 0x89, 0x64, 0x46, 0xcb, 0x62, 0xef, 0x4e, 0x47, + 0xad, 0x6d, 0x1f, 0xbe, 0x2b, 0x89, 0x84, 0xa4, 0x8a, 0xcd, 0x7c, 0x05, 0x19, 0xd6, 0xe8, 0x7a, + 0x33, 0x10, 0x6e, 0x9a, 0x91, 0xc2, 0x98, 0x80, 0x8b, 0xf0, 0x4e, 0x12, 0x67, 0x34, 0x93, 0x34, + 0xe6, 0xc2, 0xac, 0x01, 0x5a, 0x9f, 0x70, 0x4b, 0x2d, 0xdb, 0x56, 0xd2, 0x7a, 0x8b, 0x00, 0xd8, + 0x76, 0xad, 0x00, 0xf6, 0x24, 0x34, 0x09, 0x5a, 0x6f, 0x7a, 0x5e, 0x9c, 0xd4, 0xb2, 0x7f, 0xe0, + 0x9f, 0xf6, 0x90, 0x19, 0xae, 0x5f, 0x27, 0x33, 0x07, 0x92, 0xcf, 0x9a, 0x1c, 0x07, 0xfb, 0xe9, + 0x8d, 0x23, 0xc4, 0xe6, 0x15, 0x33, 0x2a, 0x77, 0xdb, 0x5b, 0x61, 0x82, 0xd2, 0x77, 0xdd, 0xfd, + 0x75, 0x72, 0xda, 0x75, 0x74, 0x8d, 0xfb, 0x3b, 0x93, 0x15, 0x29, 0x4e, 0xab, 0xe4, 0xb6, 0xd0, + 0xfc, 0x31, 0x14, 0xb2, 0xaf, 0xf5, 0x53, 0x7a, 0x6b, 0x05, 0xa7, 0xaa, 0x9a, 0xbb, 0x49, 0x30, + 0xe1, 0x7b, 0x7f, 0xd3, 0xd8, 0xf8, 0x1a, 0xa2, 0xd6, 0x74, 0xdb, 0x69, 0xad, 0x96, 0x7c, 0x83, + 0x06, 0xfc, 0x3e, 0x1c, 0xa8, 0xbf, 0x78, 0xf4, 0x46, 0xb2, 0x6d, 0x8f, 0x2f, 0xd1, 0xaf, 0x6f, + 0x7f, 0xd7, 0xe5, 0x28, 0x67, 0xbc, 0xcc, 0x3b, 0x4d, 0xbd, 0x72, 0x27, 0xea, 0x99, 0x2d, 0xd9, + 0x95, 0xd7, 0x7c, 0x4a, 0x2b, 0xc8, 0x08, 0xc7, 0xa3, 0xe6, 0x8f, 0xa4, 0x33, 0x67, 0x5f, 0x48, + 0x9b, 0xc5, 0x03, 0xdb, 0x70, 0x11, 0x5a, 0x82, 0x46, 0x69, 0xe4, 0xb1, 0x86, 0x1c, 0xdb, 0xd5, + 0x57, 0xa1, 0xf7, 0x8f, 0x1a, 0x4b, 0x35, 0x82, 0xb2, 0x55, 0x3a, 0xc2, 0x3f, 0x12, 0xa4, 0x32, + 0x6e, 0xf9, 0x43, 0xc5, 0x6f, 0x84, 0x7b, 0x8c, 0x67, 0x96, 0x95, 0x61, 0x4b, 0xbb, 0x1d, 0xde, + 0xa9, 0xcf, 0xb7, 0xd7, 0x99, 0xce, 0x42, 0xdf, 0x8b, 0x73, 0x5f, 0xeb, 0x9d, 0xc1, 0x19, 0xdb, + 0xca, 0x30, 0x6d, 0xa4, 0xfa, 0x84, 0xa5, 0x0f, 0x79, 0x90, 0x5e, 0x5c, 0x2a, 0xc1, 0xf6, 0x12, + 0x41, 0xd8, 0x83, 0x59, 0xee, 0x6f, 0x62, 0xdc, 0x9d, 0x3e, 0x4a, 0x15, 0x93, 0xf4, 0x1c, 0xc5, + 0xf3, 0xc0, 0x22, 0x41, 0xce, 0x5e, 0xb6, 0x2c, 0x28, 0xa5, 0x47, 0xfc, 0xaa, 0xdf, 0x1d, 0xd6, + 0x88, 0xf3, 0xdf, 0xba, 0x87, 0x0d, 0x9b, 0xed, 0x72, 0x3b, 0x02, 0xb0, 0xb1, 0xcd, 0xb4, 0xc0, + 0x8d, 0x09, 0x3c, 0x48, 0x97, 0x7e, 0x06, 0x21, 0x93, 0x0a, 0x66, 0x8a, 0x5c, 0xd5, 0x17, 0xa0, + 0xef, 0xfb, 0xe2, 0x48, 0xb4, 0xaa, 0xcf, 0x30, 0x09, 0xba, 0xc0, 0xd4, 0x7f, 0x49, 0x37, 0x8f, + 0x30, 0xa3, 0xd2, 0xc2, 0x80, 0x0c, 0xd1, 0x6b, 0x3c, 0x94, 0x64, 0x56, 0x3d, 0xa4, 0xa7, 0x32, + 0x10, 0x82, 0xfa, 0xe9, 0x5d, 0xe5, 0x64, 0x5f, 0xcc, 0xbc, 0x55, 0x69, 0xe9, 0x42, 0xb5, 0xf8, + 0x60, 0xa3, 0x2f, 0x04, 0x08, 0x27, 0x23, 0xe9, 0xe5, 0x3f, 0x2d, 0x18, 0x09, 0x9b, 0xec, 0x5e, + 0x23, 0xa9, 0x16, 0x35, 0x41, 0x98, 0x32, 0x5f, 0xa8, 0xda, 0xea, 0xa3, 0xf6, 0xb7, 0xab, 0x6a, + 0xad, 0x6e, 0xf1, 0x2a, 0x03, 0xcb, 0xdc, 0x27, 0xb8, 0x3c, 0x81, 0x8f, 0x44, +}; +static const uint8_t ml_dsa_65_0_sig_digest[] = { + 0x3a, 0xd5, 0xf2, 0x3a, 0xbe, 0x98, 0x11, 0x09, 0x1f, 0x76, 0xfc, 0xe1, 0xb0, 0x8a, 0x52, 0x04, + 0x9a, 0x4f, 0x4f, 0xc2, 0x5f, 0x72, 0xa1, 0xc3, 0x3f, 0x84, 0xd0, 0x4f, 0xb1, 0x0b, 0xb3, 0x66, +}; + +static const uint8_t ml_dsa_65_1_sig_priv[] = { + 0xf2, 0x6b, 0xfe, 0x12, 0x68, 0x86, 0xf4, 0x82, 0x22, 0x94, 0x4d, 0x02, 0x18, 0xfa, 0xc1, 0x7c, + 0xd8, 0xa9, 0xcc, 0x6d, 0x67, 0xa0, 0x23, 0xfd, 0xc0, 0x7a, 0xff, 0xc2, 0xd0, 0x25, 0xf7, 0x70, + 0x63, 0x85, 0x0d, 0x88, 0x0e, 0x98, 0xfe, 0xe5, 0x02, 0xe0, 0x17, 0x32, 0x70, 0x00, 0xcc, 0xaf, + 0x61, 0x45, 0x73, 0xb3, 0x5a, 0xde, 0xfe, 0xbc, 0xac, 0xee, 0xa4, 0xb2, 0xc4, 0xd0, 0x45, 0xe5, + 0xbb, 0xfd, 0x3e, 0x5a, 0x72, 0xe3, 0x71, 0xad, 0x83, 0xb9, 0x94, 0x98, 0x77, 0xd8, 0xe6, 0x56, + 0xd4, 0x6b, 0x47, 0x75, 0x0f, 0x73, 0x0f, 0x96, 0xdb, 0x43, 0x0b, 0x18, 0x60, 0x88, 0x67, 0x5d, + 0x9a, 0x9b, 0xd7, 0x8e, 0x47, 0xb8, 0x9d, 0x04, 0xa8, 0x51, 0x7e, 0xd2, 0x22, 0x06, 0x95, 0x33, + 0x9f, 0x99, 0xa9, 0x7f, 0x35, 0x3c, 0xe4, 0x20, 0x47, 0x77, 0x20, 0x9f, 0x5f, 0x3c, 0x9e, 0x9a, + 0x36, 0x14, 0x54, 0x01, 0x57, 0x48, 0x60, 0x50, 0x75, 0x28, 0x64, 0x61, 0x72, 0x60, 0x54, 0x20, + 0x75, 0x48, 0x60, 0x32, 0x73, 0x85, 0x34, 0x24, 0x68, 0x63, 0x71, 0x73, 0x81, 0x26, 0x71, 0x68, + 0x32, 0x61, 0x24, 0x71, 0x14, 0x18, 0x26, 0x15, 0x05, 0x77, 0x36, 0x27, 0x50, 0x35, 0x21, 0x82, + 0x50, 0x15, 0x31, 0x47, 0x48, 0x24, 0x43, 0x76, 0x18, 0x85, 0x66, 0x18, 0x05, 0x64, 0x27, 0x01, + 0x06, 0x06, 0x01, 0x45, 0x42, 0x60, 0x80, 0x68, 0x25, 0x08, 0x08, 0x36, 0x13, 0x05, 0x04, 0x32, + 0x34, 0x87, 0x00, 0x70, 0x71, 0x70, 0x02, 0x51, 0x37, 0x15, 0x08, 0x28, 0x25, 0x72, 0x61, 0x67, + 0x08, 0x52, 0x63, 0x44, 0x07, 0x88, 0x60, 0x42, 0x03, 0x17, 0x24, 0x64, 0x80, 0x08, 0x70, 0x23, + 0x56, 0x41, 0x46, 0x17, 0x46, 0x01, 0x57, 0x74, 0x02, 0x76, 0x31, 0x64, 0x73, 0x83, 0x50, 0x62, + 0x72, 0x61, 0x62, 0x75, 0x45, 0x73, 0x46, 0x33, 0x65, 0x14, 0x36, 0x46, 0x12, 0x26, 0x04, 0x34, + 0x02, 0x81, 0x20, 0x34, 0x41, 0x88, 0x26, 0x77, 0x33, 0x40, 0x18, 0x58, 0x03, 0x41, 0x16, 0x58, + 0x88, 0x04, 0x88, 0x32, 0x71, 0x05, 0x85, 0x83, 0x42, 0x55, 0x34, 0x20, 0x18, 0x46, 0x12, 0x54, + 0x28, 0x03, 0x67, 0x10, 0x84, 0x31, 0x76, 0x00, 0x40, 0x85, 0x46, 0x71, 0x71, 0x56, 0x00, 0x50, + 0x15, 0x33, 0x43, 0x13, 0x37, 0x57, 0x13, 0x86, 0x43, 0x77, 0x85, 0x57, 0x54, 0x81, 0x75, 0x60, + 0x37, 0x31, 0x28, 0x52, 0x20, 0x78, 0x65, 0x53, 0x76, 0x10, 0x84, 0x87, 0x57, 0x13, 0x66, 0x03, + 0x56, 0x81, 0x36, 0x66, 0x68, 0x41, 0x55, 0x64, 0x63, 0x70, 0x26, 0x21, 0x02, 0x30, 0x28, 0x35, + 0x02, 0x45, 0x88, 0x80, 0x02, 0x06, 0x44, 0x58, 0x24, 0x13, 0x88, 0x83, 0x22, 0x34, 0x22, 0x50, + 0x47, 0x11, 0x01, 0x86, 0x45, 0x60, 0x67, 0x36, 0x82, 0x22, 0x18, 0x74, 0x11, 0x60, 0x58, 0x60, + 0x87, 0x26, 0x31, 0x85, 0x12, 0x70, 0x84, 0x83, 0x88, 0x68, 0x88, 0x51, 0x00, 0x55, 0x02, 0x57, + 0x77, 0x42, 0x13, 0x23, 0x14, 0x04, 0x76, 0x80, 0x72, 0x25, 0x51, 0x56, 0x10, 0x63, 0x12, 0x21, + 0x03, 0x86, 0x27, 0x30, 0x28, 0x12, 0x01, 0x37, 0x48, 0x32, 0x53, 0x86, 0x15, 0x46, 0x50, 0x05, + 0x34, 0x87, 0x61, 0x04, 0x88, 0x18, 0x35, 0x85, 0x44, 0x46, 0x24, 0x67, 0x43, 0x83, 0x02, 0x26, + 0x56, 0x41, 0x41, 0x77, 0x86, 0x56, 0x41, 0x75, 0x25, 0x61, 0x36, 0x05, 0x47, 0x65, 0x00, 0x14, + 0x32, 0x38, 0x16, 0x81, 0x06, 0x30, 0x61, 0x25, 0x16, 0x30, 0x50, 0x44, 0x13, 0x08, 0x75, 0x00, + 0x50, 0x20, 0x68, 0x21, 0x55, 0x74, 0x61, 0x18, 0x62, 0x05, 0x15, 0x51, 0x08, 0x24, 0x01, 0x13, + 0x81, 0x33, 0x64, 0x83, 0x23, 0x00, 0x55, 0x73, 0x62, 0x40, 0x61, 0x75, 0x15, 0x78, 0x21, 0x14, + 0x13, 0x64, 0x21, 0x47, 0x07, 0x76, 0x80, 0x76, 0x76, 0x17, 0x75, 0x50, 0x61, 0x14, 0x40, 0x82, + 0x87, 0x83, 0x50, 0x87, 0x30, 0x86, 0x35, 0x30, 0x28, 0x20, 0x10, 0x01, 0x48, 0x18, 0x34, 0x65, + 0x23, 0x10, 0x25, 0x42, 0x40, 0x22, 0x54, 0x34, 0x35, 0x33, 0x71, 0x70, 0x20, 0x61, 0x55, 0x74, + 0x33, 0x01, 0x02, 0x60, 0x58, 0x24, 0x80, 0x12, 0x46, 0x41, 0x38, 0x10, 0x76, 0x67, 0x34, 0x63, + 0x48, 0x85, 0x06, 0x48, 0x04, 0x23, 0x22, 0x66, 0x57, 0x71, 0x68, 0x18, 0x04, 0x32, 0x01, 0x31, + 0x01, 0x55, 0x22, 0x27, 0x55, 0x72, 0x10, 0x00, 0x43, 0x88, 0x76, 0x62, 0x84, 0x77, 0x07, 0x77, + 0x14, 0x07, 0x20, 0x53, 0x74, 0x17, 0x51, 0x17, 0x66, 0x84, 0x47, 0x83, 0x61, 0x03, 0x52, 0x10, + 0x05, 0x40, 0x46, 0x55, 0x61, 0x47, 0x26, 0x70, 0x40, 0x22, 0x10, 0x34, 0x41, 0x01, 0x03, 0x48, + 0x33, 0x05, 0x72, 0x32, 0x75, 0x82, 0x45, 0x85, 0x20, 0x70, 0x80, 0x82, 0x20, 0x23, 0x62, 0x81, + 0x15, 0x47, 0x80, 0x23, 0x67, 0x23, 0x73, 0x34, 0x44, 0x33, 0x85, 0x10, 0x05, 0x50, 0x30, 0x03, + 0x48, 0x13, 0x01, 0x36, 0x45, 0x11, 0x06, 0x33, 0x82, 0x22, 0x78, 0x75, 0x42, 0x02, 0x40, 0x45, + 0x04, 0x47, 0x43, 0x05, 0x30, 0x44, 0x42, 0x02, 0x28, 0x26, 0x64, 0x24, 0x74, 0x75, 0x86, 0x11, + 0x85, 0x43, 0x25, 0x46, 0x10, 0x62, 0x82, 0x71, 0x08, 0x27, 0x45, 0x13, 0x73, 0x18, 0x84, 0x73, + 0x51, 0x51, 0x67, 0x14, 0x70, 0x11, 0x07, 0x08, 0x62, 0x16, 0x25, 0x27, 0x36, 0x68, 0x44, 0x01, + 0x18, 0x63, 0x74, 0x50, 0x31, 0x13, 0x43, 0x65, 0x80, 0x11, 0x16, 0x52, 0x86, 0x42, 0x51, 0x81, + 0x51, 0x17, 0x05, 0x68, 0x05, 0x73, 0x60, 0x37, 0x63, 0x85, 0x86, 0x11, 0x23, 0x23, 0x38, 0x13, + 0x87, 0x48, 0x82, 0x74, 0x71, 0x81, 0x87, 0x65, 0x58, 0x26, 0x60, 0x34, 0x76, 0x16, 0x15, 0x24, + 0x06, 0x78, 0x16, 0x40, 0x03, 0x45, 0x72, 0x31, 0x63, 0x73, 0x31, 0x85, 0x02, 0x66, 0x44, 0x36, + 0x24, 0x82, 0x56, 0x38, 0x86, 0x10, 0x40, 0x54, 0x72, 0x70, 0x24, 0x22, 0x72, 0x78, 0x47, 0x07, + 0x86, 0x30, 0x48, 0x72, 0x84, 0x57, 0x06, 0x34, 0x78, 0x37, 0x63, 0x25, 0x56, 0x64, 0x81, 0x30, + 0x62, 0x77, 0x22, 0x84, 0x20, 0x10, 0x74, 0x25, 0x04, 0x21, 0x76, 0x47, 0x72, 0x35, 0x05, 0x06, + 0x22, 0x50, 0x34, 0x11, 0x26, 0x67, 0x03, 0x05, 0x42, 0x04, 0x16, 0x01, 0x27, 0x17, 0x86, 0x67, + 0x70, 0x51, 0x53, 0x13, 0x12, 0x62, 0x03, 0x25, 0x05, 0x38, 0x37, 0x44, 0x02, 0x66, 0x84, 0x74, + 0x14, 0x40, 0x35, 0x20, 0x40, 0x30, 0x44, 0x64, 0x27, 0x50, 0x77, 0x47, 0x06, 0x15, 0x84, 0x48, + 0x13, 0x14, 0x32, 0x48, 0x11, 0x74, 0x80, 0x68, 0x85, 0x81, 0x17, 0x67, 0x38, 0x22, 0x76, 0x16, + 0x18, 0x44, 0x55, 0x47, 0x85, 0x36, 0x44, 0x11, 0x52, 0x01, 0x81, 0x50, 0x41, 0x00, 0x00, 0x25, + 0x83, 0x41, 0x62, 0x22, 0x12, 0x54, 0x88, 0x77, 0x70, 0x48, 0x84, 0x25, 0x77, 0x75, 0x40, 0x16, + 0x46, 0x24, 0x88, 0x81, 0x65, 0x70, 0x02, 0x66, 0x28, 0x64, 0x12, 0x40, 0x30, 0x60, 0x53, 0x06, + 0x44, 0x02, 0x48, 0x78, 0x75, 0x68, 0x21, 0x23, 0x30, 0x05, 0x81, 0x17, 0x72, 0x66, 0x88, 0x71, + 0x50, 0x25, 0x03, 0x51, 0x42, 0x27, 0x20, 0x81, 0x03, 0x52, 0x73, 0x53, 0x63, 0x57, 0x13, 0x60, + 0x41, 0x20, 0x47, 0x12, 0x55, 0x57, 0x58, 0x16, 0x38, 0x63, 0x21, 0x34, 0x51, 0x76, 0x33, 0x26, + 0x70, 0x41, 0x18, 0x11, 0x07, 0x37, 0x16, 0x12, 0x01, 0x14, 0x28, 0x56, 0x78, 0x10, 0x86, 0x24, + 0x24, 0x32, 0x01, 0x13, 0x57, 0x53, 0x46, 0x46, 0x24, 0x05, 0x20, 0x16, 0x56, 0x83, 0x30, 0x30, + 0x61, 0x20, 0x75, 0x07, 0x05, 0x74, 0x14, 0x17, 0x43, 0x72, 0x23, 0x04, 0x18, 0x61, 0x50, 0x13, + 0x67, 0x31, 0x75, 0x36, 0x71, 0x02, 0x38, 0x74, 0x21, 0x80, 0x20, 0x48, 0x66, 0x23, 0x52, 0x54, + 0x77, 0x27, 0x45, 0x73, 0x23, 0x88, 0x60, 0x50, 0x88, 0x82, 0x70, 0x23, 0x72, 0x08, 0x44, 0x66, + 0x44, 0x36, 0x12, 0x57, 0x66, 0x14, 0x25, 0x12, 0x17, 0x34, 0x64, 0x82, 0x01, 0x54, 0x61, 0x57, + 0x50, 0x31, 0x65, 0x64, 0x75, 0x44, 0x76, 0x48, 0x16, 0x44, 0x46, 0x55, 0x80, 0x64, 0x26, 0x53, + 0x27, 0x22, 0x10, 0x87, 0x84, 0x03, 0x15, 0x35, 0x15, 0x20, 0x86, 0x14, 0x04, 0x03, 0x26, 0x43, + 0x31, 0x43, 0x31, 0x45, 0x46, 0x34, 0x36, 0x87, 0x44, 0x41, 0x21, 0x77, 0x61, 0x20, 0x85, 0x06, + 0x28, 0x51, 0x15, 0x62, 0x77, 0x20, 0x38, 0x58, 0x78, 0x27, 0x12, 0x22, 0x46, 0x71, 0x51, 0x38, + 0x11, 0x15, 0x40, 0x03, 0x78, 0x36, 0x15, 0x57, 0x34, 0x28, 0x53, 0x21, 0x37, 0x35, 0x04, 0x76, + 0x00, 0x56, 0x72, 0x48, 0x46, 0x01, 0x56, 0x67, 0x62, 0x36, 0x14, 0x51, 0x23, 0x54, 0x32, 0x35, + 0x82, 0x83, 0x21, 0x60, 0x38, 0x62, 0x21, 0x03, 0x62, 0x76, 0x40, 0x34, 0x66, 0x88, 0x50, 0x73, + 0x00, 0x53, 0x87, 0x31, 0x37, 0x50, 0x11, 0x32, 0x86, 0x52, 0x18, 0x64, 0x16, 0x63, 0x48, 0x71, + 0x70, 0x47, 0x24, 0x85, 0x31, 0x86, 0x60, 0x86, 0x33, 0x52, 0x85, 0x82, 0x68, 0x17, 0x70, 0x88, + 0x84, 0x56, 0x52, 0x77, 0x04, 0x48, 0x22, 0x22, 0x54, 0x57, 0x20, 0x31, 0x76, 0x47, 0x26, 0x25, + 0x04, 0x35, 0x38, 0x44, 0x55, 0x21, 0x14, 0x02, 0x13, 0x64, 0x74, 0x87, 0x68, 0x68, 0x73, 0x05, + 0x22, 0x45, 0x54, 0x45, 0x83, 0x46, 0x64, 0x54, 0x80, 0x07, 0x32, 0x87, 0x52, 0x43, 0x54, 0x54, + 0x14, 0x73, 0x24, 0x87, 0x36, 0x41, 0x74, 0x84, 0x06, 0x35, 0x13, 0x40, 0x61, 0x54, 0x21, 0x31, + 0x48, 0x63, 0x05, 0x74, 0x24, 0x84, 0x74, 0x76, 0x11, 0x10, 0x16, 0x63, 0x77, 0x12, 0x26, 0x61, + 0x31, 0x28, 0x70, 0x34, 0x25, 0x01, 0x30, 0x76, 0x76, 0x06, 0x21, 0x58, 0x42, 0x87, 0x31, 0x72, + 0x76, 0x03, 0x76, 0x26, 0x78, 0x05, 0x88, 0x25, 0x25, 0x86, 0x17, 0x02, 0x85, 0x88, 0x76, 0x20, + 0x36, 0x57, 0x30, 0x81, 0x83, 0x61, 0x05, 0x80, 0x21, 0x45, 0x74, 0x01, 0x12, 0x74, 0x51, 0x28, + 0x77, 0x26, 0x30, 0x14, 0x54, 0x84, 0x13, 0x78, 0x06, 0x00, 0x12, 0x64, 0x00, 0x37, 0x44, 0x68, + 0x40, 0x57, 0x05, 0x27, 0x07, 0x41, 0x56, 0x22, 0x31, 0x40, 0x23, 0x26, 0x55, 0x42, 0x55, 0x16, + 0x02, 0x65, 0x32, 0x16, 0x33, 0x44, 0x46, 0x48, 0x04, 0x52, 0x06, 0x53, 0x44, 0x40, 0x11, 0x28, + 0x46, 0x67, 0x56, 0x81, 0x72, 0x75, 0x51, 0x38, 0x21, 0x86, 0x46, 0x03, 0x22, 0x87, 0x21, 0x70, + 0x68, 0x50, 0x75, 0x13, 0x11, 0x44, 0x35, 0x12, 0x60, 0x02, 0x13, 0x47, 0x18, 0x38, 0x78, 0x86, + 0x38, 0x58, 0x45, 0x57, 0x23, 0x03, 0x88, 0x66, 0x56, 0x82, 0x18, 0x31, 0x20, 0x08, 0x61, 0x47, + 0x78, 0x08, 0x68, 0x37, 0x21, 0x04, 0x65, 0x47, 0x58, 0x70, 0x34, 0x58, 0x73, 0x24, 0x22, 0x30, + 0x66, 0x05, 0x01, 0x28, 0x87, 0x85, 0x77, 0x74, 0x23, 0x86, 0x65, 0x84, 0x85, 0x57, 0x85, 0x63, + 0x06, 0x55, 0x61, 0x75, 0x46, 0x22, 0x87, 0x00, 0x18, 0x53, 0x08, 0x03, 0x07, 0x50, 0x42, 0x70, + 0xfc, 0xb8, 0x7b, 0x22, 0x3d, 0x24, 0xae, 0x5d, 0xb1, 0x89, 0x04, 0x21, 0xc3, 0xff, 0x1d, 0x59, + 0xb8, 0x4b, 0x19, 0xe2, 0x4d, 0x14, 0x36, 0x99, 0x19, 0x1c, 0x7e, 0x9a, 0x46, 0x48, 0x42, 0x20, + 0x6b, 0xba, 0x24, 0x7e, 0x8c, 0x6b, 0x27, 0xba, 0x26, 0xe6, 0x8a, 0xd5, 0xa7, 0x1d, 0x03, 0x61, + 0xcd, 0x5c, 0x74, 0xce, 0x50, 0xc2, 0xce, 0xf1, 0x91, 0x31, 0xef, 0x54, 0x66, 0x23, 0x7f, 0xfe, + 0xf7, 0xfe, 0x6b, 0x5f, 0xd1, 0x98, 0x23, 0x8e, 0x1c, 0xa0, 0xb1, 0x01, 0x30, 0xc6, 0x29, 0xcc, + 0x91, 0x91, 0xf5, 0x78, 0x6f, 0x5c, 0xd6, 0x28, 0xa4, 0x22, 0x56, 0xcb, 0x6f, 0xc7, 0xd7, 0x09, + 0x56, 0x88, 0xaf, 0x1b, 0xc8, 0x43, 0x51, 0xa4, 0x7b, 0x4b, 0x38, 0x2e, 0xf6, 0x1f, 0xd6, 0x5c, + 0x9e, 0xc2, 0x26, 0xf4, 0x2b, 0x0a, 0x19, 0x7c, 0x6a, 0xd8, 0xf0, 0xb0, 0x15, 0xd0, 0xb1, 0xc7, + 0xe0, 0x14, 0x28, 0x95, 0x6a, 0x9b, 0xb2, 0xde, 0x9a, 0x97, 0xe5, 0x75, 0x66, 0xf8, 0xf5, 0x66, + 0x86, 0xa1, 0xf4, 0x68, 0x0c, 0xec, 0xea, 0x87, 0x3b, 0x69, 0x1c, 0xf8, 0xbd, 0x63, 0xab, 0x73, + 0x73, 0xba, 0xe8, 0x09, 0x5b, 0xa7, 0x76, 0x3e, 0x50, 0xd6, 0x83, 0x9d, 0x00, 0x35, 0xbb, 0xfb, + 0x91, 0xba, 0x60, 0x72, 0x17, 0x98, 0xfb, 0x2c, 0x80, 0x2c, 0x60, 0x3a, 0x08, 0xa1, 0x24, 0x05, + 0xe0, 0xb5, 0x20, 0xea, 0x41, 0x43, 0x8f, 0xea, 0xef, 0xa5, 0x62, 0xdc, 0x78, 0x92, 0xf4, 0x58, + 0x9f, 0x8d, 0x2b, 0x96, 0x5e, 0xe5, 0x49, 0x73, 0xa7, 0x2c, 0x8d, 0x33, 0x5c, 0x62, 0x61, 0x98, + 0x80, 0x64, 0x13, 0x31, 0x03, 0x10, 0xe3, 0x2e, 0xfe, 0x6b, 0x39, 0xb5, 0xcf, 0xb1, 0xd1, 0x33, + 0xad, 0xe0, 0x1b, 0xce, 0x94, 0x21, 0x6c, 0xf4, 0xcd, 0x8f, 0x86, 0x43, 0x03, 0x1d, 0xb8, 0xc2, + 0x47, 0xb5, 0x73, 0x21, 0xca, 0x1e, 0xfb, 0xb8, 0x53, 0x63, 0x7d, 0x0c, 0x57, 0x52, 0x14, 0xfc, + 0x77, 0xa5, 0xa6, 0x84, 0xd5, 0x0a, 0xbf, 0xe4, 0xe9, 0x71, 0x99, 0x8e, 0x06, 0x6e, 0x50, 0x24, + 0xda, 0x02, 0x76, 0x8a, 0xed, 0xe1, 0x3e, 0x83, 0xf0, 0x51, 0x54, 0xa9, 0x99, 0x29, 0x48, 0x42, + 0x7a, 0xa9, 0x8c, 0x87, 0x42, 0x51, 0xaf, 0x56, 0x94, 0x23, 0x53, 0x89, 0x44, 0xfa, 0xd8, 0x93, + 0xfc, 0x65, 0x6e, 0x9c, 0xed, 0x80, 0x6a, 0x85, 0xd9, 0xc3, 0x36, 0x71, 0x02, 0x25, 0x29, 0x36, + 0x8e, 0x7e, 0xc7, 0x0c, 0x9e, 0xe9, 0x74, 0x30, 0x1c, 0x08, 0xcb, 0xe6, 0xac, 0x5e, 0x88, 0xe6, + 0x37, 0x79, 0x5c, 0xb2, 0xa2, 0x15, 0xff, 0xaa, 0x08, 0xed, 0xde, 0x40, 0xac, 0xfa, 0xee, 0x2a, + 0x40, 0xd5, 0x05, 0xcf, 0x58, 0xa6, 0x69, 0x66, 0x31, 0x5a, 0x68, 0x98, 0x24, 0x03, 0xd8, 0x1b, + 0xfa, 0x89, 0xe3, 0x7c, 0x9e, 0x42, 0x1d, 0xa5, 0x88, 0xba, 0x7e, 0x42, 0x2a, 0xc7, 0x44, 0x6a, + 0x1e, 0x61, 0xc8, 0x22, 0x29, 0x9d, 0xfc, 0x34, 0xec, 0xfa, 0xbe, 0x5c, 0xb6, 0x26, 0xb9, 0x6c, + 0x8e, 0xa6, 0xc9, 0x3b, 0xdb, 0xd2, 0xd5, 0xbd, 0x70, 0xc5, 0xf8, 0x26, 0x7a, 0x84, 0xe0, 0x07, + 0xa7, 0x11, 0x5e, 0x5b, 0xe5, 0xf1, 0x20, 0x32, 0xa3, 0x7c, 0xab, 0x05, 0xd5, 0x41, 0xe3, 0xde, + 0xa5, 0x1a, 0x83, 0x2e, 0xde, 0x8d, 0x34, 0x9a, 0xfd, 0xd5, 0xe6, 0xfc, 0xfc, 0x83, 0x46, 0xe3, + 0xd4, 0x7c, 0xf1, 0x7f, 0xea, 0x87, 0x5e, 0x38, 0x5d, 0xb9, 0x8a, 0xc2, 0xdb, 0xe8, 0xb4, 0xf8, + 0x05, 0x37, 0x31, 0x0d, 0xd9, 0x4c, 0xd0, 0xb6, 0x25, 0xe9, 0x97, 0x85, 0xdb, 0x04, 0x9a, 0x01, + 0xf5, 0x4b, 0xa1, 0xf4, 0x2a, 0xdf, 0xec, 0xae, 0x24, 0x11, 0xd3, 0x2b, 0x2f, 0x84, 0x6c, 0x88, + 0xa3, 0x0c, 0x76, 0xea, 0x0a, 0x38, 0xb2, 0x71, 0xb6, 0xac, 0xa8, 0x23, 0x6e, 0x61, 0xeb, 0xb8, + 0x4a, 0x9d, 0xc4, 0x9e, 0x5c, 0x5b, 0xee, 0x7e, 0x7d, 0x8d, 0xa2, 0xc1, 0xa1, 0xa0, 0xa3, 0x14, + 0x50, 0xe0, 0x8f, 0xab, 0xbb, 0x1b, 0x1f, 0x05, 0xaa, 0xe3, 0x00, 0xd8, 0xcd, 0xe7, 0x35, 0xb4, + 0x7b, 0xbd, 0xb0, 0x5c, 0xcc, 0x0c, 0x05, 0x33, 0x6b, 0xe4, 0x51, 0x73, 0x1b, 0x6b, 0x77, 0x7b, + 0xe5, 0xcb, 0xaf, 0x98, 0x53, 0x5f, 0x7e, 0x08, 0xff, 0xcd, 0x8a, 0x44, 0x9e, 0x1d, 0x43, 0x6a, + 0x4f, 0x05, 0x99, 0x01, 0xf5, 0x6f, 0x01, 0x30, 0xbd, 0x15, 0xd7, 0x51, 0x16, 0x45, 0x40, 0x6b, + 0xf3, 0x13, 0xca, 0x1f, 0x22, 0x02, 0xa4, 0xa8, 0x6a, 0x1d, 0x04, 0x7f, 0xd5, 0x8a, 0x3e, 0x87, + 0x7f, 0x1d, 0x5a, 0x79, 0x75, 0xd1, 0x6d, 0x67, 0xb3, 0x23, 0xc6, 0x28, 0x7b, 0x9c, 0xce, 0xee, + 0x98, 0x9e, 0xe8, 0x44, 0xa9, 0x3e, 0x7e, 0xfd, 0x3b, 0xd9, 0xd8, 0x31, 0x6d, 0xa3, 0x77, 0xdf, + 0x0b, 0xb9, 0xe2, 0x61, 0xa2, 0x71, 0xd5, 0x0c, 0xb7, 0x01, 0x67, 0xc3, 0x0d, 0x19, 0x2d, 0xaa, + 0xde, 0x96, 0x0e, 0xea, 0x33, 0x5e, 0xec, 0x52, 0xe5, 0x2d, 0x95, 0x39, 0xe1, 0xf9, 0x5d, 0x9e, + 0xb6, 0x5e, 0x54, 0x8f, 0x16, 0x60, 0x99, 0xed, 0x88, 0x2c, 0x30, 0x72, 0x53, 0x6a, 0x6c, 0xaa, + 0x05, 0x21, 0xa5, 0xaa, 0x7c, 0x64, 0x72, 0xa0, 0xc0, 0x4f, 0x80, 0xda, 0x20, 0x5d, 0x52, 0x18, + 0x77, 0x07, 0xdf, 0x5c, 0x2f, 0x2e, 0xa2, 0x5f, 0xef, 0x00, 0xca, 0x7b, 0xf0, 0xd3, 0xb7, 0xf8, + 0x1e, 0x31, 0x9e, 0x61, 0xca, 0x2c, 0xc5, 0xa5, 0x25, 0xa2, 0x7b, 0x56, 0xaa, 0xba, 0xe4, 0xd5, + 0x35, 0xe5, 0xec, 0x24, 0x2d, 0x81, 0x1a, 0x24, 0xd7, 0x45, 0x76, 0xbf, 0x4b, 0x8a, 0x72, 0xfa, + 0x5f, 0xae, 0xc1, 0xa2, 0x83, 0xb6, 0x1d, 0x60, 0x28, 0x7e, 0x1e, 0x2e, 0xc8, 0xc6, 0xab, 0x04, + 0x56, 0x5f, 0xd5, 0xcd, 0x64, 0x26, 0x34, 0x94, 0xe8, 0x03, 0x41, 0x63, 0x35, 0x5b, 0x45, 0x84, + 0xce, 0xfa, 0x0b, 0x66, 0x40, 0x85, 0x1a, 0xe1, 0x23, 0xe9, 0x8f, 0xbd, 0xa9, 0x23, 0xfc, 0xa3, + 0x8e, 0x38, 0xb3, 0x84, 0xe2, 0xb9, 0x54, 0x41, 0x4b, 0x36, 0x4f, 0xb8, 0xb0, 0x87, 0x56, 0x04, + 0x8b, 0x75, 0xc7, 0x85, 0x31, 0xd4, 0xa5, 0x12, 0x99, 0xc4, 0x9d, 0xea, 0x4b, 0x36, 0x8c, 0x19, + 0x82, 0xfe, 0xad, 0x4a, 0xb1, 0xaa, 0x52, 0x35, 0xa4, 0xa1, 0x7f, 0xb0, 0x64, 0x6f, 0x04, 0x04, + 0x7b, 0xf0, 0x80, 0x48, 0xa1, 0x1c, 0xf8, 0x95, 0x8b, 0x68, 0x34, 0xb7, 0xfd, 0x00, 0x31, 0x30, + 0x6a, 0x39, 0xc8, 0xae, 0x68, 0xc3, 0x53, 0x65, 0x19, 0x7c, 0x1e, 0x57, 0x97, 0xfc, 0x47, 0x3e, + 0xb1, 0x94, 0x54, 0x48, 0x6f, 0xeb, 0xaa, 0xec, 0x5c, 0x2e, 0xe9, 0x2c, 0xcc, 0x3a, 0xf3, 0xc7, + 0x43, 0x08, 0x7d, 0x2d, 0x56, 0x4b, 0x7d, 0xe9, 0xe5, 0x96, 0xf3, 0x12, 0x4b, 0xe9, 0x08, 0xf3, + 0x04, 0x5a, 0x75, 0x1a, 0x7d, 0x7e, 0x37, 0xe6, 0xc8, 0xc1, 0xfe, 0xf3, 0x32, 0x63, 0x2d, 0x0b, + 0xbe, 0x05, 0x13, 0x6a, 0x44, 0x58, 0x7f, 0x54, 0x5f, 0x5f, 0xf5, 0x2f, 0xb8, 0x0b, 0xf2, 0xbf, + 0x0b, 0xf4, 0x30, 0x2f, 0xcf, 0xec, 0xfe, 0x08, 0xec, 0x51, 0xf2, 0x29, 0xd7, 0xac, 0x28, 0xe1, + 0x75, 0x42, 0x61, 0xbc, 0xe7, 0xb1, 0x53, 0x4f, 0x7d, 0x3b, 0xb0, 0x8d, 0x01, 0x15, 0x1e, 0xbe, + 0xec, 0xd9, 0x54, 0xc2, 0x4e, 0x70, 0x3e, 0xea, 0x39, 0x14, 0x26, 0xb7, 0x01, 0x79, 0x5d, 0x06, + 0x93, 0x85, 0x99, 0xaa, 0x7d, 0xdc, 0xf9, 0x2e, 0x44, 0x56, 0x9b, 0xfa, 0x9d, 0x91, 0x2a, 0x8e, + 0x89, 0x48, 0x51, 0xe3, 0xd0, 0x53, 0xb3, 0xad, 0x43, 0x29, 0xb7, 0x6a, 0x50, 0xc0, 0x78, 0x4d, + 0x42, 0xf3, 0x7c, 0x5f, 0x90, 0x06, 0xac, 0x2a, 0x9d, 0x5d, 0xe5, 0x18, 0x3f, 0xa3, 0xc6, 0x5e, + 0xcd, 0xb6, 0xcf, 0x31, 0x67, 0xa4, 0x7a, 0x8f, 0x5c, 0x59, 0xbd, 0xd7, 0x9b, 0x7c, 0x24, 0x06, + 0x97, 0xe1, 0x59, 0x72, 0x85, 0x02, 0x74, 0xfe, 0x41, 0xad, 0x84, 0xd9, 0x0d, 0xcb, 0x34, 0x16, + 0x11, 0xe7, 0x66, 0xd2, 0x12, 0xdc, 0x76, 0x3c, 0xf9, 0x4c, 0x8c, 0x41, 0x94, 0xcc, 0xa9, 0x1b, + 0x21, 0x03, 0x28, 0xe4, 0xa3, 0x37, 0x4e, 0x29, 0xd2, 0x48, 0x11, 0x2b, 0xb6, 0x68, 0xa3, 0x92, + 0xc2, 0x0d, 0x87, 0x91, 0x03, 0x76, 0xb5, 0x00, 0x1f, 0x3f, 0xfb, 0xbe, 0xc3, 0xe0, 0x08, 0xbf, + 0x2f, 0x46, 0xf7, 0x40, 0x73, 0x83, 0xa8, 0x0d, 0xda, 0x08, 0x2b, 0xdb, 0x8f, 0xe9, 0x25, 0xe4, + 0xf1, 0x2b, 0x37, 0x92, 0x27, 0x0e, 0x5a, 0x46, 0xb8, 0xc5, 0x7b, 0x6e, 0x5a, 0x4b, 0x95, 0x58, + 0x4e, 0xf3, 0x80, 0xed, 0x49, 0x93, 0xec, 0x52, 0x9f, 0xf2, 0xaa, 0x39, 0xdd, 0x6d, 0xfe, 0x88, + 0xfd, 0xeb, 0x6e, 0xda, 0x0e, 0x8d, 0xa7, 0x95, 0x66, 0xb0, 0x7d, 0x37, 0xae, 0xcc, 0x64, 0x37, + 0x25, 0x95, 0x18, 0xf9, 0x7e, 0x6c, 0x86, 0x12, 0xb3, 0xc3, 0x57, 0x03, 0xbf, 0xf9, 0x92, 0x15, + 0x3e, 0x66, 0x0e, 0x2e, 0x20, 0x77, 0xa0, 0x5f, 0x26, 0x5f, 0xb5, 0x12, 0x1d, 0xd7, 0x9f, 0x0a, + 0x33, 0xbc, 0x38, 0xec, 0x83, 0x08, 0xe2, 0xa9, 0x84, 0xcd, 0x3d, 0x8a, 0xc6, 0x09, 0x30, 0x6f, + 0x77, 0x93, 0xd7, 0xde, 0x08, 0xd8, 0x45, 0xa4, 0x21, 0x28, 0x26, 0x4e, 0x5c, 0x17, 0x77, 0x74, + 0xe3, 0x5d, 0x58, 0x7c, 0x96, 0xb2, 0x47, 0x05, 0x42, 0x21, 0x78, 0x5d, 0xb3, 0x8d, 0xdc, 0x6f, + 0xdb, 0xf7, 0xbf, 0x6f, 0x66, 0x4b, 0xd6, 0x30, 0x14, 0xc0, 0xbf, 0x94, 0x2a, 0x83, 0x91, 0x6c, + 0xbf, 0x2c, 0x42, 0x85, 0x41, 0xed, 0xa2, 0xbb, 0xcb, 0xfc, 0xf9, 0x35, 0xde, 0xfc, 0xb3, 0x63, + 0xe1, 0x64, 0xaa, 0x51, 0x2d, 0xd5, 0xfa, 0x79, 0x53, 0x31, 0x40, 0x0b, 0x9b, 0xd0, 0x3c, 0xe3, + 0xd7, 0x2d, 0x91, 0x05, 0x62, 0xc3, 0x81, 0xfe, 0x93, 0x1e, 0x8c, 0x37, 0x9e, 0x30, 0x23, 0x73, + 0x3a, 0xb9, 0x18, 0x6e, 0x5d, 0xef, 0x31, 0xe9, 0xf6, 0x25, 0x7f, 0xb8, 0x47, 0x74, 0xce, 0x28, + 0x23, 0xd4, 0x4f, 0xc1, 0x42, 0xcb, 0xeb, 0x59, 0x8a, 0x68, 0xfd, 0x39, 0x48, 0x37, 0x1a, 0x5d, + 0x0c, 0x09, 0x64, 0xc6, 0xe1, 0x21, 0x5d, 0x89, 0xf6, 0x58, 0xe5, 0x50, 0x4a, 0xd0, 0x93, 0xbc, + 0x86, 0x02, 0xba, 0xd2, 0x36, 0x24, 0x9d, 0x7e, 0xaf, 0xb6, 0xa1, 0xa0, 0x7c, 0xa7, 0xc7, 0x4d, + 0xac, 0x30, 0x7a, 0x70, 0x0f, 0x2f, 0x81, 0x40, 0xc1, 0x08, 0x6b, 0x21, 0xf2, 0xe1, 0x51, 0x9c, + 0x1d, 0x46, 0x94, 0x93, 0x2a, 0x1c, 0x18, 0xcb, 0xed, 0x0d, 0x0e, 0x29, 0xde, 0xfc, 0x52, 0x52, + 0x97, 0x93, 0x70, 0x85, 0xe2, 0x63, 0x0d, 0xc6, 0x2c, 0x0c, 0x05, 0x0c, 0x4f, 0xf2, 0x70, 0x87, + 0x2b, 0xe7, 0xbb, 0x52, 0x2d, 0xd6, 0x99, 0x1b, 0x59, 0x6f, 0xc2, 0x92, 0x11, 0x72, 0x5d, 0x99, + 0x60, 0xb1, 0x6a, 0x52, 0xea, 0x91, 0x78, 0x19, 0x23, 0xc0, 0x3b, 0x71, 0x9d, 0x09, 0xd6, 0xe7, + 0x10, 0x6d, 0xc5, 0x70, 0x55, 0xc1, 0x9e, 0xf8, 0x76, 0xe5, 0xec, 0x23, 0x17, 0xe7, 0xe4, 0x23, + 0xc9, 0x71, 0x45, 0x40, 0x72, 0x01, 0x9e, 0x28, 0xe6, 0x5c, 0x81, 0xed, 0x52, 0x7a, 0xf1, 0x89, + 0xbd, 0xfc, 0xf5, 0x21, 0xc9, 0x23, 0x40, 0x75, 0x54, 0xac, 0xbf, 0x69, 0x45, 0xd1, 0x85, 0x44, + 0x3d, 0xac, 0x1a, 0x1a, 0x08, 0x8a, 0x68, 0xb5, 0x17, 0xd5, 0xd9, 0x90, 0xe1, 0x10, 0x30, 0xde, + 0x4f, 0x75, 0x09, 0xe8, 0x7a, 0x77, 0xb3, 0x7c, 0xf2, 0x0a, 0x78, 0xe2, 0xcd, 0x48, 0x94, 0x17, + 0x3c, 0x32, 0xa3, 0x27, 0x35, 0x51, 0x16, 0xb7, 0x18, 0x51, 0x44, 0x42, 0x65, 0x60, 0x6a, 0x0a, + 0x9a, 0x6d, 0x94, 0x61, 0xcc, 0x5d, 0xd8, 0x3b, 0x52, 0x7e, 0x4d, 0xbd, 0x6a, 0xee, 0x03, 0x3d, + 0x66, 0x1c, 0x3d, 0xe8, 0xc1, 0x82, 0x97, 0xe5, 0xd1, 0x31, 0xdb, 0xc8, 0xf6, 0x96, 0xe9, 0x47, + 0xc9, 0x5c, 0x71, 0x77, 0x2b, 0x62, 0x44, 0x74, 0x4d, 0x06, 0x1e, 0x14, 0x45, 0x3b, 0x9f, 0xb1, + 0x17, 0x34, 0x80, 0x2d, 0xba, 0x6f, 0x81, 0x79, 0xb8, 0x0d, 0xac, 0xfe, 0xb6, 0xba, 0xdf, 0xd1, + 0x4e, 0x05, 0x76, 0x73, 0x6f, 0x80, 0x10, 0xc5, 0x32, 0x87, 0xa3, 0xd3, 0x93, 0x18, 0x79, 0xef, + 0x27, 0x3b, 0xbf, 0xcd, 0xb5, 0xde, 0x5b, 0x88, 0xaf, 0x51, 0xfd, 0x8a, 0x8c, 0x8f, 0x0a, 0x58, + 0x94, 0xe2, 0x25, 0xdf, 0xe8, 0x73, 0xfc, 0xc0, 0x3c, 0xb1, 0xc9, 0xb5, 0x78, 0x25, 0xf1, 0x11, + 0x75, 0xc8, 0x7d, 0x08, 0x78, 0xb9, 0xe6, 0x15, 0x6b, 0x40, 0x1b, 0x2f, 0xbe, 0x30, 0x03, 0x6b, + 0xfc, 0x7d, 0xb1, 0x00, 0x02, 0x71, 0xb7, 0xff, 0x5d, 0x63, 0xa8, 0x09, 0x50, 0x75, 0xef, 0xbd, + 0x34, 0xee, 0x73, 0xde, 0x60, 0x14, 0x95, 0x2d, 0x15, 0xbc, 0x30, 0x23, 0x07, 0x02, 0xd8, 0x7c, + 0x9a, 0x96, 0xd5, 0xe9, 0xf1, 0xf0, 0xf9, 0x26, 0x25, 0x96, 0xaa, 0x58, 0xb7, 0xe4, 0x1a, 0xd9, + 0xa0, 0x9e, 0xad, 0xb9, 0x44, 0xb6, 0x3f, 0xd9, 0x8b, 0x34, 0x7d, 0x11, 0xbd, 0x52, 0x97, 0xc3, + 0xbe, 0x28, 0x23, 0x85, 0x9f, 0x2f, 0x35, 0xa4, 0xe5, 0x4e, 0x13, 0x68, 0x89, 0x09, 0xc3, 0x1a, + 0x83, 0xe7, 0xde, 0xce, 0x4b, 0xdf, 0x31, 0x03, 0x9c, 0x72, 0xba, 0x54, 0xa1, 0x20, 0x2d, 0x17, + 0x2a, 0x6b, 0x8a, 0x2c, 0xe9, 0x6d, 0xed, 0xca, 0x5b, 0x24, 0xf7, 0xb9, 0x42, 0xc1, 0x4e, 0x13, + 0x3d, 0xaa, 0x8a, 0xb8, 0xcb, 0xd2, 0x4c, 0x1f, 0x0b, 0xbe, 0xb1, 0x27, 0x97, 0x67, 0x26, 0x72, + 0xe2, 0x2c, 0xe6, 0xc2, 0x12, 0x37, 0xb2, 0x79, 0x7d, 0x8e, 0x54, 0xcc, 0x8f, 0xc7, 0x6c, 0x43, + 0xb4, 0x75, 0x29, 0x66, 0xa3, 0xa4, 0x09, 0x44, 0xe7, 0x2d, 0x37, 0x3f, 0x0d, 0x3e, 0x84, 0xf9, + 0xa3, 0x30, 0x1e, 0xae, 0x9e, 0xda, 0x35, 0x44, 0x4b, 0x1e, 0x49, 0xe6, 0x61, 0x18, 0x20, 0x6a, + 0x56, 0xeb, 0x46, 0xd4, 0x8d, 0x20, 0x95, 0x4a, 0x77, 0x9a, 0x1e, 0x74, 0xe3, 0xe3, 0xb2, 0xbd, + 0x40, 0x3d, 0x46, 0xb3, 0x35, 0x10, 0x11, 0xcb, 0x6f, 0x8a, 0x86, 0x72, 0xb2, 0xf3, 0xd9, 0x90, + 0x31, 0x47, 0x55, 0x77, 0x6c, 0xe3, 0x23, 0x7f, 0x0a, 0x50, 0xe7, 0x71, 0x20, 0x53, 0x09, 0xc0, + 0x5d, 0x9a, 0x78, 0xd3, 0x68, 0x88, 0xa8, 0x3b, 0xad, 0x78, 0xe8, 0x6e, 0xdf, 0x36, 0xa8, 0x8d, + 0xc7, 0x1c, 0x5f, 0x11, 0x56, 0x83, 0x90, 0xd0, 0xb5, 0x92, 0x02, 0xe2, 0x9e, 0xe1, 0x1e, 0xcb, + 0x9f, 0x56, 0x89, 0x63, 0xe8, 0x17, 0x70, 0x83, 0x9f, 0xf2, 0x39, 0xad, 0x03, 0x15, 0x6c, 0xc0, + 0x71, 0xe8, 0xb7, 0x40, 0x15, 0x95, 0xec, 0xee, 0x62, 0x34, 0xac, 0x34, 0xb7, 0x11, 0x70, 0x3d, + 0x68, 0xc6, 0x7a, 0x28, 0x83, 0xbe, 0x9c, 0x18, 0xab, 0x7f, 0x1a, 0x1b, 0x2e, 0x5c, 0x90, 0xa2, + 0x32, 0x3c, 0xdf, 0x1e, 0xd4, 0x98, 0x50, 0xb8, 0x39, 0x38, 0x19, 0x2f, 0x62, 0x8c, 0x9e, 0xf6, + 0x5b, 0x77, 0x93, 0x95, 0xee, 0x37, 0x34, 0xc7, 0xa9, 0x01, 0xf7, 0x47, 0x38, 0x86, 0xd7, 0x12, + 0xd2, 0x15, 0x41, 0x68, 0x16, 0xc3, 0x01, 0x6c, 0xc2, 0x83, 0x83, 0xd4, 0x78, 0x7b, 0x46, 0xf6, + 0x89, 0xdc, 0xe1, 0x11, 0xda, 0x4d, 0xb8, 0xac, 0x10, 0xe8, 0x4f, 0x66, 0xa5, 0xc2, 0xbd, 0xa1, + 0xb3, 0xfc, 0x97, 0x7f, 0x6a, 0x0f, 0x73, 0x2e, 0xda, 0x4f, 0x69, 0xb9, 0x75, 0x51, 0xa4, 0xb8, + 0xb2, 0x61, 0xd6, 0x88, 0x71, 0x94, 0xd3, 0xaf, 0xe7, 0xf4, 0xb8, 0x7f, 0xb3, 0xd4, 0x1a, 0xc6, + 0xdc, 0xdb, 0x8f, 0xd3, 0x9b, 0xe5, 0x0f, 0x2f, 0x38, 0x2b, 0xaa, 0x4d, 0x19, 0xc7, 0x45, 0x0a, + 0xb3, 0xa1, 0xac, 0x4c, 0x63, 0xcf, 0x93, 0x0a, 0xaa, 0x51, 0x7a, 0x15, 0xd5, 0xc0, 0xd5, 0x49, + 0xfe, 0x03, 0x22, 0x00, 0x71, 0xd3, 0x69, 0x22, 0x3e, 0x51, 0x29, 0x6e, 0xcb, 0xf8, 0x0d, 0xcd, + 0x79, 0xfb, 0xdf, 0xb8, 0xdf, 0x62, 0x90, 0x4d, 0x5a, 0x36, 0x20, 0x0f, 0x29, 0xcc, 0x47, 0xe8, + 0x0c, 0x86, 0x15, 0xef, 0x1b, 0x78, 0xdb, 0xb2, 0x6a, 0x1a, 0xa7, 0xa6, 0x6e, 0x4d, 0x9a, 0x51, + 0xc9, 0x72, 0xac, 0x9c, 0x94, 0xea, 0xb9, 0x95, 0x14, 0xb5, 0xad, 0xae, 0x62, 0x51, 0xe8, 0xaa, + 0x30, 0xa5, 0xe5, 0x87, 0x42, 0x4e, 0x3b, 0x7b, 0xcc, 0x42, 0xeb, 0xe7, 0x33, 0x3d, 0x92, 0x10, + 0x97, 0x26, 0x53, 0xf8, 0x11, 0x8b, 0x83, 0xab, 0xe1, 0xbf, 0x7e, 0x9e, 0xe9, 0xcd, 0xac, 0x28, + 0x99, 0x7d, 0x14, 0x4c, 0x34, 0xde, 0xa6, 0x5b, 0x59, 0x51, 0x2c, 0x73, 0x29, 0x27, 0xdb, 0xa8, + 0x20, 0x7d, 0x56, 0x91, 0x98, 0x47, 0x21, 0xb7, 0x27, 0x9a, 0xfc, 0xdd, 0xe0, 0x6a, 0x6b, 0xd2, + 0x68, 0x0e, 0xbb, 0x9b, 0x2e, 0x3c, 0xfe, 0xe9, 0xa6, 0x6d, 0x73, 0xd0, 0xc0, 0xde, 0xd6, 0x53, + 0x70, 0x8b, 0x09, 0x0b, 0x82, 0x30, 0x65, 0xf9, 0x70, 0x78, 0x49, 0xe3, 0xb3, 0x7d, 0x41, 0x25, + 0xca, 0x69, 0x3e, 0x74, 0x2e, 0x02, 0x3f, 0x05, 0x8a, 0xdc, 0x95, 0x07, 0x9b, 0xb0, 0x0c, 0x56, + 0xbe, 0x0d, 0x2f, 0x07, 0x81, 0x82, 0xef, 0xab, 0x30, 0x72, 0xb0, 0xfd, 0x09, 0x76, 0x7b, 0x8a, + 0x13, 0xc2, 0x80, 0x5a, 0x75, 0x91, 0xb5, 0xb2, 0xe1, 0x24, 0x75, 0xb5, 0xc8, 0x24, 0xdb, 0xeb, + 0x15, 0x79, 0x30, 0xab, 0x38, 0x9f, 0x91, 0x5f, 0xcc, 0xec, 0x8f, 0x48, 0x64, 0x7e, 0xe4, 0xb6, + 0x6a, 0xb6, 0xb5, 0x36, 0xc2, 0x2d, 0xe3, 0xe5, 0xee, 0x4a, 0xbb, 0x42, 0xf8, 0xe0, 0x00, 0x9a, + 0xf0, 0x45, 0x54, 0xf1, 0x28, 0xac, 0xa3, 0xcc, 0xe4, 0x03, 0xbb, 0x01, 0xfd, 0xb7, 0xb5, 0xe2, + 0xa7, 0x2b, 0x82, 0x91, 0x1c, 0x1f, 0xd0, 0x65, 0x23, 0xff, 0x90, 0x19, 0x21, 0x41, 0xc6, 0x89, + 0xec, 0xcb, 0x0b, 0xe6, 0x1b, 0x4c, 0x6d, 0x77, 0x06, 0x29, 0x59, 0x02, 0x18, 0xa4, 0x01, 0x1a, + 0x68, 0xb8, 0x6f, 0xf5, 0x0d, 0x23, 0x03, 0x9c, 0x9b, 0xcd, 0x43, 0x61, 0xf6, 0x98, 0x0a, 0x60, + 0xef, 0x88, 0xd1, 0x44, 0x0d, 0x30, 0x4c, 0x5b, 0x4b, 0x52, 0xd6, 0xed, 0xc2, 0x91, 0x12, 0xdc, + 0x3a, 0x8a, 0xf2, 0x85, 0x89, 0xe8, 0xf6, 0x29, 0x48, 0xed, 0xb6, 0xbe, 0x76, 0x64, 0x6d, 0x59, + 0x66, 0x06, 0xb9, 0xe7, 0x05, 0xfe, 0xe3, 0xf1, 0x44, 0xa0, 0x7b, 0xc9, 0xed, 0x1d, 0x40, 0x0c, +}; +static const uint8_t ml_dsa_65_1_sig_msg[] = { + 0x88, 0x5a, 0x0b, 0xdd, 0x8d, 0xe7, 0x4b, 0xc7, 0x11, 0x69, 0x0a, 0xa6, 0x14, 0xdd, 0xa5, 0x32, + 0xf4, 0xd8, 0xc7, 0xea, 0x2c, 0x27, 0x85, 0x5a, 0x57, 0x8e, 0x63, 0x61, 0xca, 0xae, 0x2c, 0x0b, + 0xf7, 0xe7, 0x73, 0xb4, 0x90, 0x0a, 0x32, 0x93, 0x12, 0x1a, 0x6e, 0x0d, 0xd6, 0x10, 0x10, 0x7a, + 0x7a, 0x65, 0xbd, 0x6e, 0x11, 0xf6, 0x19, 0xfc, 0x0e, 0x9c, 0xe7, 0xbf, 0x7b, 0x5d, 0xe1, 0x80, + 0x76, 0xe1, 0xb7, 0x25, 0x57, 0x20, 0x97, 0xb2, 0x47, 0xd8, 0xe0, 0x46, 0x24, 0x94, 0xf6, 0x3f, + 0x4e, 0xdf, 0xbe, 0xac, 0x2f, 0xa2, 0xec, 0xae, 0x0c, 0xca, 0xd4, 0x28, 0xbd, 0x79, 0x6c, 0xf2, + 0x60, 0x92, 0xa1, 0xcd, 0x50, 0x5f, 0x59, 0x39, 0x11, 0xed, 0x10, 0xfd, 0xa4, 0x26, 0xc7, 0xe3, + 0xc5, 0xa4, 0x39, 0xe8, 0x50, 0x42, 0x13, 0x18, 0xae, 0x07, 0x85, 0xb0, 0x5a, 0xa9, 0x9f, 0x58, + 0xd6, 0x85, 0x6d, 0xeb, 0x78, 0xbb, 0xe4, 0x88, 0xc7, 0x0e, 0xee, 0x42, 0xbb, 0x9a, 0xb5, 0x92, + 0x7b, 0x2e, 0xd2, 0x5c, 0xd1, 0x43, 0x77, 0xcd, 0x7e, 0x1a, 0x88, 0x34, 0xe8, 0x21, 0x48, 0x00, + 0x2f, 0xcb, 0x98, 0x5a, 0xb9, 0x43, 0x12, 0x97, 0x01, 0x0b, 0x2b, 0xc7, 0x0f, 0x91, 0x32, 0x37, + 0x3c, 0x6d, 0xd2, 0xa2, 0xa9, 0xcf, 0x24, 0x6f, 0xe0, 0x26, 0x2e, 0x8b, 0x53, 0xe6, 0x93, 0xf3, + 0xd6, 0xfe, 0xd3, 0xed, 0xd1, 0xf2, 0x00, 0x4e, 0xd1, 0x7c, 0x2c, 0xf5, 0xb2, 0x57, 0xf4, 0xad, + 0xa5, 0xdc, 0x1a, 0x7c, 0x15, 0x1f, 0xfe, 0x03, 0xb9, 0x6a, 0x4d, 0xb9, 0x91, 0xe4, 0x13, 0x2d, + 0x01, 0xde, 0x1f, 0x03, 0x3e, 0xd8, 0x13, 0x57, 0xea, 0xe7, 0xc1, 0xa8, 0xd2, 0xdd, 0xd9, 0x2d, + 0xdf, 0xc0, 0x6f, 0x67, 0x13, 0x94, 0xd2, 0xf6, 0x02, 0x12, 0xc6, 0xe4, 0x49, 0xea, 0x35, 0x93, + 0x24, 0xfe, 0xd3, 0x8c, 0x84, 0xd3, 0x6d, 0x15, 0x43, 0x2e, 0x11, 0xe7, 0x15, 0x00, 0x15, 0x80, + 0x4f, 0x97, 0xa3, 0xc6, 0x77, 0x38, 0x2c, 0xd4, 0x6a, 0xa4, 0xd7, 0xac, 0xee, 0x56, 0x86, 0xfb, + 0xce, 0xd7, 0xa9, 0xe8, 0x5d, 0x29, 0xc4, 0x83, 0x86, 0xe6, 0x9f, 0x40, 0x69, 0x3d, 0x9a, 0xda, + 0xbe, 0xb4, 0x3b, 0xd0, 0xe5, 0x03, 0x6a, 0xcd, 0xe6, 0x31, 0xb5, 0x49, 0x57, 0xf4, 0xfc, 0xe2, + 0x6f, 0x7a, 0x24, 0xb0, 0xda, 0xd4, 0x34, 0x8a, 0x67, 0x89, 0xca, 0xe1, 0x06, 0x13, 0x06, 0x20, + 0xed, 0x2f, 0xa0, 0xea, 0x38, 0xf5, 0x75, 0xf2, 0x87, 0x83, 0xbc, 0x92, 0xb3, 0x2b, 0x0c, 0x51, + 0xc8, 0xa6, 0x54, 0x6f, 0x5d, 0x88, 0x09, 0x5f, 0x9f, 0x73, 0xc6, 0x5b, 0xf6, 0xf2, 0x51, 0xa2, + 0xc4, 0x69, 0x74, 0x64, 0x45, 0xc5, 0x88, 0xc3, 0xea, 0x81, 0x39, 0xe4, 0x33, 0xd4, 0xfe, 0x2d, + 0xe4, 0xc0, 0xd3, 0x58, 0xb6, 0xca, 0x8a, 0x62, 0x94, 0xe6, 0xaf, 0xc1, 0xb9, 0x60, 0x74, 0xc0, + 0x68, 0xef, 0x67, 0xb1, 0x58, 0xf1, 0x12, 0x9c, 0xfe, 0x0a, 0x3a, 0xe7, 0xeb, 0x9d, 0x45, 0x4f, + 0x35, 0x7f, 0xbb, 0x6a, 0xb3, 0xb9, 0x92, 0x2b, 0x1b, 0xcd, 0x55, 0x58, 0x61, 0x87, 0xcd, 0x24, + 0x69, 0x24, 0x82, 0x78, 0x23, 0x34, 0xac, 0x9f, 0x2b, 0x86, 0x12, 0x48, 0xf6, 0xa5, 0x30, 0xe9, + 0x3e, 0x11, 0x48, 0x87, 0x84, 0xdd, 0xe5, 0xea, 0x67, 0x8a, 0xe5, 0x05, 0x90, 0x3e, 0x23, 0x10, + 0x53, 0x30, 0x8c, 0x1b, 0x87, 0x84, 0x60, 0x7e, 0x06, 0x3f, 0x48, 0x98, 0xa4, 0xfa, 0xb6, 0x01, + 0xd3, 0xe6, 0x96, 0x85, 0x97, 0x21, 0x55, 0xf6, 0x3f, 0x09, 0xfd, 0x84, 0xb2, 0xb3, 0xdf, 0x74, + 0x1f, 0xb6, 0x42, 0xac, 0xa6, 0x03, 0xd0, 0xd5, 0x96, 0xe0, 0xa8, 0xda, 0xd4, 0x24, 0xf4, 0x64, + 0x0f, 0x98, 0xb9, 0x6f, 0xb2, 0x42, 0xc6, 0x95, 0xdc, 0x33, 0x1f, 0x57, 0x59, 0xf7, 0x5e, 0xaf, + 0x19, 0x1c, 0xbd, 0x98, 0x5e, 0xc5, 0x99, 0x8d, 0x56, 0x48, 0xc8, 0x5e, 0xb6, 0x31, 0x29, 0x5f, + 0x61, 0x56, 0x7c, 0x11, 0x63, 0xf9, 0x90, 0xdc, 0x4f, 0xa1, 0x71, 0x40, 0x91, 0x26, 0x1e, 0x5f, + 0x3e, 0x5f, 0x0b, 0xfe, 0x84, 0x55, 0xbb, 0x8b, 0xaa, 0x1d, 0x69, 0x42, 0x1f, 0x15, 0x37, 0x4e, + 0x73, 0xb0, 0x7e, 0x78, 0x57, 0x9d, 0x0e, 0x25, 0x1a, 0x41, 0xee, 0x1a, 0x50, 0x43, 0xaa, 0xbf, + 0x8b, 0xe7, 0x73, 0xee, 0x7f, 0x9d, 0x0f, 0xdf, 0xcf, 0xd3, 0xae, 0x71, 0x1f, 0xab, 0x1d, 0x3d, + 0xbc, 0xc2, 0x84, 0x3b, 0xe5, 0xa9, 0x46, 0xb2, 0x4d, 0x8b, 0x9b, 0x94, 0x35, 0x8b, 0x5f, 0x59, + 0x8e, 0x88, 0xed, 0x3d, 0x53, 0xf3, 0x10, 0xf8, 0xec, 0x63, 0x22, 0x9d, 0x4f, 0x5b, 0xb1, 0xb6, + 0xd5, 0x24, 0xa5, 0xaf, 0x9c, 0x39, 0x47, 0x79, 0x25, 0xc7, 0xe2, 0x90, 0x95, 0xfc, 0x43, 0xf1, + 0x71, 0xfe, 0xcd, 0xd0, 0x61, 0xf3, 0x62, 0x62, 0x71, 0x21, 0x75, 0x2c, 0x23, 0x6b, 0x79, 0x2f, + 0x1b, 0x31, 0x90, 0x79, 0x7c, 0xd0, 0x57, 0x5c, 0x58, 0x4f, 0x30, 0xb5, 0x56, 0x81, 0x19, 0x61, + 0x90, 0x45, 0x09, 0xc9, 0x8b, 0xcd, 0xe8, 0x65, 0x9d, 0x22, 0x80, 0xf4, 0x95, 0xa0, 0xc9, 0x55, + 0x7d, 0x38, 0x11, 0xaf, 0x5e, 0xd4, 0x37, 0x7b, 0xc7, 0x59, 0x9e, 0x49, 0x59, 0xff, 0x85, 0xf2, + 0x15, 0x0a, 0xcd, 0xec, 0xc1, 0xf7, 0x67, 0x2d, 0xe1, 0xee, 0x4d, 0xb4, 0x4c, 0x1f, 0xb5, 0xf7, + 0x99, 0x8a, 0xb5, 0xdb, 0x74, 0x2f, 0x6c, 0x5d, 0x32, 0xcb, 0xc0, 0xf2, 0xfb, 0xc9, 0x54, 0xea, + 0xd6, 0xcc, 0x13, 0x4b, 0x97, 0x62, 0xdf, 0x33, 0x13, 0x86, 0xde, 0xca, 0x31, 0x69, 0x47, 0x88, + 0x4b, 0x9a, 0x13, 0xad, 0xea, 0x5c, 0xbe, 0x29, 0x56, 0x64, 0x4f, 0xa1, 0x2a, 0x7b, 0xb3, 0xbf, + 0xb9, 0x7e, 0x1d, 0x93, 0xa7, 0x01, 0x91, 0xac, 0x38, 0xa0, 0x37, 0x32, 0x58, 0xc2, 0xc2, 0x81, + 0x6d, 0xea, 0x6e, 0xaf, 0x88, 0x0d, 0x69, 0xf4, 0x5f, 0xba, 0x4c, 0x29, 0x0f, 0x18, 0xd3, 0x4b, + 0xb8, 0x36, 0x8c, 0xf4, 0xeb, 0xb4, 0x72, 0xba, 0x49, 0x9c, 0xbb, 0x54, 0x50, 0x1e, 0xe3, 0xa2, + 0x8e, 0x5f, 0xb9, 0xfd, 0xc6, 0x6c, 0xf6, 0x45, 0x72, 0x09, 0x47, 0x19, 0xbb, 0xdb, 0x48, 0xf3, + 0xf4, 0x88, 0x51, 0x3b, 0x65, 0x50, 0xe1, 0x27, 0xe8, 0x34, 0x1c, 0x7e, 0x53, 0xdc, 0xfd, 0xa7, + 0xd4, 0x08, 0x05, 0x58, 0x0b, 0xc7, 0xd3, 0x0a, 0x72, 0xf2, 0x44, 0xcc, 0xdb, 0x5a, 0xef, 0x66, + 0x1b, 0x0f, 0x30, 0x4e, 0xc5, 0xb7, 0xab, 0x93, 0xb8, 0xc5, 0xc4, 0x9a, 0x77, 0x68, 0x38, 0xb7, + 0xd5, 0x23, 0x74, 0xaa, 0x41, 0x63, 0x02, 0x24, 0xd6, 0x16, 0xf3, 0x10, 0xe4, 0x99, 0xec, 0xad, + 0xce, 0x93, 0xe7, 0x8b, 0x94, 0xd3, 0xca, 0x48, 0xb3, 0x47, 0xbc, 0x0e, 0xec, 0xaa, 0x20, 0x66, + 0x02, 0x29, 0x65, 0xc8, 0x07, 0xbe, 0xf9, 0x02, 0x9b, 0xc5, 0x22, 0x8f, 0x00, 0x5e, 0xdb, 0x74, + 0xd4, 0xb1, 0x44, 0x98, 0xce, 0x3a, 0xe1, 0x3b, 0xeb, 0x7c, 0x69, 0x3b, 0x66, 0x9e, 0xe9, 0xf9, + 0xa6, 0xf4, 0x6f, 0xc0, 0x0e, 0xc0, 0x5e, 0x13, 0x2b, 0xb6, 0xc6, 0x76, 0x0f, 0xb5, 0xc5, 0x1c, + 0x83, 0x23, 0xac, 0xd6, 0xa3, 0xc7, 0x5a, 0x72, 0xe9, 0x73, 0x89, 0x66, 0xd1, 0x25, 0xb9, 0x61, + 0x3b, 0x31, 0x45, 0xc6, 0x7b, 0x5e, 0x98, 0x81, 0x87, 0xe8, 0x5f, 0x29, 0xad, 0xcb, 0xaf, 0x74, + 0xe3, 0x3a, 0x61, 0x1f, 0xff, 0x25, 0x2a, 0xeb, 0xba, 0xeb, 0x1e, 0xa6, 0x41, 0xe6, 0xfc, 0x8b, + 0xdf, 0x73, 0x41, 0xbe, 0x2a, 0xa8, 0x57, 0xe4, 0x43, 0xac, 0xfb, 0xce, 0xb2, 0x15, 0x5d, 0x08, + 0x1a, 0xcb, 0x4c, 0xcd, 0xb0, 0x98, 0xd5, 0x7c, 0xef, 0x6f, 0x6f, 0xd3, 0x42, 0xdb, 0x2d, 0x83, + 0xb6, 0x12, 0x3e, 0x0a, 0xd3, 0xc9, 0x3f, 0x30, 0x08, 0x11, 0xb8, 0xd5, 0xa1, 0x1a, 0x5a, 0x29, + 0xbe, 0x60, 0x81, 0x6f, 0x69, 0xb2, 0x9d, 0x1d, 0x7e, 0x15, 0x88, 0x69, 0xd8, 0x60, 0xf6, 0xfb, + 0x82, 0x9d, 0xe8, 0x0d, 0x3e, 0x1b, 0x69, 0x9c, 0x3a, 0xb6, 0x80, 0x4e, 0xb6, 0x54, 0x91, 0x78, + 0xd9, 0x47, 0x33, 0x38, 0xd6, 0xaf, 0x20, 0x9e, 0x1f, 0x7d, 0x26, 0x3c, 0x66, 0x7a, 0xe6, 0x89, + 0x5f, 0x6e, 0x29, 0x33, 0x92, 0x34, 0x71, 0xf1, 0x99, 0x58, 0x1f, 0x8a, 0x51, 0xbd, 0x9a, 0xa4, + 0x52, 0xee, 0xe4, 0xbf, 0xe9, 0x56, 0x69, 0xac, 0xd0, 0x7b, 0x41, 0xb0, 0x0c, 0x03, 0xf5, 0x5a, + 0x40, 0xd1, 0x0b, 0x50, 0xf8, 0xe4, 0x67, 0xbd, 0x07, 0x1c, 0x8f, 0x40, 0x5c, 0xf1, 0x19, 0x61, + 0x2d, 0x32, 0x40, 0x5b, 0xd5, 0x27, 0x5a, 0x6b, 0xbf, 0x22, 0x17, 0xf9, 0xf1, 0x79, 0x0d, 0x29, + 0x99, 0x7b, 0x7b, 0x6b, 0x1e, 0xc8, 0xd7, 0x92, 0x4a, 0xb9, 0xe6, 0x44, 0xc1, 0x29, 0xce, 0xe8, + 0x74, 0x33, 0x29, 0x1a, 0x2c, 0x8e, 0xd6, 0xbc, 0x3c, 0x2a, 0x19, 0xd0, 0x76, 0xb1, 0x77, 0xee, + 0x60, 0x50, 0x69, 0x2a, 0xda, 0x8e, 0x95, 0x57, 0x4d, 0x6c, 0xe9, 0xab, 0xe4, 0x97, 0x95, 0xd8, + 0xf2, 0x8e, 0xab, 0x69, 0x67, 0x6e, 0x79, 0x03, 0xa6, 0x56, 0xfa, 0xb3, 0x20, 0x25, 0xfe, 0x34, + 0x65, 0xcb, 0xdb, 0x57, 0x01, 0xc1, 0x77, 0x20, 0x9d, 0x91, 0x89, 0xa5, 0x91, 0x7c, 0x13, 0x37, + 0xde, 0x39, 0xf5, 0x75, 0xe5, 0xdd, 0xb9, 0x3c, 0xa7, 0x6b, 0xeb, 0x52, 0xaf, 0x32, 0xe8, 0xd7, + 0x12, 0x7b, 0x28, 0xf7, 0xce, 0x73, 0x12, 0xe8, 0x03, 0x90, 0x47, 0x21, 0xab, 0x21, 0x6e, 0x92, + 0xa8, 0xa9, 0xe6, 0x09, 0xfc, 0x10, 0xaf, 0x8d, 0xc2, 0xaa, 0xca, 0x14, 0xa9, 0x7b, 0xb0, 0xe4, + 0xb2, 0x34, 0xc7, 0x00, 0x0e, 0xbb, 0xe0, 0xc4, 0x42, 0xf1, 0x85, 0x94, 0x6b, 0x7c, 0xe7, 0x72, + 0x80, 0x95, 0xcd, 0x60, 0x16, 0x9b, 0x0b, 0xd9, 0x7b, 0x36, 0xb3, 0xae, 0x38, 0x55, 0xd9, 0x89, + 0x25, 0xb2, 0x9d, 0x92, 0x94, 0xef, 0x27, 0x75, 0x09, 0xfc, 0xa4, 0x07, 0xea, 0x2b, 0xc4, 0x76, + 0x59, 0x02, 0x6a, 0x82, 0x04, 0xd6, 0x96, 0x4f, 0xc6, 0x5b, 0xef, 0x35, 0x31, 0xe9, 0xc1, 0xe6, + 0xf9, 0x70, 0xbf, 0x2f, 0xf2, 0x40, 0x75, 0xea, 0x17, 0xd1, 0x36, 0xad, 0xea, 0xd2, 0x35, 0x6b, + 0x6c, 0xe4, 0x98, 0xf9, 0x3c, 0xd2, 0xf9, 0xe5, 0xe1, 0x90, 0xd2, 0x09, 0xd9, 0x3e, 0x47, 0x3f, + 0xaa, 0x8e, 0xd9, 0x20, 0x96, 0x31, 0x5b, 0xf1, 0xfc, 0xa6, 0x55, 0xfe, 0xbc, 0x78, 0xe0, 0x99, + 0x65, 0xc9, 0x74, 0x78, 0x29, 0x6b, 0x75, 0xd3, 0x90, 0x56, 0x60, 0x4d, 0x32, 0x71, 0x91, 0x6d, + 0xcf, 0xf2, 0x25, 0xcb, 0x6b, 0x9a, 0x34, 0xe1, 0x5d, 0xc1, 0x64, 0xb2, 0xa6, 0x8a, 0x3b, 0x42, + 0xde, 0x05, 0x7a, 0x6b, 0xac, 0x17, 0x32, 0xcf, 0x59, 0x45, 0xbb, 0xca, 0x12, 0xb8, 0xb3, 0x61, + 0x59, 0xfb, 0x89, 0xf7, 0xbb, 0xbe, 0x9f, 0xe0, 0x34, 0x21, 0x8f, 0x5b, 0x3b, 0xcf, 0x18, 0x4c, + 0x20, 0x73, 0x06, 0xe6, 0xd2, 0xea, 0x69, 0x59, 0xea, 0xe0, 0x89, 0x0a, 0x7b, 0x68, 0x02, 0xec, + 0x1d, 0xa0, 0x82, 0xbe, 0xd6, 0x5b, 0xb6, 0xe4, 0xeb, 0x4d, 0x56, 0x15, 0x70, 0x1c, 0xb0, 0xe3, + 0x50, 0x36, 0x33, 0x14, 0xa4, 0xd1, 0x01, 0xdb, 0xba, 0x60, 0x53, 0x71, 0xa3, 0x8b, 0x2d, 0x8a, + 0x37, 0xff, 0x78, 0xeb, 0xb3, 0x69, 0x82, 0x53, 0x88, 0xaa, 0xb7, 0xd3, 0xc6, 0x23, 0xb9, 0x3e, + 0x51, 0x2d, 0x96, 0xa9, 0xf3, 0x39, 0xec, 0x96, 0x8b, 0x35, 0x27, 0x59, 0xaf, 0x3e, 0x8f, 0xa3, + 0x21, 0x1c, 0x39, 0x29, 0x5b, 0x01, 0x10, 0xe6, 0xdf, 0x26, 0x4e, 0x90, 0x67, 0x8c, 0x11, 0xe2, + 0xb9, 0x03, 0xaf, 0x32, 0x2e, 0x4f, 0xa7, 0x70, 0x28, 0xd3, 0xec, 0xc4, 0x4f, 0x62, 0x79, 0xd6, + 0x3b, 0x1e, 0x60, 0xd8, 0x06, 0x72, 0x41, 0x01, 0x5f, 0xc4, 0xf8, 0x9b, 0xaa, 0x15, 0x6a, 0x78, + 0xfa, 0x77, 0xbb, 0x29, 0x14, 0xca, 0xc2, 0x81, 0xf4, 0x40, 0x9c, 0x9c, 0x03, 0x70, 0xab, 0xd7, + 0xc1, 0xf8, 0xa5, 0xd1, 0x04, 0x0b, 0x59, 0x75, 0x2c, 0xc4, 0xfd, 0xf0, 0xd1, 0x9c, 0xb0, 0xc5, + 0x6f, 0xef, 0x34, 0xfa, 0x3a, 0x3b, 0xce, 0xe1, 0xf0, 0x64, 0xe3, 0x60, 0xe8, 0x6d, 0xc5, 0x5d, + 0xb5, 0xc9, 0x37, 0x5b, 0xda, 0xda, 0x67, 0x2e, 0x72, 0xf6, 0x64, 0xe3, 0xac, 0xb2, 0xe6, 0xd8, + 0xa0, 0x84, 0x09, 0xc8, 0xcd, 0x60, 0xa1, 0xf9, 0x53, 0x80, 0xab, 0x6c, 0x3a, 0xcb, 0x6b, 0x91, + 0xa8, 0xa9, 0xa3, 0xb7, 0x75, 0x50, 0x49, 0x79, 0xb8, 0x02, 0x5a, 0xdb, 0x34, 0x22, 0x61, 0x9b, + 0xd1, 0x1e, 0x2b, 0x54, 0xfe, 0x6d, 0x07, 0x58, 0x81, 0xac, 0xac, 0x24, 0x53, 0x20, 0x31, 0xcc, + 0xd2, 0x99, 0x06, 0x0e, 0x4e, 0xb7, 0xf7, 0xcb, 0xd8, 0x08, 0x36, 0xd4, 0xb8, 0x23, 0xa5, 0xff, + 0xa4, 0xfe, 0x8c, 0x6b, 0x98, 0x3d, 0x2a, 0xae, 0xb8, 0xf1, 0x6f, 0x6c, 0x1c, 0x22, 0x81, 0xef, + 0xd7, 0x13, 0xff, 0xda, 0x22, 0x06, 0x9a, 0x5d, 0x8a, 0xc4, 0x91, 0x29, 0x1c, 0xbf, 0x49, 0xf1, + 0x18, 0xc9, 0x46, 0xd5, 0x0f, 0x08, 0xe0, 0xd1, 0x73, 0x28, 0x14, 0xe8, 0x15, 0x81, 0x90, 0x6a, + 0x31, 0x53, 0x94, 0x01, 0x14, 0xbe, 0xc8, 0xeb, 0xd4, 0x9c, 0x73, 0x79, 0x0f, 0x9e, 0xd7, 0xcc, + 0xd9, 0x85, 0xed, 0xad, 0x8d, 0xb3, 0x42, 0x6b, 0x15, 0x13, 0x98, 0xeb, 0xf1, 0x6e, 0xfa, 0xfe, + 0x3d, 0xa0, 0xc7, 0xf3, 0x8b, 0x22, 0x76, 0x05, 0x76, 0xd4, 0x88, 0x52, 0x73, 0xf5, 0xe4, 0x0b, + 0x14, 0x05, 0x57, 0x10, 0x7f, 0xce, 0x0b, 0xf8, 0x46, 0x1f, 0x24, 0x8b, 0xc4, 0x3f, 0xbf, 0x5c, + 0xee, 0xe7, 0x6e, 0xf3, 0xa9, 0xeb, 0xd2, 0x30, 0x95, 0x6c, 0x7b, 0x98, 0xac, 0x89, 0x8a, 0x39, + 0x9e, 0x5c, 0x2a, 0xb0, 0xcb, 0xe9, 0xe5, 0xab, 0x94, 0x71, 0xdf, 0x5e, 0x53, 0x0c, 0x72, 0xf2, + 0x6c, 0x34, 0xdb, 0xfe, 0x2f, 0x83, 0x68, 0x3e, 0xb6, 0x22, 0xf9, 0x64, 0x7a, 0xa0, 0x6a, 0x26, + 0x7d, 0x78, 0x97, 0x36, 0x31, 0x2c, 0x90, 0xc9, 0xe5, 0x9d, 0x77, 0x12, 0x2a, 0x88, 0x53, 0x8f, + 0xd0, 0xf5, 0x39, 0x16, 0xaf, 0x08, 0xb2, 0x36, 0x93, 0x5c, 0xdc, 0x5b, 0xb3, 0xcb, 0x49, 0x0c, + 0x83, 0x09, 0xe6, 0xa7, 0x9b, 0x43, 0xe7, 0xa5, 0x4a, 0x8a, 0x07, 0xe1, 0xba, 0xfb, 0x9b, 0x93, + 0x7e, 0xac, 0x2f, 0xc3, 0xac, 0xed, 0x30, 0x64, 0x1f, 0x33, 0x79, 0x19, 0xd2, 0xdb, 0x54, 0xec, + 0x7f, 0x32, 0x0e, 0xc5, 0x1c, 0xd1, 0x3c, 0x00, 0xb9, 0xe6, 0x03, 0xdf, 0x6d, 0xd2, 0x69, 0x0c, + 0x75, 0xaf, 0x37, 0x07, 0xb7, 0xc9, 0x3e, 0x91, 0xcf, 0x02, 0x78, 0xd7, 0x43, 0xa1, 0x8b, 0x4e, + 0x69, 0x74, 0xb4, 0x24, 0x08, 0x10, 0x42, 0xb5, 0xb4, 0xe7, 0x8c, 0xeb, 0x7f, 0xff, 0x67, 0x98, + 0x0b, 0xbc, 0xba, 0x5e, 0x29, 0xbe, 0x61, 0x33, 0x56, 0x16, 0xd6, 0x5e, 0x86, 0xf0, 0xe7, 0x46, + 0xd1, 0x83, 0xdf, 0xd4, 0x6b, 0x75, 0xc9, 0x30, 0x0d, 0x60, 0xc5, 0x19, 0xfd, 0x95, 0xa8, 0xa6, + 0x61, 0xff, 0xc8, 0x2a, 0xe7, 0x5d, 0xd1, 0x49, 0x49, 0x1f, 0x99, 0xd1, 0x41, 0x4f, 0x15, 0x79, + 0x00, 0x8a, 0x80, 0x27, 0xa6, 0xc9, 0x98, 0xd3, 0xe7, 0xa2, 0xbb, 0xfa, 0x07, 0xab, 0x53, 0xef, + 0xe8, 0x17, 0xae, 0x9c, 0x6a, 0xe8, 0xd0, 0x52, 0xaa, 0x85, 0x9d, 0x03, 0x48, 0xb0, 0xd2, 0xc8, + 0x5b, 0xcc, 0xc4, 0x50, 0x84, 0x90, 0xbe, 0x0f, 0x9b, 0x32, 0x13, 0xb8, 0xaf, 0x7c, 0xce, 0xe7, + 0x22, 0xe2, 0x82, 0x13, 0x18, 0x71, 0x46, 0xc5, 0xda, 0x05, 0xb7, 0x65, 0xd8, 0x33, 0x06, 0xfa, + 0x5a, 0x6b, 0x76, 0xd6, 0x92, 0x76, 0xd1, 0x6a, 0x2b, 0xc6, 0x0d, 0xb1, 0xad, 0xab, 0x57, 0x62, + 0xea, 0x76, 0x37, 0x4e, 0xab, 0x2d, 0x34, 0xd2, 0xa3, 0x57, 0xc7, 0x56, 0xfb, 0xea, 0xd6, 0xa9, + 0xe3, 0xc1, 0x63, 0x07, 0xde, 0xb9, 0x5e, 0x5a, 0x30, 0x2e, 0x41, 0x4d, 0x43, 0xe9, 0x1c, 0xa1, + 0x5b, 0xb2, 0x4f, 0xaf, 0xdc, 0xe9, 0xbb, 0xbe, 0x73, 0x55, 0x90, 0xf0, 0xd0, 0x02, 0x98, 0x6d, + 0x13, 0x50, 0x9a, 0xca, 0x4c, 0xb3, 0x15, 0x3a, 0x26, 0x14, 0x38, 0x67, 0xeb, 0xa7, 0x27, 0x33, + 0x48, 0x97, 0x58, 0x94, 0x57, 0xea, 0xf9, 0x7e, 0x8b, 0xb0, 0xbb, 0xf3, 0xf4, 0x84, 0x6e, 0x69, + 0x95, 0x2c, 0xf4, 0x6b, 0x1c, 0x65, 0x39, 0xb4, 0x46, 0xa7, 0x99, 0xd6, 0x68, 0x47, 0x6e, 0x2e, + 0x49, 0x84, 0x75, 0x3e, 0x6c, 0x2e, 0x9a, 0x08, 0xbc, 0xb7, 0x2f, 0x86, 0x68, 0x5c, 0xe1, 0xbf, + 0xea, 0xa1, 0xaf, 0x59, 0xd6, 0x71, 0xb7, 0xbd, 0xd6, 0xc5, 0xc2, 0xf2, 0xf3, 0xb5, 0x36, 0xbb, + 0x36, 0x23, 0x4f, 0xd6, 0x44, 0x59, 0x0a, 0x44, 0x86, 0xca, 0xdc, 0xd4, 0x22, 0x0f, 0x79, 0x09, + 0x99, 0x8c, 0x8c, 0x9e, 0x03, 0xa4, 0x51, 0x99, 0x5a, 0xb9, 0x97, 0x76, 0x73, 0x20, 0xd3, 0x98, + 0x8c, 0x52, 0x96, 0xe1, 0x65, 0x7b, 0x4c, 0x77, 0x40, 0xb2, 0xfe, 0x27, 0x0a, 0x11, 0x76, 0x6e, + 0x3b, 0x35, 0x12, 0xc6, 0x4e, 0xc2, 0x0e, 0xcc, 0x04, 0xb5, 0x51, 0x91, 0xd0, 0x4a, 0xf7, 0x84, + 0xf2, 0xe7, 0xe5, 0x99, 0x7e, 0xb5, 0x3e, 0xac, 0x53, 0xdb, 0x61, 0x11, 0x71, 0x56, 0x4e, 0xab, + 0x4a, 0x68, 0xc1, 0x6a, 0xa5, 0xc5, 0x7f, 0x72, 0xeb, 0x14, 0x97, 0xa4, 0x27, 0xa0, 0x53, 0xa1, + 0xc4, 0x70, 0x7d, 0x58, 0xbd, 0xc1, 0xd7, 0xfd, 0x9f, 0xb8, 0x8c, 0xce, 0x34, 0xf9, 0xe1, 0x9c, + 0x59, 0x79, 0x31, 0x24, 0xec, 0xbb, 0xf5, 0x6f, 0x3f, 0xa3, 0x5a, 0x55, 0xb3, 0xde, 0x64, 0xdf, + 0xa9, 0x95, 0x0b, 0x53, 0xf2, 0xa7, 0x25, 0x7b, 0x8c, 0xad, 0x25, 0x9a, 0x35, 0xbf, 0x15, 0x46, + 0x69, 0x4a, 0x83, 0x8c, 0x80, 0xfc, 0x37, 0xd0, 0xc3, 0x6f, 0x00, 0xe2, 0x3c, 0x63, 0xab, 0xc5, + 0x53, 0xc1, 0x8d, 0x4a, 0x40, 0x4b, 0xe6, 0xdc, 0x05, 0xb1, 0x20, 0x23, 0x8b, 0xb8, 0xdf, 0x40, + 0x86, 0x97, 0xb9, 0x5e, 0xa4, 0xb7, 0xa1, 0x37, 0xe0, 0x4b, 0x9e, 0xd9, 0x84, 0x2b, 0x2d, 0xad, + 0xd1, 0xb1, 0x52, 0x15, 0x00, 0x9b, 0xdd, 0x23, 0xa9, 0x27, 0x44, 0x21, 0x33, 0x17, 0x1c, 0x61, + 0x49, 0x84, 0x0d, 0x6a, 0x11, 0x7c, 0x77, 0xa5, 0xd6, 0x8e, 0xe6, 0x1d, 0x6e, 0x90, 0x04, 0x4a, + 0xd3, 0x54, 0x3a, 0xa7, 0x1a, 0x28, 0xc5, 0x94, 0x01, 0xca, 0xdb, 0x1b, 0x5d, 0x78, 0xc5, 0xc6, + 0x69, 0x0d, 0x69, 0x88, 0x75, 0x00, 0x02, 0x0b, 0x59, 0x6c, 0x3e, 0xc5, 0x30, 0xdf, 0xee, 0x85, + 0x43, 0xa2, 0x9a, 0xf9, 0xdd, 0x85, 0x6e, 0xb3, 0x0d, 0x83, 0x6a, 0x13, 0x88, 0xd0, 0x12, 0x15, + 0x53, 0x16, 0xfc, 0x5c, 0x15, 0x47, 0xec, 0x6d, 0x4d, 0x18, 0x2d, 0x88, 0xdb, 0xd2, 0x17, 0x6c, + 0xde, 0x64, 0xec, 0x70, 0x8d, 0x19, 0xdc, 0x66, 0x69, 0x7f, 0xcf, 0x61, 0x6e, 0x4f, 0x23, 0x86, + 0xf5, 0x1a, 0x98, 0x47, 0x4b, 0xcc, 0xe9, 0x2f, 0x12, 0x28, 0x12, 0xb9, 0xeb, 0xd8, 0x32, 0xdc, + 0xe4, 0xd8, 0x63, 0xac, 0x56, 0x08, 0x2f, 0xec, 0x5e, 0x47, 0x29, 0xff, 0x76, 0xfe, 0x95, 0x60, + 0xd2, 0x19, 0x61, 0x0e, 0xaf, 0xfc, 0x44, 0x42, 0x11, 0x42, 0x79, 0xbc, 0x06, 0x3a, 0xad, 0x93, + 0x7e, 0x46, 0x60, 0x03, 0xb0, 0xf5, 0x9f, 0x57, 0x28, 0x48, 0x44, 0x8f, 0x0e, 0xfa, 0x72, 0x8c, + 0xe4, 0x18, 0xf4, 0x99, 0x6b, 0xb1, 0x23, 0x45, 0xdc, 0x13, 0xa2, 0xf6, 0x5f, 0x57, 0x35, 0xa2, + 0xd7, 0x38, 0xf9, 0xe9, 0x8a, 0x7a, 0x79, 0xc6, 0xb2, 0xcd, 0xbf, 0xd3, 0x41, 0x21, 0x56, 0xb3, + 0x39, 0xd9, 0x14, 0x3b, 0xdd, 0x85, 0xcb, 0x78, 0x2f, 0xeb, 0x7e, 0x29, 0xbc, 0x52, 0x24, 0xe7, + 0x1b, 0x85, 0xb1, 0x65, 0xae, 0xab, 0x65, 0xf9, 0x54, 0xd2, 0x1f, 0x37, 0x29, 0x52, 0x30, 0x5b, + 0x3d, 0x5f, 0x48, 0x84, 0x3f, 0x51, 0x27, 0x88, 0x9d, 0xa7, 0x94, 0xf0, 0x73, 0xcd, 0x98, 0xd2, + 0x05, 0xe8, 0x25, 0x71, 0x7c, 0x93, 0x13, 0x82, 0x5d, 0x53, 0x8d, 0x05, 0x0e, 0x69, 0x20, 0xc4, + 0xdb, 0xf2, 0xf6, 0x55, 0x24, 0x29, 0xd0, 0x41, 0xf6, 0x2d, 0xf8, 0xc1, 0x2e, 0xc2, 0x4d, 0xe1, + 0xd7, 0x2d, 0xa0, 0x49, 0x16, 0x0b, 0x4d, 0x34, 0xb5, 0x6d, 0xae, 0x10, 0x93, 0x1e, 0xb6, 0x95, + 0x69, 0xc2, 0xb3, 0xc0, 0xaf, 0x6f, 0xff, 0xa5, 0x32, 0x3c, 0x7d, 0xc9, 0xc7, 0xc8, 0xef, 0x0c, + 0x64, 0x20, 0x23, 0xc4, 0xfe, 0x89, 0x87, 0x8e, 0xb3, 0xa6, 0xc5, 0x24, 0xcf, 0x03, 0x7e, 0x74, + 0xf7, 0xbf, 0x89, 0x1e, 0xcf, 0xb1, 0x02, 0xfa, 0xf2, 0x9f, 0xd3, 0x9d, 0x99, 0x00, 0xda, 0x7a, + 0x92, 0x7d, 0x13, 0x11, 0x92, 0xad, 0x55, 0xf2, 0xe1, 0x82, 0x72, 0xb1, 0x6a, 0xf1, 0x45, 0x05, + 0xda, 0x17, 0xc9, 0xa1, 0x42, 0x82, 0x89, 0x77, 0x31, 0xb6, 0x72, 0x54, 0x7c, 0x68, 0x10, 0x25, + 0x57, 0x30, 0x16, 0x15, 0x08, 0x58, 0x8b, 0xc1, 0x61, 0xcb, 0xa0, 0x58, 0x29, 0x33, 0xb1, 0x64, + 0xf4, 0x4f, 0x06, 0xaa, 0x25, 0x31, 0xaa, 0xa8, 0x92, 0x1c, 0x69, 0x1e, 0x6e, 0xb6, 0xbe, 0x81, + 0xda, 0x9b, 0xe5, 0x1c, 0x56, 0x39, 0x55, 0xe0, 0xc1, 0xef, 0xd3, 0xed, 0x2a, 0x1c, 0x94, 0x9b, + 0xd4, 0xe0, 0x0b, 0x3a, 0xe9, 0xeb, 0xc1, 0x3c, 0x4c, 0x6c, 0x4e, 0x5e, 0x39, 0x4c, 0xb0, 0x34, + 0xb9, 0xcb, 0x75, 0xbe, 0xce, 0x86, 0x44, 0xff, 0x89, 0xef, 0x95, 0xe7, 0x6e, 0xf7, 0x15, 0xe1, + 0x7a, 0xa2, 0x6b, 0x1f, 0xeb, 0x77, 0x4c, 0x50, 0x59, 0xb3, 0xa3, 0x9a, 0x38, 0xdf, 0xd0, 0x57, + 0xd6, 0x41, 0xe4, 0x3f, 0xfe, 0x0f, 0x3e, 0x40, 0xff, 0xf6, 0xb2, 0x36, 0x3c, 0x1b, 0xf0, 0xef, + 0x07, 0x87, 0x3d, 0x09, 0xa4, 0x87, 0x76, 0x9d, 0x0a, 0x73, 0xcd, 0x0c, 0xc6, 0x44, 0xf5, 0x3c, + 0x25, 0xd2, 0x02, 0x5e, 0xe7, 0x1c, 0x69, 0xb7, 0xac, 0x0f, 0xa6, 0x61, 0x15, 0x57, 0xc4, 0x27, + 0xc0, 0x69, 0xdf, 0x2e, 0x1b, 0xf6, 0x29, 0xd9, 0xa0, 0xcb, 0x5c, 0x67, 0xc7, 0xea, 0x4f, 0xa6, + 0x58, 0xc7, 0x8d, 0x00, 0x42, 0xb0, 0x59, 0xe6, 0xb6, 0x58, 0xff, 0xce, 0x60, 0x16, 0x69, 0x67, + 0xdb, 0x94, 0xf7, 0x16, 0xeb, 0x4d, 0x04, 0xb3, 0xd2, 0x45, 0x0f, 0x40, 0x03, 0x1f, 0x10, 0xac, + 0xdd, 0x07, 0x77, 0x7f, 0xbe, 0x9f, 0xbb, 0xb7, 0x7f, 0xcb, 0x7c, 0x1f, 0xa9, 0xfc, 0x1e, 0xaf, + 0x0c, 0x5f, 0x86, 0xd7, 0x96, 0x2d, 0xae, 0xd0, 0x47, 0x4b, 0xa0, 0xfe, 0x68, 0xd9, 0xb2, 0x32, + 0x77, 0xa9, 0xca, 0x7f, 0xc6, 0x76, 0xc6, 0x61, 0x6b, 0x8e, 0x43, 0x9a, 0x1d, 0x4b, 0xff, 0x72, + 0x43, 0x78, 0x19, 0xb5, 0x51, 0x87, 0x56, 0xa7, 0x87, 0x3e, 0xf5, 0x84, 0x01, 0x26, 0x46, 0xc3, + 0x65, 0x9a, 0x6b, 0xa8, 0x6e, 0x62, 0x27, 0x26, 0x14, 0xd8, 0x5e, 0xec, 0xd5, 0x35, 0x0e, 0x3c, + 0xd0, 0xa1, 0x25, 0xae, 0x9c, 0x17, 0xcc, 0xe2, 0x52, 0x39, 0xe1, 0xee, 0x9c, 0xdb, 0x39, 0xca, + 0x7b, 0x18, 0xcf, 0x2c, 0x88, 0xcf, 0x14, 0x68, 0x26, 0xb6, 0xcc, 0x1e, 0x6a, 0xa8, 0xe1, 0x69, + 0x2c, 0x91, 0x5f, 0x3b, 0xf1, 0xc1, 0xdb, 0x34, 0xc6, 0xf3, 0x78, 0x83, 0xcb, 0x4e, 0xdc, 0xe0, + 0xf7, 0xc9, 0x95, 0xb6, 0x9e, 0x3a, 0xce, 0x30, 0xdc, 0x16, 0x6f, 0x78, 0x4c, 0x93, 0xd6, 0xcb, + 0xbc, 0xac, 0x3c, 0x79, 0xbc, 0x31, 0x93, 0x10, 0xce, 0x6e, 0x66, 0x57, 0x00, 0xf1, 0x7f, 0x96, + 0x2f, 0x18, 0xb2, 0x40, 0x73, 0x9d, 0x15, 0x69, 0x0b, 0x1b, 0x6c, 0x85, 0xd1, 0xaa, 0xa3, 0x2d, + 0x4a, 0x79, 0x74, 0x4a, 0xe5, 0x0c, 0xf9, 0xa9, 0x0a, 0x09, 0x54, 0xb4, 0xa4, 0xd9, 0x4c, 0x49, + 0x9b, 0x41, 0x23, 0xef, 0xc0, 0x20, 0x44, 0x31, 0xf7, 0x22, 0x85, 0xb5, 0xda, 0x9e, 0x19, 0x22, + 0x23, 0x0a, 0x30, 0x4d, 0x3a, 0x1b, 0xd8, 0x52, 0x08, 0x72, 0x61, 0xb7, 0xcf, 0x0d, 0x8b, 0x90, + 0xd1, 0x46, 0x23, 0xeb, 0xcd, 0xc6, 0x38, 0x7b, 0xc6, 0xaf, 0x65, 0xbe, 0x5f, 0x01, 0x1b, 0x6b, + 0xc1, 0x23, 0xc1, 0x30, 0x6a, 0x1e, 0x8f, 0xbf, 0x2d, 0xf0, 0xb6, 0xf8, 0x9b, 0x0a, 0xe0, 0x5d, + 0xe0, 0xe4, 0xb7, 0xf5, 0x0a, 0xda, 0x46, 0xe5, 0x3a, 0x9b, 0x6b, 0xca, 0xda, 0x06, 0x43, 0xbe, + 0x6b, 0xfd, 0xc2, 0xb0, 0x6a, 0x6c, 0x75, 0x88, 0x3c, 0x2d, 0xc6, 0x13, 0xac, 0x72, 0x16, 0x31, + 0x7a, 0x40, 0xc4, 0xa2, 0xc0, 0x86, 0x69, 0x83, 0xd3, 0x2c, 0x9c, 0xe0, 0xa6, 0xcc, 0xed, 0xf4, + 0x03, 0x62, 0x6b, 0xb2, 0x3b, 0x5b, 0x9d, 0xa5, 0x86, 0x77, 0x7c, 0x73, 0x5e, 0x19, 0x11, 0xd7, + 0x7b, 0x11, 0x96, 0xc8, 0xfa, 0x47, 0x21, 0xd6, 0xb0, 0xfe, 0x0b, 0x08, 0x11, 0xfc, 0x00, 0xb9, + 0xa1, 0x24, 0x2c, 0xbd, 0x4a, 0x92, 0x43, 0x10, 0x08, 0xbe, 0xe9, 0xe1, 0x5d, 0x19, 0x82, 0xde, + 0x34, 0xae, 0xdc, 0xa6, 0x85, 0x8f, 0x19, 0x30, 0x20, 0xb6, 0x44, 0x7f, 0x6b, 0xa6, 0x63, 0x70, + 0x59, 0xda, 0x8d, 0xe0, 0xf8, 0x46, 0x86, 0x57, 0xb8, 0x1c, 0x57, 0x13, 0x78, 0x41, 0x8c, 0xf5, + 0x7d, 0x77, 0xae, 0x75, 0x6c, 0x59, 0x93, 0x2e, 0x05, 0x25, 0x03, 0xd1, 0xea, 0xfb, 0x2d, 0x60, + 0xd2, 0x61, 0x23, 0xea, 0x0e, 0xff, 0x55, 0xe3, 0x24, 0x49, 0x00, 0x19, 0xbd, 0x1e, 0x56, 0x24, + 0x87, 0x2f, 0x7b, 0x98, 0x07, 0x36, 0xd2, 0x7c, 0xc5, 0x9b, 0xe0, 0x4e, 0x29, 0xab, 0xa1, 0xb8, + 0x35, 0x15, 0x31, 0xce, 0x65, 0x14, 0x24, 0xf8, 0x10, 0xb5, 0xab, 0x3e, 0xd5, 0x58, 0xca, 0xe5, + 0x73, 0x2d, 0x7c, 0x8b, 0xb4, 0x62, 0x75, 0x03, 0x30, 0x89, 0xfe, 0x32, 0xf8, 0x65, 0x99, 0xd0, + 0x88, 0xd5, 0x72, 0x88, 0x03, 0xc9, 0x51, 0x03, 0xba, 0x2f, 0xfb, 0x7c, 0x39, 0x02, 0x05, 0xc4, + 0xce, 0xd8, 0xb3, 0xc2, 0x7b, 0x29, 0x8e, 0xa7, 0x9d, 0x35, 0x97, 0xb7, 0x17, 0xde, 0x28, 0x0b, + 0x32, 0xe5, 0x41, 0xda, 0x1d, 0x98, 0xbd, 0x27, 0xef, 0xf7, 0xb4, 0x43, 0x09, 0x13, 0x39, 0xc7, + 0x40, 0x16, 0x11, 0x20, 0x71, 0xcb, 0xb6, 0xc9, 0xb0, 0x8f, 0x20, 0xc1, 0xf0, 0x40, 0xfb, 0x6e, + 0x73, 0x04, 0x8f, 0x73, 0xca, 0x45, 0xdb, 0xe0, 0xf9, 0x25, 0x8d, 0x32, 0xf2, 0x3e, 0x36, 0xbe, + 0xf7, 0x88, 0xf8, 0x13, 0x4d, 0x9b, 0x10, 0xc2, 0x58, 0x0b, 0x20, 0xf8, 0x78, 0xb6, 0x4c, 0x7d, + 0x2a, 0xa6, 0x81, 0x40, 0xd1, 0x30, 0x50, 0x38, 0x2a, 0x5f, 0xbc, 0x81, 0x8e, 0x0f, 0xd4, 0xd0, + 0x87, 0x99, 0x78, 0x3d, 0xbe, 0x25, 0x15, 0xf4, 0x45, 0x61, 0xa3, 0x1a, 0x7d, 0x05, 0x3f, 0xb5, + 0xa6, 0x1c, 0x41, 0xc6, 0x0e, 0xbe, 0x57, 0x6f, 0xc5, 0xb6, 0x38, 0x63, 0x90, 0x55, 0x23, 0xfc, + 0x26, 0x9e, 0xfd, 0xb8, 0x6c, 0xf2, 0x99, 0x6b, 0x6d, 0x90, 0xfe, 0x28, 0xa0, 0x16, 0xee, 0x63, + 0xc2, 0x4c, 0xd6, 0xb2, 0x0c, 0xfa, 0x6e, 0x85, 0x51, 0xe4, 0x2f, 0x57, 0x91, 0x82, 0x84, 0x43, + 0x8a, 0x44, 0x31, 0x6c, 0x68, 0x02, 0x01, 0x7c, 0xce, 0x4d, 0xc0, 0x7c, 0x43, 0xa9, 0x54, 0xf5, + 0x0e, 0xca, 0xe6, 0x15, 0x98, 0xae, 0x41, 0x57, 0x0a, 0x66, 0xba, 0x6d, 0x6e, 0x68, 0xb9, 0x2e, + 0x0d, 0x42, 0xd2, 0xf5, 0x0b, 0xfc, 0x2d, 0xa8, 0x61, 0x6e, 0x60, 0x4e, 0x51, 0x78, 0xeb, 0x0c, + 0x52, 0x9e, 0xc0, 0x4a, 0xb0, 0x92, 0x85, 0x5c, 0x3a, 0x3d, 0x69, 0x95, 0xab, 0x62, 0xeb, 0x2f, + 0x9b, 0x12, 0xf5, 0x2e, 0xb5, 0xa6, 0x93, 0xce, 0x14, 0x97, 0xa7, 0x1e, 0x0a, 0x7b, 0x94, 0x74, + 0xfb, 0x65, 0xd0, 0x5a, 0x97, 0x55, 0x40, 0x02, 0x71, 0x87, 0x9c, 0x9f, 0xcb, 0x41, 0x3f, 0x08, + 0x8d, 0x6a, 0xca, 0xe6, 0xec, 0xe6, 0x71, 0x22, 0xf8, 0x58, 0x9f, 0xf1, 0x94, 0xf6, 0xe4, 0xd6, + 0xdc, 0x35, 0xd7, 0xeb, 0x6b, 0x78, 0x99, 0x66, 0xf9, 0xe2, 0x15, 0x27, 0xc9, 0x8c, 0x27, 0xb4, + 0x89, 0x3c, 0x15, 0xee, 0x52, 0x71, 0xa9, 0xd2, 0x50, 0x3c, 0xd2, 0x31, 0xbb, 0x3a, 0xe5, 0x87, + 0xaf, 0x65, 0x2b, 0xf2, 0xf5, 0xc9, 0x44, 0xa2, 0x59, 0x1c, 0x57, 0x96, 0xb9, 0xc2, 0x5e, 0xcb, + 0x8a, 0x5b, 0x2b, 0x7a, 0x7e, 0x93, 0x3c, 0x08, 0x27, 0xcd, 0xb4, 0xb0, 0x1b, 0xf3, 0x82, 0x50, + 0x78, 0xcf, 0xea, 0x28, 0x57, 0xb1, 0x0f, 0xb4, 0xb6, 0x93, 0x82, 0x8e, 0x7a, 0xd1, 0x9f, 0x04, + 0xec, 0xee, 0x24, 0x3d, 0x8a, 0x5e, 0x56, 0x99, 0x8d, 0x83, 0xa4, 0x05, 0x7d, 0xfb, 0x36, 0xdb, + 0xab, 0xd1, 0x67, 0x59, 0xc7, 0x4a, 0xb9, 0xaf, 0x99, 0xb6, 0xd8, 0xd4, 0x2c, 0xca, 0x8c, 0xcc, + 0xd2, 0x32, 0xab, 0x51, 0xce, 0x2d, 0x22, 0xe0, 0x29, 0xb1, 0x73, 0x10, 0x60, 0xa8, 0x6b, 0x8f, + 0x68, 0xaf, 0x58, 0x06, 0x9d, 0x72, 0x36, 0x98, 0x3f, 0xf3, 0x6b, 0xad, 0x3e, 0x7f, 0x4a, 0x00, + 0x94, 0x04, 0xae, 0xe9, 0x8a, 0x9e, 0x8a, 0x03, 0xd8, 0x04, 0xcc, 0xfe, 0xe3, 0xf8, 0xa2, 0x04, + 0x64, 0x17, 0x54, 0x77, 0xca, 0x20, 0xd0, 0x80, 0x1b, 0x36, 0xef, 0x59, 0x31, 0xfa, 0xe4, 0xf5, + 0xaf, 0x56, 0x09, 0x02, 0xad, 0xcf, 0xa6, 0xbc, 0x26, 0x23, 0x27, 0x6d, 0xf3, 0x52, 0xce, 0x2f, + 0x4c, 0x9c, 0xa8, 0x23, 0x75, 0xfa, 0x56, 0x9e, 0x07, 0x5b, 0xb9, 0x30, 0x5a, 0xb1, 0x27, 0xff, + 0x72, 0xbf, 0x50, 0xb1, 0x27, 0xef, 0xa1, 0x0c, 0x3a, 0xc9, 0x72, 0x21, 0xbe, 0xd8, 0xdc, 0xd5, + 0x66, 0x4a, 0x0a, 0x58, 0xfa, 0x57, 0xb4, 0x00, 0x07, 0x31, 0xf2, 0x4e, 0xdc, 0xe0, 0x86, 0x99, + 0x45, 0xe5, 0x45, 0xcf, 0x27, 0x35, 0x79, 0x57, 0xf5, 0xa2, 0x7a, 0x29, 0xfa, 0x5e, 0xcf, 0xf9, + 0xa9, 0x96, 0x11, 0xe1, 0x4a, 0x6c, 0xe5, 0xb8, 0x8e, 0x78, 0xe6, 0xa1, 0x46, 0x97, 0xae, 0xb4, + 0xf3, 0x6d, 0x7f, 0x8e, 0xd1, 0x86, 0x6b, 0x78, 0x2b, 0x55, 0xc5, 0xdf, 0x0f, 0x43, 0x78, 0xed, + 0xd2, 0x38, 0xe5, 0x8b, 0x94, 0x7a, 0x06, 0xc5, 0x73, 0x17, 0x55, 0x93, 0xad, 0xa5, 0xac, 0xba, + 0x81, 0x8a, 0x6d, 0x73, 0x4b, 0xa1, 0x32, 0x8f, 0x21, 0xa6, 0x5b, 0x51, 0x31, 0x58, 0xd0, 0xe4, + 0x0b, 0x93, 0x46, 0xf2, 0x51, 0x30, 0x3e, 0x60, 0xe1, 0xcb, 0x30, 0x04, 0x15, 0x8d, 0x1e, 0x87, + 0xa6, 0xf6, 0x38, 0xe0, 0x27, 0x84, 0x81, 0x18, 0x2b, 0x37, 0xbb, 0xd3, 0xdb, 0xe7, 0x91, 0xa3, + 0x1b, 0x6b, 0x20, 0xcb, 0x2c, 0x52, 0xb1, 0xb9, 0x6a, 0x94, 0xf8, 0xcd, 0xba, 0x5d, 0xc7, 0xdd, + 0x79, 0x36, 0x38, 0xc2, 0xfc, 0xec, 0x4f, 0x2b, 0x5f, 0x73, 0x44, 0x03, 0xe9, 0xa9, 0xf5, 0xd9, + 0x99, 0xea, 0x61, 0xdc, 0x6a, 0x98, 0xbe, 0xde, 0xb9, 0x34, 0xcc, 0x76, 0xb0, 0xe1, 0x8c, 0x70, + 0x3a, 0xa5, 0x7c, 0xd1, 0xc0, 0x2a, 0x8e, 0x7d, 0x47, 0x8a, 0x63, 0xea, 0x30, 0x6b, 0xee, 0x36, + 0x0b, 0xa8, 0xae, 0x46, 0xcd, 0x01, 0x83, 0xf6, 0x07, 0xf9, 0xed, 0x8b, 0x69, 0x97, 0xb6, 0xc3, + 0x5d, 0x75, 0x6e, 0xd8, 0xdf, 0x01, 0x82, 0x48, 0x31, 0x2f, 0xde, 0xed, 0x8e, 0xc5, 0xd8, 0xa6, + 0xc0, 0x36, 0x0e, 0x66, 0xa4, 0xe9, 0xe5, 0xa9, 0x7d, 0x5c, 0xd2, 0x43, 0x72, 0xc0, 0xad, 0x26, + 0x78, 0xf2, 0xb0, 0x08, 0x12, 0xae, 0x6c, 0x1a, 0x0f, 0x53, 0x30, 0xb3, 0xab, 0x01, 0x53, 0xda, + 0x3c, 0x5f, 0x4c, 0x17, 0xbd, 0x2f, 0xb6, 0x0e, 0x7e, 0x80, 0x87, 0x4c, 0x1b, 0x92, 0x9b, 0x62, + 0xe3, 0x89, 0xee, 0xe2, 0xa0, 0x14, 0x06, 0x0d, 0x4d, 0xcc, 0x96, 0x5a, 0xf8, 0x64, 0x2a, 0x05, + 0xa9, 0xee, 0xd5, 0x0d, 0x23, 0x90, 0xb0, 0x67, 0xd5, 0x51, 0x1d, 0x18, 0xbc, 0xba, 0xe6, 0xa5, + 0xad, 0x29, 0x18, 0xd5, 0x06, 0xfc, 0xc9, 0x12, 0x6d, 0x70, 0xa8, 0x6e, 0x96, 0x8b, 0x5f, 0x9c, + 0x99, 0x43, 0x07, 0x02, 0x37, 0x48, 0x8c, 0xfb, 0x5f, 0xf5, 0xde, 0x69, 0x26, 0x73, 0x7d, 0xf6, + 0x3a, 0x2c, 0xe5, 0x58, 0x01, 0xc3, 0x48, 0xb0, 0xf0, 0x0d, 0x56, 0xaf, 0x8c, 0x0f, 0x5c, 0xb3, + 0xba, 0x44, 0x8c, 0x39, 0xb0, 0x20, 0xd2, 0x93, 0x81, 0x19, 0x99, 0x4e, 0xac, 0xb9, 0x1f, 0xc3, + 0x1f, 0x34, 0x7d, 0xf3, 0x3e, 0x1a, 0xe1, 0x26, 0x7c, 0xb7, 0x22, 0x0a, 0xdc, 0x0d, 0x14, 0xf8, + 0x43, 0x8a, 0x23, 0x46, 0x37, 0x9c, 0x2a, 0xb8, 0x1f, 0x24, 0x72, 0xe2, 0xea, 0xc4, 0x67, 0x13, + 0x17, 0x33, 0xbd, 0xa0, 0x07, 0xa0, 0x3e, 0xde, 0x8b, 0xc4, 0xd6, 0xdb, 0xd9, 0xf1, 0xb8, 0xf4, + 0xfb, 0x83, 0x13, 0x14, 0xcd, 0x36, 0xf6, 0xdc, 0xd5, 0x85, 0x93, 0x7c, 0xf9, 0x6c, 0xea, 0x52, + 0x92, 0xfb, 0xfc, 0x95, 0x02, 0x10, 0x7b, 0x57, 0x9f, 0xf0, 0x7c, 0x2e, 0x79, 0x00, 0x3d, 0xb2, + 0xa1, 0x6c, 0x4e, 0xd4, 0x17, 0xfa, 0x0f, 0x13, 0xc8, 0xbf, 0xb1, 0x82, 0xf7, 0xdd, 0xcf, 0x08, + 0xf2, 0x50, 0xdb, 0x16, 0xa4, 0x5a, 0x60, 0x4a, 0x57, 0x2b, 0x0e, 0xdc, 0x4a, 0xbf, 0x9c, 0x86, + 0x08, 0x8a, 0x5a, 0xc8, 0x74, 0xdd, 0xa2, 0x6e, 0x12, 0xa0, 0xef, 0x63, 0x5a, 0xd2, 0x82, 0xad, + 0xcd, 0xc7, 0xed, 0x16, 0x86, 0x45, 0x3d, 0xfb, 0x35, 0xc3, 0xb1, 0xba, 0x68, 0x21, 0xb4, 0xb7, + 0x22, 0x0b, 0x55, 0x79, 0x8b, 0x9c, 0xcf, 0xe0, 0x66, 0x61, 0x5c, 0xe2, 0x55, 0x96, 0x0d, 0x09, + 0xe6, 0x77, 0xfe, 0xfe, 0x76, 0xbe, 0x91, 0x5e, 0x04, 0xe5, 0x65, 0x44, 0xbd, 0x09, 0xd0, 0x6f, + 0x83, 0x44, 0xf9, 0x68, 0xdc, 0x68, 0x25, 0xcb, 0xc6, 0x64, 0xd5, 0x18, 0xa4, 0x41, 0xe1, 0x9b, + 0x07, 0x6f, 0xc3, 0x38, 0x91, 0x37, 0xfc, 0x1b, 0x73, 0x32, 0xe2, 0xb0, 0x68, 0x95, 0x44, 0x3b, + 0x7a, 0x00, 0x23, 0x36, 0x31, 0x15, 0x79, 0xa9, 0xb0, 0x8f, 0x36, 0x73, 0xda, 0x05, 0x90, 0xe6, + 0x96, 0xce, 0xd9, 0x01, 0x44, 0x4a, 0x70, 0xa6, 0x7b, 0x2a, 0x7d, 0x55, 0x12, 0xd6, 0x5b, 0xfc, + 0xd7, 0xaf, 0x1e, 0x34, 0x27, 0x77, 0x69, 0xe1, 0x71, 0x08, 0x83, 0x01, 0xde, 0x78, 0x46, 0xf0, + 0x88, 0xf4, 0x87, 0xc4, 0x92, 0x1b, 0xeb, 0x98, 0x35, 0x4b, 0xae, 0x9a, 0xf6, 0xea, 0xb2, 0x34, + 0x91, 0x14, 0xeb, 0x21, 0xf6, 0x18, 0xdb, 0x1d, 0x92, 0x6c, 0x1d, 0x2f, 0xe3, 0xa5, 0xf2, 0x29, + 0xc5, 0x73, 0x40, 0xc4, 0x0a, 0xec, 0x11, 0xc2, 0xd0, 0x14, 0x4d, 0x03, 0x94, 0xfc, 0x4d, 0x8e, + 0x38, 0x66, 0xa7, 0xd0, 0xa1, 0x0b, 0x64, 0xc8, 0xb9, 0x92, 0xb0, 0xa4, 0xdd, 0xbc, 0xad, 0x82, + 0x4e, 0x43, 0x97, 0x43, 0x78, 0xea, 0x9a, 0x38, 0xe5, 0x8c, 0x2c, 0x5a, 0xe1, 0x94, 0xaf, 0x43, + 0x10, 0xfb, 0xec, 0x90, 0x28, 0x41, 0x6c, 0x5c, 0xb7, 0xb8, 0xaf, 0xa5, 0x24, 0xf7, 0x4f, 0xfd, + 0x6f, 0x2e, 0x98, 0x44, 0x3f, 0x5e, 0x89, 0x24, 0xf6, 0xcf, 0x11, 0x0e, 0x67, 0x1b, 0x81, 0x68, + 0x37, 0xd5, 0x9b, 0x2d, 0xb9, 0x1c, 0xb1, 0xe6, 0x87, 0xd6, 0xa2, 0x02, 0x0f, 0x91, 0x08, 0xf6, + 0x9b, 0x94, 0x76, 0x62, 0xfd, 0xe7, 0x18, 0xac, 0x28, 0xa6, 0xac, 0xda, 0x27, 0xf4, 0x33, 0x59, + 0xbb, 0xbe, 0x36, 0x2c, 0xee, 0xea, 0x91, 0xe6, 0x91, 0x95, 0x2c, 0x58, 0x0a, 0xb2, 0xca, 0xa3, + 0xaa, 0x39, 0x03, 0x9a, 0x75, 0x3c, 0x27, 0x6e, 0x02, 0x89, 0x17, 0x4b, 0x02, 0x42, 0x7c, 0xb4, + 0x2e, 0xad, 0xb4, 0xd9, 0x35, 0xb2, 0x30, 0x9e, 0x2f, 0xec, 0x9f, 0x25, 0x56, 0x1a, 0x35, 0x40, + 0xf1, 0xaf, 0x1d, 0xa4, 0xa8, 0x62, 0x07, 0x70, 0x98, 0x6c, 0xde, 0x1e, 0x89, 0xc1, 0xd3, 0x30, + 0xbb, 0x82, 0x72, 0x40, 0xf2, 0xbc, 0x53, 0xc7, 0xde, 0xab, 0xfc, 0x7d, 0xad, 0xbf, 0xda, 0xe0, + 0xa7, 0xa1, 0x0c, 0xd6, 0x73, 0x37, 0x36, 0xa1, 0xee, 0xa6, 0x96, 0x88, 0x79, 0x0e, 0x4a, 0x2c, + 0x69, 0x4c, 0xe5, 0x30, 0xfb, 0xdd, 0xe1, 0xfe, 0x86, 0x90, 0xdc, 0xdf, 0x03, 0xf5, 0x17, 0x2f, + 0xf4, 0x58, 0x2d, 0xd3, 0xed, 0x3d, 0x7d, 0xa0, 0xb3, 0x6e, 0x1e, 0xd3, 0xbb, 0xd9, 0x57, 0xba, + 0x8b, 0x00, 0x72, 0xc4, 0xee, 0xcf, 0x39, 0xd5, 0x74, 0xfa, 0x13, 0xf0, 0xd7, 0xe9, 0x10, 0x0c, + 0x7a, 0x52, 0x62, 0xd0, 0xc9, 0xd5, 0x2d, 0xdc, 0x11, 0xd4, 0xff, 0x34, 0xb2, 0x55, 0xf9, 0x99, + 0x81, 0xb4, 0xc9, 0x14, 0x02, 0x91, 0x81, 0x56, 0x29, 0xf6, 0xa9, 0x1a, 0x19, 0x8e, 0x74, 0xb3, + 0xa3, 0xd1, 0x28, 0xb5, 0x72, 0xd8, 0x6f, 0x54, 0x15, 0x74, 0x55, 0x70, 0x26, 0x62, 0xcb, 0x1d, + 0x15, 0x2c, 0x7f, 0x4c, 0x9c, 0xb4, 0xde, 0xa2, 0x07, 0xd5, 0xa9, 0x38, 0x29, 0x42, 0x51, 0x67, + 0x44, 0x26, 0x97, 0x7e, 0x73, 0x0e, 0xc6, 0x01, 0x00, 0x65, 0xc8, 0xe0, 0x34, 0x88, 0x2b, 0xd3, + 0x2f, 0xd3, 0x5c, 0x6a, 0xf6, 0xb8, 0xd9, 0x3a, 0x50, 0x9c, 0xc3, 0x39, 0xd9, 0x6f, 0xb9, 0xdd, + 0x55, 0x8a, 0xf9, 0x52, 0x35, 0xfb, 0xf1, 0x71, 0x97, 0x76, 0x04, 0x75, 0xee, 0x2e, 0x3f, 0xca, + 0x0e, 0x83, 0xa8, 0xe3, 0x1f, 0xa7, 0xf1, 0x3d, 0x78, 0xcc, 0x79, 0x64, 0x80, 0x5e, 0x77, 0x05, + 0xdb, 0xb7, 0x0f, 0x73, 0x53, 0x3a, 0x56, 0xd8, 0xb7, 0x7c, 0x12, 0xe8, 0xf6, 0x51, 0x07, 0xc9, + 0x01, 0x43, 0x97, 0x51, 0x75, 0x95, 0x94, 0x65, 0xfd, 0x4d, 0x8c, 0x8c, 0xd3, 0xa8, 0xee, 0xa9, + 0x5e, 0xfb, 0xc7, 0xf6, 0xf8, 0x40, 0x0e, 0xa5, 0xd5, 0x1e, 0x79, 0xb4, 0x0c, 0xef, 0x8b, 0x04, + 0x59, 0x4d, 0x0c, 0x6f, 0x08, 0xd5, 0x00, 0xa2, 0xad, 0x08, 0xb4, 0x62, 0xe0, 0x2c, 0xf6, 0x30, + 0x31, 0x1e, 0xd7, 0x81, 0x56, 0x61, 0x17, 0x0d, 0xb3, 0x9f, 0x27, 0x75, 0x38, 0x42, 0x6e, 0xb2, + 0xb0, 0x6c, 0xb8, 0xc9, 0xd8, 0x20, 0xc8, 0x36, 0x7d, 0x1d, 0x57, 0x10, 0x4e, 0xc1, 0x45, 0xfc, + 0x93, 0xb1, 0xf7, 0x7b, 0xa1, 0x3b, 0x71, 0x12, 0x16, 0xe5, 0x8f, 0xd0, 0x0c, 0x7d, 0xc0, 0x05, + 0x18, 0x02, 0x24, 0x25, 0x28, 0x8a, 0xe1, 0x29, 0x9a, 0x79, 0xbd, 0xc7, 0x73, 0x2d, 0xf3, 0x42, + 0x70, 0x33, 0xf3, 0xf8, 0x48, 0x87, 0xb4, 0xd4, 0x91, 0xe1, 0x53, 0xba, 0x4a, 0x63, 0xaf, 0x3a, + 0xe5, 0xcb, 0x3d, 0x41, 0x04, 0xb5, 0x30, 0x87, 0xaa, 0x40, 0x03, 0x56, 0x10, 0x02, 0xf3, 0x6a, + 0x9f, 0xda, 0x33, 0xbc, 0xb8, 0xa5, 0xd0, 0x56, 0x43, 0x29, 0xda, 0x58, 0x12, 0x8b, 0x6a, 0x9d, + 0xcf, 0xcd, 0xca, 0x66, 0x98, 0x92, 0x1d, 0xa4, 0xef, 0xac, 0x9e, 0x19, 0xde, 0xf7, 0xfe, 0x6c, + 0x3a, 0x66, 0x46, 0xb4, 0x00, 0x7f, 0x08, 0xaf, 0x31, 0xd6, 0xd3, 0x22, 0x59, 0x1f, 0x34, 0x48, + 0x5a, 0xe1, 0x4e, 0x0f, 0x6f, 0x2d, 0xd0, 0xe5, 0x8e, 0x34, 0x3b, 0xc0, 0x55, 0x02, 0x2d, 0x17, + 0x4b, 0x34, 0x78, 0x46, 0xd4, 0xc4, 0x7f, 0x1d, 0xdc, 0x39, 0x94, 0x69, 0x78, 0xab, 0xd8, 0x2b, + 0x6d, 0xf3, 0x1c, 0x0b, 0x0f, 0x4a, 0xa0, 0xb2, 0xac, 0x1a, 0x79, 0x7f, 0x9d, 0xe5, 0xe8, 0xc6, + 0x40, 0x4b, 0xce, 0x32, 0x4b, 0xa1, 0x3c, 0x77, 0xed, 0x5d, 0x59, 0x0f, 0xe0, 0x7d, 0x00, 0x07, + 0xb4, 0xd8, 0xa6, 0x3e, 0xc9, 0x6d, 0x62, 0x19, 0x66, 0xc3, 0xe7, 0x10, 0x3b, 0x6c, 0x7a, 0x36, + 0x49, 0x75, 0xe6, 0x78, 0xb3, 0x8d, 0x04, 0x13, 0x31, 0xe6, 0x79, 0x72, 0x64, 0x07, 0x76, 0x94, + 0x2b, 0xb4, 0xec, 0x18, 0x1c, 0x32, 0x3c, 0x26, 0xc4, 0x81, 0xbf, 0x4f, 0xb5, 0x6e, 0x5d, 0x67, + 0xcf, 0xbe, 0x17, 0x57, 0x11, 0x2b, 0xbc, 0xa0, 0xf0, 0xc2, 0x70, 0x06, 0x94, 0x26, 0x9b, 0x26, + 0x12, 0x9c, 0x7f, 0x99, 0xd4, 0x4a, 0xf5, 0x60, 0xcd, 0xf7, 0xa4, 0x70, 0x2e, 0xf5, 0xd6, 0xa2, + 0xec, 0x0e, 0x99, 0x00, 0x2e, 0x89, 0x30, 0xaa, 0x4e, 0xc0, 0x62, 0x11, 0x93, 0x0a, 0x1e, 0x68, + 0xf2, 0xed, 0x44, 0x8b, 0x10, 0x4a, 0x75, 0x68, 0xbf, 0x46, 0xe1, 0x41, 0xd6, 0x0b, 0x61, 0x53, + 0xd4, 0x03, 0x10, 0xb3, 0x8f, 0x8e, 0x14, 0x57, 0x27, 0x8f, 0xe3, 0x49, 0xb2, 0xb4, 0xa7, 0xae, + 0x39, 0x7a, 0x7b, 0x8f, 0x48, 0xaa, 0xa5, 0xfd, 0xc1, 0x28, 0x8e, 0x43, 0xe0, 0x58, 0x39, 0x32, + 0x0a, 0x14, 0xc6, 0x3a, 0xb8, 0x58, 0xe2, 0x6e, 0x7d, 0x8c, 0x35, 0xb6, 0x47, 0x37, 0x90, 0x4d, + 0x89, 0xc1, 0x9a, 0x10, 0x3d, 0x6b, 0x68, 0x9a, 0x3d, 0xc9, 0x0c, 0x72, 0xfc, 0x92, 0xe3, 0x5d, + 0x45, 0x2b, 0x81, 0x43, 0x02, 0x30, 0x70, 0xd4, 0x8b, 0xb9, 0xfb, 0xb0, 0x45, 0xe3, 0xc6, 0xce, + 0x9a, 0x8b, 0xd5, 0xc4, 0xb6, 0x7f, 0x5d, 0x8b, 0x58, 0xc9, 0x6a, 0x28, 0x2d, 0x6e, 0x27, 0x78, + 0x3d, 0x7b, 0x99, 0x0e, 0x05, 0x2b, 0xd9, 0x5e, 0x86, 0x50, 0x8f, 0x9b, 0xf7, 0xc0, 0x64, 0xa8, + 0xf2, 0x39, 0xe0, 0x24, 0x0a, 0x20, 0xd8, 0xdf, 0x3a, 0x87, 0x6e, 0xdc, 0x8f, 0xf6, 0x24, 0x1b, + 0x54, 0xf2, 0x70, 0xa9, 0x8c, 0xb8, 0x07, 0x7a, 0xaf, 0xe0, 0xe5, 0x8e, 0x5e, 0x98, 0x13, 0xc6, + 0xa5, 0xf9, 0x1f, 0x52, 0x89, 0x7b, 0x6a, 0xad, 0x24, 0x26, 0xc6, 0x0d, 0xa5, 0x88, 0x3e, 0x6b, + 0xdf, 0xee, 0x33, 0x0a, 0x86, 0x09, 0xa2, 0x11, 0x8b, 0x69, 0x9f, 0x75, 0xce, 0xfd, 0x05, 0x01, + 0x95, 0x14, 0x64, 0xcd, 0x62, 0x04, 0x09, 0x87, 0xfc, 0xf6, 0xb2, 0x2e, 0xca, 0x92, 0xe4, 0x4f, + 0x55, 0xb3, 0x8c, 0x64, 0x99, 0xa8, 0xda, 0x0a, 0xc7, 0x82, 0x56, 0x93, 0x03, 0x67, 0xa4, 0xd7, + 0x54, 0x91, 0xa0, 0x89, 0xd8, 0x94, 0x1f, 0x6c, 0x53, 0xcc, 0xb2, 0x60, 0x13, 0x6a, 0x93, 0xe1, + 0xfc, 0xa3, 0xdd, 0x72, 0xd5, 0x5a, 0x92, 0x35, 0x9e, 0x3d, 0x62, 0x82, 0x70, 0x5d, 0x54, 0xaf, + 0x57, 0xc6, 0x98, 0x5e, 0x74, 0xe0, 0xf2, 0x33, 0x26, 0x61, 0xbf, 0x2b, 0xdd, 0x78, 0x47, 0x29, + 0x04, 0xc7, 0xf0, 0x58, 0x17, 0xfc, 0x9d, 0xed, 0xef, 0x15, 0x6a, 0xca, 0xc7, 0x46, 0xce, 0x12, + 0xf8, 0x90, 0xd8, 0x5a, 0x93, 0x98, 0xa9, 0xed, 0xfb, 0xf4, 0x6e, 0x73, 0x48, 0x81, 0x4a, 0x08, + 0x07, 0x29, 0xc8, 0x3e, 0x70, 0x4c, 0x40, 0x30, 0x20, 0x2c, 0xf6, 0x1e, 0xcd, 0xee, 0x27, 0x95, + 0xd5, 0x07, 0xac, 0x28, 0x81, 0x4f, 0x53, 0xcd, 0x06, 0x60, 0xa5, 0x57, 0x2c, 0xbe, 0x1a, 0xe5, + 0x33, 0x38, 0xb8, 0xef, 0xdc, 0xa3, 0x1a, 0xa5, 0xb9, 0x5a, 0xa9, 0xe7, 0x65, 0xaf, 0x4d, 0xa0, + 0x4c, 0x9b, 0x31, 0x62, 0x67, 0x7e, 0x41, 0xc0, 0x18, 0xa5, 0xe1, 0x8a, 0xf2, 0xf9, 0x8a, 0xca, + 0x14, 0x5c, 0xcd, 0x1b, 0x8f, 0x74, 0x31, 0x07, 0x6a, 0x14, 0xa7, 0xc2, 0x0f, 0x6c, 0x72, 0xe8, + 0xeb, 0x97, 0x51, 0xb7, 0x89, 0x2e, 0x41, 0x01, 0x54, 0x47, 0x63, 0x0e, 0xaa, 0x84, 0xb9, 0x60, + 0x1c, 0xb9, 0x54, 0xd8, 0x97, 0x39, 0x38, 0x9d, 0x52, 0xbb, 0x91, 0xa9, 0x7f, 0x96, 0x08, 0x7c, + 0xb3, 0x8b, 0x0e, 0xab, 0x59, 0xa7, 0x84, 0x68, 0x34, 0x65, 0x55, 0xc7, 0x12, 0x84, 0xc2, 0xfb, + 0xbd, 0x27, 0x58, 0x18, 0xe9, 0x26, 0x73, 0xfa, 0x42, 0xab, 0x5e, 0x0d, 0x97, 0x76, 0x67, 0xa9, + 0x0f, 0x75, 0x92, 0x6c, 0x80, 0x76, 0x87, 0x75, 0xd2, 0x3d, 0xfe, 0x0b, 0x33, 0x7b, 0x48, 0xb0, + 0xc8, 0x28, 0x1f, 0xe6, 0x3f, 0x18, 0xf2, 0x45, 0xf8, 0x8f, 0x21, 0xe1, 0x1c, 0x56, 0xa5, 0x33, + 0x71, 0x88, 0x42, 0x5a, 0x34, 0x8b, 0x24, 0xdd, 0x0e, 0x98, 0x30, 0xdb, 0x6b, 0x6c, 0x89, 0x64, + 0x8c, 0x7a, 0x63, 0x3c, 0xa9, 0xd8, 0x32, 0x51, 0xd0, 0xc6, 0xf7, 0xa4, 0x53, 0x95, 0x0d, 0x02, + 0x19, 0x6a, 0x77, 0xbc, 0xdf, 0xd5, 0x2b, 0x2c, 0x65, 0xc9, 0xbf, 0x72, 0x69, 0xc3, 0x0c, 0xef, + 0x34, 0x75, 0x76, 0x29, 0x59, 0xbe, 0x9d, 0xe9, 0x44, 0x21, 0x2f, 0x5f, 0xb7, 0x89, 0xa6, 0xcd, + 0x0a, 0x9a, 0x9e, 0x77, 0x5b, 0xbd, 0xda, 0x03, 0xa4, 0xbc, 0xfb, 0x47, 0xc1, 0x77, 0x73, 0x00, + 0x26, 0xae, 0x2e, 0xfa, 0x62, 0x18, 0x9d, 0xb8, 0xe2, 0xd3, 0x7a, 0xb9, 0xd8, 0xcf, 0xe9, 0x61, + 0x11, 0x80, 0xe9, 0xdc, 0xc3, 0x32, 0x9e, 0x63, 0x6f, 0xd9, 0x42, 0xf6, 0x76, 0x7f, 0xbc, 0xbf, + 0xdb, 0x08, 0x2f, 0xa0, 0xeb, 0xb8, 0x4d, 0xf3, 0x76, 0x62, 0xaa, 0xfa, 0x20, 0x4a, 0xdd, 0xe6, + 0xb3, 0x72, 0xc7, 0x7d, 0x36, 0x4f, 0x08, 0x56, 0x4f, 0x19, 0xb2, 0xb0, 0x0c, 0x13, 0x1a, 0x8c, + 0xce, 0x9a, 0x04, 0xb5, 0xb6, 0x9c, 0xd3, 0xd8, 0xfe, 0x1f, 0x2c, 0xcc, 0x89, 0xee, 0x7d, 0x22, + 0x8a, 0x4e, 0x0a, 0x91, 0x0c, 0x8b, 0x5a, 0xe0, 0xbd, 0xe5, 0x3d, 0xbe, 0x90, 0x4b, 0x13, 0xa3, + 0x2f, 0x33, 0xe9, 0x9d, 0x6c, 0x67, 0x35, 0xbd, 0x03, 0xd4, 0x09, 0x90, 0x2f, 0xc6, 0x3c, 0x8d, + 0xd8, 0x43, 0xfc, 0x1f, 0xb7, 0x49, 0xc0, 0xb7, 0x38, 0x70, 0x1d, 0xeb, 0x5a, 0xd7, 0xac, 0x07, + 0xaf, 0x5b, 0x93, 0xc5, 0x7b, 0x55, 0x65, 0x86, 0x6e, 0xc1, 0xdb, 0xcd, 0x42, 0x92, 0x50, 0xdb, + 0xd1, 0x97, 0x95, 0x3d, 0x53, 0xc3, 0xfe, 0xc2, 0xf9, 0x65, 0xf3, 0xd2, 0xee, 0xa4, 0x7e, 0xde, + 0xa1, 0x4b, 0x23, 0x7f, 0xa1, 0x0d, 0x25, 0x6e, 0x80, 0x4f, 0xe3, 0xb5, 0x0c, 0xba, 0x1c, 0x2b, + 0x42, 0x0b, 0x8f, 0xd9, 0xb6, 0x4e, 0x52, 0xd2, 0xdb, 0x35, 0xd2, 0xa1, 0xc4, 0xe6, 0xd6, 0x51, + 0x76, 0xe7, 0x87, 0x5e, 0xbe, 0x93, 0xe6, 0x61, 0x71, 0x4c, 0x8b, 0xa6, 0x96, 0xda, 0xf7, 0xcb, + 0x06, 0xb7, 0xb8, 0xc4, 0xf6, 0xf5, 0xc6, 0x29, 0xaa, 0xe1, 0x13, 0x87, 0x6f, 0x96, 0xba, 0x0c, + 0xf6, 0x79, 0x8f, 0x03, 0x86, 0x22, 0xe3, 0xfb, 0xcf, 0x86, 0xcf, 0x7c, 0x77, 0xfd, 0xb4, 0xee, + 0xbd, 0x42, 0x38, 0x7f, 0xf2, 0xcc, 0xcb, 0x06, 0xea, 0x0d, 0x81, 0xa1, 0x8e, 0xb5, 0xe7, 0x40, + 0xc8, 0x03, 0xa3, 0x4b, 0xc8, 0xb4, 0x0e, 0x3e, 0x36, 0xab, 0x90, 0xc1, 0xfc, 0xb0, 0x37, 0x2b, + 0x83, 0xa1, 0x3d, 0x56, 0xd6, 0x83, 0x0f, 0x99, 0xc4, 0x58, 0xb8, 0x94, 0x61, 0x19, 0xa6, 0x60, + 0x47, 0xcb, 0x2d, 0xaf, 0x29, 0x38, 0x90, 0xfa, 0x99, 0x0f, 0x02, 0x02, 0x65, 0x90, 0x5f, 0xa2, + 0xa2, 0xe3, 0xbb, 0x34, 0x15, 0x2f, 0x0b, 0xf5, 0xb2, 0xcc, 0x83, 0x59, 0xaf, 0xa7, 0x4d, 0x38, + 0xad, 0xf6, 0x52, 0x5c, 0x53, 0xd9, 0x0e, 0x3f, 0xd6, 0x53, 0x86, 0xe2, 0x79, 0xc2, 0x65, 0x48, + 0xb2, 0x67, 0x3b, 0xaf, 0x52, 0x53, 0x57, 0x9a, 0x27, 0x80, 0x88, 0x37, 0x77, 0x67, 0x4e, 0x1f, + 0xf1, 0x7b, 0xc5, 0xcb, 0xd8, 0x11, 0x0a, 0xdd, 0x92, 0x0e, 0x88, 0x6c, 0xca, 0x33, 0x76, 0x3b, + 0x04, 0xfa, 0xc0, 0xfd, 0xc6, 0x3f, 0xb4, 0x72, 0xc2, 0x2b, 0x6d, 0x5e, 0xb6, 0xa1, 0x4e, 0x5f, + 0xc0, 0x50, 0x16, 0xef, 0xfe, 0x6a, 0x42, 0x72, 0x65, 0x02, 0xee, 0x07, 0xc6, 0x19, 0xc6, 0x95, + 0xde, 0x3f, 0xd9, 0xc5, 0xc6, 0x0e, 0x70, 0x07, 0x6a, 0xc3, 0x36, 0x1b, 0x84, 0x6f, 0xdf, 0x80, + 0x16, 0x4e, 0x86, 0x90, 0xc8, 0x55, 0x7b, 0xdd, 0xc0, 0x86, 0x0c, 0x37, 0x47, 0x1f, 0x35, 0xf8, + 0x47, 0xf2, 0xcd, 0x96, 0x21, 0x64, 0xad, 0x46, 0xe1, 0xdf, 0x44, 0x79, 0x48, 0x02, 0xf9, 0x71, + 0x39, 0x35, 0x26, 0xfc, 0x12, 0x0d, 0x88, 0xac, 0xd6, 0xfa, 0x29, 0x74, 0x55, 0x51, 0xe7, 0xaf, + 0x3d, 0x7e, 0x1e, 0x7e, 0xe0, 0x18, 0xb6, 0x3c, 0x4b, 0x99, 0x9d, 0x51, 0x02, 0x51, 0xd8, 0xe9, + 0xfa, 0x61, 0x88, 0x2e, 0xcf, 0x73, 0x77, 0x65, 0x71, 0xae, 0xae, 0xd7, 0xa1, 0xf9, 0xe0, 0x7f, + 0x30, 0x46, 0xcb, 0x20, 0xec, 0xf4, 0xd2, 0xc1, 0x63, 0xf5, 0x6f, 0x8a, 0x72, 0xf9, 0x5b, 0x85, + 0xd2, 0xca, 0x6d, 0x35, 0xd1, 0x17, 0xf6, 0x08, 0x9e, 0x0a, 0x73, 0xb3, 0xda, 0x1a, 0x32, 0xba, + 0x23, 0x10, 0x4a, 0x5d, 0xd7, 0xaa, 0xb4, 0x68, 0x97, 0x59, 0x45, 0xc5, 0x7c, 0x16, 0x6f, 0xe4, + 0x62, 0x89, 0xf1, 0xd3, 0xb4, 0x03, 0x90, 0x7b, 0xa4, 0xa2, 0xca, 0xa0, 0x5d, 0x69, 0x1b, 0xa9, + 0xbb, 0xeb, 0xa0, 0xe2, 0xde, 0xbe, 0x0e, 0xc4, 0x9e, 0x21, 0x38, 0x61, 0x92, 0x9b, 0xab, 0x69, + 0xaa, 0xd0, 0x1d, 0xf6, 0xc3, 0xee, 0xa6, 0xc3, 0xf3, 0x29, 0x1b, 0xe5, 0x6e, 0x52, 0x89, 0xd0, + 0xba, 0xd8, 0x60, 0x27, 0x80, 0x1a, 0xb5, 0x7f, 0x7f, 0xb5, 0xc2, 0x5a, 0xc6, 0x83, 0xa4, 0xc0, + 0x88, 0x39, 0xf3, 0xe7, 0x39, 0xd6, 0x81, 0x1c, 0x13, 0x20, 0xfd, 0x93, 0x3d, 0x8e, 0x79, 0x60, + 0x7c, 0xff, 0xe4, 0x37, 0x5b, 0x33, 0xa3, 0x9d, 0xb7, 0x57, 0xcd, 0x45, 0x0a, 0xb9, 0xe4, 0xf1, + 0xbc, 0x59, 0x74, 0xe8, 0xb3, 0x06, 0xd0, 0x9f, 0x0f, 0xbc, 0x5b, 0x23, 0xb8, 0x6c, 0xd6, 0x4d, + 0xfa, 0xcc, 0x14, 0xab, 0x74, 0x61, 0x1a, 0xfc, 0x22, 0xa6, 0xed, 0x09, 0x76, 0x91, 0xd8, 0x6e, + 0x44, 0xb6, 0x00, 0x14, 0xdc, 0x74, 0x2d, 0x90, 0xaa, 0x59, 0x98, 0x76, 0x30, 0xc5, 0x44, 0xa4, + 0x61, 0x43, 0xd6, 0xe2, 0x28, 0x28, 0xa7, 0xbd, 0x6e, 0x50, 0x5c, 0xe1, 0x96, 0x7a, 0xf8, 0xa8, + 0x32, 0x8c, 0xe9, 0xfd, 0x11, 0x37, 0x91, 0xd1, 0xaf, 0x3c, 0xd3, 0x1c, 0x1e, 0x88, 0x4d, 0x7e, + 0x87, 0x84, 0x84, 0x6f, 0x39, 0x0b, 0xfb, 0x2d, 0xb3, 0x12, 0x4c, 0x6d, 0x45, 0xdd, 0xcd, 0x7d, + 0x75, 0xb7, 0xfe, 0x7e, 0x44, 0xcc, 0x29, 0xe5, 0xb3, 0x10, 0xee, 0x23, 0x55, 0x5b, 0xcf, 0xba, + 0xbd, 0xa1, 0xbe, 0x64, 0xf8, 0x6e, 0x60, 0x31, 0x0a, 0x2d, 0xc9, 0x3b, 0x1d, 0x44, 0xe1, 0x9d, + 0x60, 0x28, 0x77, 0xee, +}; + +static const uint8_t ml_dsa_65_1_sig_digest[] = { + 0x04, 0x0d, 0xa6, 0x57, 0x2b, 0x30, 0x8b, 0xbd, 0x33, 0x25, 0x00, 0xfd, 0x67, 0x5f, 0xb8, 0x89, + 0x23, 0xfc, 0xd7, 0xa9, 0xca, 0xe0, 0x15, 0x0b, 0xd0, 0x1c, 0x48, 0x48, 0x46, 0x52, 0xcc, 0x66, +}; + +static const uint8_t ml_dsa_65_1_sig_add_random[] = { + 0x4e, 0x7a, 0x01, 0x7c, 0x15, 0x03, 0x9d, 0xc2, 0x00, 0x51, 0xd2, 0x96, 0x0e, 0x5e, 0x15, 0x59, + 0xcc, 0x27, 0xed, 0x46, 0x87, 0x7c, 0xb9, 0x81, 0x16, 0x19, 0x9a, 0x0f, 0x41, 0x05, 0xfe, 0x32, +}; + +static ML_DSA_SIG_TEST_DATA slh_dsa_sig_testdata[] = { + ML_DSA_SIG_TEST_DET_ITEM("ML-DSA-65", ml_dsa_65_0), + ML_DSA_SIG_TEST_ITEM("ML-DSA-65", ml_dsa_65_1), +}; +#endif + +/* + * Test vectors from + * https://github.com/usnistgov/ACVP-Server/blob/master/gen-val/json-files/ML-DSA-keyGen-FIPS204/internalProjection.json + */ +static const uint8_t ml_dsa_65_0_keygen_seed[] = { + 0x70, 0xce, 0xfb, 0x9a, 0xed, 0x5b, 0x68, 0xe0, 0x18, 0xb0, 0x79, 0xda, 0x82, 0x84, 0xb9, 0xd5, + 0xca, 0xd5, 0x49, 0x9e, 0xd9, 0xc2, 0x65, 0xff, 0x73, 0x58, 0x80, 0x05, 0xd8, 0x5c, 0x22, 0x5c, +}; +static const uint8_t ml_dsa_65_0_keygen_pub[] = { + 0xd2, 0xfd, 0x03, 0xf3, 0xa1, 0xb7, 0xf6, 0x35, 0xaf, 0x9f, 0x34, 0xd5, 0x80, 0xa9, 0x8f, 0x52, + 0x4c, 0x73, 0x5b, 0xd5, 0xba, 0x23, 0x55, 0xdc, 0x6e, 0x03, 0x5b, 0xd2, 0x17, 0x65, 0x58, 0x0c, + 0xbb, 0x11, 0x19, 0x23, 0xf1, 0x94, 0xa7, 0xcc, 0x8a, 0x7b, 0xb2, 0xeb, 0xc5, 0xc0, 0xe7, 0x1a, + 0xa6, 0x37, 0xcc, 0x80, 0x0e, 0x61, 0x03, 0xb8, 0x50, 0xa5, 0x39, 0xb2, 0xa3, 0x9e, 0x1b, 0x6d, + 0x71, 0x3e, 0x5d, 0xb8, 0x31, 0x4c, 0x9a, 0xe1, 0xf8, 0xbf, 0x8a, 0x38, 0xf0, 0x6a, 0xfb, 0x9d, + 0x73, 0xb1, 0x61, 0xb0, 0xff, 0xe3, 0xa4, 0x89, 0x17, 0x06, 0xae, 0x26, 0xd5, 0x4f, 0xfb, 0x49, + 0x6d, 0xf8, 0xdc, 0x0f, 0x19, 0x83, 0x50, 0x95, 0x00, 0xc9, 0xab, 0xbd, 0x28, 0xe5, 0x9b, 0x3f, + 0xcd, 0xab, 0xbd, 0xad, 0xab, 0xd4, 0x5e, 0xc3, 0x14, 0x99, 0x37, 0x8b, 0xde, 0x84, 0x9e, 0x7c, + 0x1f, 0x19, 0xb7, 0x04, 0x4d, 0x67, 0xe0, 0x51, 0x06, 0xd7, 0x13, 0x6d, 0x95, 0x38, 0x0d, 0x56, + 0x05, 0xd4, 0x46, 0x5d, 0x87, 0x75, 0x57, 0x06, 0x5d, 0xf0, 0xa7, 0x5d, 0x3c, 0x28, 0x54, 0x2f, + 0x40, 0xfe, 0xed, 0x42, 0xec, 0x7e, 0x28, 0x06, 0x37, 0xb0, 0x83, 0xd9, 0x88, 0xbc, 0xa5, 0xf6, + 0x39, 0x4e, 0x02, 0x39, 0x6c, 0x46, 0x76, 0x18, 0x4f, 0xb6, 0x33, 0x18, 0xda, 0xfa, 0xf5, 0xbb, + 0xdd, 0xe0, 0x0e, 0x30, 0x8f, 0xe8, 0x40, 0x19, 0xc2, 0x34, 0x0a, 0x3f, 0x3e, 0x1c, 0x08, 0x65, + 0x62, 0x49, 0x70, 0x71, 0x12, 0x83, 0x35, 0x6a, 0xe1, 0x4b, 0xd6, 0xb9, 0x4d, 0x1c, 0x9a, 0xe1, + 0x88, 0xde, 0x1a, 0x8a, 0x2c, 0xa8, 0x24, 0xa8, 0xea, 0xe2, 0xfe, 0x6a, 0xfb, 0x38, 0xd8, 0x3a, + 0x2d, 0x99, 0x99, 0x6a, 0xb2, 0x1f, 0xe3, 0xe8, 0x4c, 0x0b, 0xe6, 0xb6, 0xda, 0x08, 0x87, 0x9b, + 0x67, 0x73, 0x74, 0xfa, 0x7c, 0x69, 0x1b, 0x13, 0xd4, 0x0f, 0xa9, 0xd4, 0xcc, 0x26, 0xb2, 0x28, + 0x8d, 0x5a, 0x8c, 0x9a, 0x43, 0x72, 0x43, 0x81, 0x00, 0x4d, 0x61, 0xb0, 0xd5, 0x7f, 0xf4, 0x00, + 0x31, 0x4c, 0x8e, 0x30, 0xee, 0x79, 0x6a, 0xf1, 0x0f, 0x7e, 0xe2, 0x1b, 0xf1, 0x3d, 0x08, 0x18, + 0x04, 0x65, 0xab, 0xc7, 0x2e, 0xdd, 0xb0, 0x80, 0xc6, 0xa0, 0x71, 0x84, 0xe3, 0xee, 0xdc, 0x47, + 0xc1, 0x9a, 0xa7, 0xf0, 0x9d, 0x1f, 0x33, 0x09, 0xe1, 0x83, 0xa2, 0xbd, 0x9b, 0x05, 0x73, 0xdd, + 0xe4, 0x74, 0xa8, 0x1b, 0xa4, 0xf7, 0x8d, 0x0c, 0x52, 0x3d, 0x0c, 0x04, 0xf9, 0x00, 0x60, 0xfd, + 0x57, 0x1a, 0x35, 0xc0, 0x37, 0xe0, 0x79, 0xc5, 0xe2, 0x10, 0xd7, 0x39, 0x0d, 0xf5, 0x68, 0xf2, + 0xe2, 0xf0, 0x3c, 0xe4, 0x44, 0x20, 0xc8, 0x2f, 0x3f, 0xe6, 0x9e, 0xb9, 0xb4, 0x8e, 0xe9, 0x09, + 0x62, 0xd6, 0xb0, 0xf2, 0x44, 0x40, 0x64, 0x8f, 0x71, 0xed, 0xb2, 0x41, 0xee, 0x65, 0x66, 0xfc, + 0x1a, 0x64, 0xca, 0xbf, 0x66, 0xbe, 0x6f, 0xec, 0xbc, 0xb1, 0x38, 0x7c, 0x82, 0xa7, 0xbc, 0x20, + 0x2d, 0x9e, 0x36, 0x79, 0x98, 0xe2, 0xa2, 0x91, 0xaf, 0x0c, 0xd1, 0x57, 0x06, 0x77, 0xfe, 0x8d, + 0x63, 0xa3, 0x28, 0x5a, 0x2e, 0xa6, 0xeb, 0x29, 0xaf, 0x9d, 0xc1, 0xae, 0xc1, 0xc3, 0x6c, 0x47, + 0x06, 0xb1, 0x2b, 0xaa, 0x20, 0x83, 0x96, 0x92, 0xf2, 0x86, 0xa6, 0xe0, 0x32, 0x14, 0x68, 0xf7, + 0x47, 0x93, 0x45, 0xc4, 0xd5, 0x2f, 0xbd, 0xb2, 0xf0, 0x67, 0x25, 0xb5, 0x54, 0xb8, 0x9e, 0x24, + 0x92, 0x61, 0x26, 0x81, 0xac, 0xeb, 0xc6, 0xc7, 0xba, 0xda, 0x92, 0x25, 0x81, 0x8d, 0xbc, 0x35, + 0xd6, 0x4c, 0x22, 0xc4, 0x8b, 0xff, 0x80, 0xa7, 0x30, 0xd0, 0x71, 0x6d, 0xfa, 0xc9, 0x9d, 0xfd, + 0x5b, 0x89, 0x92, 0x61, 0x1d, 0x0c, 0x93, 0xee, 0x90, 0xbd, 0xb2, 0x60, 0x02, 0x2a, 0xfe, 0x25, + 0xd9, 0x13, 0xe0, 0x6e, 0xff, 0xb5, 0x9c, 0xb1, 0xf8, 0xa6, 0x0c, 0xbf, 0xa5, 0xab, 0x2f, 0x45, + 0x9a, 0x16, 0xf4, 0x67, 0xe9, 0x89, 0x52, 0x5e, 0x0a, 0x37, 0xeb, 0xe5, 0x6e, 0x83, 0x3f, 0xde, + 0x55, 0xdb, 0x9d, 0x15, 0x30, 0xad, 0xcf, 0x45, 0x84, 0x6d, 0xf2, 0x81, 0xe4, 0x7c, 0xaa, 0x1e, + 0x0a, 0x27, 0xef, 0xde, 0x21, 0x07, 0xd3, 0x54, 0xce, 0xa0, 0xf6, 0xa4, 0x54, 0x69, 0x2f, 0x04, + 0xcd, 0x83, 0x8e, 0xbd, 0xd4, 0x6e, 0x19, 0x1e, 0x5d, 0x9c, 0x11, 0x83, 0x9a, 0x2c, 0x3f, 0x48, + 0x8a, 0x4f, 0xc7, 0xcd, 0x26, 0x5a, 0x7b, 0x5d, 0x32, 0xb0, 0x8c, 0xbd, 0xbf, 0xab, 0x9d, 0x2c, + 0xcd, 0x76, 0x22, 0x2c, 0x8e, 0xe3, 0x7d, 0xdc, 0xbd, 0x2a, 0xa0, 0x63, 0xed, 0x86, 0x14, 0x73, + 0xa6, 0x45, 0x4c, 0xae, 0xa3, 0x77, 0x85, 0x0b, 0x1a, 0x2b, 0x9d, 0xdb, 0xbc, 0xb3, 0x74, 0xfa, + 0xb5, 0xb1, 0x2f, 0x35, 0x1c, 0x8e, 0x58, 0x88, 0x87, 0x2e, 0x5c, 0xd1, 0xf6, 0x0a, 0x4f, 0xae, + 0x1f, 0xf8, 0x37, 0xd1, 0x92, 0xc2, 0x2b, 0xeb, 0x41, 0xee, 0x6f, 0xa3, 0x92, 0xfc, 0xdf, 0x45, + 0x50, 0xff, 0x46, 0xb5, 0xce, 0x90, 0x6d, 0x01, 0x7e, 0xf3, 0x07, 0x7d, 0xf1, 0x32, 0x30, 0x0d, + 0x8b, 0xbf, 0xa9, 0xbb, 0x03, 0xc7, 0x5e, 0x79, 0xe2, 0xf0, 0x4c, 0x28, 0x4a, 0xd0, 0x6a, 0x44, + 0x39, 0x96, 0x49, 0xc3, 0xe2, 0xa2, 0xa8, 0xd1, 0xef, 0xe9, 0xb7, 0xa4, 0xe0, 0xc2, 0x71, 0x04, + 0x7a, 0xb7, 0x59, 0x08, 0xbf, 0xf7, 0xdf, 0x9e, 0x30, 0xec, 0xa5, 0x47, 0x74, 0x5b, 0xae, 0x23, + 0xa8, 0x6f, 0xf9, 0xa8, 0xb5, 0x8c, 0x25, 0x38, 0xb8, 0x8b, 0x86, 0x64, 0x01, 0x07, 0x69, 0x02, + 0xdc, 0x5f, 0x0b, 0xd7, 0x61, 0x68, 0x7b, 0x49, 0xea, 0xfe, 0x36, 0xd3, 0x50, 0xcb, 0xed, 0xfd, + 0xd3, 0x6c, 0x12, 0x1c, 0xf2, 0x37, 0x86, 0xbf, 0xcf, 0x7e, 0x47, 0x07, 0x64, 0x96, 0xea, 0xb6, + 0xbb, 0xda, 0x77, 0x40, 0x49, 0xc2, 0xeb, 0xab, 0xe2, 0xde, 0x99, 0xc4, 0xc2, 0x4f, 0x2d, 0xb7, + 0x36, 0x84, 0x01, 0x5b, 0x37, 0x39, 0x77, 0x49, 0x67, 0x60, 0xcf, 0x9a, 0xc2, 0x3d, 0x8b, 0x62, + 0x31, 0x33, 0xdb, 0x2d, 0xe1, 0x0d, 0x73, 0xfa, 0x6a, 0xd1, 0xc6, 0xda, 0xc8, 0x43, 0x4f, 0x28, + 0xc6, 0xe2, 0x51, 0xce, 0x72, 0x93, 0xcf, 0xf3, 0xf3, 0xb6, 0x1e, 0xfc, 0xb5, 0xa4, 0x35, 0x12, + 0x36, 0x70, 0xf2, 0x98, 0x46, 0xa1, 0x3d, 0xf3, 0xee, 0x71, 0x26, 0x04, 0x46, 0x1f, 0x1b, 0xab, + 0x8f, 0x4e, 0xbc, 0x83, 0x6d, 0xe0, 0x58, 0x97, 0x8a, 0xe7, 0x34, 0x39, 0x6a, 0x98, 0x08, 0x1b, + 0x35, 0xcc, 0x98, 0x18, 0x8a, 0x86, 0x94, 0x9c, 0x99, 0x27, 0x0d, 0x47, 0x09, 0x85, 0x4c, 0x5b, + 0x35, 0xb1, 0x7f, 0x48, 0xa3, 0x73, 0x13, 0x4c, 0x81, 0x4c, 0xc8, 0xa0, 0xf3, 0xe2, 0xfa, 0x80, + 0x7f, 0x2a, 0x91, 0x85, 0x30, 0x90, 0x78, 0x64, 0x77, 0x82, 0x82, 0xd7, 0x5e, 0x03, 0xa4, 0x1b, + 0x25, 0x04, 0xee, 0xd8, 0x16, 0xa4, 0x17, 0xa3, 0xac, 0x6b, 0xa1, 0x60, 0x80, 0xc3, 0x9b, 0x73, + 0x10, 0x19, 0x20, 0x02, 0xa7, 0x28, 0xf7, 0xf2, 0x03, 0x95, 0x00, 0x9a, 0x9e, 0x16, 0x76, 0x7c, + 0xe1, 0x97, 0x1f, 0x5d, 0xe7, 0xd2, 0x29, 0xa5, 0x06, 0x13, 0x36, 0x9e, 0x43, 0x82, 0x04, 0x5a, + 0x8e, 0x81, 0x90, 0x1f, 0x4d, 0xba, 0x81, 0x02, 0xf3, 0xd4, 0x13, 0xfe, 0x35, 0xb3, 0x26, 0xa8, + 0x74, 0xf2, 0x33, 0xb7, 0x19, 0xa7, 0x13, 0x76, 0x00, 0xd3, 0x5d, 0x33, 0xae, 0xb6, 0xb7, 0x25, + 0x96, 0x24, 0x08, 0x3a, 0xa9, 0x68, 0x73, 0x0c, 0x8f, 0x78, 0x29, 0x2a, 0xd2, 0x8f, 0x14, 0xee, + 0xab, 0xe6, 0x60, 0x83, 0x59, 0x84, 0xfe, 0x69, 0xef, 0x23, 0xde, 0xc8, 0xc3, 0x27, 0xc0, 0xeb, + 0x0b, 0x88, 0x2d, 0x58, 0x7e, 0x1e, 0xc4, 0x33, 0xda, 0x85, 0xc9, 0xfd, 0x1e, 0x0a, 0x34, 0x99, + 0x4d, 0xea, 0x24, 0x0c, 0x85, 0x44, 0x52, 0xd1, 0x8c, 0x30, 0xf4, 0x96, 0xe4, 0x9e, 0xc9, 0x04, + 0xb6, 0x02, 0xe0, 0xf5, 0x06, 0x2e, 0xdc, 0xda, 0x03, 0x28, 0x0a, 0x53, 0xb4, 0x31, 0x35, 0x74, + 0xcc, 0x2c, 0x0d, 0x54, 0x71, 0xbc, 0x96, 0x13, 0xbd, 0xfd, 0x66, 0x41, 0xf5, 0xbd, 0x12, 0x7b, + 0xab, 0x5b, 0x5e, 0xb3, 0xd4, 0x99, 0xa3, 0x31, 0x14, 0x04, 0x82, 0x20, 0xe8, 0x19, 0xf8, 0xee, + 0x12, 0xca, 0x92, 0x2c, 0x8f, 0x17, 0xd9, 0xc9, 0xf5, 0x1a, 0xd5, 0xbd, 0x68, 0x83, 0xb1, 0x0e, + 0x6a, 0xa2, 0x48, 0x3b, 0xa4, 0x9d, 0xc5, 0x47, 0xda, 0x76, 0x86, 0x15, 0x13, 0x44, 0xf4, 0xe9, + 0x09, 0x9b, 0x38, 0xe4, 0x30, 0xb5, 0x22, 0x6b, 0x05, 0x98, 0x32, 0xcf, 0x03, 0xdb, 0x48, 0xfb, + 0x02, 0xdb, 0xa4, 0xe6, 0x15, 0x93, 0xdc, 0x45, 0x76, 0x36, 0x04, 0x91, 0x89, 0x0e, 0x53, 0xec, + 0x0e, 0x6a, 0xc7, 0x3c, 0xf3, 0x2b, 0x25, 0xd8, 0x23, 0xb3, 0x84, 0x56, 0xe2, 0x86, 0x50, 0x5a, + 0x54, 0x1e, 0x5a, 0xee, 0xe9, 0x6b, 0x19, 0x14, 0xf5, 0xf7, 0x66, 0x87, 0xce, 0x2b, 0x01, 0x60, + 0x22, 0x7a, 0xbe, 0xd7, 0x79, 0x93, 0x59, 0x4b, 0xcd, 0x83, 0x13, 0x66, 0x20, 0x6d, 0x75, 0x71, + 0x40, 0x82, 0xf1, 0xc4, 0x6f, 0x1f, 0x44, 0x39, 0xac, 0x81, 0xa5, 0x7a, 0xf3, 0x1c, 0x81, 0xc5, + 0x55, 0x30, 0x7a, 0x07, 0x0f, 0xfa, 0x94, 0xe0, 0x47, 0x9b, 0x78, 0x4b, 0xbd, 0x88, 0xa6, 0x0c, + 0xd4, 0xc7, 0xcf, 0xd9, 0x4e, 0x6a, 0xfe, 0x02, 0xf6, 0xb2, 0x1f, 0x72, 0xaf, 0x0d, 0xcd, 0x66, + 0x09, 0xd4, 0x0c, 0x96, 0x5c, 0x14, 0xe5, 0xf2, 0x38, 0x91, 0x83, 0xe5, 0x3d, 0xe9, 0x30, 0xf7, + 0xde, 0x1d, 0x44, 0x21, 0x5c, 0xf4, 0x91, 0x44, 0x84, 0x4e, 0x8b, 0x87, 0xf7, 0x8a, 0x7f, 0x13, + 0x2a, 0xef, 0xe2, 0x2b, 0xe8, 0x0b, 0x4e, 0x3a, 0x05, 0xee, 0x3a, 0x68, 0xcc, 0xf6, 0x09, 0xef, + 0x44, 0x04, 0x74, 0x02, 0xe4, 0x49, 0x30, 0x46, 0xe6, 0xf9, 0xc7, 0x67, 0xff, 0x8a, 0x75, 0xe2, + 0x8b, 0x3c, 0xe0, 0x77, 0xfd, 0xe7, 0xe7, 0xee, 0xd3, 0x13, 0xb5, 0xbf, 0x7e, 0x46, 0x01, 0x27, + 0xca, 0x81, 0x82, 0xe9, 0xbc, 0x79, 0x4c, 0x0d, 0xfa, 0x73, 0x0f, 0xb9, 0x20, 0x08, 0x05, 0x75, + 0xa7, 0x51, 0xb5, 0xca, 0xec, 0x85, 0xa1, 0x09, 0xb4, 0x42, 0x2b, 0xa2, 0x66, 0x74, 0x3f, 0x0d, + 0x03, 0x2b, 0xda, 0x8f, 0x1c, 0xa6, 0x24, 0x8c, 0xdb, 0x91, 0x75, 0x30, 0xdf, 0x13, 0x02, 0xa5, + 0xf8, 0xc1, 0x8d, 0xc6, 0x42, 0xd5, 0x24, 0x78, 0xc9, 0x8c, 0x12, 0xa3, 0xf1, 0x6e, 0xf2, 0xb6, + 0x2b, 0x4f, 0x59, 0xea, 0x1b, 0xb5, 0x8d, 0xe7, 0xb6, 0x5b, 0x3c, 0x71, 0x53, 0xce, 0x6d, 0xa5, + 0xe4, 0x95, 0x07, 0x46, 0xf8, 0x0e, 0x08, 0x7a, 0x0e, 0x35, 0x86, 0xd0, 0x97, 0x79, 0x1b, 0xf3, + 0x6d, 0xef, 0x86, 0x5d, 0x68, 0x59, 0x1d, 0x39, 0xd0, 0x90, 0x37, 0x73, 0xee, 0xa9, 0x62, 0x14, + 0x7f, 0x34, 0x70, 0x41, 0x38, 0xb5, 0x4d, 0xf7, 0x92, 0x4c, 0xdd, 0x8c, 0x33, 0x3d, 0xb5, 0xe1, + 0xa4, 0x09, 0xcc, 0xb2, 0xb3, 0x4e, 0x2c, 0x3c, 0x8c, 0x7f, 0xdd, 0x3f, 0xd8, 0xd0, 0x12, 0xcb, + 0xf3, 0x82, 0xaa, 0xa8, 0x5e, 0x83, 0xa1, 0x2f, 0x23, 0x5a, 0x2d, 0x14, 0x7d, 0x03, 0x5b, 0x7b, + 0x28, 0xb3, 0x4b, 0x6f, 0x57, 0x94, 0x9f, 0x32, 0x24, 0x82, 0xa7, 0xd4, 0xd3, 0xb1, 0x50, 0x45, + 0xc4, 0x20, 0xd5, 0xad, 0xdc, 0x7f, 0x0e, 0x69, 0xb4, 0xdc, 0x1c, 0xba, 0x58, 0xb0, 0x1d, 0x87, + 0x24, 0x80, 0xb0, 0x6a, 0x26, 0x0d, 0x82, 0x7d, 0x89, 0x1b, 0x13, 0xc4, 0xc5, 0xca, 0x50, 0xc7, + 0x48, 0xde, 0x3c, 0x77, 0x1b, 0xe6, 0x1e, 0x9a, 0xa1, 0x70, 0x16, 0x5c, 0xb0, 0x1f, 0x4b, 0xf5, + 0xda, 0x27, 0xa7, 0x79, 0x1d, 0x3a, 0xd3, 0xf6, 0x26, 0x7b, 0x4c, 0xb4, 0xe6, 0x1b, 0x28, 0xfa, + 0x17, 0x08, 0x41, 0x8d, 0x93, 0x2d, 0xfc, 0x41, 0x61, 0x88, 0x0c, 0x5d, 0x3b, 0x17, 0xa9, 0x66, + 0x3a, 0x90, 0x61, 0xfa, 0x8f, 0x18, 0x04, 0x31, 0x58, 0x50, 0xfe, 0x4e, 0x73, 0x06, 0xc8, 0x82, + 0xb3, 0x82, 0x27, 0xe8, 0x67, 0xf8, 0x08, 0x72, 0xcd, 0xc1, 0x94, 0x4d, 0x47, 0x26, 0x15, 0xea, + 0x49, 0x00, 0xef, 0x7d, 0x27, 0x0b, 0x88, 0x1d, 0x41, 0x30, 0xf5, 0x6c, 0x5c, 0xc9, 0x80, 0xd9, + 0x2a, 0x47, 0xad, 0xa6, 0x65, 0x7e, 0xb6, 0xf3, 0x7a, 0x38, 0x5d, 0x2d, 0x8c, 0xc9, 0x93, 0xe1, + 0x44, 0x2e, 0xb0, 0x52, 0x81, 0x85, 0x36, 0x36, 0x99, 0x1e, 0x34, 0xaa, 0xdc, 0x68, 0x95, 0x4d, + 0x04, 0xe7, 0xad, 0xef, 0x76, 0xbf, 0x88, 0x0f, 0x05, 0x9b, 0x0c, 0xbb, 0x55, 0xd9, 0x15, 0xa4, + 0xb1, 0x23, 0xe2, 0xf1, 0x33, 0x9a, 0x07, 0x3c, 0xbf, 0xbc, 0x40, 0x9b, 0xef, 0xf6, 0x40, 0x0a, + 0xe0, 0x96, 0xd5, 0xae, 0x18, 0xec, 0x42, 0xcf, 0xfa, 0xd5, 0xb4, 0x98, 0x0f, 0xa3, 0x5b, 0xf0, + 0x34, 0x13, 0xad, 0xb5, 0xd7, 0xe6, 0x87, 0x6a, 0xc3, 0x55, 0xd1, 0xc9, 0xed, 0x70, 0xca, 0x2b, + 0x97, 0x39, 0x54, 0xd1, 0x2b, 0x3c, 0xdd, 0x76, 0xac, 0x68, 0x35, 0xdb, 0x96, 0x00, 0x3e, 0xd8, + 0xc4, 0xe2, 0x88, 0xb7, 0x1f, 0xd7, 0x7d, 0xba, 0xa7, 0x63, 0x57, 0x20, 0xe1, 0x2a, 0xe0, 0xa3, + 0x17, 0xde, 0x80, 0x8c, 0x66, 0x4e, 0x31, 0x7f, 0x55, 0x27, 0x57, 0x91, 0xf3, 0x24, 0x5c, 0xa4, + 0xfe, 0x5d, 0x4d, 0x41, 0x07, 0x7f, 0xc1, 0x50, 0xa6, 0xe4, 0x03, 0xd5, 0xa2, 0x08, 0xe4, 0x6e, + 0xad, 0xbe, 0x8f, 0x2c, 0xfb, 0x8a, 0xf4, 0x72, 0xf4, 0xa0, 0xce, 0xac, 0x01, 0x52, 0x19, 0x47, + 0x8e, 0x6b, 0x86, 0xc9, 0x58, 0xcf, 0x86, 0x52, 0x5b, 0x74, 0x85, 0xc1, 0x73, 0x4c, 0x7e, 0xf0, + 0x0e, 0x90, 0x68, 0x3f, 0xff, 0x5d, 0xbd, 0x0a, 0x7d, 0x41, 0x3a, 0x85, 0x50, 0x21, 0x02, 0x6a, + 0x1b, 0x32, 0x01, 0x3a, 0x46, 0x16, 0xcb, 0xcd, 0x37, 0x00, 0xac, 0xbc, 0x70, 0x5b, 0xe3, 0xef, + 0xba, 0x62, 0x5c, 0x69, 0xa0, 0x25, 0x26, 0x7b, 0xce, 0x9d, 0x13, 0x5e, 0x3f, 0x5b, 0x5c, 0xc8, + 0xc4, 0x39, 0x56, 0x40, 0x7e, 0x84, 0xb6, 0x66, 0x31, 0x03, 0xe2, 0x9c, 0x24, 0x20, 0x35, 0x55, + 0x1a, 0xe7, 0x97, 0xf5, 0x6c, 0x63, 0x74, 0xbe, 0x0c, 0x79, 0x8c, 0x0c, 0xf3, 0x98, 0xf1, 0xed, +}; +static const uint8_t ml_dsa_65_0_keygen_priv[] = { + 0xd2, 0xfd, 0x03, 0xf3, 0xa1, 0xb7, 0xf6, 0x35, 0xaf, 0x9f, 0x34, 0xd5, 0x80, 0xa9, 0x8f, 0x52, + 0x4c, 0x73, 0x5b, 0xd5, 0xba, 0x23, 0x55, 0xdc, 0x6e, 0x03, 0x5b, 0xd2, 0x17, 0x65, 0x58, 0x0c, + 0xe3, 0x8d, 0x1c, 0x14, 0xf6, 0x46, 0x7c, 0x35, 0xa9, 0xf3, 0x80, 0xd2, 0x7d, 0xe6, 0x1f, 0x7c, + 0x75, 0x03, 0x15, 0x69, 0xea, 0x2e, 0xc8, 0x26, 0x0e, 0xee, 0x91, 0x05, 0x26, 0x1b, 0x7f, 0xe1, + 0x60, 0xc9, 0x13, 0x44, 0xb0, 0xc6, 0x76, 0x4c, 0x20, 0x4e, 0x5b, 0x8d, 0x42, 0x46, 0x50, 0xbe, + 0xc0, 0x6b, 0x9e, 0x2e, 0x62, 0x5a, 0xf0, 0x7e, 0x23, 0xf4, 0x95, 0x0c, 0xa2, 0x4f, 0xb4, 0xd6, + 0xec, 0x2c, 0x8b, 0x3a, 0x71, 0x7c, 0x93, 0x11, 0xeb, 0x87, 0x27, 0x9f, 0xe2, 0x5e, 0x31, 0x1f, + 0x48, 0xb8, 0x25, 0x65, 0x01, 0xf6, 0x46, 0x34, 0x12, 0xb5, 0x0d, 0xbc, 0x89, 0xa8, 0x69, 0xba, + 0x22, 0x41, 0x11, 0x26, 0x48, 0x40, 0x07, 0x38, 0x73, 0x02, 0x12, 0x44, 0x25, 0x44, 0x57, 0x54, + 0x83, 0x72, 0x50, 0x33, 0x35, 0x62, 0x58, 0x42, 0x32, 0x01, 0x62, 0x11, 0x83, 0x61, 0x02, 0x45, + 0x66, 0x56, 0x48, 0x35, 0x61, 0x20, 0x84, 0x52, 0x60, 0x68, 0x50, 0x45, 0x65, 0x55, 0x12, 0x72, + 0x47, 0x47, 0x21, 0x21, 0x25, 0x40, 0x22, 0x21, 0x42, 0x81, 0x17, 0x65, 0x03, 0x06, 0x42, 0x61, + 0x52, 0x13, 0x43, 0x25, 0x24, 0x33, 0x82, 0x12, 0x11, 0x35, 0x62, 0x33, 0x32, 0x07, 0x47, 0x86, + 0x22, 0x31, 0x50, 0x83, 0x70, 0x84, 0x26, 0x43, 0x45, 0x64, 0x51, 0x48, 0x31, 0x14, 0x86, 0x24, + 0x66, 0x86, 0x74, 0x33, 0x71, 0x36, 0x67, 0x26, 0x01, 0x47, 0x07, 0x72, 0x11, 0x61, 0x58, 0x85, + 0x58, 0x38, 0x71, 0x83, 0x80, 0x67, 0x01, 0x65, 0x78, 0x70, 0x64, 0x77, 0x85, 0x60, 0x02, 0x88, + 0x53, 0x48, 0x46, 0x62, 0x25, 0x83, 0x54, 0x88, 0x04, 0x74, 0x40, 0x12, 0x57, 0x43, 0x71, 0x07, + 0x75, 0x44, 0x38, 0x71, 0x21, 0x14, 0x22, 0x08, 0x88, 0x72, 0x23, 0x58, 0x87, 0x46, 0x14, 0x85, + 0x53, 0x71, 0x67, 0x73, 0x82, 0x28, 0x22, 0x74, 0x14, 0x03, 0x57, 0x73, 0x28, 0x71, 0x83, 0x80, + 0x78, 0x14, 0x34, 0x87, 0x52, 0x07, 0x64, 0x74, 0x01, 0x60, 0x75, 0x61, 0x06, 0x08, 0x61, 0x32, + 0x21, 0x46, 0x15, 0x65, 0x42, 0x67, 0x08, 0x20, 0x84, 0x10, 0x73, 0x13, 0x03, 0x61, 0x02, 0x86, + 0x50, 0x45, 0x26, 0x12, 0x16, 0x68, 0x33, 0x55, 0x25, 0x84, 0x73, 0x53, 0x54, 0x52, 0x65, 0x17, + 0x10, 0x60, 0x00, 0x38, 0x57, 0x77, 0x81, 0x24, 0x26, 0x80, 0x41, 0x46, 0x43, 0x26, 0x67, 0x41, + 0x06, 0x03, 0x55, 0x41, 0x28, 0x33, 0x37, 0x25, 0x23, 0x06, 0x77, 0x82, 0x15, 0x16, 0x31, 0x73, + 0x00, 0x08, 0x75, 0x26, 0x58, 0x46, 0x34, 0x63, 0x88, 0x08, 0x84, 0x64, 0x51, 0x11, 0x24, 0x05, + 0x32, 0x10, 0x11, 0x18, 0x18, 0x64, 0x78, 0x22, 0x41, 0x00, 0x38, 0x55, 0x75, 0x42, 0x10, 0x46, + 0x83, 0x43, 0x73, 0x38, 0x80, 0x07, 0x83, 0x43, 0x78, 0x74, 0x13, 0x57, 0x62, 0x32, 0x68, 0x80, + 0x65, 0x86, 0x48, 0x53, 0x48, 0x35, 0x51, 0x58, 0x50, 0x74, 0x46, 0x05, 0x88, 0x70, 0x07, 0x72, + 0x01, 0x31, 0x00, 0x87, 0x54, 0x88, 0x14, 0x20, 0x84, 0x16, 0x61, 0x15, 0x60, 0x56, 0x85, 0x11, + 0x58, 0x08, 0x05, 0x88, 0x63, 0x01, 0x82, 0x86, 0x13, 0x14, 0x17, 0x22, 0x01, 0x68, 0x17, 0x17, + 0x86, 0x58, 0x53, 0x10, 0x62, 0x28, 0x52, 0x82, 0x26, 0x15, 0x04, 0x31, 0x42, 0x88, 0x54, 0x31, + 0x78, 0x05, 0x80, 0x11, 0x50, 0x45, 0x68, 0x82, 0x33, 0x66, 0x36, 0x36, 0x40, 0x65, 0x15, 0x24, + 0x47, 0x67, 0x06, 0x45, 0x36, 0x42, 0x26, 0x86, 0x75, 0x06, 0x35, 0x41, 0x33, 0x47, 0x85, 0x12, + 0x17, 0x80, 0x83, 0x87, 0x65, 0x51, 0x42, 0x31, 0x38, 0x87, 0x56, 0x62, 0x05, 0x17, 0x40, 0x85, + 0x28, 0x14, 0x17, 0x21, 0x38, 0x12, 0x60, 0x81, 0x24, 0x41, 0x45, 0x75, 0x01, 0x82, 0x87, 0x10, + 0x10, 0x02, 0x13, 0x25, 0x57, 0x04, 0x21, 0x72, 0x42, 0x78, 0x61, 0x11, 0x70, 0x05, 0x30, 0x47, + 0x72, 0x13, 0x20, 0x30, 0x21, 0x67, 0x44, 0x31, 0x57, 0x71, 0x45, 0x57, 0x10, 0x54, 0x16, 0x65, + 0x74, 0x15, 0x24, 0x02, 0x43, 0x71, 0x51, 0x20, 0x55, 0x11, 0x67, 0x83, 0x67, 0x82, 0x52, 0x53, + 0x35, 0x66, 0x42, 0x46, 0x13, 0x70, 0x22, 0x32, 0x74, 0x00, 0x07, 0x06, 0x81, 0x87, 0x17, 0x57, + 0x80, 0x28, 0x68, 0x01, 0x72, 0x10, 0x04, 0x27, 0x55, 0x22, 0x86, 0x42, 0x53, 0x15, 0x81, 0x76, + 0x30, 0x86, 0x40, 0x83, 0x11, 0x43, 0x30, 0x53, 0x82, 0x73, 0x53, 0x03, 0x72, 0x35, 0x68, 0x70, + 0x45, 0x41, 0x15, 0x73, 0x14, 0x12, 0x31, 0x64, 0x32, 0x66, 0x63, 0x56, 0x21, 0x51, 0x50, 0x82, + 0x10, 0x30, 0x23, 0x38, 0x17, 0x21, 0x27, 0x10, 0x23, 0x14, 0x22, 0x75, 0x77, 0x28, 0x37, 0x71, + 0x62, 0x75, 0x06, 0x88, 0x72, 0x14, 0x18, 0x73, 0x13, 0x03, 0x01, 0x50, 0x71, 0x58, 0x62, 0x86, + 0x62, 0x88, 0x86, 0x86, 0x03, 0x27, 0x01, 0x46, 0x17, 0x22, 0x71, 0x38, 0x53, 0x81, 0x70, 0x33, + 0x88, 0x68, 0x13, 0x78, 0x81, 0x04, 0x86, 0x57, 0x30, 0x16, 0x52, 0x31, 0x40, 0x83, 0x07, 0x56, + 0x82, 0x10, 0x32, 0x31, 0x28, 0x50, 0x06, 0x50, 0x81, 0x63, 0x06, 0x75, 0x76, 0x65, 0x11, 0x60, + 0x14, 0x17, 0x12, 0x12, 0x55, 0x56, 0x48, 0x11, 0x41, 0x13, 0x28, 0x82, 0x62, 0x07, 0x47, 0x64, + 0x24, 0x48, 0x23, 0x24, 0x77, 0x53, 0x26, 0x08, 0x17, 0x58, 0x11, 0x56, 0x37, 0x48, 0x35, 0x51, + 0x47, 0x86, 0x85, 0x66, 0x66, 0x81, 0x73, 0x20, 0x21, 0x36, 0x75, 0x22, 0x74, 0x66, 0x83, 0x44, + 0x57, 0x00, 0x66, 0x64, 0x77, 0x20, 0x47, 0x22, 0x28, 0x56, 0x87, 0x12, 0x47, 0x02, 0x48, 0x07, + 0x02, 0x54, 0x23, 0x01, 0x25, 0x71, 0x37, 0x36, 0x75, 0x36, 0x00, 0x52, 0x68, 0x15, 0x33, 0x35, + 0x82, 0x06, 0x13, 0x73, 0x24, 0x08, 0x71, 0x76, 0x15, 0x22, 0x42, 0x60, 0x18, 0x53, 0x43, 0x11, + 0x64, 0x57, 0x76, 0x17, 0x61, 0x56, 0x68, 0x76, 0x60, 0x65, 0x54, 0x78, 0x10, 0x33, 0x63, 0x14, + 0x21, 0x83, 0x21, 0x60, 0x15, 0x55, 0x80, 0x42, 0x38, 0x42, 0x03, 0x13, 0x12, 0x34, 0x36, 0x25, + 0x27, 0x30, 0x82, 0x81, 0x25, 0x47, 0x51, 0x35, 0x44, 0x12, 0x67, 0x35, 0x00, 0x10, 0x01, 0x83, + 0x85, 0x74, 0x42, 0x40, 0x13, 0x03, 0x61, 0x27, 0x81, 0x26, 0x26, 0x81, 0x18, 0x87, 0x43, 0x51, + 0x20, 0x62, 0x71, 0x27, 0x51, 0x56, 0x10, 0x22, 0x22, 0x81, 0x11, 0x81, 0x41, 0x66, 0x66, 0x38, + 0x20, 0x86, 0x75, 0x56, 0x12, 0x40, 0x06, 0x54, 0x61, 0x12, 0x74, 0x40, 0x34, 0x58, 0x58, 0x78, + 0x10, 0x07, 0x85, 0x25, 0x72, 0x88, 0x57, 0x22, 0x22, 0x25, 0x50, 0x84, 0x00, 0x41, 0x26, 0x08, + 0x36, 0x46, 0x28, 0x78, 0x46, 0x78, 0x05, 0x02, 0x28, 0x20, 0x77, 0x13, 0x60, 0x75, 0x14, 0x43, + 0x68, 0x78, 0x64, 0x31, 0x38, 0x77, 0x73, 0x73, 0x55, 0x41, 0x27, 0x00, 0x54, 0x07, 0x08, 0x28, + 0x68, 0x80, 0x04, 0x53, 0x83, 0x43, 0x22, 0x81, 0x00, 0x64, 0x35, 0x48, 0x67, 0x66, 0x50, 0x17, + 0x75, 0x76, 0x12, 0x75, 0x43, 0x81, 0x62, 0x40, 0x33, 0x43, 0x45, 0x38, 0x87, 0x21, 0x66, 0x14, + 0x70, 0x48, 0x41, 0x43, 0x14, 0x66, 0x58, 0x78, 0x45, 0x82, 0x02, 0x25, 0x45, 0x73, 0x15, 0x21, + 0x32, 0x03, 0x02, 0x48, 0x80, 0x80, 0x13, 0x71, 0x25, 0x54, 0x32, 0x72, 0x05, 0x68, 0x65, 0x24, + 0x68, 0x04, 0x06, 0x16, 0x83, 0x50, 0x54, 0x53, 0x37, 0x37, 0x27, 0x22, 0x20, 0x68, 0x08, 0x25, + 0x50, 0x84, 0x72, 0x86, 0x74, 0x22, 0x36, 0x16, 0x80, 0x07, 0x55, 0x18, 0x12, 0x17, 0x84, 0x44, + 0x81, 0x15, 0x64, 0x50, 0x71, 0x10, 0x58, 0x15, 0x51, 0x10, 0x10, 0x47, 0x16, 0x21, 0x07, 0x58, + 0x61, 0x18, 0x78, 0x00, 0x52, 0x72, 0x64, 0x52, 0x17, 0x43, 0x23, 0x40, 0x76, 0x48, 0x67, 0x30, + 0x77, 0x63, 0x64, 0x87, 0x51, 0x31, 0x63, 0x84, 0x68, 0x74, 0x53, 0x63, 0x84, 0x23, 0x54, 0x66, + 0x10, 0x48, 0x36, 0x33, 0x85, 0x21, 0x48, 0x42, 0x03, 0x82, 0x51, 0x10, 0x33, 0x57, 0x46, 0x80, + 0x16, 0x43, 0x34, 0x02, 0x07, 0x03, 0x53, 0x22, 0x12, 0x75, 0x73, 0x34, 0x65, 0x83, 0x33, 0x87, + 0x43, 0x85, 0x17, 0x50, 0x36, 0x60, 0x88, 0x02, 0x58, 0x75, 0x80, 0x88, 0x31, 0x63, 0x60, 0x18, + 0x21, 0x32, 0x26, 0x15, 0x68, 0x74, 0x11, 0x10, 0x33, 0x14, 0x13, 0x05, 0x34, 0x16, 0x72, 0x65, + 0x35, 0x50, 0x13, 0x34, 0x80, 0x87, 0x10, 0x26, 0x48, 0x68, 0x84, 0x52, 0x71, 0x44, 0x23, 0x58, + 0x80, 0x35, 0x57, 0x70, 0x54, 0x84, 0x28, 0x70, 0x55, 0x88, 0x86, 0x83, 0x86, 0x25, 0x21, 0x82, + 0x72, 0x61, 0x17, 0x78, 0x85, 0x17, 0x67, 0x73, 0x00, 0x57, 0x71, 0x11, 0x78, 0x51, 0x10, 0x65, + 0x63, 0x57, 0x02, 0x87, 0x40, 0x13, 0x40, 0x01, 0x26, 0x53, 0x45, 0x12, 0x05, 0x46, 0x75, 0x18, + 0x80, 0x70, 0x33, 0x35, 0x66, 0x22, 0x62, 0x00, 0x70, 0x23, 0x26, 0x87, 0x72, 0x63, 0x11, 0x13, + 0x33, 0x33, 0x81, 0x41, 0x70, 0x62, 0x28, 0x61, 0x51, 0x47, 0x31, 0x30, 0x25, 0x46, 0x51, 0x17, + 0x61, 0x58, 0x07, 0x41, 0x61, 0x37, 0x37, 0x06, 0x14, 0x00, 0x54, 0x88, 0x77, 0x75, 0x67, 0x77, + 0x66, 0x53, 0x16, 0x72, 0x66, 0x66, 0x88, 0x76, 0x43, 0x58, 0x31, 0x04, 0x87, 0x57, 0x06, 0x76, + 0x47, 0x00, 0x43, 0x63, 0x58, 0x60, 0x52, 0x03, 0x44, 0x27, 0x36, 0x48, 0x61, 0x23, 0x72, 0x16, + 0x10, 0x62, 0x42, 0x08, 0x60, 0x83, 0x23, 0x54, 0x03, 0x55, 0x55, 0x73, 0x00, 0x61, 0x03, 0x65, + 0x34, 0x27, 0x14, 0x15, 0x86, 0x62, 0x55, 0x80, 0x16, 0x53, 0x10, 0x18, 0x26, 0x11, 0x35, 0x46, + 0x82, 0x46, 0x13, 0x25, 0x83, 0x47, 0x70, 0x50, 0x06, 0x01, 0x56, 0x02, 0x11, 0x68, 0x54, 0x53, + 0x03, 0x68, 0x73, 0x36, 0x41, 0x88, 0x86, 0x33, 0x42, 0x52, 0x01, 0x58, 0x33, 0x42, 0x32, 0x88, + 0x56, 0x81, 0x77, 0x55, 0x51, 0x48, 0x48, 0x12, 0x01, 0x58, 0x13, 0x85, 0x04, 0x14, 0x71, 0x83, + 0x57, 0x07, 0x54, 0x55, 0x54, 0x55, 0x28, 0x27, 0x31, 0x36, 0x02, 0x12, 0x32, 0x68, 0x32, 0x13, + 0x82, 0x58, 0x70, 0x28, 0x58, 0x53, 0x44, 0x86, 0x72, 0x73, 0x42, 0x84, 0x18, 0x22, 0x08, 0x83, + 0x61, 0x02, 0x14, 0x16, 0x17, 0x12, 0x41, 0x57, 0x48, 0x85, 0x25, 0x10, 0x26, 0x07, 0x36, 0x76, + 0x12, 0x66, 0x17, 0x21, 0x32, 0x36, 0x03, 0x25, 0x41, 0x10, 0x11, 0x22, 0x66, 0x60, 0x16, 0x16, + 0x32, 0x64, 0x26, 0x05, 0x18, 0x63, 0x51, 0x58, 0x51, 0x31, 0x42, 0x53, 0x84, 0x56, 0x66, 0x27, + 0x83, 0x33, 0x54, 0x50, 0x76, 0x46, 0x50, 0x80, 0x25, 0x43, 0x41, 0x57, 0x35, 0x78, 0x25, 0x43, + 0x02, 0x82, 0x38, 0x47, 0x45, 0x70, 0x15, 0x67, 0x51, 0x77, 0x47, 0x80, 0x31, 0x52, 0x75, 0x00, + 0x00, 0x94, 0x7b, 0xca, 0x93, 0xc2, 0x7d, 0x58, 0x4e, 0x2c, 0x66, 0xea, 0xc9, 0xc7, 0x64, 0x0c, + 0x1c, 0xa2, 0x17, 0xee, 0xf6, 0x6d, 0xab, 0xbc, 0xb2, 0x60, 0xb4, 0xc3, 0x43, 0x00, 0xfa, 0x05, + 0x13, 0x57, 0x82, 0x0f, 0x57, 0x39, 0x25, 0x44, 0x98, 0x2f, 0xd1, 0x10, 0x57, 0xde, 0x23, 0x3e, + 0x6d, 0x2d, 0xd8, 0x49, 0x72, 0xa7, 0xe4, 0x7d, 0x4d, 0xba, 0x99, 0xbc, 0x30, 0xcf, 0x8f, 0x2a, + 0xd5, 0xa2, 0xc0, 0x24, 0x31, 0x95, 0xed, 0x27, 0x30, 0xff, 0xa9, 0x2d, 0x22, 0x7d, 0x15, 0x30, + 0x95, 0x97, 0x2d, 0x4b, 0x34, 0x47, 0xff, 0xac, 0x45, 0xa2, 0x3e, 0xb4, 0x1c, 0xbc, 0x87, 0xcd, + 0xd1, 0x25, 0x0a, 0x8a, 0x47, 0x8b, 0x0f, 0x7a, 0x1d, 0x5b, 0x39, 0xaa, 0x22, 0x06, 0xe4, 0x86, + 0x45, 0x58, 0x4f, 0xe7, 0xbf, 0x7a, 0x13, 0x16, 0x8f, 0x48, 0x27, 0x65, 0xe5, 0x7b, 0xb9, 0x24, + 0xac, 0x6d, 0x9a, 0x11, 0x36, 0x9f, 0x4a, 0x6a, 0xff, 0xcd, 0x16, 0x9b, 0x7d, 0x75, 0x12, 0x9b, + 0x35, 0xd5, 0x13, 0x4a, 0x31, 0x76, 0x1b, 0xb8, 0x35, 0x5a, 0xee, 0xed, 0x27, 0xe2, 0x01, 0xa0, + 0x63, 0x13, 0x01, 0x3e, 0x30, 0x7a, 0x01, 0xa7, 0x3a, 0xea, 0x79, 0x55, 0xc0, 0x57, 0x8c, 0x8c, + 0x5e, 0x5a, 0x1a, 0x2d, 0x2f, 0xa4, 0x59, 0x3f, 0xac, 0xd9, 0x04, 0xc6, 0x20, 0x40, 0xbd, 0xb9, + 0xf3, 0x29, 0x93, 0x35, 0x36, 0xbf, 0x8d, 0x81, 0xc4, 0x25, 0x6b, 0xaa, 0xe8, 0x72, 0x3f, 0xd4, + 0xdc, 0x66, 0xbb, 0x5e, 0x7f, 0x9c, 0xa4, 0x90, 0x31, 0xa1, 0x93, 0xec, 0xec, 0xbb, 0x5d, 0xc3, + 0x90, 0xec, 0x6d, 0x55, 0x13, 0xc7, 0x9a, 0x05, 0x2b, 0x3f, 0xd4, 0x36, 0x12, 0xfb, 0x73, 0x75, + 0x31, 0x5d, 0x80, 0x91, 0xf7, 0x9b, 0xab, 0x13, 0x18, 0xf1, 0x78, 0x54, 0x56, 0x1b, 0xc9, 0x3a, + 0xe0, 0xe5, 0xcd, 0x6d, 0x13, 0x1e, 0x56, 0x2c, 0x81, 0x14, 0x81, 0x0c, 0x93, 0x9a, 0xe5, 0x63, + 0xaa, 0x10, 0xb4, 0x7c, 0xe4, 0x48, 0x43, 0x17, 0xf3, 0x4a, 0xbd, 0x02, 0xd0, 0xcc, 0xad, 0x58, + 0xdd, 0x29, 0xbc, 0xf6, 0x57, 0xbb, 0xd9, 0x25, 0x4b, 0x01, 0xca, 0x97, 0x26, 0x09, 0x19, 0x38, + 0xed, 0x32, 0x05, 0x4b, 0x37, 0xdd, 0x61, 0x72, 0x40, 0xf4, 0x43, 0x4c, 0x1a, 0x4a, 0x87, 0x11, + 0xaa, 0x3a, 0x39, 0x9a, 0x8a, 0x53, 0x88, 0x33, 0x0b, 0x70, 0x59, 0xec, 0xcb, 0xb6, 0xb1, 0xb9, + 0xcf, 0x71, 0x87, 0xad, 0xf1, 0x0b, 0x0c, 0x91, 0x71, 0xd3, 0xc0, 0xf6, 0xe2, 0xd4, 0x60, 0xa4, + 0x19, 0x24, 0x76, 0x72, 0xe3, 0xb9, 0xfe, 0xa2, 0xc9, 0x59, 0x10, 0xbf, 0x2f, 0xb6, 0xa5, 0xd6, + 0x1f, 0x25, 0x74, 0x53, 0xb0, 0x7a, 0xfb, 0x64, 0xb0, 0xba, 0x27, 0x58, 0xbc, 0xd7, 0x35, 0x75, + 0x1f, 0x2d, 0x53, 0x51, 0x5e, 0x23, 0x6f, 0xe8, 0xa5, 0xb4, 0x39, 0x3b, 0x80, 0xbf, 0x06, 0xdf, + 0x97, 0xbd, 0xc6, 0x38, 0x00, 0x87, 0xe6, 0xaa, 0x8d, 0xde, 0x6e, 0x09, 0x81, 0x11, 0xa7, 0x34, + 0x3f, 0xcd, 0xd1, 0xe9, 0x03, 0x70, 0x8e, 0x63, 0x7e, 0xbf, 0x28, 0x32, 0x3c, 0xda, 0x6b, 0x94, + 0x05, 0x81, 0x0e, 0xdc, 0xfb, 0x36, 0x91, 0x14, 0x9e, 0xcf, 0x22, 0x4c, 0x50, 0xf8, 0xdf, 0x92, + 0xa9, 0x4a, 0xa4, 0x77, 0x0a, 0x0e, 0x91, 0x46, 0x61, 0x94, 0xbb, 0x0e, 0x27, 0xbf, 0x1c, 0xab, + 0xf1, 0x6a, 0xdf, 0xd3, 0x51, 0x22, 0x00, 0x33, 0xf7, 0x6f, 0x59, 0x25, 0x55, 0x7b, 0xcf, 0x96, + 0x34, 0xe9, 0x46, 0x13, 0x59, 0x62, 0x1d, 0x80, 0xb4, 0xbb, 0xad, 0x7e, 0x2a, 0x6e, 0x43, 0x2d, + 0xc4, 0x3b, 0x12, 0x6c, 0xa4, 0x2a, 0xb8, 0x8a, 0xa8, 0x8f, 0x0a, 0x84, 0xaf, 0x58, 0x02, 0x9c, + 0x99, 0xa0, 0x24, 0x8f, 0x0c, 0x45, 0x40, 0x71, 0xf3, 0x5b, 0x83, 0x1f, 0xed, 0x12, 0x54, 0xd6, + 0xf4, 0xe2, 0x72, 0x04, 0x85, 0x78, 0x62, 0x15, 0xf7, 0xc7, 0xf0, 0xc4, 0xed, 0x15, 0xfa, 0x85, + 0x3c, 0xd3, 0xaa, 0x07, 0x25, 0x9b, 0x39, 0x24, 0x0a, 0x82, 0x13, 0x5c, 0x29, 0x23, 0xa7, 0x2b, + 0x87, 0x6f, 0xab, 0xb3, 0xf0, 0xf2, 0xc0, 0x96, 0x13, 0xde, 0x39, 0xd4, 0x59, 0xa0, 0x7c, 0x14, + 0xe7, 0xba, 0x43, 0x7d, 0x80, 0x41, 0x49, 0x1f, 0xce, 0xc1, 0x43, 0x34, 0x04, 0xba, 0xd1, 0xda, + 0x9e, 0xe9, 0x47, 0x1e, 0x17, 0xcb, 0x69, 0x1b, 0x2a, 0x35, 0x37, 0x10, 0xc9, 0xff, 0xa4, 0xe5, + 0x17, 0x81, 0x12, 0x02, 0x77, 0x64, 0xeb, 0x7d, 0xe8, 0x09, 0xc3, 0xe1, 0xf1, 0xfa, 0x41, 0x78, + 0xa5, 0xd4, 0xdc, 0x9e, 0xe2, 0x78, 0x57, 0xef, 0xf2, 0x6b, 0x91, 0x71, 0x1f, 0xc1, 0x44, 0xd5, + 0xa7, 0x75, 0xb8, 0xb5, 0x0d, 0x5d, 0xb9, 0x39, 0xba, 0x32, 0x07, 0x68, 0x0c, 0x24, 0x2f, 0xc8, + 0x21, 0x94, 0x7f, 0x93, 0x4c, 0x8d, 0xae, 0xe2, 0x03, 0x56, 0x3d, 0x28, 0x60, 0x6b, 0xe6, 0x24, + 0xa3, 0x29, 0x01, 0x93, 0x2d, 0xae, 0x85, 0x71, 0x2a, 0xf6, 0xc8, 0x01, 0x60, 0x26, 0x92, 0x7e, + 0x9b, 0x81, 0x29, 0x57, 0x4b, 0xe3, 0xcb, 0x1e, 0x95, 0x33, 0x2b, 0x05, 0x27, 0x07, 0xac, 0x8a, + 0xa8, 0xf4, 0x35, 0xe8, 0x8b, 0x7e, 0x56, 0x8d, 0x49, 0x87, 0xc6, 0xac, 0x0e, 0x90, 0x2b, 0x06, + 0x09, 0xa0, 0x2d, 0x91, 0xb3, 0xf5, 0xfd, 0x3f, 0xd9, 0x01, 0xdd, 0xd0, 0xdb, 0x98, 0x73, 0xbd, + 0x7c, 0x71, 0xed, 0x92, 0x1d, 0x45, 0x77, 0xa7, 0x8c, 0x4f, 0xcc, 0x9b, 0xf0, 0x75, 0x20, 0x3d, + 0x38, 0xf5, 0xe7, 0x6e, 0x74, 0xf2, 0x77, 0x48, 0x4e, 0x05, 0x7b, 0x61, 0x89, 0x00, 0x41, 0x31, + 0xb0, 0xc9, 0xb1, 0xa1, 0x55, 0x29, 0x4d, 0x1c, 0xd3, 0xd5, 0x20, 0x8e, 0x26, 0x69, 0x01, 0xd7, + 0xd3, 0x14, 0xfa, 0xcc, 0xe7, 0xe2, 0xaa, 0x58, 0x45, 0x83, 0xa1, 0x1e, 0x4d, 0x7c, 0x21, 0xb9, + 0x4a, 0x32, 0xe5, 0x08, 0xed, 0xdb, 0xbd, 0x7a, 0x65, 0xaa, 0x86, 0xb4, 0xfd, 0xfa, 0x6b, 0xc2, + 0x85, 0xd4, 0xcf, 0xf5, 0x39, 0x26, 0xc7, 0x17, 0x3f, 0xbe, 0x1f, 0x89, 0xcc, 0x30, 0x32, 0x34, + 0xb8, 0x78, 0xc6, 0xb8, 0x10, 0x1f, 0x58, 0xac, 0x8d, 0x3e, 0x5e, 0x1b, 0xf5, 0xab, 0x6b, 0x26, + 0x29, 0x7c, 0xc9, 0x7b, 0x95, 0x95, 0x4a, 0xab, 0xdb, 0x25, 0xbe, 0x00, 0x8a, 0x3f, 0x47, 0xe5, + 0x64, 0x87, 0xb0, 0x0d, 0x3d, 0xed, 0xa8, 0x90, 0xd9, 0x2c, 0x83, 0x95, 0x7f, 0xea, 0xc6, 0xb8, + 0x29, 0x1a, 0xf6, 0x59, 0x59, 0xe1, 0xd1, 0xfc, 0xa3, 0xbd, 0x19, 0x6e, 0x9f, 0xc9, 0xe6, 0x7e, + 0x06, 0x07, 0x09, 0x48, 0x22, 0xe5, 0xb4, 0x19, 0x1d, 0xb9, 0x68, 0x24, 0xb9, 0xf0, 0x3f, 0x2e, + 0xf5, 0x7f, 0x52, 0x38, 0xba, 0x7e, 0x1e, 0x84, 0xed, 0x55, 0xb7, 0xdf, 0xf3, 0xd6, 0xc2, 0xc1, + 0x27, 0x36, 0x92, 0xa9, 0xa1, 0x92, 0x72, 0x16, 0x61, 0x30, 0xdb, 0x89, 0xfc, 0x67, 0xdc, 0x94, + 0xdb, 0x61, 0x4e, 0x3e, 0x82, 0xba, 0x3a, 0x35, 0x12, 0xb0, 0x12, 0xd5, 0x1f, 0xb4, 0x86, 0xb5, + 0xa3, 0x15, 0x0b, 0x78, 0xe7, 0x24, 0xe2, 0xa1, 0x2d, 0xe0, 0x7d, 0x86, 0x71, 0xfb, 0xa2, 0xda, + 0x7f, 0xd5, 0xd1, 0x47, 0x20, 0x8f, 0xc3, 0xaf, 0x65, 0x3e, 0x65, 0x20, 0xfc, 0x40, 0x87, 0x1a, + 0xf2, 0x17, 0x7e, 0x65, 0xcb, 0xd0, 0xea, 0xf3, 0x04, 0x21, 0x7b, 0x36, 0x7a, 0x66, 0x5f, 0x22, + 0x4c, 0xae, 0xdf, 0xe9, 0x30, 0x06, 0xac, 0x1e, 0x14, 0xbc, 0xd6, 0x7a, 0x88, 0xd1, 0x71, 0xf3, + 0xd8, 0xf3, 0xe3, 0x58, 0xa7, 0x19, 0x26, 0xba, 0x3e, 0x5c, 0x23, 0x9a, 0x53, 0x12, 0x63, 0xec, + 0x94, 0x37, 0xbf, 0x2a, 0x03, 0x3b, 0x8b, 0x55, 0xb2, 0xc0, 0xcb, 0x6e, 0x7e, 0x97, 0x31, 0x6e, + 0x22, 0xdf, 0x77, 0xca, 0xd9, 0x10, 0xd2, 0x0e, 0xec, 0xe1, 0xc5, 0x09, 0x10, 0xa5, 0xcc, 0x32, + 0xad, 0xab, 0x09, 0x37, 0x75, 0x50, 0xf9, 0x2d, 0x5b, 0xb1, 0xf4, 0xc0, 0x7f, 0x4a, 0x28, 0x22, + 0x33, 0x8e, 0x2c, 0xff, 0x53, 0x48, 0xdf, 0x77, 0xcf, 0x8e, 0xf8, 0xe6, 0x65, 0x7d, 0xed, 0x1e, + 0x0c, 0xe0, 0x58, 0xe3, 0xcc, 0xfb, 0xf3, 0x9b, 0x3f, 0x16, 0x6e, 0x30, 0x3d, 0x33, 0xc3, 0x55, + 0x6c, 0x9a, 0xc8, 0xec, 0xb3, 0xdf, 0x7c, 0x74, 0xab, 0x36, 0xd0, 0xf2, 0x79, 0x44, 0x41, 0xba, + 0x98, 0x08, 0x82, 0x7b, 0x57, 0x8f, 0xb5, 0xc2, 0x9e, 0x49, 0x4e, 0x21, 0x53, 0x9a, 0xd3, 0xab, + 0x2b, 0x41, 0xbf, 0x16, 0x1d, 0x7f, 0x69, 0x58, 0x9d, 0x45, 0x24, 0xc5, 0x4c, 0x89, 0xb4, 0x86, + 0xf7, 0x5d, 0x25, 0x2f, 0x54, 0x1c, 0xc6, 0x3b, 0x9e, 0x70, 0x6d, 0x64, 0xa1, 0x28, 0x9a, 0x23, + 0x06, 0xc5, 0x95, 0x36, 0x3c, 0xb6, 0xfb, 0xef, 0x0a, 0x1b, 0x5b, 0x17, 0xab, 0x5b, 0x17, 0x94, + 0xbf, 0x27, 0x03, 0x6f, 0x64, 0xea, 0xf0, 0xbd, 0x43, 0x0d, 0xd5, 0x8d, 0x80, 0x01, 0x0c, 0xcd, + 0xad, 0xa4, 0xa5, 0xa3, 0xa1, 0xe4, 0x1a, 0x6f, 0xbf, 0x12, 0x9d, 0x73, 0x77, 0x9a, 0x37, 0xae, + 0x5c, 0x8d, 0x68, 0x41, 0xa9, 0x99, 0x3c, 0x51, 0xe3, 0x64, 0xe0, 0x4f, 0xac, 0x8e, 0x25, 0xa4, + 0xe6, 0x87, 0x2f, 0x6c, 0x86, 0x0f, 0xa2, 0x65, 0xc1, 0xc4, 0x42, 0x6a, 0xd9, 0xc2, 0x1d, 0x26, + 0xda, 0x8c, 0x27, 0x85, 0x46, 0xad, 0xcd, 0x83, 0x1f, 0x2b, 0x8b, 0x26, 0xd4, 0xe1, 0xf6, 0x70, + 0x62, 0x3d, 0x95, 0xc8, 0x36, 0x2d, 0xa6, 0x62, 0xd1, 0xff, 0x0a, 0xb6, 0x87, 0x50, 0x3f, 0x32, + 0x8d, 0xe0, 0x95, 0x81, 0x0e, 0xde, 0x12, 0xb4, 0x9e, 0xad, 0x15, 0x33, 0x51, 0x95, 0x58, 0xc1, + 0xe9, 0x40, 0xb4, 0x6e, 0x4e, 0xdb, 0x02, 0x7b, 0xe9, 0xda, 0x20, 0x39, 0xb2, 0x5d, 0xcf, 0x73, + 0x57, 0xe1, 0x9e, 0x54, 0x16, 0xae, 0x26, 0x8c, 0x14, 0xfb, 0x3a, 0x8b, 0xab, 0xcb, 0x3d, 0x23, + 0xf7, 0x0c, 0xc9, 0xd5, 0x96, 0x81, 0xc5, 0xd8, 0x33, 0xac, 0x22, 0xe6, 0x53, 0xd8, 0x6e, 0x22, + 0xce, 0x82, 0x25, 0x40, 0x75, 0x5d, 0x8d, 0x24, 0x3c, 0x15, 0x21, 0x3d, 0x07, 0x6c, 0x6b, 0x26, + 0x43, 0x6d, 0xdc, 0x07, 0xc7, 0xe0, 0x01, 0x34, 0x7b, 0x0c, 0xb8, 0x78, 0x3d, 0xfe, 0xfe, 0xdf, + 0x27, 0x5f, 0xec, 0x47, 0x92, 0x68, 0x67, 0x34, 0x00, 0x7f, 0x0f, 0xf8, 0x54, 0x08, 0x11, 0xc2, + 0xaf, 0xe6, 0xca, 0x15, 0x14, 0x20, 0x53, 0x2f, 0xa5, 0x52, 0x6a, 0x10, 0x74, 0xc3, 0xd7, 0x89, + 0xf2, 0x93, 0x2d, 0xe4, 0x2e, 0x3a, 0xcf, 0xbf, 0x94, 0x76, 0x0f, 0x42, 0x6d, 0x96, 0xcf, 0x03, + 0x3f, 0xa4, 0x9e, 0x2f, 0x45, 0x8f, 0x9a, 0x9c, 0x2e, 0x71, 0xda, 0xcf, 0xe0, 0x09, 0xdd, 0x9c, + 0x3f, 0x3c, 0x8a, 0xb3, 0x28, 0x2d, 0x6f, 0x38, 0x3b, 0x98, 0x1c, 0x82, 0xd6, 0x36, 0x4f, 0x0e, + 0x4b, 0xdb, 0x2a, 0xf6, 0xa9, 0x5b, 0xa6, 0x1f, 0x47, 0x41, 0x50, 0xca, 0xd7, 0x23, 0x3f, 0x89, + 0x03, 0xdf, 0x97, 0x2d, 0xbb, 0x03, 0x28, 0xc0, 0xcb, 0x9d, 0x0c, 0xcb, 0xef, 0x88, 0x3d, 0x2e, + 0x6a, 0xdd, 0x18, 0x0e, 0xca, 0x1b, 0x66, 0x2f, 0xc1, 0xd2, 0xdb, 0xbd, 0xdb, 0x36, 0x34, 0x21, + 0x9e, 0x1e, 0xff, 0x38, 0xb1, 0xe5, 0x28, 0x75, 0x35, 0x6c, 0x03, 0xea, 0xde, 0x94, 0x20, 0x55, + 0xf4, 0x83, 0x50, 0x4b, 0xbb, 0xcb, 0x43, 0x02, 0xa4, 0x17, 0xcf, 0x6d, 0x32, 0x8e, 0xd7, 0x93, + 0xb1, 0xa3, 0xc0, 0x96, 0x9b, 0x7b, 0x34, 0x18, 0xf5, 0x0a, 0xb3, 0x9f, 0x83, 0xc5, 0x66, 0x6c, + 0x90, 0xe3, 0x83, 0x56, 0xf7, 0xf9, 0xd4, 0x94, 0xa6, 0xdc, 0xb6, 0x3d, 0x67, 0xc3, 0x4e, 0x3d, + 0x14, 0xa4, 0xe1, 0x55, 0x96, 0x49, 0x79, 0x26, 0xc8, 0x56, 0x8d, 0x8e, 0xc3, 0xdb, 0xd9, 0xc2, + 0xe8, 0x2c, 0x38, 0x5b, 0xcf, 0xb8, 0xd9, 0x67, 0x48, 0x63, 0xbd, 0x4f, 0xbf, 0x17, 0x57, 0xdb, + 0x44, 0x7b, 0xf8, 0x04, 0xae, 0x95, 0x01, 0x47, 0xc9, 0x1f, 0xbf, 0x9a, 0xa1, 0x78, 0x91, 0x04, + 0x4c, 0xca, 0xa7, 0x3b, 0x45, 0x52, 0x85, 0x97, 0x46, 0x2c, 0xed, 0x75, 0x1d, 0x01, 0x5e, 0xbb, + 0xa9, 0xe2, 0xb7, 0xcd, 0xcb, 0xe6, 0xdc, 0x05, 0xaa, 0x9e, 0xae, 0x0c, 0x86, 0x84, 0x8a, 0x34, + 0x75, 0xbb, 0x1c, 0x57, 0x44, 0xf5, 0x90, 0x3e, 0xe4, 0xa8, 0x42, 0xa4, 0x69, 0xcc, 0x18, 0x12, + 0x71, 0xf2, 0x45, 0xad, 0x70, 0xd0, 0x2a, 0x48, 0x37, 0x86, 0x3b, 0x29, 0x6b, 0x4a, 0xdb, 0x4e, + 0x8d, 0x03, 0xd8, 0x2b, 0x64, 0xaa, 0x11, 0xdd, 0x31, 0xcd, 0xf2, 0x1e, 0xdf, 0x1d, 0xfe, 0x32, + 0x76, 0xc4, 0xdb, 0xc8, 0x77, 0xe3, 0x5b, 0x15, 0xfb, 0x28, 0x35, 0xec, 0x3a, 0x1c, 0x45, 0x31, + 0x68, 0xa3, 0x8c, 0xa8, 0xe5, 0x63, 0xcf, 0x3e, 0x9a, 0x00, 0x73, 0x6c, 0xd5, 0xcf, 0xbd, 0x28, + 0x41, 0xd1, 0x0f, 0x94, 0xad, 0x55, 0x79, 0x9c, 0x29, 0x27, 0xe5, 0x46, 0x1b, 0x28, 0xba, 0xc5, + 0x17, 0x4d, 0x0c, 0xe3, 0xf8, 0xf7, 0xcd, 0x76, 0x09, 0xfb, 0xc8, 0xda, 0x0c, 0x38, 0xcc, 0x21, + 0x69, 0x5c, 0xed, 0xad, 0x12, 0xf8, 0xd2, 0xe6, 0x49, 0x51, 0xa8, 0x99, 0x6e, 0x51, 0x0d, 0x6d, + 0x52, 0x79, 0x7c, 0x5b, 0xa0, 0xeb, 0x4a, 0xfa, 0x6b, 0xf2, 0xcc, 0x43, 0xda, 0x09, 0xde, 0x31, + 0x79, 0xe8, 0x99, 0xbd, 0x71, 0x88, 0xb3, 0x2a, 0x98, 0xa4, 0x99, 0xd3, 0x72, 0xf3, 0x70, 0x7c, + 0xed, 0x47, 0x9b, 0x09, 0x81, 0xcb, 0x50, 0xc0, 0xc0, 0x53, 0x9c, 0xf7, 0xe3, 0x10, 0x0b, 0x72, + 0x0e, 0x46, 0x66, 0x52, 0xa4, 0xf4, 0x99, 0xc2, 0xba, 0x3a, 0x17, 0xf5, 0x23, 0x22, 0x68, 0x73, + 0x0b, 0x96, 0x2b, 0xc5, 0x72, 0xc0, 0xde, 0x96, 0xe8, 0xc9, 0xe2, 0x8f, 0x7e, 0x35, 0x32, 0xc2, + 0x22, 0x41, 0x96, 0xaa, 0x9e, 0x27, 0x68, 0x8d, 0xd0, 0x50, 0xd7, 0xcb, 0x78, 0x54, 0xfb, 0x3c, + 0x35, 0xf9, 0xc6, 0x2e, 0xfb, 0x10, 0xda, 0x84, 0x83, 0x3f, 0x29, 0xbb, 0x1b, 0xe5, 0xef, 0x3b, + 0x53, 0x36, 0x38, 0xee, 0xf7, 0x43, 0xd8, 0x11, 0x9d, 0xdc, 0x29, 0x0b, 0xdf, 0x08, 0xb6, 0xf0, + 0xf9, 0xe4, 0xe1, 0xe1, 0x34, 0x46, 0xc5, 0x3e, 0xd6, 0x98, 0x05, 0xda, 0x26, 0x90, 0x8a, 0x15, + 0xdf, 0x1c, 0x48, 0xe0, 0x09, 0xec, 0x12, 0x53, 0xbd, 0x5a, 0x58, 0x98, 0xeb, 0xb5, 0x12, 0x1c, + 0xc2, 0x49, 0x04, 0xc8, 0xb1, 0x0e, 0x24, 0xe6, 0x80, 0xe5, 0x65, 0x98, 0x50, 0x76, 0xfd, 0xa1, + 0x1d, 0x13, 0xff, 0xdf, 0xa4, 0xdb, 0x28, 0xac, 0x9f, 0x0a, 0xea, 0x2f, 0x81, 0xfd, 0x7e, 0xd4, + 0xdc, 0xa8, 0xd3, 0xb2, 0xe3, 0x84, 0x8b, 0x4d, 0x60, 0x46, 0xf6, 0xe0, 0xde, 0x3a, 0x4f, 0x68, + 0x3f, 0x25, 0xe0, 0x60, 0x5e, 0x84, 0xb3, 0x6f, 0x48, 0x3c, 0x40, 0x4e, 0xf8, 0x99, 0xcb, 0x3f, + 0xcc, 0xbe, 0x8c, 0xb2, 0xa6, 0xf0, 0xa7, 0xe1, 0x0b, 0x19, 0x48, 0xcd, 0x4f, 0x93, 0xf1, 0x81, + 0x55, 0x5f, 0x66, 0x1d, 0x31, 0xd4, 0x26, 0x80, 0x8b, 0xbf, 0x9f, 0x66, 0xfd, 0x60, 0xd6, 0x49, + 0x26, 0x9c, 0xa3, 0xfe, 0x99, 0x1b, 0x22, 0x42, 0x8c, 0x37, 0xad, 0x2a, 0x08, 0x68, 0x0f, 0x74, + 0x7c, 0xc0, 0x36, 0x0c, 0xcd, 0x37, 0x3d, 0xc6, 0xa9, 0xf4, 0x3a, 0x66, 0x47, 0x0e, 0x01, 0x4e, + 0x72, 0xb3, 0xd8, 0xc3, 0x8e, 0x02, 0x04, 0x42, 0xd8, 0xaa, 0xb9, 0x74, 0xe6, 0x04, 0x93, 0x74, + 0x14, 0x5b, 0x04, 0xcb, 0x7f, 0x30, 0x44, 0xaa, 0xc1, 0xef, 0xda, 0xb2, 0xa1, 0x8b, 0xb4, 0x64, + 0xd4, 0xf2, 0xf2, 0xd8, 0x14, 0x39, 0x74, 0xc9, 0x5e, 0xee, 0x85, 0x6d, 0x59, 0xec, 0x00, 0x28, + 0x8e, 0xd4, 0x3f, 0xf5, 0xcc, 0x88, 0x03, 0x00, 0x6c, 0x99, 0x55, 0x14, 0xa2, 0xcc, 0x9c, 0xa6, + 0x22, 0xb6, 0x1b, 0xcd, 0x75, 0xec, 0x51, 0xc2, 0x02, 0xa9, 0x17, 0x10, 0x5b, 0x4a, 0x4b, 0xed, + 0x1b, 0x80, 0x14, 0x68, 0x31, 0xdc, 0xed, 0x07, 0xef, 0xd2, 0xed, 0x25, 0x73, 0x9f, 0x54, 0x09, + 0x69, 0x11, 0xb1, 0x50, 0xd3, 0x07, 0x7c, 0xcd, 0x73, 0x1a, 0x03, 0x61, 0x68, 0x27, 0x25, 0xd5, + 0x38, 0x03, 0xf8, 0xfc, 0xea, 0xa8, 0x39, 0x19, 0x29, 0x1e, 0xdb, 0x44, 0x93, 0xec, 0x84, 0xcc, + 0xe1, 0xd0, 0xf8, 0x2a, 0x67, 0x92, 0x36, 0xea, 0xd1, 0x00, 0x2a, 0xe8, 0x01, 0x8c, 0xac, 0x9f, + 0xdb, 0xd2, 0x46, 0xff, 0x09, 0x3d, 0x80, 0x3c, 0x0d, 0xe3, 0x32, 0x6a, 0x57, 0x90, 0x7b, 0x0d, + 0xd6, 0xb0, 0x1d, 0x08, 0x14, 0x58, 0xc7, 0x57, 0x28, 0xc6, 0x00, 0x82, 0x99, 0x28, 0x89, 0x0a, + 0x56, 0xaa, 0xaf, 0xef, 0xcf, 0x74, 0x23, 0xb7, 0x0a, 0x6d, 0x86, 0xb4, 0x15, 0xb8, 0x35, 0x8d, + 0xd0, 0x44, 0xab, 0xee, 0x00, 0xb9, 0xc9, 0x79, 0x5f, 0xc8, 0xf6, 0x1a, 0x64, 0x68, 0x6d, 0xf5, + 0xf8, 0x76, 0xa8, 0xf3, 0x30, 0x61, 0x59, 0x9a, 0xe8, 0x30, 0xf7, 0xeb, 0x4c, 0x4b, 0xff, 0x87, + 0x5f, 0x4a, 0x93, 0x6c, 0x40, 0x3c, 0x5d, 0x16, 0x0d, 0xe5, 0xd3, 0x3c, 0xae, 0xe4, 0x0f, 0xb7, + 0x18, 0xdd, 0xa4, 0x47, 0x8a, 0xc6, 0xf5, 0x1c, 0x59, 0xc2, 0x15, 0x52, 0x54, 0xbd, 0x77, 0x67, + 0x11, 0x18, 0x41, 0x1e, 0x26, 0x09, 0xd0, 0x00, 0x30, 0x6f, 0xc9, 0x50, 0x70, 0x04, 0xa3, 0x1e, + 0x89, 0x57, 0xea, 0x40, 0xc2, 0x56, 0x4b, 0x83, 0xc3, 0xab, 0xb7, 0x1a, 0x87, 0xc1, 0x1b, 0xd1, + 0x8d, 0x78, 0x91, 0xc4, 0x49, 0xdb, 0xbe, 0x79, 0xb4, 0xa4, 0xfb, 0x04, 0x83, 0x07, 0xce, 0x0e, + 0x81, 0x2b, 0x2c, 0x68, 0xec, 0xab, 0x77, 0xfd, 0x11, 0x11, 0x52, 0x6a, 0xb0, 0x81, 0x73, 0x06, + 0xce, 0xbc, 0xb0, 0x49, 0x7c, 0x55, 0x24, 0x31, 0xce, 0x15, 0xe4, 0xab, 0x52, 0x28, 0x3f, 0x67, + 0x94, 0x80, 0xd6, 0x9d, 0xdd, 0xe1, 0xf2, 0x57, 0x9c, 0xfd, 0xbe, 0x0b, 0xca, 0x95, 0xfc, 0x5b, + 0x2d, 0xb0, 0xc5, 0xcc, 0x76, 0xa3, 0x19, 0x50, 0xf5, 0x11, 0x6a, 0xae, 0x5f, 0x02, 0xd4, 0x67, + 0x10, 0xe4, 0x25, 0x7a, 0x75, 0xfd, 0xed, 0xf2, 0xf4, 0x7c, 0xe3, 0x7c, 0x20, 0x3e, 0x7f, 0x24, + 0xd3, 0xc9, 0x17, 0x97, 0x13, 0xc5, 0xd8, 0x07, 0xc2, 0x96, 0x14, 0x9a, 0x75, 0xcc, 0xb4, 0x44, + 0xf0, 0xc6, 0xf6, 0xab, 0xdd, 0x2d, 0xbb, 0x29, 0x85, 0xfe, 0x26, 0x74, 0x82, 0x85, 0x8a, 0x1e, +}; +static const uint8_t ml_dsa_65_1_keygen_seed[] = { + 0x4b, 0x4b, 0x71, 0xc5, 0xa1, 0xbc, 0x10, 0x74, 0xf2, 0x16, 0x7a, 0x1d, 0x68, 0x72, 0x9c, 0xdb, + 0x9e, 0x16, 0xab, 0xa3, 0x65, 0x1f, 0xf0, 0x2a, 0x0a, 0x0f, 0x4c, 0x88, 0x3c, 0xaa, 0xc8, 0x27, +}; +static const uint8_t ml_dsa_65_1_keygen_pub[] = { + 0xf8, 0xd4, 0x94, 0x5a, 0x92, 0xce, 0x46, 0xdd, 0x24, 0xd7, 0x51, 0xda, 0x02, 0xf0, 0x68, 0x48, + 0x2c, 0x69, 0xb0, 0xdb, 0xf0, 0x50, 0x16, 0x34, 0xc4, 0xa2, 0x47, 0xe1, 0xec, 0xf9, 0x8b, 0x27, + 0x04, 0x74, 0xc8, 0x1a, 0xa0, 0xd8, 0xf4, 0x5c, 0x0e, 0x8b, 0x5d, 0x02, 0x75, 0x1e, 0x79, 0x7d, + 0x10, 0x19, 0x04, 0x58, 0x67, 0x82, 0xea, 0x09, 0xf4, 0xe3, 0xa5, 0x67, 0xc2, 0xbf, 0x51, 0x46, + 0xdf, 0xbe, 0x76, 0x6b, 0xcf, 0x8d, 0x0e, 0x4e, 0xf4, 0x60, 0x16, 0xc6, 0xed, 0x7b, 0x16, 0x74, + 0x90, 0xfd, 0x2f, 0x8e, 0x9c, 0x53, 0xcb, 0x42, 0x66, 0x03, 0x31, 0xb1, 0xb6, 0x28, 0x10, 0xd2, + 0x14, 0x77, 0xf5, 0xc9, 0x30, 0x1d, 0x6d, 0x05, 0x4f, 0xb0, 0x76, 0xe7, 0x7f, 0x35, 0xc1, 0x94, + 0x2a, 0xae, 0x87, 0x46, 0x69, 0xe0, 0x95, 0x7a, 0x03, 0x12, 0x23, 0x86, 0x1e, 0xb5, 0x63, 0xad, + 0x72, 0x37, 0x81, 0x10, 0x55, 0x67, 0x44, 0x5b, 0x54, 0x22, 0xb1, 0x79, 0xe4, 0x82, 0x8a, 0x43, + 0x06, 0x07, 0x9c, 0x4d, 0x42, 0xb7, 0x93, 0xa1, 0x35, 0x8b, 0x05, 0xd0, 0x2d, 0x45, 0x65, 0xe4, + 0xaf, 0xa2, 0xd1, 0xcd, 0x32, 0xb6, 0xe7, 0xa4, 0x22, 0x4d, 0x3a, 0x86, 0xe8, 0xab, 0x79, 0xe1, + 0xdc, 0x33, 0xa1, 0x1d, 0x99, 0x41, 0x16, 0x36, 0xf9, 0x39, 0xc3, 0xad, 0x0d, 0x39, 0x35, 0x1c, + 0xd0, 0x57, 0xfc, 0x6b, 0xdb, 0x32, 0xec, 0xa7, 0x42, 0x7c, 0xa0, 0x84, 0x2f, 0x70, 0xb4, 0x16, + 0xdb, 0x14, 0x51, 0x87, 0x96, 0xf6, 0x8c, 0x66, 0xe3, 0xcd, 0x04, 0x72, 0x0d, 0xa0, 0x2b, 0x32, + 0xa3, 0x43, 0x0e, 0x0e, 0x02, 0x7f, 0x48, 0x97, 0x46, 0x02, 0xeb, 0xaa, 0xed, 0x0f, 0x1f, 0xb5, + 0x76, 0x3a, 0x91, 0x4c, 0xd6, 0xdb, 0x7c, 0x4e, 0xcd, 0xfb, 0xe0, 0x76, 0xb0, 0x34, 0x8d, 0xa1, + 0xae, 0x1f, 0x67, 0xc6, 0x3e, 0xac, 0xa5, 0xdd, 0x8c, 0x27, 0xad, 0x54, 0x90, 0x07, 0x79, 0x95, + 0x22, 0x39, 0x53, 0x9d, 0xfe, 0xa2, 0x2b, 0xe7, 0x0d, 0x54, 0x66, 0x1b, 0xfd, 0x97, 0x3d, 0x13, + 0x42, 0xf7, 0x1f, 0x6a, 0x97, 0xce, 0x79, 0x8e, 0xff, 0xf8, 0x52, 0xfd, 0x78, 0x9d, 0xa5, 0x6c, + 0x86, 0x7c, 0x1f, 0xd2, 0x31, 0x7c, 0x81, 0x74, 0xca, 0x0e, 0x07, 0x87, 0xde, 0x99, 0xf7, 0x7d, + 0x26, 0x46, 0x55, 0xa3, 0x6b, 0x1d, 0x85, 0x89, 0xb4, 0xc4, 0xc1, 0x74, 0x3e, 0x74, 0x2c, 0x31, + 0xad, 0x19, 0x53, 0x9c, 0xbf, 0x83, 0x66, 0xec, 0x18, 0x8d, 0xd6, 0x06, 0x39, 0x2d, 0x72, 0x7a, + 0x53, 0xc3, 0xbc, 0x41, 0x11, 0xce, 0x2c, 0xd3, 0x30, 0xfa, 0x0e, 0x48, 0x4f, 0x19, 0x32, 0x4a, + 0xa5, 0xfd, 0x57, 0x7d, 0xbb, 0x05, 0x5a, 0x3b, 0xa6, 0xf2, 0xe9, 0x64, 0x37, 0x1c, 0x0d, 0x4b, + 0x91, 0x50, 0xe4, 0xeb, 0x91, 0x55, 0xdb, 0x87, 0x1b, 0x6a, 0x3f, 0x32, 0x1d, 0xb2, 0xb3, 0xeb, + 0x9e, 0x67, 0x9a, 0xdc, 0xa6, 0x2e, 0xa6, 0xf7, 0xdb, 0x5c, 0x44, 0x71, 0xf4, 0x70, 0xd4, 0x2d, + 0x6c, 0x16, 0x1c, 0xc1, 0xa4, 0x38, 0x70, 0xe7, 0xbf, 0x84, 0x5c, 0xfa, 0x69, 0x6d, 0x71, 0x62, + 0x9c, 0x21, 0xd5, 0x3a, 0x4d, 0xe2, 0x2a, 0xe7, 0x3c, 0x39, 0x83, 0x72, 0x22, 0x07, 0x7a, 0xbd, + 0x8a, 0x1a, 0xfd, 0xfa, 0xb6, 0xb4, 0xdc, 0x5a, 0x2d, 0x68, 0xba, 0xf6, 0xec, 0x95, 0x62, 0x1b, + 0xaf, 0xe7, 0x25, 0x70, 0x71, 0xa6, 0x2f, 0x07, 0x84, 0x81, 0x80, 0xfe, 0x4b, 0xdc, 0x29, 0xce, + 0x7c, 0xaf, 0x29, 0x11, 0x56, 0x4b, 0xe1, 0xdb, 0x7d, 0xa4, 0x5e, 0xe5, 0x88, 0x52, 0xd0, 0x45, + 0x74, 0x56, 0xd1, 0x99, 0x79, 0xce, 0x66, 0xf3, 0x82, 0x1c, 0x30, 0x53, 0x99, 0x65, 0xe4, 0xc3, + 0xa1, 0x69, 0x1d, 0xcb, 0xb4, 0xad, 0x0e, 0x7a, 0xa1, 0x33, 0x18, 0x5d, 0x24, 0x86, 0x86, 0x0d, + 0x4a, 0x5f, 0xbd, 0x26, 0x05, 0x85, 0x24, 0x17, 0x72, 0xb5, 0x97, 0x6e, 0xb4, 0x49, 0xa7, 0x24, + 0x94, 0x63, 0x7d, 0xb5, 0x9c, 0xef, 0x54, 0x56, 0x7f, 0x7f, 0xed, 0x5b, 0x0e, 0xd6, 0x18, 0xc9, + 0x52, 0x7c, 0x28, 0xc3, 0x8b, 0xa3, 0x62, 0x62, 0x1c, 0xce, 0xda, 0x11, 0xa0, 0x0d, 0xeb, 0xb8, + 0x24, 0xd3, 0x1c, 0x7d, 0x5b, 0x35, 0x99, 0x07, 0x7b, 0x9f, 0xf7, 0x36, 0xc3, 0x24, 0x5f, 0x1f, + 0x3d, 0xcc, 0xa6, 0xd8, 0xd7, 0x4b, 0xa9, 0x6b, 0x19, 0x5b, 0x51, 0xcd, 0xc1, 0xc6, 0x8e, 0x29, + 0xe5, 0xea, 0xd5, 0x9c, 0xda, 0xdf, 0x5a, 0x05, 0xb9, 0x24, 0xb2, 0xa7, 0x90, 0xf8, 0x0c, 0xfd, + 0x8b, 0x8b, 0x17, 0xae, 0x1f, 0xad, 0x36, 0xad, 0xfd, 0x77, 0xb0, 0x78, 0xc5, 0xa5, 0x35, 0xa5, + 0x29, 0x36, 0x96, 0xc7, 0x25, 0x9a, 0xb0, 0x30, 0x5c, 0x58, 0x9b, 0x29, 0x86, 0xb6, 0xa8, 0x41, + 0xf2, 0x1c, 0xf8, 0x68, 0x6d, 0x6b, 0x18, 0x6e, 0xa5, 0x38, 0xc2, 0x9c, 0x76, 0x54, 0xa6, 0xad, + 0x74, 0xda, 0xed, 0xce, 0x94, 0x36, 0x27, 0xbf, 0x5d, 0x49, 0x7c, 0xd7, 0x61, 0x1d, 0xdd, 0x90, + 0x0e, 0xfe, 0xbe, 0x11, 0xf9, 0xe6, 0x11, 0xf4, 0x16, 0xb0, 0x69, 0x4b, 0x62, 0x1d, 0x4e, 0xe7, + 0x41, 0xcf, 0x21, 0x75, 0x9c, 0x92, 0xba, 0x8b, 0xfa, 0xc9, 0x0e, 0xd9, 0xd2, 0x74, 0xa9, 0xee, + 0xd5, 0x97, 0x74, 0xca, 0xbd, 0xe5, 0x32, 0xd7, 0x64, 0x4d, 0x04, 0x8b, 0x83, 0xca, 0x97, 0xbf, + 0xda, 0xef, 0x30, 0xf0, 0xb2, 0x40, 0x0a, 0x1b, 0xb6, 0x47, 0xc7, 0xbc, 0x9e, 0x60, 0xf5, 0x74, + 0x51, 0x91, 0x5a, 0x0b, 0x53, 0x1e, 0x29, 0xd2, 0x1c, 0x20, 0x07, 0xaa, 0xec, 0x52, 0x2f, 0x41, + 0x29, 0xa7, 0xc2, 0x51, 0xd7, 0xff, 0xfa, 0xb2, 0x0b, 0xcd, 0x5b, 0x05, 0x63, 0xed, 0x78, 0x81, + 0x4a, 0x3b, 0x20, 0x47, 0xa3, 0x75, 0xdd, 0x9a, 0x91, 0x9a, 0x3e, 0x8f, 0xaa, 0x0e, 0xdf, 0xf6, + 0x3e, 0x03, 0x07, 0xec, 0x9c, 0xd1, 0x4f, 0xab, 0x37, 0x2e, 0x96, 0x53, 0x24, 0xcb, 0xf5, 0x41, + 0xd9, 0x9e, 0xb4, 0x98, 0xcd, 0x09, 0x3b, 0x18, 0x8b, 0x1c, 0xb7, 0x9d, 0xd6, 0xad, 0xac, 0xc1, + 0xc9, 0xe3, 0x06, 0x48, 0x3b, 0xe7, 0x0c, 0x1b, 0xdd, 0xd1, 0xf6, 0x7b, 0x0b, 0x86, 0xda, 0xf8, + 0xfd, 0x90, 0x5f, 0x7b, 0xb6, 0x23, 0x91, 0x38, 0xa7, 0x33, 0x00, 0xc5, 0x8e, 0xe3, 0x0b, 0x6d, + 0x48, 0x24, 0x48, 0x03, 0xa5, 0xff, 0xa9, 0x93, 0x6b, 0x0a, 0x06, 0xb1, 0x6e, 0xeb, 0x2a, 0x88, + 0x0f, 0xf2, 0xfb, 0xdd, 0xa1, 0xa0, 0x81, 0x30, 0x06, 0xc9, 0x6e, 0xd0, 0xb6, 0xa3, 0x0b, 0x5d, + 0x10, 0x52, 0x8c, 0xf5, 0xaf, 0xd4, 0x5b, 0xea, 0xa8, 0x23, 0x69, 0xbd, 0x82, 0x54, 0xa1, 0xa7, + 0x25, 0x00, 0x48, 0x25, 0x2e, 0xee, 0xa5, 0x23, 0xdc, 0xec, 0x9f, 0xff, 0x06, 0x90, 0x06, 0xb2, + 0xf9, 0xa8, 0x65, 0x31, 0x03, 0xd4, 0x7e, 0xcf, 0x79, 0xbd, 0xad, 0x25, 0x72, 0xa1, 0x18, 0x71, + 0xc0, 0x18, 0x64, 0x65, 0x05, 0x16, 0x48, 0x37, 0xdc, 0xf9, 0x1c, 0x2e, 0x22, 0xcc, 0x55, 0xb3, + 0x44, 0x99, 0x0b, 0xdf, 0xf2, 0xd5, 0x03, 0x63, 0xfe, 0x34, 0xa1, 0x9c, 0x5c, 0xb4, 0x6c, 0xf0, + 0xc1, 0x93, 0x17, 0x52, 0x48, 0xec, 0x50, 0x97, 0x8f, 0x2c, 0xee, 0x4e, 0x83, 0xed, 0x2b, 0x7b, + 0xbf, 0xde, 0x44, 0x71, 0x85, 0x90, 0x17, 0xd3, 0x41, 0x8c, 0xf3, 0xd3, 0x82, 0x2b, 0xcc, 0xea, + 0x6b, 0x8d, 0x30, 0xcf, 0x11, 0xff, 0x00, 0x85, 0x69, 0xd9, 0xf0, 0xbf, 0x46, 0x2c, 0xe6, 0xd7, + 0x3f, 0x8c, 0x11, 0x9e, 0x3d, 0x3a, 0xb3, 0x0a, 0x68, 0xd4, 0x67, 0xcc, 0x60, 0xa9, 0x07, 0x66, + 0x1f, 0xa1, 0xdd, 0x47, 0xff, 0x39, 0x77, 0x84, 0x7b, 0xe3, 0x8a, 0xba, 0xdd, 0x7d, 0x4b, 0x4e, + 0x1b, 0x12, 0x7e, 0xaa, 0x13, 0x1b, 0xf3, 0xb0, 0xb1, 0xfa, 0xfc, 0x57, 0x16, 0x5b, 0x69, 0xa4, + 0x85, 0x00, 0x75, 0x3b, 0x9d, 0xc1, 0x41, 0xb9, 0x81, 0x9c, 0xcd, 0x9b, 0x4c, 0xac, 0xfb, 0xdf, + 0xe4, 0xe0, 0x5c, 0xa5, 0xcd, 0xfe, 0xa9, 0x12, 0x60, 0x2c, 0xff, 0x1e, 0xe0, 0x4f, 0xd2, 0x91, + 0x47, 0x80, 0xe7, 0x13, 0x17, 0x6a, 0xb4, 0x38, 0x3f, 0x3c, 0xed, 0xaf, 0x2c, 0x0b, 0x5e, 0x6b, + 0x64, 0x0d, 0x3b, 0x59, 0x05, 0xec, 0x8e, 0xa9, 0x63, 0x0b, 0xd3, 0x67, 0x2a, 0x18, 0x13, 0x57, + 0x01, 0xe4, 0x14, 0x06, 0x27, 0xe9, 0x8f, 0x1b, 0xdc, 0x78, 0xb0, 0x5d, 0x9f, 0x22, 0x24, 0xc5, + 0x9a, 0xb3, 0x95, 0x1a, 0x06, 0x53, 0xe6, 0x72, 0x9b, 0x7b, 0x4b, 0xb0, 0x03, 0x5f, 0xc9, 0x64, + 0xc1, 0x50, 0x86, 0xfc, 0xe0, 0xc6, 0xad, 0x85, 0x15, 0x5b, 0x94, 0x0c, 0x1a, 0xa1, 0x34, 0x28, + 0xf1, 0xe6, 0xc2, 0x0f, 0xf9, 0x56, 0x61, 0xd2, 0x83, 0xf2, 0xab, 0xe3, 0xd4, 0x3c, 0x07, 0x2b, + 0x16, 0x9d, 0x68, 0xc7, 0x40, 0xe6, 0x7e, 0x3c, 0xd9, 0xd4, 0x4d, 0x80, 0xbb, 0xf1, 0xd4, 0x55, + 0x20, 0x4d, 0x3b, 0x56, 0xf0, 0x6d, 0x9c, 0xd2, 0x66, 0xa2, 0xa9, 0x28, 0xc9, 0x18, 0xf7, 0x37, + 0xa9, 0xe4, 0x75, 0xbe, 0x20, 0xf2, 0x6d, 0x97, 0xa3, 0xc0, 0xb7, 0x19, 0x4d, 0x60, 0x43, 0xca, + 0xbc, 0xb8, 0xbd, 0x14, 0xbb, 0x4b, 0xfa, 0x94, 0xd1, 0x3c, 0x0d, 0x9b, 0xdd, 0x4e, 0x6b, 0x06, + 0x2d, 0x46, 0x85, 0xd2, 0x2f, 0x3d, 0xd7, 0xa2, 0xea, 0x64, 0xfa, 0xb5, 0x3a, 0x0e, 0x06, 0xe0, + 0xe4, 0x25, 0xfd, 0x48, 0x7e, 0x33, 0x3a, 0xc6, 0x66, 0x90, 0x17, 0x49, 0x2a, 0xc4, 0x5f, 0xbb, + 0x9e, 0x23, 0x13, 0xf6, 0xbc, 0xbc, 0x6e, 0x48, 0x4a, 0x59, 0x65, 0xe9, 0x41, 0x2f, 0xab, 0xad, + 0x6a, 0x6f, 0xd0, 0x36, 0x75, 0xce, 0x1c, 0x70, 0x15, 0x8b, 0x33, 0xe1, 0x7c, 0xd1, 0x8f, 0xb4, + 0x43, 0x92, 0xf0, 0x67, 0x53, 0xd5, 0x65, 0xfb, 0xab, 0x2d, 0x4c, 0xb0, 0x9a, 0x85, 0xed, 0xc2, + 0x0c, 0x9c, 0x12, 0x27, 0x65, 0x57, 0xb0, 0x3d, 0xc4, 0x1b, 0x70, 0x42, 0xa0, 0xd7, 0xfc, 0xb5, + 0xd2, 0x36, 0xbe, 0xc4, 0xb9, 0x07, 0xf6, 0xfc, 0xfa, 0xc6, 0x2c, 0x3a, 0x07, 0xbd, 0x92, 0xea, + 0x85, 0x74, 0x0f, 0x1a, 0x50, 0x15, 0x91, 0xfb, 0x8d, 0x93, 0x0a, 0x52, 0x7f, 0xca, 0xca, 0x42, + 0x7a, 0x61, 0x25, 0x6f, 0x65, 0x91, 0xdc, 0x1f, 0x3c, 0xba, 0xf1, 0x9c, 0xf3, 0xf9, 0xb5, 0xab, + 0x5a, 0xae, 0xc9, 0x7a, 0x95, 0xbd, 0x5d, 0x90, 0x56, 0xf5, 0xe4, 0x63, 0xbd, 0x86, 0xee, 0x03, + 0xd1, 0xcd, 0x5a, 0x14, 0x31, 0x2d, 0xcc, 0xc3, 0x34, 0x59, 0x58, 0xde, 0x85, 0x48, 0x8d, 0x1d, + 0xb2, 0xc5, 0x4d, 0x33, 0x93, 0xb8, 0xbb, 0xf9, 0x0c, 0x14, 0x11, 0xa9, 0xa8, 0xb3, 0xbc, 0xf9, + 0xa1, 0x33, 0x05, 0xfc, 0x5a, 0xf5, 0x28, 0x18, 0xfc, 0xc4, 0x03, 0x9d, 0x5c, 0x8c, 0x6e, 0xd8, + 0x7d, 0x8c, 0x01, 0xa0, 0x89, 0x98, 0x2e, 0xcb, 0x6f, 0xeb, 0x7a, 0xd0, 0x9a, 0x79, 0x60, 0x3a, + 0xce, 0xed, 0x01, 0xcf, 0x45, 0x3b, 0x46, 0x20, 0xcd, 0x36, 0xe7, 0x3b, 0x76, 0xb9, 0x19, 0x24, + 0xd9, 0xbe, 0x97, 0x3c, 0x8b, 0xa8, 0xb5, 0xb3, 0x60, 0x99, 0x8a, 0x18, 0x2f, 0x9a, 0x4f, 0xef, + 0x55, 0x63, 0xa0, 0xc5, 0x50, 0x5b, 0x18, 0x11, 0x07, 0x23, 0xa2, 0x68, 0xca, 0x45, 0x43, 0x03, + 0x99, 0x79, 0x23, 0x1f, 0xb0, 0x82, 0xa6, 0x39, 0x65, 0x8b, 0x9f, 0x54, 0x68, 0xe1, 0xbd, 0x16, + 0xf9, 0x6a, 0x15, 0x8e, 0x0f, 0x39, 0xa1, 0x60, 0x10, 0x9a, 0x7c, 0xf2, 0x44, 0xca, 0xd1, 0x77, + 0xb2, 0xb1, 0xf4, 0x18, 0x06, 0x27, 0x92, 0x96, 0xe7, 0xd6, 0x62, 0x24, 0x25, 0xb7, 0x5a, 0x13, + 0x20, 0xe7, 0xe3, 0xce, 0xb2, 0xde, 0xbd, 0x1f, 0x73, 0x9b, 0x29, 0xa8, 0xa3, 0xbe, 0xf2, 0x3d, + 0x5d, 0xd2, 0x71, 0x2a, 0x82, 0xe3, 0x20, 0x45, 0x0a, 0xac, 0xd8, 0xe9, 0xee, 0xe7, 0x8a, 0x7d, + 0x01, 0x9a, 0xa0, 0x9e, 0x42, 0xcd, 0x99, 0x23, 0x70, 0x20, 0x86, 0x82, 0x93, 0x08, 0xad, 0xf0, + 0x9c, 0x0d, 0x0a, 0x88, 0xb5, 0x8b, 0x2f, 0x7c, 0x45, 0x34, 0xf7, 0x56, 0x31, 0xaf, 0x1a, 0x5b, + 0x0b, 0x68, 0x55, 0x2f, 0x40, 0x24, 0x81, 0xf9, 0xa9, 0x6b, 0x6a, 0x6a, 0x0a, 0x14, 0xe9, 0x3e, + 0x27, 0x72, 0xec, 0x72, 0xd2, 0x86, 0xaa, 0xf2, 0xcc, 0x9e, 0xc6, 0x45, 0x0e, 0x80, 0xf4, 0x26, + 0x73, 0xa2, 0xdf, 0xd2, 0x5c, 0x0e, 0x0d, 0x58, 0x31, 0xda, 0x8a, 0xbd, 0x63, 0x19, 0x66, 0xdc, + 0x06, 0x88, 0xc3, 0x8d, 0x60, 0x2a, 0xaf, 0xe8, 0xbb, 0xab, 0x8f, 0xf5, 0xfb, 0x90, 0x03, 0xbf, + 0xe2, 0xe4, 0x5a, 0x74, 0xa1, 0x26, 0x15, 0x98, 0xaf, 0x63, 0x4f, 0x89, 0x6c, 0xd8, 0xf4, 0xc0, + 0x4c, 0x5f, 0xaa, 0x64, 0x42, 0xa7, 0x88, 0x12, 0x1c, 0xe8, 0x16, 0x3a, 0x08, 0x5b, 0x4e, 0x66, + 0x30, 0x8f, 0xf5, 0x72, 0xcf, 0x00, 0x5e, 0x96, 0x0c, 0x8a, 0x21, 0xa8, 0x25, 0x52, 0xae, 0x6d, + 0xd1, 0xad, 0xdf, 0xe0, 0x8c, 0xa3, 0x7b, 0x82, 0xdf, 0xff, 0x78, 0x26, 0x09, 0xf0, 0x3d, 0xc1, + 0x6e, 0x0b, 0x86, 0x23, 0x98, 0xc9, 0xfa, 0x09, 0xdf, 0xa4, 0xd3, 0x55, 0x10, 0xf4, 0xba, 0x7e, + 0x77, 0xc0, 0x23, 0x3c, 0xf9, 0x23, 0xe4, 0x79, 0x2f, 0xad, 0x9c, 0x5d, 0x7a, 0x05, 0xfa, 0x17, + 0x44, 0x38, 0x53, 0x77, 0x40, 0xec, 0x82, 0x2b, 0x26, 0x70, 0xbf, 0x1f, 0x24, 0x42, 0x80, 0xa5, + 0xa7, 0x08, 0x0b, 0x21, 0xce, 0xd5, 0x64, 0x6f, 0x50, 0x77, 0xcb, 0x39, 0xf2, 0x35, 0x55, 0xa1, + 0x12, 0xfa, 0x1e, 0x14, 0x58, 0xbc, 0x45, 0xc4, 0x91, 0xd5, 0x09, 0x2b, 0x76, 0x3a, 0xb7, 0xd2, + 0x91, 0xb8, 0xc0, 0x7b, 0xbe, 0xa2, 0xe3, 0x99, 0x82, 0xca, 0x19, 0xdf, 0xf6, 0xe4, 0xee, 0xf1, + 0x75, 0x57, 0xe8, 0xef, 0x10, 0x1d, 0x80, 0x8f, 0xfb, 0x6e, 0xd7, 0x3d, 0xae, 0xce, 0xb7, 0x7c, + 0x4c, 0xfa, 0x2e, 0x39, 0x1c, 0xea, 0x50, 0xf1, 0xa7, 0x58, 0x01, 0xc2, 0xd3, 0x44, 0x07, 0xaa, + 0xac, 0x4b, 0x51, 0x38, 0xb4, 0x63, 0x2a, 0x71, 0x0a, 0x40, 0xf3, 0x9b, 0xa7, 0xed, 0x36, 0x45, + 0x4e, 0x0b, 0x05, 0x4e, 0x00, 0xba, 0xfc, 0x02, 0x7d, 0x01, 0x30, 0x32, 0x73, 0xdd, 0x22, 0x89, + 0xe7, 0x66, 0x6d, 0x98, 0xc3, 0xb6, 0x02, 0xcf, 0xad, 0x31, 0xb7, 0x68, 0x0e, 0x6b, 0x15, 0x72, +}; + +static const uint8_t ml_dsa_65_1_keygen_priv[] = { + 0xf8, 0xd4, 0x94, 0x5a, 0x92, 0xce, 0x46, 0xdd, 0x24, 0xd7, 0x51, 0xda, 0x02, 0xf0, 0x68, 0x48, + 0x2c, 0x69, 0xb0, 0xdb, 0xf0, 0x50, 0x16, 0x34, 0xc4, 0xa2, 0x47, 0xe1, 0xec, 0xf9, 0x8b, 0x27, + 0xb8, 0x70, 0x45, 0x29, 0x48, 0xd3, 0xfd, 0x91, 0xdf, 0xab, 0xba, 0x18, 0x4b, 0x77, 0x78, 0xe2, + 0x22, 0x3c, 0x61, 0x01, 0x96, 0x91, 0x8c, 0x5a, 0xc4, 0x71, 0xff, 0xe2, 0x7c, 0x45, 0xc2, 0x16, + 0x90, 0x6a, 0x32, 0xe4, 0x21, 0xba, 0x0c, 0x8e, 0xb4, 0x3b, 0xde, 0x77, 0x4c, 0x81, 0x51, 0x02, + 0x0b, 0xb3, 0x3e, 0x6d, 0xd3, 0xcc, 0xb6, 0x7e, 0x07, 0xff, 0x15, 0x08, 0xa5, 0x91, 0xc4, 0x0f, + 0x29, 0xc4, 0xf4, 0xe0, 0x3c, 0x07, 0x61, 0xda, 0xfa, 0xa6, 0xc4, 0xe4, 0xd7, 0x51, 0x5d, 0x3d, + 0x04, 0x4f, 0x7e, 0x5d, 0x9b, 0x6f, 0x76, 0xc3, 0x52, 0x3f, 0x07, 0xb8, 0x6b, 0x96, 0x6b, 0xc2, + 0x05, 0x02, 0x73, 0x65, 0x41, 0x31, 0x57, 0x20, 0x50, 0x23, 0x25, 0x40, 0x26, 0x55, 0x01, 0x41, + 0x03, 0x21, 0x12, 0x18, 0x24, 0x02, 0x77, 0x83, 0x50, 0x86, 0x50, 0x55, 0x07, 0x41, 0x84, 0x52, + 0x27, 0x67, 0x52, 0x05, 0x14, 0x07, 0x64, 0x77, 0x20, 0x06, 0x80, 0x72, 0x38, 0x70, 0x11, 0x50, + 0x67, 0x23, 0x63, 0x52, 0x23, 0x80, 0x82, 0x31, 0x86, 0x77, 0x54, 0x85, 0x34, 0x61, 0x22, 0x74, + 0x12, 0x32, 0x10, 0x18, 0x46, 0x04, 0x47, 0x62, 0x03, 0x40, 0x61, 0x34, 0x65, 0x08, 0x84, 0x68, + 0x56, 0x00, 0x45, 0x08, 0x21, 0x75, 0x31, 0x84, 0x75, 0x06, 0x55, 0x34, 0x22, 0x27, 0x00, 0x03, + 0x46, 0x50, 0x01, 0x31, 0x88, 0x43, 0x36, 0x65, 0x70, 0x72, 0x23, 0x41, 0x25, 0x66, 0x76, 0x41, + 0x27, 0x10, 0x34, 0x57, 0x62, 0x50, 0x34, 0x42, 0x76, 0x61, 0x48, 0x80, 0x20, 0x31, 0x70, 0x00, + 0x65, 0x83, 0x86, 0x65, 0x81, 0x01, 0x55, 0x80, 0x21, 0x23, 0x52, 0x64, 0x25, 0x44, 0x34, 0x77, + 0x78, 0x02, 0x25, 0x51, 0x76, 0x86, 0x66, 0x86, 0x27, 0x38, 0x57, 0x32, 0x83, 0x83, 0x74, 0x18, + 0x38, 0x30, 0x57, 0x83, 0x28, 0x43, 0x08, 0x75, 0x07, 0x57, 0x38, 0x80, 0x60, 0x06, 0x05, 0x72, + 0x15, 0x37, 0x22, 0x37, 0x25, 0x53, 0x30, 0x20, 0x66, 0x45, 0x68, 0x62, 0x06, 0x53, 0x20, 0x07, + 0x40, 0x24, 0x36, 0x18, 0x77, 0x30, 0x43, 0x15, 0x25, 0x46, 0x58, 0x67, 0x64, 0x78, 0x25, 0x81, + 0x15, 0x54, 0x78, 0x66, 0x47, 0x04, 0x31, 0x04, 0x37, 0x55, 0x40, 0x06, 0x34, 0x72, 0x86, 0x84, + 0x67, 0x52, 0x11, 0x38, 0x44, 0x45, 0x06, 0x85, 0x58, 0x40, 0x85, 0x06, 0x22, 0x07, 0x27, 0x45, + 0x15, 0x66, 0x52, 0x88, 0x37, 0x30, 0x43, 0x87, 0x34, 0x30, 0x57, 0x32, 0x52, 0x47, 0x37, 0x38, + 0x70, 0x63, 0x01, 0x47, 0x05, 0x03, 0x64, 0x41, 0x13, 0x36, 0x15, 0x60, 0x45, 0x18, 0x40, 0x88, + 0x15, 0x12, 0x21, 0x31, 0x12, 0x52, 0x02, 0x50, 0x48, 0x10, 0x26, 0x71, 0x82, 0x17, 0x05, 0x14, + 0x21, 0x88, 0x11, 0x00, 0x20, 0x85, 0x20, 0x12, 0x54, 0x83, 0x81, 0x56, 0x82, 0x02, 0x01, 0x08, + 0x85, 0x84, 0x84, 0x72, 0x14, 0x34, 0x67, 0x53, 0x73, 0x58, 0x87, 0x36, 0x17, 0x87, 0x36, 0x87, + 0x23, 0x38, 0x56, 0x80, 0x27, 0x48, 0x80, 0x67, 0x57, 0x16, 0x07, 0x30, 0x83, 0x46, 0x88, 0x58, + 0x75, 0x40, 0x24, 0x78, 0x14, 0x41, 0x46, 0x04, 0x51, 0x71, 0x86, 0x21, 0x65, 0x07, 0x64, 0x07, + 0x24, 0x70, 0x87, 0x64, 0x30, 0x01, 0x85, 0x40, 0x46, 0x33, 0x14, 0x03, 0x76, 0x53, 0x04, 0x32, + 0x60, 0x25, 0x44, 0x03, 0x33, 0x40, 0x13, 0x42, 0x05, 0x54, 0x37, 0x67, 0x41, 0x65, 0x15, 0x26, + 0x88, 0x73, 0x84, 0x36, 0x72, 0x32, 0x43, 0x77, 0x72, 0x87, 0x25, 0x71, 0x23, 0x64, 0x32, 0x84, + 0x61, 0x13, 0x15, 0x88, 0x44, 0x04, 0x84, 0x02, 0x44, 0x80, 0x26, 0x23, 0x44, 0x43, 0x44, 0x63, + 0x56, 0x63, 0x16, 0x55, 0x62, 0x45, 0x71, 0x08, 0x45, 0x04, 0x43, 0x71, 0x48, 0x13, 0x50, 0x30, + 0x30, 0x53, 0x35, 0x56, 0x36, 0x16, 0x21, 0x70, 0x56, 0x07, 0x56, 0x30, 0x60, 0x58, 0x30, 0x23, + 0x34, 0x20, 0x55, 0x26, 0x28, 0x43, 0x23, 0x73, 0x44, 0x25, 0x80, 0x10, 0x52, 0x68, 0x44, 0x21, + 0x88, 0x60, 0x66, 0x64, 0x00, 0x56, 0x88, 0x15, 0x35, 0x73, 0x26, 0x15, 0x74, 0x40, 0x42, 0x73, + 0x25, 0x11, 0x12, 0x70, 0x13, 0x74, 0x30, 0x03, 0x15, 0x71, 0x54, 0x27, 0x42, 0x55, 0x57, 0x36, + 0x57, 0x23, 0x03, 0x67, 0x07, 0x71, 0x33, 0x33, 0x15, 0x45, 0x01, 0x23, 0x85, 0x58, 0x57, 0x55, + 0x28, 0x57, 0x71, 0x80, 0x34, 0x55, 0x82, 0x23, 0x42, 0x04, 0x44, 0x40, 0x27, 0x51, 0x10, 0x78, + 0x61, 0x12, 0x30, 0x84, 0x23, 0x18, 0x43, 0x46, 0x76, 0x75, 0x65, 0x13, 0x32, 0x84, 0x16, 0x87, + 0x17, 0x28, 0x30, 0x26, 0x30, 0x72, 0x77, 0x67, 0x22, 0x16, 0x15, 0x18, 0x87, 0x78, 0x42, 0x07, + 0x05, 0x14, 0x87, 0x60, 0x28, 0x20, 0x06, 0x01, 0x54, 0x20, 0x34, 0x08, 0x13, 0x65, 0x35, 0x80, + 0x17, 0x26, 0x68, 0x16, 0x20, 0x25, 0x54, 0x30, 0x61, 0x25, 0x77, 0x14, 0x60, 0x70, 0x56, 0x88, + 0x65, 0x27, 0x83, 0x82, 0x53, 0x46, 0x37, 0x75, 0x28, 0x65, 0x57, 0x46, 0x78, 0x74, 0x30, 0x23, + 0x85, 0x54, 0x11, 0x75, 0x16, 0x38, 0x73, 0x12, 0x54, 0x03, 0x13, 0x68, 0x83, 0x12, 0x30, 0x24, + 0x78, 0x26, 0x44, 0x05, 0x60, 0x05, 0x77, 0x64, 0x54, 0x05, 0x04, 0x50, 0x46, 0x38, 0x56, 0x45, + 0x82, 0x31, 0x03, 0x02, 0x66, 0x77, 0x32, 0x38, 0x56, 0x18, 0x83, 0x24, 0x53, 0x73, 0x72, 0x58, + 0x05, 0x36, 0x23, 0x58, 0x23, 0x68, 0x61, 0x88, 0x65, 0x58, 0x04, 0x80, 0x54, 0x37, 0x35, 0x17, + 0x00, 0x61, 0x53, 0x72, 0x32, 0x63, 0x35, 0x28, 0x05, 0x78, 0x46, 0x12, 0x74, 0x77, 0x66, 0x87, + 0x25, 0x28, 0x55, 0x15, 0x15, 0x67, 0x54, 0x67, 0x32, 0x08, 0x36, 0x13, 0x32, 0x13, 0x78, 0x55, + 0x58, 0x66, 0x28, 0x42, 0x16, 0x47, 0x80, 0x50, 0x71, 0x24, 0x01, 0x07, 0x80, 0x70, 0x53, 0x82, + 0x73, 0x18, 0x65, 0x32, 0x22, 0x61, 0x67, 0x16, 0x58, 0x56, 0x32, 0x51, 0x82, 0x06, 0x25, 0x60, + 0x54, 0x86, 0x72, 0x71, 0x54, 0x22, 0x26, 0x32, 0x33, 0x18, 0x45, 0x37, 0x17, 0x80, 0x37, 0x71, + 0x10, 0x62, 0x04, 0x06, 0x31, 0x68, 0x68, 0x74, 0x55, 0x34, 0x21, 0x16, 0x05, 0x05, 0x36, 0x84, + 0x66, 0x20, 0x67, 0x16, 0x47, 0x82, 0x27, 0x25, 0x00, 0x35, 0x53, 0x38, 0x03, 0x15, 0x85, 0x23, + 0x28, 0x41, 0x45, 0x71, 0x66, 0x28, 0x85, 0x21, 0x40, 0x31, 0x04, 0x85, 0x48, 0x78, 0x43, 0x72, + 0x65, 0x65, 0x42, 0x62, 0x37, 0x38, 0x37, 0x26, 0x82, 0x81, 0x56, 0x07, 0x86, 0x01, 0x27, 0x04, + 0x58, 0x82, 0x54, 0x04, 0x36, 0x17, 0x73, 0x26, 0x75, 0x62, 0x20, 0x47, 0x06, 0x23, 0x53, 0x06, + 0x61, 0x04, 0x01, 0x66, 0x02, 0x75, 0x57, 0x04, 0x57, 0x86, 0x77, 0x26, 0x03, 0x76, 0x63, 0x60, + 0x82, 0x63, 0x25, 0x26, 0x50, 0x60, 0x57, 0x17, 0x38, 0x16, 0x36, 0x18, 0x68, 0x25, 0x33, 0x48, + 0x16, 0x81, 0x71, 0x75, 0x51, 0x51, 0x06, 0x28, 0x23, 0x52, 0x20, 0x66, 0x02, 0x04, 0x18, 0x81, + 0x86, 0x32, 0x30, 0x75, 0x13, 0x54, 0x28, 0x04, 0x24, 0x35, 0x56, 0x31, 0x70, 0x63, 0x76, 0x58, + 0x22, 0x86, 0x80, 0x38, 0x46, 0x85, 0x06, 0x61, 0x34, 0x48, 0x54, 0x30, 0x36, 0x82, 0x02, 0x31, + 0x73, 0x01, 0x06, 0x21, 0x23, 0x47, 0x48, 0x52, 0x34, 0x36, 0x78, 0x84, 0x82, 0x86, 0x16, 0x82, + 0x70, 0x33, 0x35, 0x71, 0x21, 0x85, 0x08, 0x32, 0x05, 0x03, 0x60, 0x84, 0x87, 0x47, 0x86, 0x51, + 0x16, 0x70, 0x83, 0x34, 0x32, 0x54, 0x78, 0x11, 0x47, 0x64, 0x06, 0x45, 0x45, 0x88, 0x25, 0x30, + 0x23, 0x55, 0x17, 0x78, 0x41, 0x01, 0x37, 0x81, 0x58, 0x28, 0x03, 0x87, 0x66, 0x82, 0x00, 0x42, + 0x41, 0x53, 0x03, 0x87, 0x57, 0x45, 0x36, 0x62, 0x56, 0x48, 0x68, 0x56, 0x14, 0x01, 0x62, 0x20, + 0x05, 0x84, 0x14, 0x26, 0x33, 0x84, 0x28, 0x32, 0x68, 0x45, 0x85, 0x38, 0x13, 0x75, 0x21, 0x50, + 0x20, 0x56, 0x47, 0x04, 0x87, 0x31, 0x76, 0x83, 0x16, 0x11, 0x41, 0x71, 0x43, 0x20, 0x31, 0x21, + 0x05, 0x30, 0x17, 0x64, 0x05, 0x30, 0x86, 0x26, 0x21, 0x23, 0x15, 0x62, 0x58, 0x77, 0x62, 0x24, + 0x10, 0x61, 0x71, 0x44, 0x85, 0x73, 0x21, 0x07, 0x53, 0x01, 0x35, 0x15, 0x44, 0x46, 0x26, 0x10, + 0x55, 0x30, 0x51, 0x24, 0x35, 0x43, 0x66, 0x75, 0x66, 0x67, 0x58, 0x65, 0x33, 0x50, 0x22, 0x13, + 0x13, 0x44, 0x83, 0x76, 0x46, 0x36, 0x37, 0x74, 0x33, 0x83, 0x58, 0x01, 0x70, 0x20, 0x82, 0x83, + 0x22, 0x81, 0x23, 0x01, 0x04, 0x26, 0x86, 0x50, 0x24, 0x14, 0x65, 0x32, 0x78, 0x86, 0x75, 0x36, + 0x67, 0x12, 0x46, 0x03, 0x38, 0x25, 0x21, 0x17, 0x86, 0x35, 0x75, 0x50, 0x51, 0x75, 0x55, 0x87, + 0x04, 0x12, 0x32, 0x63, 0x45, 0x58, 0x51, 0x88, 0x45, 0x72, 0x10, 0x00, 0x03, 0x15, 0x51, 0x87, + 0x22, 0x27, 0x66, 0x43, 0x08, 0x51, 0x12, 0x00, 0x11, 0x62, 0x62, 0x46, 0x55, 0x52, 0x30, 0x63, + 0x65, 0x53, 0x20, 0x74, 0x18, 0x85, 0x06, 0x73, 0x01, 0x23, 0x45, 0x47, 0x66, 0x34, 0x82, 0x78, + 0x52, 0x73, 0x24, 0x28, 0x71, 0x86, 0x74, 0x33, 0x61, 0x03, 0x17, 0x83, 0x33, 0x14, 0x25, 0x73, + 0x58, 0x23, 0x81, 0x68, 0x03, 0x58, 0x70, 0x42, 0x14, 0x42, 0x23, 0x31, 0x73, 0x23, 0x47, 0x74, + 0x65, 0x28, 0x33, 0x58, 0x20, 0x72, 0x54, 0x00, 0x45, 0x14, 0x34, 0x52, 0x13, 0x52, 0x11, 0x45, + 0x04, 0x47, 0x28, 0x44, 0x05, 0x86, 0x55, 0x24, 0x30, 0x16, 0x78, 0x16, 0x85, 0x33, 0x00, 0x86, + 0x08, 0x55, 0x30, 0x68, 0x11, 0x00, 0x10, 0x40, 0x25, 0x10, 0x03, 0x12, 0x73, 0x46, 0x51, 0x12, + 0x25, 0x32, 0x37, 0x68, 0x67, 0x27, 0x62, 0x74, 0x77, 0x60, 0x86, 0x88, 0x36, 0x08, 0x60, 0x65, + 0x51, 0x75, 0x38, 0x21, 0x70, 0x83, 0x31, 0x04, 0x26, 0x70, 0x41, 0x77, 0x87, 0x53, 0x25, 0x81, + 0x83, 0x84, 0x67, 0x02, 0x84, 0x81, 0x55, 0x55, 0x27, 0x58, 0x18, 0x32, 0x13, 0x00, 0x35, 0x18, + 0x10, 0x20, 0x58, 0x82, 0x44, 0x68, 0x26, 0x77, 0x21, 0x17, 0x06, 0x70, 0x21, 0x10, 0x86, 0x38, + 0x33, 0x33, 0x61, 0x41, 0x67, 0x71, 0x78, 0x73, 0x62, 0x17, 0x34, 0x00, 0x02, 0x34, 0x47, 0x63, + 0x76, 0x13, 0x72, 0x05, 0x76, 0x30, 0x60, 0x64, 0x50, 0x15, 0x20, 0x07, 0x27, 0x73, 0x16, 0x56, + 0x54, 0x16, 0x67, 0x31, 0x25, 0x26, 0x12, 0x08, 0x35, 0x20, 0x63, 0x88, 0x55, 0x42, 0x40, 0x35, + 0x44, 0x87, 0x38, 0x77, 0x61, 0x20, 0x08, 0x58, 0x28, 0x05, 0x06, 0x66, 0x48, 0x05, 0x02, 0x68, + 0x10, 0x15, 0x78, 0x22, 0x73, 0x35, 0x23, 0x02, 0x05, 0x74, 0x25, 0x18, 0x31, 0x87, 0x26, 0x46, + 0x60, 0x46, 0x16, 0x36, 0x57, 0x70, 0x71, 0x26, 0x18, 0x80, 0x43, 0x37, 0x56, 0x71, 0x05, 0x78, + 0x1a, 0xa2, 0xbb, 0xe6, 0x8a, 0xee, 0x92, 0xff, 0xd1, 0xbe, 0x88, 0xd0, 0x1d, 0xd9, 0x0e, 0xbc, + 0x8d, 0x1a, 0x9f, 0x5d, 0xa6, 0x5f, 0xb4, 0x82, 0xfa, 0x23, 0xe9, 0x2a, 0x0b, 0xff, 0xab, 0x24, + 0x16, 0x63, 0x79, 0x56, 0xb1, 0xa4, 0xf7, 0xd0, 0xe3, 0x92, 0xb9, 0x10, 0x71, 0x00, 0x69, 0xfd, + 0x0e, 0x18, 0xeb, 0x26, 0xe6, 0xca, 0x74, 0x1e, 0xd0, 0x91, 0x5f, 0xc9, 0xfc, 0xe0, 0xc0, 0xeb, + 0xcc, 0xa4, 0x5c, 0x7b, 0xe2, 0x46, 0x49, 0x82, 0x9b, 0x0a, 0xc3, 0xa4, 0x3c, 0x4c, 0xc2, 0xe4, + 0xcc, 0xec, 0xc8, 0x27, 0xfd, 0x31, 0x91, 0x51, 0x5d, 0xf2, 0xa1, 0x20, 0x35, 0x93, 0x41, 0x57, + 0x7b, 0xaf, 0x0b, 0xc0, 0x5f, 0x83, 0x58, 0xd5, 0x18, 0xa5, 0x7e, 0xd3, 0x03, 0x3a, 0x73, 0xb8, + 0x23, 0x0e, 0x8b, 0x23, 0xf6, 0x27, 0xf6, 0x14, 0x5a, 0xfb, 0x0e, 0xd0, 0x74, 0x21, 0x46, 0xc6, + 0x1a, 0x21, 0xaa, 0x6c, 0xe4, 0x0a, 0xc7, 0x59, 0x28, 0xf0, 0x07, 0xf3, 0x9e, 0x26, 0x96, 0x38, + 0x3f, 0xa4, 0x8c, 0x75, 0x69, 0x4f, 0x10, 0x6e, 0x62, 0x3b, 0x6f, 0x41, 0xe0, 0x70, 0xd0, 0xe9, + 0x85, 0xe9, 0xd5, 0x42, 0xba, 0x2b, 0x5f, 0x53, 0xa4, 0x7b, 0x00, 0xcb, 0x64, 0x72, 0xf9, 0xd0, + 0x3c, 0x3d, 0xbd, 0xd1, 0xc1, 0x13, 0xb0, 0x81, 0x28, 0x10, 0x5f, 0x6f, 0xcb, 0x28, 0x1c, 0x30, + 0x2c, 0x04, 0x10, 0xc3, 0x22, 0x34, 0xe0, 0xe9, 0xf2, 0x79, 0xae, 0x96, 0xf3, 0xce, 0xb0, 0xb0, + 0xa4, 0x90, 0x44, 0x3a, 0x8c, 0xd4, 0x6b, 0xde, 0x80, 0xae, 0xf7, 0xb1, 0xbf, 0x7d, 0xf4, 0x8f, + 0x98, 0x21, 0x5b, 0x2f, 0x55, 0x6d, 0x0e, 0xb9, 0x16, 0x69, 0x54, 0x17, 0xdd, 0x64, 0x3c, 0x93, + 0xad, 0x1d, 0x70, 0x3c, 0xb2, 0x38, 0x41, 0x8c, 0x61, 0x99, 0xf7, 0xfb, 0x49, 0x36, 0xca, 0xb6, + 0x49, 0x00, 0x72, 0xa2, 0x45, 0x57, 0x7f, 0xec, 0xaf, 0xa7, 0x50, 0x7a, 0x2a, 0xbb, 0xf3, 0xe2, + 0xd1, 0x85, 0xd9, 0xdc, 0xa2, 0x2c, 0xea, 0xa9, 0x36, 0x62, 0x16, 0x8f, 0x43, 0xec, 0xe8, 0x42, + 0x1b, 0x7a, 0x9a, 0x5a, 0x22, 0x26, 0x22, 0x7f, 0x22, 0xbb, 0x49, 0x76, 0x15, 0x42, 0x68, 0x81, + 0xeb, 0x9b, 0xaf, 0xae, 0xb7, 0xe1, 0x4a, 0x17, 0x7a, 0xc6, 0x10, 0x24, 0x25, 0x79, 0x1a, 0x15, + 0x11, 0xfa, 0x9b, 0xcf, 0x2b, 0x3e, 0x45, 0x3c, 0xa7, 0x01, 0xd0, 0xc8, 0xac, 0x45, 0x71, 0x45, + 0x41, 0xa0, 0x47, 0x83, 0x53, 0x17, 0x3a, 0x6e, 0xe5, 0x70, 0x78, 0xf1, 0x05, 0x95, 0x17, 0x91, + 0x0b, 0xcc, 0xcf, 0x0c, 0x98, 0x42, 0x48, 0x3c, 0xc8, 0xe5, 0xd3, 0x51, 0x66, 0xac, 0x13, 0xbd, + 0xd7, 0xd9, 0xc7, 0x60, 0x81, 0x97, 0x52, 0xac, 0x40, 0xcc, 0x61, 0x52, 0x8f, 0x4a, 0x93, 0x74, + 0x9b, 0xf5, 0x71, 0x12, 0x16, 0x10, 0x1c, 0xb0, 0xec, 0x79, 0xb6, 0xe0, 0xbb, 0x92, 0xd4, 0xf9, + 0x04, 0x2d, 0xa1, 0x76, 0xe6, 0xc1, 0x75, 0xea, 0x1b, 0x27, 0x38, 0xb7, 0xa6, 0x35, 0x55, 0x51, + 0xaf, 0x4c, 0x11, 0xae, 0xb5, 0xba, 0x92, 0xec, 0xdf, 0x28, 0xe5, 0x21, 0xe1, 0x73, 0x05, 0x98, + 0xe4, 0x80, 0xa6, 0xec, 0x13, 0x0c, 0x65, 0x38, 0x8f, 0xaf, 0xaf, 0x5b, 0xd3, 0xf4, 0x3f, 0x56, + 0x6d, 0x02, 0x06, 0xa6, 0xce, 0xff, 0xdc, 0x01, 0xae, 0xfb, 0xf5, 0x2b, 0x46, 0xbc, 0xca, 0xbc, + 0xe8, 0x0a, 0xf4, 0x53, 0xd1, 0xce, 0x84, 0x0b, 0x31, 0x57, 0xd4, 0xb1, 0xd1, 0x5d, 0xdb, 0xf0, + 0xe8, 0x64, 0x93, 0x9a, 0x5c, 0x41, 0x1b, 0x47, 0x1a, 0x90, 0x77, 0xe5, 0x78, 0x5e, 0xd9, 0x92, + 0x8e, 0xe1, 0xc0, 0x5e, 0x0b, 0xae, 0x9d, 0x4f, 0xb8, 0xc9, 0xb0, 0xb7, 0xa8, 0x14, 0xa2, 0x37, + 0x84, 0xb0, 0x4f, 0x63, 0xbb, 0x5a, 0x53, 0x3a, 0xef, 0x4c, 0x18, 0x62, 0x17, 0xa2, 0x43, 0x02, + 0xe7, 0x06, 0xaf, 0x88, 0xd4, 0xf9, 0xe8, 0x5b, 0x71, 0xce, 0x42, 0x7d, 0x19, 0xc1, 0x49, 0xe0, + 0x1a, 0xc6, 0x98, 0xeb, 0xbe, 0x6b, 0x5c, 0xea, 0x2e, 0x3a, 0x43, 0xdf, 0x29, 0x76, 0xce, 0xbe, + 0xa3, 0xc9, 0x64, 0x24, 0xd2, 0xfd, 0xa2, 0x7d, 0xc3, 0xdc, 0xd7, 0xa3, 0x69, 0x90, 0xce, 0x7b, + 0x95, 0x47, 0xf2, 0x47, 0x03, 0x9e, 0x83, 0x19, 0x4e, 0x34, 0xb3, 0xdc, 0xd9, 0x0d, 0x65, 0xd3, + 0x64, 0x1a, 0xd5, 0xb9, 0x0c, 0x41, 0x14, 0xd0, 0x44, 0x1f, 0xa4, 0x6f, 0xac, 0x16, 0xa9, 0xf0, + 0x69, 0x1b, 0x36, 0xb3, 0x90, 0x12, 0xf2, 0x36, 0x1e, 0xe0, 0xb8, 0x7c, 0x23, 0xfc, 0x45, 0x4b, + 0x21, 0x20, 0x5a, 0xe0, 0xd7, 0xe6, 0xd9, 0xc1, 0x62, 0x06, 0x19, 0x24, 0xc2, 0x51, 0x3c, 0x36, + 0x9c, 0xa7, 0x44, 0xdd, 0x2d, 0xdc, 0xf9, 0xc0, 0xc3, 0x14, 0x41, 0x3d, 0x48, 0x98, 0x31, 0x10, + 0x80, 0x75, 0x73, 0x09, 0xd5, 0xaa, 0xd1, 0xa3, 0x76, 0x1a, 0x32, 0x23, 0xb6, 0x0f, 0x66, 0xb0, + 0xe3, 0x92, 0xf8, 0x21, 0x59, 0x7a, 0x01, 0x11, 0x88, 0xbf, 0x35, 0xb2, 0x50, 0x02, 0xc2, 0x98, + 0xf0, 0x1d, 0x6a, 0x54, 0x63, 0xd3, 0x17, 0x6e, 0x1c, 0x7f, 0xd0, 0xff, 0x1a, 0x70, 0xe1, 0x12, + 0xad, 0xf9, 0x23, 0x0e, 0x9f, 0xcc, 0x9c, 0x42, 0x3e, 0x31, 0x0e, 0x67, 0xc3, 0x58, 0x60, 0xa0, + 0x9c, 0xc4, 0xd3, 0xdf, 0xc4, 0xec, 0x0b, 0x16, 0xaf, 0x46, 0x73, 0x73, 0xfa, 0xa5, 0x9d, 0x0e, + 0x32, 0x6d, 0x82, 0xb6, 0x05, 0x43, 0x82, 0x47, 0x6a, 0x1d, 0x47, 0xce, 0xfd, 0x27, 0x09, 0xec, + 0x82, 0x9e, 0x3b, 0x29, 0xae, 0x0c, 0x09, 0xe6, 0xb4, 0x1d, 0xd5, 0x40, 0xce, 0xc3, 0x7f, 0x00, + 0x32, 0xc9, 0x49, 0xb9, 0x29, 0x8a, 0xde, 0x79, 0x30, 0x6e, 0x37, 0x6c, 0x61, 0x84, 0xfb, 0xf7, + 0x44, 0x0c, 0x14, 0xd2, 0x17, 0xb1, 0xa5, 0x57, 0x88, 0x6c, 0xa7, 0x9a, 0xf8, 0x62, 0x5d, 0xcb, + 0x91, 0x42, 0x12, 0x6a, 0x70, 0xfa, 0xd6, 0xf8, 0x13, 0xf3, 0xa5, 0x62, 0x5f, 0x2e, 0x13, 0x8e, + 0x62, 0x5d, 0x38, 0xb3, 0x99, 0xe2, 0x0a, 0xd0, 0x5d, 0x68, 0x25, 0x52, 0x18, 0x0f, 0xee, 0xe5, + 0xc1, 0xe3, 0x70, 0xf2, 0xb6, 0xe6, 0xd5, 0x72, 0x0a, 0xd3, 0x13, 0xb9, 0x8b, 0xfd, 0x46, 0x64, + 0x68, 0xc7, 0x27, 0xdc, 0x1f, 0x2f, 0x1c, 0xd1, 0x41, 0xdc, 0x7c, 0xce, 0x35, 0x92, 0xa4, 0x6f, + 0xb3, 0xc6, 0x33, 0x02, 0x93, 0x2b, 0x83, 0x2f, 0x30, 0x9a, 0xe3, 0x0e, 0x67, 0x14, 0xab, 0x95, + 0x2a, 0xb8, 0x4d, 0x76, 0xa5, 0x93, 0x06, 0xd0, 0x5e, 0x12, 0x51, 0x17, 0x1f, 0x8c, 0x7f, 0x8b, + 0x7b, 0x2a, 0xbe, 0xd1, 0x23, 0xd4, 0x74, 0x28, 0x74, 0x1a, 0x85, 0x83, 0xee, 0x5b, 0x8e, 0x97, + 0x39, 0x50, 0xb4, 0xf5, 0xc7, 0x54, 0xda, 0x46, 0x79, 0xf3, 0xa0, 0x6e, 0xb1, 0x81, 0x15, 0xc3, + 0x04, 0x9d, 0xe8, 0xe2, 0x32, 0xaf, 0xb6, 0x57, 0x47, 0xc0, 0xae, 0xea, 0xf5, 0x71, 0x6f, 0xe5, + 0xb8, 0x9a, 0xd6, 0xac, 0xe9, 0x0f, 0x8c, 0xc4, 0xe1, 0x37, 0xa8, 0xd9, 0xc6, 0x5c, 0xc3, 0xa9, + 0x8c, 0x7f, 0xba, 0xed, 0x0e, 0x74, 0x51, 0xa8, 0xf6, 0x23, 0x89, 0x05, 0x38, 0xda, 0x9a, 0x7b, + 0x82, 0x1d, 0x8c, 0xd9, 0xf4, 0x9a, 0x1a, 0xac, 0x81, 0x0e, 0xdd, 0xd7, 0xee, 0x00, 0xaa, 0x8c, + 0xf3, 0x42, 0xf0, 0x49, 0x1a, 0x50, 0xe6, 0x17, 0xdc, 0xd5, 0x35, 0x24, 0x2d, 0x54, 0xf0, 0xee, + 0x83, 0x92, 0xd1, 0xb8, 0xbf, 0x7d, 0x69, 0xc8, 0x1f, 0xa3, 0x35, 0xfd, 0xf4, 0xae, 0x16, 0x3a, + 0x1b, 0xb7, 0x02, 0x4e, 0xe8, 0x83, 0xdb, 0xff, 0x9a, 0x1c, 0xe1, 0x54, 0xf4, 0x31, 0x6d, 0x60, + 0x63, 0xdc, 0x72, 0x83, 0xf1, 0x51, 0xc4, 0xec, 0xf5, 0xa9, 0xe8, 0xd1, 0xc2, 0x5d, 0x02, 0x38, + 0xca, 0xb9, 0xa9, 0x25, 0x78, 0x8f, 0xff, 0x6b, 0xd6, 0x85, 0x19, 0x71, 0x36, 0x94, 0xb2, 0x31, + 0xa0, 0x7e, 0x82, 0x6c, 0xfb, 0x6f, 0x39, 0x10, 0x42, 0x8e, 0x32, 0x19, 0x11, 0x67, 0x82, 0xe0, + 0x7e, 0x13, 0x22, 0x28, 0xb5, 0x58, 0xcd, 0x38, 0x05, 0x91, 0x86, 0x6c, 0x02, 0x8e, 0x1f, 0x3b, + 0xd2, 0x32, 0x7b, 0xf7, 0xc6, 0x1f, 0xca, 0xca, 0xc8, 0x48, 0x5e, 0xb4, 0x32, 0x13, 0xc2, 0x09, + 0x22, 0x25, 0x2b, 0x29, 0x31, 0x86, 0x1e, 0x07, 0x77, 0x12, 0xcb, 0xb5, 0x70, 0x18, 0x76, 0xbc, + 0xf6, 0x6f, 0xaf, 0x1c, 0xf6, 0x58, 0x2d, 0x4f, 0x4e, 0xb8, 0x7c, 0xf8, 0x2c, 0x1b, 0x78, 0x07, + 0xa2, 0x55, 0xe7, 0x3d, 0xed, 0x3a, 0x7f, 0xef, 0x23, 0x13, 0x9d, 0xe9, 0x6a, 0xe8, 0x00, 0xc2, + 0x92, 0x22, 0x46, 0xa5, 0x4f, 0x3f, 0x3a, 0x6e, 0xba, 0x2c, 0x8e, 0x83, 0x88, 0xdb, 0xdb, 0x41, + 0xa4, 0x13, 0x1a, 0x69, 0x28, 0x09, 0x24, 0xf6, 0xd7, 0xc1, 0x39, 0x52, 0xad, 0xf9, 0xf6, 0x13, + 0x1c, 0x1d, 0x6a, 0xe6, 0xa3, 0xa0, 0x85, 0xf8, 0xfd, 0x5e, 0x4a, 0x45, 0xc2, 0x95, 0x1a, 0x8d, + 0x65, 0xc3, 0x45, 0xcc, 0x06, 0x7b, 0x13, 0xca, 0x32, 0xb1, 0xa6, 0xc2, 0x8a, 0x63, 0x59, 0xc4, + 0x8d, 0xfc, 0x11, 0x9f, 0xf7, 0xae, 0x92, 0x05, 0x41, 0x69, 0xda, 0xc2, 0x91, 0x19, 0x50, 0x8f, + 0x17, 0xff, 0xb0, 0xbc, 0x92, 0x5e, 0x35, 0x7a, 0xf7, 0x0b, 0x85, 0xc2, 0x14, 0xdb, 0x03, 0x68, + 0xe1, 0x42, 0x5a, 0xc8, 0x78, 0x97, 0x8c, 0x34, 0x64, 0x85, 0xcf, 0xee, 0xb9, 0x93, 0x5b, 0xd9, + 0x4d, 0x20, 0x3e, 0x27, 0x1c, 0x2e, 0xe9, 0xef, 0xfc, 0x63, 0xc5, 0x4b, 0x6d, 0x05, 0xc1, 0x5e, + 0xaf, 0xe0, 0xd0, 0xd5, 0x62, 0xc4, 0x58, 0xb0, 0xc7, 0xeb, 0x0d, 0x84, 0xcc, 0x12, 0x3f, 0xbc, + 0x30, 0xea, 0xab, 0x78, 0xb4, 0x7f, 0x9c, 0xb1, 0x1a, 0xd7, 0xac, 0xb5, 0x42, 0x21, 0xf5, 0x69, + 0x98, 0x17, 0x7d, 0x85, 0xeb, 0xc6, 0x2d, 0xee, 0xa0, 0x42, 0xe4, 0x11, 0x70, 0x7f, 0xa7, 0x8c, + 0x54, 0x54, 0x45, 0x37, 0x24, 0x61, 0xbf, 0x5d, 0x4c, 0x9e, 0x4b, 0x57, 0x78, 0xbd, 0xe3, 0xc9, + 0xdb, 0x02, 0xf6, 0x97, 0x96, 0x5d, 0x2c, 0xd2, 0xa1, 0x0b, 0xe6, 0x6a, 0xa9, 0xdb, 0xee, 0x72, + 0x8b, 0x52, 0xa9, 0x11, 0x7c, 0x53, 0xa5, 0xa2, 0xd9, 0x0d, 0x59, 0xf8, 0x6d, 0x8a, 0x60, 0x14, + 0x36, 0xca, 0x41, 0xd4, 0xa9, 0x9e, 0x3c, 0x2e, 0x66, 0x26, 0x1e, 0x37, 0xa3, 0xa5, 0xb7, 0xd4, + 0xdd, 0x21, 0xcd, 0xd4, 0x6e, 0xb4, 0xc6, 0x22, 0x68, 0x52, 0x0f, 0xfb, 0xbc, 0xaa, 0x8b, 0xf3, + 0xde, 0x71, 0x46, 0x52, 0xcb, 0xf8, 0x3e, 0x7e, 0x2c, 0xd5, 0x7f, 0xef, 0x6a, 0xbf, 0x89, 0x46, + 0x39, 0x2a, 0x33, 0xd9, 0x84, 0xfe, 0x1c, 0xb1, 0xa0, 0x8f, 0xe5, 0xdd, 0x08, 0x8f, 0x97, 0x44, + 0x99, 0xb7, 0x04, 0xd9, 0x4f, 0x06, 0x46, 0xc7, 0x97, 0x7d, 0xcd, 0x7a, 0x75, 0xe8, 0x01, 0x2c, + 0xa3, 0x5e, 0x39, 0xca, 0x7e, 0xe7, 0xae, 0x1c, 0x0c, 0x27, 0x01, 0x3a, 0x32, 0xde, 0xe2, 0x9c, + 0xd1, 0x41, 0x37, 0x9d, 0xa5, 0x04, 0xcf, 0xf6, 0xed, 0x88, 0x53, 0x95, 0x98, 0x40, 0xe8, 0x29, + 0x17, 0x0d, 0x2d, 0x15, 0xa2, 0x65, 0xcd, 0x9a, 0x8b, 0xa4, 0x87, 0x18, 0x84, 0x84, 0x73, 0x09, + 0x0f, 0x40, 0xc1, 0xbf, 0x3d, 0xd4, 0x15, 0x92, 0x67, 0x32, 0x4b, 0xf9, 0x85, 0x84, 0x00, 0x09, + 0x1f, 0xce, 0x51, 0x5d, 0x54, 0x1f, 0x66, 0x08, 0xd3, 0x95, 0xde, 0xe9, 0xc5, 0xf6, 0x73, 0x37, + 0x5e, 0x44, 0x3f, 0x10, 0x43, 0x39, 0xf4, 0x44, 0xc4, 0x81, 0x9a, 0x63, 0x02, 0x32, 0xea, 0x7d, + 0x41, 0x3c, 0xd8, 0xa3, 0x55, 0x6e, 0x60, 0xd7, 0xd2, 0x0e, 0xd4, 0x2e, 0x45, 0xcb, 0xe3, 0x35, + 0xaa, 0x1e, 0xc6, 0x84, 0xce, 0xbe, 0x7b, 0x32, 0xc5, 0xbf, 0x4f, 0x68, 0xf9, 0x69, 0x93, 0x29, + 0x61, 0x93, 0x02, 0x47, 0xe2, 0xa9, 0xf2, 0x79, 0xf5, 0xc5, 0x87, 0x12, 0x08, 0x79, 0xf3, 0xf6, + 0x10, 0x25, 0xd6, 0xb6, 0xdc, 0x61, 0x7c, 0x9f, 0xca, 0x4a, 0xe8, 0x03, 0x4b, 0x00, 0xc8, 0xdf, + 0xd6, 0x79, 0x70, 0x61, 0xa3, 0x6c, 0x12, 0x97, 0x9e, 0x85, 0xf4, 0xaa, 0x7c, 0x9f, 0x7e, 0x57, + 0xfa, 0xe4, 0xaa, 0x44, 0xdb, 0x1a, 0xf6, 0x30, 0x6e, 0x98, 0x2a, 0x72, 0x3b, 0x6f, 0x58, 0xe9, + 0x00, 0x8b, 0x4b, 0xcf, 0x4a, 0x94, 0x8f, 0xb1, 0x31, 0xd0, 0x8a, 0xfe, 0xa9, 0xb4, 0xbd, 0x09, + 0x3c, 0xe7, 0x6f, 0x8f, 0x63, 0x66, 0xad, 0xf4, 0xeb, 0xa4, 0xe3, 0x1f, 0xc5, 0xee, 0x6d, 0xf2, + 0x2e, 0x1f, 0xf1, 0x37, 0x0c, 0x81, 0x93, 0x7d, 0x29, 0x00, 0x7a, 0x91, 0x38, 0x90, 0x4f, 0x56, + 0x9b, 0x95, 0xa3, 0x8c, 0x5d, 0xe1, 0xbf, 0x03, 0x71, 0x1c, 0x9d, 0x41, 0xfc, 0x0e, 0x72, 0x74, + 0x44, 0x26, 0xec, 0x51, 0x0e, 0x60, 0x0d, 0x12, 0x31, 0xc9, 0x9c, 0x7f, 0xcb, 0xd9, 0x1e, 0xea, + 0xaa, 0xad, 0x1e, 0xe8, 0xa2, 0x75, 0x44, 0xd0, 0xae, 0x78, 0x71, 0xb4, 0xb8, 0x81, 0xd8, 0x0d, + 0xef, 0xe2, 0x2f, 0x31, 0x88, 0xc2, 0x50, 0xab, 0x87, 0x60, 0x27, 0x7b, 0xe2, 0x29, 0x51, 0x57, + 0xbe, 0x5f, 0x33, 0x20, 0x12, 0x33, 0xb5, 0x3e, 0x23, 0x48, 0x66, 0x13, 0x84, 0x13, 0x4e, 0x6a, + 0x9b, 0xd8, 0x9e, 0x8f, 0x85, 0xb2, 0xf4, 0xe2, 0x17, 0x36, 0x8f, 0xc8, 0x61, 0x61, 0xf4, 0x91, + 0x41, 0x3c, 0x89, 0x59, 0xdb, 0x67, 0xaa, 0x5d, 0x51, 0xde, 0xd0, 0x85, 0x4f, 0xa7, 0x79, 0xad, + 0x30, 0x5e, 0x3a, 0x68, 0x95, 0x54, 0x2c, 0xd8, 0x4d, 0xa2, 0xe8, 0xf4, 0x73, 0x95, 0x85, 0xf7, + 0xaf, 0x91, 0xdf, 0xdd, 0xcb, 0x35, 0xf7, 0xe8, 0xc6, 0xf9, 0x0d, 0x1e, 0xb8, 0x10, 0xd8, 0xab, + 0xd3, 0x63, 0x34, 0xaa, 0x02, 0xe8, 0x4a, 0x4c, 0xb0, 0xdf, 0x03, 0x96, 0x1f, 0x5a, 0xad, 0xc0, + 0xcf, 0xd4, 0x5a, 0x7f, 0x59, 0x67, 0x8b, 0x06, 0x20, 0x4c, 0xe0, 0x61, 0x3f, 0x04, 0x0f, 0x3d, + 0xaf, 0xcf, 0xf3, 0xd5, 0x9c, 0x56, 0xb6, 0x55, 0xa3, 0xd3, 0xa0, 0x35, 0x93, 0x40, 0xa0, 0xf9, + 0x1a, 0xb9, 0xab, 0x1a, 0x17, 0x62, 0x1a, 0x1a, 0x57, 0xaf, 0x58, 0x8c, 0x31, 0x38, 0x5d, 0x44, + 0x66, 0x7e, 0x92, 0x58, 0xe5, 0x87, 0x07, 0x56, 0xae, 0xf7, 0xad, 0x2e, 0x2b, 0x3e, 0x33, 0x64, + 0xba, 0xec, 0x21, 0x8e, 0x0d, 0x6b, 0xe1, 0x4e, 0xa5, 0x13, 0x9f, 0xd6, 0x72, 0x75, 0x5f, 0x79, + 0x42, 0xf4, 0xbf, 0x9e, 0x02, 0x3a, 0xcf, 0x94, 0xb1, 0xe1, 0x5c, 0x58, 0x29, 0x8e, 0x29, 0xb9, + 0x58, 0x27, 0x6f, 0x0c, 0x4f, 0x04, 0x63, 0x1d, 0x41, 0xd9, 0x95, 0x59, 0xe7, 0xa7, 0x48, 0x3a, + 0xa3, 0x92, 0x52, 0x64, 0x7d, 0x86, 0x00, 0xd3, 0x3a, 0x4c, 0x86, 0x24, 0xd9, 0xa6, 0x63, 0xaf, + 0xa8, 0xc9, 0x27, 0x80, 0x80, 0x72, 0xa4, 0xc6, 0xa6, 0x3b, 0x92, 0xa7, 0x6f, 0x76, 0xa7, 0x91, + 0x76, 0x26, 0x1d, 0x90, 0x50, 0xe8, 0x90, 0xd5, 0x2c, 0xa6, 0x82, 0x79, 0xaf, 0x0b, 0x09, 0xb4, + 0x43, 0xc0, 0x01, 0xa4, 0x09, 0x25, 0x31, 0xbb, 0x8e, 0x25, 0x1f, 0x7a, 0xdc, 0xab, 0xf4, 0xe4, + 0x9d, 0xd1, 0x61, 0x6f, 0x42, 0x52, 0x8c, 0xd6, 0x72, 0x83, 0xf2, 0xc5, 0x24, 0x79, 0xd7, 0xdf, + 0xf2, 0xf3, 0x83, 0xad, 0x7e, 0xed, 0x58, 0xc1, 0x62, 0x1e, 0x4d, 0xad, 0x50, 0xac, 0x9c, 0x9f, + 0xa5, 0x09, 0x6a, 0xdb, 0x9e, 0xae, 0x77, 0xb1, 0x91, 0x22, 0xac, 0xa0, 0x0d, 0x48, 0xe9, 0x67, + 0x05, 0x03, 0x03, 0xc9, 0x3d, 0x90, 0x97, 0x6a, 0x3d, 0xdd, 0x5b, 0x3b, 0xa4, 0xa8, 0x16, 0xcf, + 0x00, 0x19, 0xb5, 0x08, 0xdb, 0x2e, 0x65, 0xcc, 0x47, 0xb1, 0x87, 0xc7, 0x84, 0x32, 0xe4, 0x1d, + 0xc9, 0xba, 0xe3, 0x28, 0xec, 0x52, 0x9d, 0xc3, 0xf6, 0xc6, 0xbe, 0x04, 0x8c, 0xa8, 0x43, 0x83, + 0x2e, 0xc0, 0x43, 0x48, 0x42, 0x11, 0x13, 0xa0, 0x2b, 0x60, 0xb3, 0x5c, 0xa6, 0x61, 0x32, 0x05, + 0x9d, 0x4d, 0x5e, 0xc2, 0x97, 0xe9, 0xb9, 0x2e, 0x8a, 0xa3, 0x13, 0x0e, 0x30, 0xda, 0xad, 0x74, + 0xee, 0x7e, 0x02, 0x15, 0x41, 0xf0, 0xb3, 0xff, 0xa7, 0x2d, 0xf6, 0x18, 0x96, 0x9d, 0x18, 0xb7, + 0xc6, 0x93, 0x62, 0x42, 0x55, 0x5f, 0xff, 0x11, 0x61, 0xd8, 0x5c, 0x03, 0x3b, 0xbb, 0x93, 0x48, + 0x94, 0x82, 0x5b, 0xe9, 0x27, 0x1e, 0xac, 0x5a, 0x44, 0x53, 0x63, 0x74, 0x3f, 0x81, 0xc4, 0x63, + 0x15, 0xf5, 0x47, 0x99, 0x5d, 0x69, 0x25, 0xfe, 0x76, 0xbe, 0x6b, 0x71, 0x45, 0xd0, 0x22, 0xad, + 0x1a, 0x01, 0x5c, 0x0b, 0x81, 0x01, 0xfe, 0x30, 0xa8, 0x1d, 0x36, 0x3b, 0x2b, 0xcd, 0x62, 0x7b, + 0xf1, 0x78, 0xff, 0x12, 0x02, 0x3f, 0x1b, 0xd8, 0x26, 0x65, 0x39, 0x3a, 0x49, 0xbf, 0xcc, 0x5a, + 0xa1, 0xf1, 0xc4, 0xfa, 0x31, 0x87, 0x36, 0xa3, 0x01, 0xd0, 0x0d, 0xd5, 0xd0, 0x15, 0xa1, 0x46, + 0x40, 0xb9, 0x1e, 0x10, 0x4c, 0x81, 0x40, 0x56, 0x89, 0x2d, 0xe7, 0xc6, 0x24, 0x24, 0x0c, 0x06, + 0xa3, 0xc5, 0xac, 0x14, 0xe5, 0x65, 0xfe, 0x5f, 0xc6, 0x17, 0x0b, 0xf3, 0x15, 0x91, 0x3c, 0xa6, + 0xf5, 0xbc, 0xba, 0xbe, 0xb9, 0xc1, 0x10, 0x80, 0x3e, 0x12, 0xd8, 0x1c, 0xcb, 0xef, 0x3c, 0x48, + 0xb0, 0xdb, 0xbe, 0xc0, 0x2f, 0x86, 0x16, 0x22, 0x7c, 0xce, 0xdc, 0xe4, 0x84, 0x37, 0xd8, 0x01, + 0x86, 0x19, 0x64, 0x93, 0x4b, 0x14, 0x9c, 0xcf, 0x34, 0xfd, 0xf7, 0xd6, 0x0d, 0x29, 0xff, 0xb4, + 0x68, 0x54, 0xce, 0x5f, 0x39, 0x29, 0xae, 0x9b, 0x6c, 0x05, 0x1c, 0x68, 0x25, 0x39, 0x9b, 0x9e, + 0xc1, 0x0a, 0x9b, 0xad, 0x15, 0x86, 0xd2, 0xe7, 0x5d, 0xaa, 0xc6, 0x8b, 0xa2, 0x52, 0x7b, 0x02, + 0x1e, 0x31, 0x53, 0xf4, 0x19, 0xb0, 0xac, 0x23, 0xa9, 0x61, 0x79, 0x9f, 0x01, 0x6a, 0x37, 0x57, + 0x2c, 0x91, 0xef, 0x79, 0x06, 0x35, 0xa1, 0xd7, 0xb7, 0xe7, 0x96, 0x8a, 0xa5, 0x70, 0xb5, 0x89, + 0x7c, 0x6c, 0xf0, 0x33, 0x95, 0xb5, 0xfd, 0x20, 0x22, 0x11, 0x4b, 0xa8, 0x4d, 0xf4, 0x17, 0xf8, + 0xf1, 0x05, 0x81, 0x03, 0x84, 0xba, 0xa4, 0x1e, 0xef, 0x2a, 0x5b, 0x0c, 0x7c, 0x3e, 0x32, 0x02, + 0x37, 0xbc, 0x67, 0xdc, 0x36, 0x80, 0x9c, 0xee, 0x73, 0xac, 0x38, 0x8f, 0xc9, 0xa0, 0x87, 0x3b, + 0x2a, 0xb6, 0x3b, 0x63, 0x8a, 0xd3, 0x64, 0xf2, 0x8b, 0x1b, 0x7d, 0x00, 0x2e, 0xf2, 0xcf, 0x5c, +}; + +static const ML_DSA_KEYGEN_TEST_DATA ml_dsa_keygen_testdata[] = { + ML_DSA_KEYGEN_TEST_ITEM("ML-DSA-65", ml_dsa_65_0), + ML_DSA_KEYGEN_TEST_ITEM("ML-DSA-65", ml_dsa_65_1), +}; diff --git a/test/ml_dsa_test.c b/test/ml_dsa_test.c new file mode 100644 index 00000000000..ede4e9345c2 --- /dev/null +++ b/test/ml_dsa_test.c @@ -0,0 +1,115 @@ +/* + * Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include +#include +#include "internal/nelem.h" +#include "testutil.h" +#include "ml_dsa.inc" + +typedef enum OPTION_choice { + OPT_ERR = -1, + OPT_EOF = 0, + OPT_CONFIG_FILE, + OPT_TEST_ENUM +} OPTION_CHOICE; + +static OSSL_LIB_CTX *lib_ctx = NULL; +static OSSL_PROVIDER *null_prov = NULL; +static OSSL_PROVIDER *lib_prov = NULL; + +static EVP_PKEY *do_gen_key(const char *alg, + const uint8_t *seed, size_t seed_len) +{ + EVP_PKEY *pkey = NULL; + EVP_PKEY_CTX *ctx = NULL; + OSSL_PARAM params[2], *p = params; + + if (seed_len != 0) + *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, + (char *)seed, seed_len); + *p = OSSL_PARAM_construct_end(); + + if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(lib_ctx, alg, NULL)) + || !TEST_int_eq(EVP_PKEY_keygen_init(ctx), 1) + || !TEST_int_eq(EVP_PKEY_CTX_set_params(ctx, params), 1) + || !TEST_int_eq(EVP_PKEY_generate(ctx, &pkey), 1)) + goto err; +err: + EVP_PKEY_CTX_free(ctx); + return pkey; +} + +static int ml_dsa_keygen_test(int tst_id) +{ + int ret = 0; + const ML_DSA_KEYGEN_TEST_DATA *tst = &ml_dsa_keygen_testdata[tst_id]; + EVP_PKEY *pkey = NULL; + uint8_t priv[5 * 1024], pub[3 * 1024]; + size_t priv_len, pub_len; + + if (!TEST_ptr(pkey = do_gen_key(tst->name, tst->seed, tst->seed_len))) + goto err; + if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY, + priv, sizeof(priv), &priv_len))) + goto err; + if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey, OSSL_PKEY_PARAM_PUB_KEY, + pub, sizeof(pub), &pub_len))) + goto err; + if (!TEST_mem_eq(pub, pub_len, tst->pub, tst->pub_len)) + goto err; + if (!TEST_mem_eq(priv, priv_len, tst->priv, tst->priv_len)) + goto err; + ret = 1; +err: + EVP_PKEY_free(pkey); + return ret; +} + +const OPTIONS *test_get_options(void) +{ + static const OPTIONS options[] = { + OPT_TEST_OPTIONS_DEFAULT_USAGE, + { "config", OPT_CONFIG_FILE, '<', + "The configuration file to use for the libctx" }, + { NULL } + }; + return options; +} + +int setup_tests(void) +{ + OPTION_CHOICE o; + char *config_file = NULL; + + while ((o = opt_next()) != OPT_EOF) { + switch (o) { + case OPT_CONFIG_FILE: + config_file = opt_arg(); + break; + case OPT_TEST_CASES: + break; + default: + case OPT_ERR: + return 0; + } + } + if (!test_get_libctx(&lib_ctx, &null_prov, config_file, &lib_prov, NULL)) + return 0; + + ADD_ALL_TESTS(ml_dsa_keygen_test, OSSL_NELEM(ml_dsa_keygen_testdata)); + return 1; +} + +void cleanup_tests(void) +{ + OSSL_PROVIDER_unload(null_prov); + OSSL_PROVIDER_unload(lib_prov); + OSSL_LIB_CTX_free(lib_ctx); +} diff --git a/test/recipes/30-test_ml_dsa.t b/test/recipes/30-test_ml_dsa.t new file mode 100644 index 00000000000..96139cc7c8f --- /dev/null +++ b/test/recipes/30-test_ml_dsa.t @@ -0,0 +1,43 @@ +#! /usr/bin/env perl +# Copyright 2024 The OpenSSL Project Authors. All Rights Reserved. +# +# Licensed under the Apache License 2.0 (the "License"). You may not use +# this file except in compliance with the License. You can obtain a copy +# in the file LICENSE in the source distribution or at +# https://www.openssl.org/source/license.html + +use strict; +use warnings; + +use OpenSSL::Test qw(:DEFAULT srctop_dir bldtop_dir srctop_file); +use OpenSSL::Test::Utils; + +BEGIN { + setup("test_ml_dsa"); +} + +my $provconf = srctop_file("test", "fips-and-base.cnf"); +# fips will be added later +my $no_fips = 1; + +use lib srctop_dir('Configurations'); +use lib bldtop_dir('.'); + +plan skip_all => 'ML-DSA is not supported in this build' if disabled('ml-dsa'); +plan tests => 2; + +ok(run(test(["ml_dsa_test"])), "running ml_dsa_test"); + +SKIP: { + skip "Skipping FIPS tests", 1 + if $no_fips; + + # ML-DSA is only present after OpenSSL 3.5 + run(test(["fips_version_test", "-config", $provconf, ">=3.5.0"]), + capture => 1, statusvar => \my $exit); + skip "FIPS provider version is too old for ML-DSA test", 1 + if !$exit; + + ok(run(test(["ml_dsa_test", "-config", $provconf])), + "running ml_dsa_test with FIPS"); +} diff --git a/util/perl/OpenSSL/paramnames.pm b/util/perl/OpenSSL/paramnames.pm index 3d7b89b688e..9fc6c5126e4 100644 --- a/util/perl/OpenSSL/paramnames.pm +++ b/util/perl/OpenSSL/paramnames.pm @@ -431,6 +431,9 @@ my %params = ( 'PKEY_PARAM_FIPS_SIGN_CHECK' => "sign-check", 'PKEY_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR', +# ML_DSA Key generation parameter + 'PKEY_PARAM_ML_DSA_SEED' => "seed", + # Key Exchange parameters 'EXCHANGE_PARAM_PAD' => "pad",# uint 'EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE' => "ecdh-cofactor-mode",# int