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 <viktor@openssl.org>
Reviewed-by: Tim Hudson <tjh@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/26127)

diff --git a/Configure b/Configure
index 2dd6234d1cca7be28b10b7e5b24c77283d4d1d1b..b090f0ad364922361bfcb74913c91e1848c6e9cc 100755 (executable)
--- 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 0f686532d3d1f9b7101cf60c33bf42dcc00885f6..7426204106f00f7a40e5520dcfe66fd5b29574b0 100644 (file)
--- 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 2642d30754b585214d2bc888451eaa141c7467d2..e476b678da347c8c6871e1e595960afd206402cd 100644 (file)
--- 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 (file)
index 0000000..f972fed
--- /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 (file)
index 0000000..7689384
--- /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 <openssl/evp.h>
+#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 (file)
index 0000000..844a1e9
--- /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 (file)
index 0000000..9ab46ab
--- /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 <openssl/core_dispatch.h>
+#include <openssl/core_names.h>
+#include <openssl/params.h>
+#include <openssl/rand.h>
+#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 (file)
index 0000000..c841da0
--- /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 <openssl/e_os2.h>
+#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 (file)
index 0000000..035475b
--- /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 (file)
index 0000000..54e1d3b
--- /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 (file)
index 0000000..88c6be3
--- /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 (file)
index 0000000..759a69b
--- /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 (file)
index 0000000..a79b058
--- /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 (file)
index 0000000..63b50c6
--- /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 <stddef.h>
+#include <string.h>
+#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 (file)
index 0000000..1645735
--- /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 <openssl/e_os2.h>
+
+/*
+ * 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 (file)
index 0000000..734bfb9
--- /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 <openssl/crypto.h>
+
+#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 (file)
index 0000000..74abdd5
--- /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 <openssl/evp.h>
+#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 (file)
index 0000000..c21122a
--- /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 (file)
index 0000000..124e654
--- /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 <openssl/e_os2.h>
+# include <openssl/types.h>
+# 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 ad17f052e45f5047ad498fa1c55538ee33bc93c4..8f60ed81e00a0454f7de2785b653c23c79792a09 100644 (file)
--- 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 e30256cbaa43e61c945eb9545a4123d1ebc48899..486186413060a27de9cdd29103de1e94445e4646 100644 (file)
--- 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 5b9190565775bc439861b69019c2f73be9487fb4..cfafbf48873fda91189e17cbacc3241d6a8ad78f 100644 (file)
--- 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 d422dbac296ef6583ac692b3ca93a487456f75ed..4728fe903f08da84a7452db5bdf82ddb1f8b31f0 100644 (file)
--- 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 f2cbb3dfe8da2f28a3e60bb92574204401cd6920..852d9dc7d2ee0dbc91f141b719f09cf2c30c4bc7 100644 (file)
--- 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 (file)
index 0000000..079e67d
--- /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 <openssl/core_dispatch.h>
+#include <openssl/core_names.h>
+#include <openssl/param_build.h>
+#include <openssl/self_test.h>
+#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 13431580d131d1acdae64510caf3971637075af1..5e511590d342b48235e229c6b8762bd8a9e973de 100644 (file)
--- 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 (file)
index 0000000..273ac7f
--- /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 (file)
index 0000000..ede4e93
--- /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 <openssl/core_names.h>
+#include <openssl/evp.h>
+#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 (file)
index 0000000..96139cc
--- /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 3d7b89b688e27ee64a8c68efa38c90f5d74a35b5..9fc6c5126e461358d9c503a1f50b0cb4253eec1f 100644 (file)
--- 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