Add submodule dependency filesHEADmaster

Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec

14 files changed, 4071 insertions, 0 deletions

diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/arch_intrinsics.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/arch_intrinsics.h
new file mode 100644
index 000000000..5f6389863
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/arch_intrinsics.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448_ARCH_32_INTRINSICS_H
+# define OSSL_CRYPTO_EC_CURVE448_ARCH_32_INTRINSICS_H
+
+#include "internal/constant_time.h"
+
+# define ARCH_WORD_BITS 32
+
+#define word_is_zero(a)     constant_time_is_zero_32(a)
+
+static ossl_inline uint64_t widemul(uint32_t a, uint32_t b)
+{
+    return ((uint64_t)a) * b;
+}
+
+#endif                          /* OSSL_CRYPTO_EC_CURVE448_ARCH_32_INTRINSICS_H */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/f_impl.c b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/f_impl.c
new file mode 100644
index 000000000..8a89d276e
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/f_impl.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2014 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#include "field.h"
+
+void gf_mul(gf_s * RESTRICT cs, const gf as, const gf bs)
+{
+    const uint32_t *a = as->limb, *b = bs->limb;
+    uint32_t *c = cs->limb;
+    uint64_t accum0 = 0, accum1 = 0, accum2 = 0;
+    uint32_t mask = (1 << 28) - 1;
+    uint32_t aa[8], bb[8];
+    int i, j;
+
+    for (i = 0; i < 8; i++) {
+        aa[i] = a[i] + a[i + 8];
+        bb[i] = b[i] + b[i + 8];
+    }
+
+    for (j = 0; j < 8; j++) {
+        accum2 = 0;
+        for (i = 0; i < j + 1; i++) {
+            accum2 += widemul(a[j - i], b[i]);
+            accum1 += widemul(aa[j - i], bb[i]);
+            accum0 += widemul(a[8 + j - i], b[8 + i]);
+        }
+        accum1 -= accum2;
+        accum0 += accum2;
+        accum2 = 0;
+        for (i = j + 1; i < 8; i++) {
+            accum0 -= widemul(a[8 + j - i], b[i]);
+            accum2 += widemul(aa[8 + j - i], bb[i]);
+            accum1 += widemul(a[16 + j - i], b[8 + i]);
+        }
+        accum1 += accum2;
+        accum0 += accum2;
+        c[j] = ((uint32_t)(accum0)) & mask;
+        c[j + 8] = ((uint32_t)(accum1)) & mask;
+        accum0 >>= 28;
+        accum1 >>= 28;
+    }
+
+    accum0 += accum1;
+    accum0 += c[8];
+    accum1 += c[0];
+    c[8] = ((uint32_t)(accum0)) & mask;
+    c[0] = ((uint32_t)(accum1)) & mask;
+
+    accum0 >>= 28;
+    accum1 >>= 28;
+    c[9] += ((uint32_t)(accum0));
+    c[1] += ((uint32_t)(accum1));
+}
+
+void gf_mulw_unsigned(gf_s * RESTRICT cs, const gf as, uint32_t b)
+{
+    const uint32_t *a = as->limb;
+    uint32_t *c = cs->limb;
+    uint64_t accum0 = 0, accum8 = 0;
+    uint32_t mask = (1 << 28) - 1;
+    int i;
+
+    assert(b <= mask);
+
+    for (i = 0; i < 8; i++) {
+        accum0 += widemul(b, a[i]);
+        accum8 += widemul(b, a[i + 8]);
+        c[i] = accum0 & mask;
+        accum0 >>= 28;
+        c[i + 8] = accum8 & mask;
+        accum8 >>= 28;
+    }
+
+    accum0 += accum8 + c[8];
+    c[8] = ((uint32_t)accum0) & mask;
+    c[9] += (uint32_t)(accum0 >> 28);
+
+    accum8 += c[0];
+    c[0] = ((uint32_t)accum8) & mask;
+    c[1] += (uint32_t)(accum8 >> 28);
+}
+
+void gf_sqr(gf_s * RESTRICT cs, const gf as)
+{
+    gf_mul(cs, as, as);         /* Performs better with a dedicated square */
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/f_impl.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/f_impl.h
new file mode 100644
index 000000000..e1ddddaee
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/arch_32/f_impl.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2014-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448_ARCH_32_F_IMPL_H
+# define OSSL_CRYPTO_EC_CURVE448_ARCH_32_F_IMPL_H
+
+# define GF_HEADROOM 2
+# define LIMB(x) ((x) & ((1 << 28) - 1)), ((x) >> 28)
+# define FIELD_LITERAL(a, b, c, d, e, f, g, h) \
+    {{LIMB(a), LIMB(b), LIMB(c), LIMB(d), LIMB(e), LIMB(f), LIMB(g), LIMB(h)}}
+
+# define LIMB_PLACE_VALUE(i) 28
+
+void gf_add_RAW(gf out, const gf a, const gf b)
+{
+    unsigned int i;
+
+    for (i = 0; i < NLIMBS; i++)
+        out->limb[i] = a->limb[i] + b->limb[i];
+}
+
+void gf_sub_RAW(gf out, const gf a, const gf b)
+{
+    unsigned int i;
+
+    for (i = 0; i < NLIMBS; i++)
+        out->limb[i] = a->limb[i] - b->limb[i];
+}
+
+void gf_bias(gf a, int amt)
+{
+    unsigned int i;
+    uint32_t co1 = ((1 << 28) - 1) * amt, co2 = co1 - amt;
+
+    for (i = 0; i < NLIMBS; i++)
+        a->limb[i] += (i == NLIMBS / 2) ? co2 : co1;
+}
+
+void gf_weak_reduce(gf a)
+{
+    uint32_t mask = (1 << 28) - 1;
+    uint32_t tmp = a->limb[NLIMBS - 1] >> 28;
+    unsigned int i;
+
+    a->limb[NLIMBS / 2] += tmp;
+    for (i = NLIMBS - 1; i > 0; i--)
+        a->limb[i] = (a->limb[i] & mask) + (a->limb[i - 1] >> 28);
+    a->limb[0] = (a->limb[0] & mask) + tmp;
+}
+
+#endif                  /* OSSL_CRYPTO_EC_CURVE448_ARCH_32_F_IMPL_H */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448.c b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448.c
new file mode 100644
index 000000000..12d97f067
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448.c
@@ -0,0 +1,727 @@
+/*
+ * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+#include <openssl/crypto.h>
+#include "word.h"
+#include "field.h"
+
+#include "point_448.h"
+#include "ed448.h"
+#include "curve448_local.h"
+
+#define COFACTOR 4
+
+#define C448_WNAF_FIXED_TABLE_BITS 5
+#define C448_WNAF_VAR_TABLE_BITS 3
+
+#define EDWARDS_D       (-39081)
+
+static const curve448_scalar_t precomputed_scalarmul_adjustment = {
+    {
+        {
+            SC_LIMB(0xc873d6d54a7bb0cfULL), SC_LIMB(0xe933d8d723a70aadULL),
+            SC_LIMB(0xbb124b65129c96fdULL), SC_LIMB(0x00000008335dc163ULL)
+        }
+    }
+};
+
+#define TWISTED_D (EDWARDS_D - 1)
+
+#define WBITS C448_WORD_BITS   /* NB this may be different from ARCH_WORD_BITS */
+
+/* Inverse. */
+static void gf_invert(gf y, const gf x, int assert_nonzero)
+{
+    mask_t ret;
+    gf t1, t2;
+
+    gf_sqr(t1, x);              /* o^2 */
+    ret = gf_isr(t2, t1);       /* +-1/sqrt(o^2) = +-1/o */
+    (void)ret;
+    if (assert_nonzero)
+        assert(ret);
+    gf_sqr(t1, t2);
+    gf_mul(t2, t1, x);          /* not direct to y in case of alias. */
+    gf_copy(y, t2);
+}
+
+/** identity = (0,1) */
+const curve448_point_t curve448_point_identity =
+    { {{{{0}}}, {{{1}}}, {{{1}}}, {{{0}}}} };
+
+static void point_double_internal(curve448_point_t p, const curve448_point_t q,
+                                  int before_double)
+{
+    gf a, b, c, d;
+
+    gf_sqr(c, q->x);
+    gf_sqr(a, q->y);
+    gf_add_nr(d, c, a);         /* 2+e */
+    gf_add_nr(p->t, q->y, q->x); /* 2+e */
+    gf_sqr(b, p->t);
+    gf_subx_nr(b, b, d, 3);     /* 4+e */
+    gf_sub_nr(p->t, a, c);      /* 3+e */
+    gf_sqr(p->x, q->z);
+    gf_add_nr(p->z, p->x, p->x); /* 2+e */
+    gf_subx_nr(a, p->z, p->t, 4); /* 6+e */
+    if (GF_HEADROOM == 5)
+        gf_weak_reduce(a);      /* or 1+e */
+    gf_mul(p->x, a, b);
+    gf_mul(p->z, p->t, a);
+    gf_mul(p->y, p->t, d);
+    if (!before_double)
+        gf_mul(p->t, b, d);
+}
+
+void curve448_point_double(curve448_point_t p, const curve448_point_t q)
+{
+    point_double_internal(p, q, 0);
+}
+
+/* Operations on [p]niels */
+static ossl_inline void cond_neg_niels(niels_t n, mask_t neg)
+{
+    gf_cond_swap(n->a, n->b, neg);
+    gf_cond_neg(n->c, neg);
+}
+
+static void pt_to_pniels(pniels_t b, const curve448_point_t a)
+{
+    gf_sub(b->n->a, a->y, a->x);
+    gf_add(b->n->b, a->x, a->y);
+    gf_mulw(b->n->c, a->t, 2 * TWISTED_D);
+    gf_add(b->z, a->z, a->z);
+}
+
+static void pniels_to_pt(curve448_point_t e, const pniels_t d)
+{
+    gf eu;
+
+    gf_add(eu, d->n->b, d->n->a);
+    gf_sub(e->y, d->n->b, d->n->a);
+    gf_mul(e->t, e->y, eu);
+    gf_mul(e->x, d->z, e->y);
+    gf_mul(e->y, d->z, eu);
+    gf_sqr(e->z, d->z);
+}
+
+static void niels_to_pt(curve448_point_t e, const niels_t n)
+{
+    gf_add(e->y, n->b, n->a);
+    gf_sub(e->x, n->b, n->a);
+    gf_mul(e->t, e->y, e->x);
+    gf_copy(e->z, ONE);
+}
+
+static void add_niels_to_pt(curve448_point_t d, const niels_t e,
+                            int before_double)
+{
+    gf a, b, c;
+
+    gf_sub_nr(b, d->y, d->x);   /* 3+e */
+    gf_mul(a, e->a, b);
+    gf_add_nr(b, d->x, d->y);   /* 2+e */
+    gf_mul(d->y, e->b, b);
+    gf_mul(d->x, e->c, d->t);
+    gf_add_nr(c, a, d->y);      /* 2+e */
+    gf_sub_nr(b, d->y, a);      /* 3+e */
+    gf_sub_nr(d->y, d->z, d->x); /* 3+e */
+    gf_add_nr(a, d->x, d->z);   /* 2+e */
+    gf_mul(d->z, a, d->y);
+    gf_mul(d->x, d->y, b);
+    gf_mul(d->y, a, c);
+    if (!before_double)
+        gf_mul(d->t, b, c);
+}
+
+static void sub_niels_from_pt(curve448_point_t d, const niels_t e,
+                              int before_double)
+{
+    gf a, b, c;
+
+    gf_sub_nr(b, d->y, d->x);   /* 3+e */
+    gf_mul(a, e->b, b);
+    gf_add_nr(b, d->x, d->y);   /* 2+e */
+    gf_mul(d->y, e->a, b);
+    gf_mul(d->x, e->c, d->t);
+    gf_add_nr(c, a, d->y);      /* 2+e */
+    gf_sub_nr(b, d->y, a);      /* 3+e */
+    gf_add_nr(d->y, d->z, d->x); /* 2+e */
+    gf_sub_nr(a, d->z, d->x);   /* 3+e */
+    gf_mul(d->z, a, d->y);
+    gf_mul(d->x, d->y, b);
+    gf_mul(d->y, a, c);
+    if (!before_double)
+        gf_mul(d->t, b, c);
+}
+
+static void add_pniels_to_pt(curve448_point_t p, const pniels_t pn,
+                             int before_double)
+{
+    gf L0;
+
+    gf_mul(L0, p->z, pn->z);
+    gf_copy(p->z, L0);
+    add_niels_to_pt(p, pn->n, before_double);
+}
+
+static void sub_pniels_from_pt(curve448_point_t p, const pniels_t pn,
+                               int before_double)
+{
+    gf L0;
+
+    gf_mul(L0, p->z, pn->z);
+    gf_copy(p->z, L0);
+    sub_niels_from_pt(p, pn->n, before_double);
+}
+
+c448_bool_t curve448_point_eq(const curve448_point_t p,
+                              const curve448_point_t q)
+{
+    mask_t succ;
+    gf a, b;
+
+    /* equality mod 2-torsion compares x/y */
+    gf_mul(a, p->y, q->x);
+    gf_mul(b, q->y, p->x);
+    succ = gf_eq(a, b);
+
+    return mask_to_bool(succ);
+}
+
+c448_bool_t curve448_point_valid(const curve448_point_t p)
+{
+    mask_t out;
+    gf a, b, c;
+
+    gf_mul(a, p->x, p->y);
+    gf_mul(b, p->z, p->t);
+    out = gf_eq(a, b);
+    gf_sqr(a, p->x);
+    gf_sqr(b, p->y);
+    gf_sub(a, b, a);
+    gf_sqr(b, p->t);
+    gf_mulw(c, b, TWISTED_D);
+    gf_sqr(b, p->z);
+    gf_add(b, b, c);
+    out &= gf_eq(a, b);
+    out &= ~gf_eq(p->z, ZERO);
+    return mask_to_bool(out);
+}
+
+static ossl_inline void constant_time_lookup_niels(niels_s * RESTRICT ni,
+                                                   const niels_t * table,
+                                                   int nelts, int idx)
+{
+    constant_time_lookup(ni, table, sizeof(niels_s), nelts, idx);
+}
+
+void curve448_precomputed_scalarmul(curve448_point_t out,
+                                    const curve448_precomputed_s * table,
+                                    const curve448_scalar_t scalar)
+{
+    unsigned int i, j, k;
+    const unsigned int n = COMBS_N, t = COMBS_T, s = COMBS_S;
+    niels_t ni;
+    curve448_scalar_t scalar1x;
+
+    curve448_scalar_add(scalar1x, scalar, precomputed_scalarmul_adjustment);
+    curve448_scalar_halve(scalar1x, scalar1x);
+
+    for (i = s; i > 0; i--) {
+        if (i != s)
+            point_double_internal(out, out, 0);
+
+        for (j = 0; j < n; j++) {
+            int tab = 0;
+            mask_t invert;
+
+            for (k = 0; k < t; k++) {
+                unsigned int bit = (i - 1) + s * (k + j * t);
+
+                if (bit < C448_SCALAR_BITS)
+                    tab |=
+                        (scalar1x->limb[bit / WBITS] >> (bit % WBITS) & 1) << k;
+            }
+
+            invert = (tab >> (t - 1)) - 1;
+            tab ^= invert;
+            tab &= (1 << (t - 1)) - 1;
+
+            constant_time_lookup_niels(ni, &table->table[j << (t - 1)],
+                                       1 << (t - 1), tab);
+
+            cond_neg_niels(ni, invert);
+            if ((i != s) || j != 0)
+                add_niels_to_pt(out, ni, j == n - 1 && i != 1);
+            else
+                niels_to_pt(out, ni);
+        }
+    }
+
+    OPENSSL_cleanse(ni, sizeof(ni));
+    OPENSSL_cleanse(scalar1x, sizeof(scalar1x));
+}
+
+void curve448_point_mul_by_ratio_and_encode_like_eddsa(
+                                    uint8_t enc[EDDSA_448_PUBLIC_BYTES],
+                                    const curve448_point_t p)
+{
+    gf x, y, z, t;
+    curve448_point_t q;
+
+    /* The point is now on the twisted curve.  Move it to untwisted. */
+    curve448_point_copy(q, p);
+
+    {
+        /* 4-isogeny: 2xy/(y^+x^2), (y^2-x^2)/(2z^2-y^2+x^2) */
+        gf u;
+
+        gf_sqr(x, q->x);
+        gf_sqr(t, q->y);
+        gf_add(u, x, t);
+        gf_add(z, q->y, q->x);
+        gf_sqr(y, z);
+        gf_sub(y, y, u);
+        gf_sub(z, t, x);
+        gf_sqr(x, q->z);
+        gf_add(t, x, x);
+        gf_sub(t, t, z);
+        gf_mul(x, t, y);
+        gf_mul(y, z, u);
+        gf_mul(z, u, t);
+        OPENSSL_cleanse(u, sizeof(u));
+    }
+
+    /* Affinize */
+    gf_invert(z, z, 1);
+    gf_mul(t, x, z);
+    gf_mul(x, y, z);
+
+    /* Encode */
+    enc[EDDSA_448_PRIVATE_BYTES - 1] = 0;
+    gf_serialize(enc, x, 1);
+    enc[EDDSA_448_PRIVATE_BYTES - 1] |= 0x80 & gf_lobit(t);
+
+    OPENSSL_cleanse(x, sizeof(x));
+    OPENSSL_cleanse(y, sizeof(y));
+    OPENSSL_cleanse(z, sizeof(z));
+    OPENSSL_cleanse(t, sizeof(t));
+    curve448_point_destroy(q);
+}
+
+c448_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
+                                curve448_point_t p,
+                                const uint8_t enc[EDDSA_448_PUBLIC_BYTES])
+{
+    uint8_t enc2[EDDSA_448_PUBLIC_BYTES];
+    mask_t low;
+    mask_t succ;
+
+    memcpy(enc2, enc, sizeof(enc2));
+
+    low = ~word_is_zero(enc2[EDDSA_448_PRIVATE_BYTES - 1] & 0x80);
+    enc2[EDDSA_448_PRIVATE_BYTES - 1] &= ~0x80;
+
+    succ = gf_deserialize(p->y, enc2, 1, 0);
+    succ &= word_is_zero(enc2[EDDSA_448_PRIVATE_BYTES - 1]);
+
+    gf_sqr(p->x, p->y);
+    gf_sub(p->z, ONE, p->x);    /* num = 1-y^2 */
+    gf_mulw(p->t, p->x, EDWARDS_D); /* dy^2 */
+    gf_sub(p->t, ONE, p->t);    /* denom = 1-dy^2 or 1-d + dy^2 */
+
+    gf_mul(p->x, p->z, p->t);
+    succ &= gf_isr(p->t, p->x); /* 1/sqrt(num * denom) */
+
+    gf_mul(p->x, p->t, p->z);   /* sqrt(num / denom) */
+    gf_cond_neg(p->x, gf_lobit(p->x) ^ low);
+    gf_copy(p->z, ONE);
+
+    {
+        gf a, b, c, d;
+
+        /* 4-isogeny 2xy/(y^2-ax^2), (y^2+ax^2)/(2-y^2-ax^2) */
+        gf_sqr(c, p->x);
+        gf_sqr(a, p->y);
+        gf_add(d, c, a);
+        gf_add(p->t, p->y, p->x);
+        gf_sqr(b, p->t);
+        gf_sub(b, b, d);
+        gf_sub(p->t, a, c);
+        gf_sqr(p->x, p->z);
+        gf_add(p->z, p->x, p->x);
+        gf_sub(a, p->z, d);
+        gf_mul(p->x, a, b);
+        gf_mul(p->z, p->t, a);
+        gf_mul(p->y, p->t, d);
+        gf_mul(p->t, b, d);
+        OPENSSL_cleanse(a, sizeof(a));
+        OPENSSL_cleanse(b, sizeof(b));
+        OPENSSL_cleanse(c, sizeof(c));
+        OPENSSL_cleanse(d, sizeof(d));
+    }
+
+    OPENSSL_cleanse(enc2, sizeof(enc2));
+    assert(curve448_point_valid(p) || ~succ);
+
+    return c448_succeed_if(mask_to_bool(succ));
+}
+
+c448_error_t x448_int(uint8_t out[X_PUBLIC_BYTES],
+                      const uint8_t base[X_PUBLIC_BYTES],
+                      const uint8_t scalar[X_PRIVATE_BYTES])
+{
+    gf x1, x2, z2, x3, z3, t1, t2;
+    int t;
+    mask_t swap = 0;
+    mask_t nz;
+
+    (void)gf_deserialize(x1, base, 1, 0);
+    gf_copy(x2, ONE);
+    gf_copy(z2, ZERO);
+    gf_copy(x3, x1);
+    gf_copy(z3, ONE);
+
+    for (t = X_PRIVATE_BITS - 1; t >= 0; t--) {
+        uint8_t sb = scalar[t / 8];
+        mask_t k_t;
+
+        /* Scalar conditioning */
+        if (t / 8 == 0)
+            sb &= -(uint8_t)COFACTOR;
+        else if (t == X_PRIVATE_BITS - 1)
+            sb = -1;
+
+        k_t = (sb >> (t % 8)) & 1;
+        k_t = 0 - k_t;             /* set to all 0s or all 1s */
+
+        swap ^= k_t;
+        gf_cond_swap(x2, x3, swap);
+        gf_cond_swap(z2, z3, swap);
+        swap = k_t;
+
+        /*
+         * The "_nr" below skips coefficient reduction. In the following
+         * comments, "2+e" is saying that the coefficients are at most 2+epsilon
+         * times the reduction limit.
+         */
+        gf_add_nr(t1, x2, z2);  /* A = x2 + z2 */ /* 2+e */
+        gf_sub_nr(t2, x2, z2);  /* B = x2 - z2 */ /* 3+e */
+        gf_sub_nr(z2, x3, z3);  /* D = x3 - z3 */ /* 3+e */
+        gf_mul(x2, t1, z2);     /* DA */
+        gf_add_nr(z2, z3, x3);  /* C = x3 + z3 */ /* 2+e */
+        gf_mul(x3, t2, z2);     /* CB */
+        gf_sub_nr(z3, x2, x3);  /* DA-CB */ /* 3+e */
+        gf_sqr(z2, z3);         /* (DA-CB)^2 */
+        gf_mul(z3, x1, z2);     /* z3 = x1(DA-CB)^2 */
+        gf_add_nr(z2, x2, x3);  /* (DA+CB) */ /* 2+e */
+        gf_sqr(x3, z2);         /* x3 = (DA+CB)^2 */
+
+        gf_sqr(z2, t1);         /* AA = A^2 */
+        gf_sqr(t1, t2);         /* BB = B^2 */
+        gf_mul(x2, z2, t1);     /* x2 = AA*BB */
+        gf_sub_nr(t2, z2, t1);  /* E = AA-BB */ /* 3+e */
+
+        gf_mulw(t1, t2, -EDWARDS_D); /* E*-d = a24*E */
+        gf_add_nr(t1, t1, z2);  /* AA + a24*E */ /* 2+e */
+        gf_mul(z2, t2, t1);     /* z2 = E(AA+a24*E) */
+    }
+
+    /* Finish */
+    gf_cond_swap(x2, x3, swap);
+    gf_cond_swap(z2, z3, swap);
+    gf_invert(z2, z2, 0);
+    gf_mul(x1, x2, z2);
+    gf_serialize(out, x1, 1);
+    nz = ~gf_eq(x1, ZERO);
+
+    OPENSSL_cleanse(x1, sizeof(x1));
+    OPENSSL_cleanse(x2, sizeof(x2));
+    OPENSSL_cleanse(z2, sizeof(z2));
+    OPENSSL_cleanse(x3, sizeof(x3));
+    OPENSSL_cleanse(z3, sizeof(z3));
+    OPENSSL_cleanse(t1, sizeof(t1));
+    OPENSSL_cleanse(t2, sizeof(t2));
+
+    return c448_succeed_if(mask_to_bool(nz));
+}
+
+void curve448_point_mul_by_ratio_and_encode_like_x448(uint8_t
+                                                      out[X_PUBLIC_BYTES],
+                                                      const curve448_point_t p)
+{
+    curve448_point_t q;
+
+    curve448_point_copy(q, p);
+    gf_invert(q->t, q->x, 0);   /* 1/x */
+    gf_mul(q->z, q->t, q->y);   /* y/x */
+    gf_sqr(q->y, q->z);         /* (y/x)^2 */
+    gf_serialize(out, q->y, 1);
+    curve448_point_destroy(q);
+}
+
+void x448_derive_public_key(uint8_t out[X_PUBLIC_BYTES],
+                            const uint8_t scalar[X_PRIVATE_BYTES])
+{
+    /* Scalar conditioning */
+    uint8_t scalar2[X_PRIVATE_BYTES];
+    curve448_scalar_t the_scalar;
+    curve448_point_t p;
+    unsigned int i;
+
+    memcpy(scalar2, scalar, sizeof(scalar2));
+    scalar2[0] &= -(uint8_t)COFACTOR;
+
+    scalar2[X_PRIVATE_BYTES - 1] &= ~((0u - 1u) << ((X_PRIVATE_BITS + 7) % 8));
+    scalar2[X_PRIVATE_BYTES - 1] |= 1 << ((X_PRIVATE_BITS + 7) % 8);
+
+    curve448_scalar_decode_long(the_scalar, scalar2, sizeof(scalar2));
+
+    /* Compensate for the encoding ratio */
+    for (i = 1; i < X448_ENCODE_RATIO; i <<= 1)
+        curve448_scalar_halve(the_scalar, the_scalar);
+
+    curve448_precomputed_scalarmul(p, curve448_precomputed_base, the_scalar);
+    curve448_point_mul_by_ratio_and_encode_like_x448(out, p);
+    curve448_point_destroy(p);
+}
+
+/* Control for variable-time scalar multiply algorithms. */
+struct smvt_control {
+    int power, addend;
+};
+
+#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3))
+# define NUMTRAILINGZEROS	__builtin_ctz
+#else
+# define NUMTRAILINGZEROS	numtrailingzeros
+static uint32_t numtrailingzeros(uint32_t i)
+{
+    uint32_t tmp;
+    uint32_t num = 31;
+
+    if (i == 0)
+        return 32;
+
+    tmp = i << 16;
+    if (tmp != 0) {
+        i = tmp;
+        num -= 16;
+    }
+    tmp = i << 8;
+    if (tmp != 0) {
+        i = tmp;
+        num -= 8;
+    }
+    tmp = i << 4;
+    if (tmp != 0) {
+        i = tmp;
+        num -= 4;
+    }
+    tmp = i << 2;
+    if (tmp != 0) {
+        i = tmp;
+        num -= 2;
+    }
+    tmp = i << 1;
+    if (tmp != 0)
+        num--;
+
+    return num;
+}
+#endif
+
+static int recode_wnaf(struct smvt_control *control,
+                       /* [nbits/(table_bits + 1) + 3] */
+                       const curve448_scalar_t scalar,
+                       unsigned int table_bits)
+{
+    unsigned int table_size = C448_SCALAR_BITS / (table_bits + 1) + 3;
+    int position = table_size - 1; /* at the end */
+    uint64_t current = scalar->limb[0] & 0xFFFF;
+    uint32_t mask = (1 << (table_bits + 1)) - 1;
+    unsigned int w;
+    const unsigned int B_OVER_16 = sizeof(scalar->limb[0]) / 2;
+    unsigned int n, i;
+
+    /* place the end marker */
+    control[position].power = -1;
+    control[position].addend = 0;
+    position--;
+
+    /*
+     * PERF: Could negate scalar if it's large.  But then would need more cases
+     * in the actual code that uses it, all for an expected reduction of like
+     * 1/5 op. Probably not worth it.
+     */
+
+    for (w = 1; w < (C448_SCALAR_BITS - 1) / 16 + 3; w++) {
+        if (w < (C448_SCALAR_BITS - 1) / 16 + 1) {
+            /* Refill the 16 high bits of current */
+            current += (uint32_t)((scalar->limb[w / B_OVER_16]
+                       >> (16 * (w % B_OVER_16))) << 16);
+        }
+
+        while (current & 0xFFFF) {
+            uint32_t pos = NUMTRAILINGZEROS((uint32_t)current);
+            uint32_t odd = (uint32_t)current >> pos;
+            int32_t delta = odd & mask;
+
+            assert(position >= 0);
+            if (odd & (1 << (table_bits + 1)))
+                delta -= (1 << (table_bits + 1));
+            current -= delta * (1 << pos);
+            control[position].power = pos + 16 * (w - 1);
+            control[position].addend = delta;
+            position--;
+        }
+        current >>= 16;
+    }
+    assert(current == 0);
+
+    position++;
+    n = table_size - position;
+    for (i = 0; i < n; i++)
+        control[i] = control[i + position];
+
+    return n - 1;
+}
+
+static void prepare_wnaf_table(pniels_t * output,
+                               const curve448_point_t working,
+                               unsigned int tbits)
+{
+    curve448_point_t tmp;
+    int i;
+    pniels_t twop;
+
+    pt_to_pniels(output[0], working);
+
+    if (tbits == 0)
+        return;
+
+    curve448_point_double(tmp, working);
+    pt_to_pniels(twop, tmp);
+
+    add_pniels_to_pt(tmp, output[0], 0);
+    pt_to_pniels(output[1], tmp);
+
+    for (i = 2; i < 1 << tbits; i++) {
+        add_pniels_to_pt(tmp, twop, 0);
+        pt_to_pniels(output[i], tmp);
+    }
+
+    curve448_point_destroy(tmp);
+    OPENSSL_cleanse(twop, sizeof(twop));
+}
+
+void curve448_base_double_scalarmul_non_secret(curve448_point_t combo,
+                                               const curve448_scalar_t scalar1,
+                                               const curve448_point_t base2,
+                                               const curve448_scalar_t scalar2)
+{
+    const int table_bits_var = C448_WNAF_VAR_TABLE_BITS;
+    const int table_bits_pre = C448_WNAF_FIXED_TABLE_BITS;
+    struct smvt_control control_var[C448_SCALAR_BITS /
+                                    (C448_WNAF_VAR_TABLE_BITS + 1) + 3];
+    struct smvt_control control_pre[C448_SCALAR_BITS /
+                                    (C448_WNAF_FIXED_TABLE_BITS + 1) + 3];
+    int ncb_pre = recode_wnaf(control_pre, scalar1, table_bits_pre);
+    int ncb_var = recode_wnaf(control_var, scalar2, table_bits_var);
+    pniels_t precmp_var[1 << C448_WNAF_VAR_TABLE_BITS];
+    int contp = 0, contv = 0, i;
+
+    prepare_wnaf_table(precmp_var, base2, table_bits_var);
+    i = control_var[0].power;
+
+    if (i < 0) {
+        curve448_point_copy(combo, curve448_point_identity);
+        return;
+    }
+    if (i > control_pre[0].power) {
+        pniels_to_pt(combo, precmp_var[control_var[0].addend >> 1]);
+        contv++;
+    } else if (i == control_pre[0].power && i >= 0) {
+        pniels_to_pt(combo, precmp_var[control_var[0].addend >> 1]);
+        add_niels_to_pt(combo, curve448_wnaf_base[control_pre[0].addend >> 1],
+                        i);
+        contv++;
+        contp++;
+    } else {
+        i = control_pre[0].power;
+        niels_to_pt(combo, curve448_wnaf_base[control_pre[0].addend >> 1]);
+        contp++;
+    }
+
+    for (i--; i >= 0; i--) {
+        int cv = (i == control_var[contv].power);
+        int cp = (i == control_pre[contp].power);
+
+        point_double_internal(combo, combo, i && !(cv || cp));
+
+        if (cv) {
+            assert(control_var[contv].addend);
+
+            if (control_var[contv].addend > 0)
+                add_pniels_to_pt(combo,
+                                 precmp_var[control_var[contv].addend >> 1],
+                                 i && !cp);
+            else
+                sub_pniels_from_pt(combo,
+                                   precmp_var[(-control_var[contv].addend)
+                                              >> 1], i && !cp);
+            contv++;
+        }
+
+        if (cp) {
+            assert(control_pre[contp].addend);
+
+            if (control_pre[contp].addend > 0)
+                add_niels_to_pt(combo,
+                                curve448_wnaf_base[control_pre[contp].addend
+                                                   >> 1], i);
+            else
+                sub_niels_from_pt(combo,
+                                  curve448_wnaf_base[(-control_pre
+                                                      [contp].addend) >> 1], i);
+            contp++;
+        }
+    }
+
+    /* This function is non-secret, but whatever this is cheap. */
+    OPENSSL_cleanse(control_var, sizeof(control_var));
+    OPENSSL_cleanse(control_pre, sizeof(control_pre));
+    OPENSSL_cleanse(precmp_var, sizeof(precmp_var));
+
+    assert(contv == ncb_var);
+    (void)ncb_var;
+    assert(contp == ncb_pre);
+    (void)ncb_pre;
+}
+
+void curve448_point_destroy(curve448_point_t point)
+{
+    OPENSSL_cleanse(point, sizeof(curve448_point_t));
+}
+
+int X448(uint8_t out_shared_key[56], const uint8_t private_key[56],
+         const uint8_t peer_public_value[56])
+{
+    return x448_int(out_shared_key, peer_public_value, private_key)
+           == C448_SUCCESS;
+}
+
+void X448_public_from_private(uint8_t out_public_value[56],
+                              const uint8_t private_key[56])
+{
+    x448_derive_public_key(out_public_value, private_key);
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448_local.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448_local.h
new file mode 100644
index 000000000..b27770661
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448_local.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (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_EC_CURVE448_LOCAL_H
+# define OSSL_CRYPTO_EC_CURVE448_LOCAL_H
+# include "curve448utils.h"
+
+int X448(uint8_t out_shared_key[56], const uint8_t private_key[56],
+         const uint8_t peer_public_value[56]);
+
+void X448_public_from_private(uint8_t out_public_value[56],
+                              const uint8_t private_key[56]);
+
+int ED448_sign(uint8_t *out_sig, const uint8_t *message, size_t message_len,
+               const uint8_t public_key[57], const uint8_t private_key[57],
+               const uint8_t *context, size_t context_len);
+
+int ED448_verify(const uint8_t *message, size_t message_len,
+                 const uint8_t signature[114], const uint8_t public_key[57],
+                 const uint8_t *context, size_t context_len);
+
+int ED448ph_sign(uint8_t *out_sig, const uint8_t hash[64],
+                 const uint8_t public_key[57], const uint8_t private_key[57],
+                 const uint8_t *context, size_t context_len);
+
+int ED448ph_verify(const uint8_t hash[64], const uint8_t signature[114],
+                   const uint8_t public_key[57], const uint8_t *context,
+                   size_t context_len);
+
+int ED448_public_from_private(uint8_t out_public_key[57],
+                              const uint8_t private_key[57]);
+
+#endif              /* OSSL_CRYPTO_EC_CURVE448_LOCAL_H */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448_tables.c b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448_tables.c
new file mode 100644
index 000000000..9ef29769e
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448_tables.c
@@ -0,0 +1,1483 @@
+/*
+ * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+#include "field.h"
+
+#include "point_448.h"
+
+static const curve448_precomputed_s curve448_precomputed_base_table = {
+    {
+        {{
+            {FIELD_LITERAL(0x00cc3b062366f4ccULL, 0x003d6e34e314aa3cULL,
+                           0x00d51c0a7521774dULL, 0x0094e060eec6ab8bULL,
+                           0x00d21291b4d80082ULL, 0x00befed12b55ef1eULL,
+                           0x00c3dd2df5c94518ULL, 0x00e0a7b112b8d4e6ULL)},
+            {FIELD_LITERAL(0x0019eb5608d8723aULL, 0x00d1bab52fb3aedbULL,
+                           0x00270a7311ebc90cULL, 0x0037c12b91be7f13ULL,
+                           0x005be16cd8b5c704ULL, 0x003e181acda888e1ULL,
+                           0x00bc1f00fc3fc6d0ULL, 0x00d3839bfa319e20ULL)},
+            {FIELD_LITERAL(0x003caeb88611909fULL, 0x00ea8b378c4df3d4ULL,
+                           0x00b3295b95a5a19aULL, 0x00a65f97514bdfb5ULL,
+                           0x00b39efba743cab1ULL, 0x0016ba98b862fd2dULL,
+                           0x0001508812ee71d7ULL, 0x000a75740eea114aULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00ebcf0eb649f823ULL, 0x00166d332e98ea03ULL,
+                           0x0059ddf64f5cd5f6ULL, 0x0047763123d9471bULL,
+                           0x00a64065c53ef62fULL, 0x00978e44c480153dULL,
+                           0x000b5b2a0265f194ULL, 0x0046a24b9f32965aULL)},
+            {FIELD_LITERAL(0x00b9eef787034df0ULL, 0x0020bc24de3390cdULL,
+                           0x000022160bae99bbULL, 0x00ae66e886e97946ULL,
+                           0x0048d4bbe02cbb8bULL, 0x0072ba97b34e38d4ULL,
+                           0x00eae7ec8f03e85aULL, 0x005ba92ecf808b2cULL)},
+            {FIELD_LITERAL(0x00c9cfbbe74258fdULL, 0x00843a979ea9eaa7ULL,
+                           0x000cbb4371cfbe90ULL, 0x0059bac8f7f0a628ULL,
+                           0x004b3dff882ff530ULL, 0x0011869df4d90733ULL,
+                           0x00595aa71f4abfc2ULL, 0x0070e2d38990c2e6ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00de2010c0a01733ULL, 0x00c739a612e24297ULL,
+                           0x00a7212643141d7cULL, 0x00f88444f6b67c11ULL,
+                           0x00484b7b16ec28f2ULL, 0x009c1b8856af9c68ULL,
+                           0x00ff4669591fe9d6ULL, 0x0054974be08a32c8ULL)},
+            {FIELD_LITERAL(0x0010de3fd682ceedULL, 0x008c07642d83ca4eULL,
+                           0x0013bb064e00a1ccULL, 0x009411ae27870e11ULL,
+                           0x00ea8e5b4d531223ULL, 0x0032fe7d2aaece2eULL,
+                           0x00d989e243e7bb41ULL, 0x000fe79a508e9b8bULL)},
+            {FIELD_LITERAL(0x005e0426b9bfc5b1ULL, 0x0041a5b1d29ee4faULL,
+                           0x0015b0def7774391ULL, 0x00bc164f1f51af01ULL,
+                           0x00d543b0942797b9ULL, 0x003c129b6398099cULL,
+                           0x002b114c6e5adf18ULL, 0x00b4e630e4018a7bULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00d490afc95f8420ULL, 0x00b096bf50c1d9b9ULL,
+                           0x00799fd707679866ULL, 0x007c74d9334afbeaULL,
+                           0x00efaa8be80ff4edULL, 0x0075c4943bb81694ULL,
+                           0x00c21c2fca161f36ULL, 0x00e77035d492bfeeULL)},
+            {FIELD_LITERAL(0x006658a190dd6661ULL, 0x00e0e9bab38609a6ULL,
+                           0x0028895c802237edULL, 0x006a0229c494f587ULL,
+                           0x002dcde96c9916b7ULL, 0x00d158822de16218ULL,
+                           0x00173b917a06856fULL, 0x00ca78a79ae07326ULL)},
+            {FIELD_LITERAL(0x00e35bfc79caced4ULL, 0x0087238a3e1fe3bbULL,
+                           0x00bcbf0ff4ceff5bULL, 0x00a19c1c94099b91ULL,
+                           0x0071e102b49db976ULL, 0x0059e3d004eada1eULL,
+                           0x008da78afa58a47eULL, 0x00579c8ebf269187ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00a16c2905eee75fULL, 0x009d4bcaea2c7e1dULL,
+                           0x00d3bd79bfad19dfULL, 0x0050da745193342cULL,
+                           0x006abdb8f6b29ab1ULL, 0x00a24fe0a4fef7efULL,
+                           0x0063730da1057dfbULL, 0x00a08c312c8eb108ULL)},
+            {FIELD_LITERAL(0x00b583be005375beULL, 0x00a40c8f8a4e3df4ULL,
+                           0x003fac4a8f5bdbf7ULL, 0x00d4481d872cd718ULL,
+                           0x004dc8749cdbaefeULL, 0x00cce740d5e5c975ULL,
+                           0x000b1c1f4241fd21ULL, 0x00a76de1b4e1cd07ULL)},
+            {FIELD_LITERAL(0x007a076500d30b62ULL, 0x000a6e117b7f090fULL,
+                           0x00c8712ae7eebd9aULL, 0x000fbd6c1d5f6ff7ULL,
+                           0x003a7977246ebf11ULL, 0x00166ed969c6600eULL,
+                           0x00aa42e469c98becULL, 0x00dc58f307cf0666ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x004b491f65a9a28bULL, 0x006a10309e8a55b7ULL,
+                           0x00b67210185187efULL, 0x00cf6497b12d9b8fULL,
+                           0x0085778c56e2b1baULL, 0x0015b4c07a814d85ULL,
+                           0x00686479e62da561ULL, 0x008de5d88f114916ULL)},
+            {FIELD_LITERAL(0x00e37c88d6bba7b1ULL, 0x003e4577e1b8d433ULL,
+                           0x0050d8ea5f510ec0ULL, 0x0042fc9f2da9ef59ULL,
+                           0x003bd074c1141420ULL, 0x00561b8b7b68774eULL,
+                           0x00232e5e5d1013a3ULL, 0x006b7f2cb3d7e73fULL)},
+            {FIELD_LITERAL(0x004bdd0f0b41e6a0ULL, 0x001773057c405d24ULL,
+                           0x006029f99915bd97ULL, 0x006a5ba70a17fe2fULL,
+                           0x0046111977df7e08ULL, 0x004d8124c89fb6b7ULL,
+                           0x00580983b2bb2724ULL, 0x00207bf330d6f3feULL)},
+        }}, {{
+            {FIELD_LITERAL(0x007efdc93972a48bULL, 0x002f5e50e78d5feeULL,
+                           0x0080dc11d61c7fe5ULL, 0x0065aa598707245bULL,
+                           0x009abba2300641beULL, 0x000c68787656543aULL,
+                           0x00ffe0fef2dc0a17ULL, 0x00007ffbd6cb4f3aULL)},
+            {FIELD_LITERAL(0x0036012f2b836efcULL, 0x00458c126d6b5fbcULL,
+                           0x00a34436d719ad1eULL, 0x0097be6167117deaULL,
+                           0x0009c219c879cff3ULL, 0x0065564493e60755ULL,
+                           0x00993ac94a8cdec0ULL, 0x002d4885a4d0dbafULL)},
+            {FIELD_LITERAL(0x00598b60b4c068baULL, 0x00c547a0be7f1afdULL,
+                           0x009582164acf12afULL, 0x00af4acac4fbbe40ULL,
+                           0x005f6ca7c539121aULL, 0x003b6e752ebf9d66ULL,
+                           0x00f08a30d5cac5d4ULL, 0x00e399bb5f97c5a9ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x007445a0409c0a66ULL, 0x00a65c369f3829c0ULL,
+                           0x0031d248a4f74826ULL, 0x006817f34defbe8eULL,
+                           0x00649741d95ebf2eULL, 0x00d46466ab16b397ULL,
+                           0x00fdc35703bee414ULL, 0x00343b43334525f8ULL)},
+            {FIELD_LITERAL(0x001796bea93f6401ULL, 0x00090c5a42e85269ULL,
+                           0x00672412ba1252edULL, 0x001201d47b6de7deULL,
+                           0x006877bccfe66497ULL, 0x00b554fd97a4c161ULL,
+                           0x009753f42dbac3cfULL, 0x00e983e3e378270aULL)},
+            {FIELD_LITERAL(0x00ac3eff18849872ULL, 0x00f0eea3bff05690ULL,
+                           0x00a6d72c21dd505dULL, 0x001b832642424169ULL,
+                           0x00a6813017b540e5ULL, 0x00a744bd71b385cdULL,
+                           0x0022a7d089130a7bULL, 0x004edeec9a133486ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00b2d6729196e8a9ULL, 0x0088a9bb2031cef4ULL,
+                           0x00579e7787dc1567ULL, 0x0030f49feb059190ULL,
+                           0x00a0b1d69c7f7d8fULL, 0x0040bdcc6d9d806fULL,
+                           0x00d76c4037edd095ULL, 0x00bbf24376415dd7ULL)},
+            {FIELD_LITERAL(0x00240465ff5a7197ULL, 0x00bb97e76caf27d0ULL,
+                           0x004b4edbf8116d39ULL, 0x001d8586f708cbaaULL,
+                           0x000f8ee8ff8e4a50ULL, 0x00dde5a1945dd622ULL,
+                           0x00e6fc1c0957e07cULL, 0x0041c9cdabfd88a0ULL)},
+            {FIELD_LITERAL(0x005344b0bf5b548cULL, 0x002957d0b705cc99ULL,
+                           0x00f586a70390553dULL, 0x0075b3229f583cc3ULL,
+                           0x00a1aa78227490e4ULL, 0x001bf09cf7957717ULL,
+                           0x00cf6bf344325f52ULL, 0x0065bd1c23ca3ecfULL)},
+        }}, {{
+            {FIELD_LITERAL(0x009bff3b3239363cULL, 0x00e17368796ef7c0ULL,
+                           0x00528b0fe0971f3aULL, 0x0008014fc8d4a095ULL,
+                           0x00d09f2e8a521ec4ULL, 0x006713ab5dde5987ULL,
+                           0x0003015758e0dbb1ULL, 0x00215999f1ba212dULL)},
+            {FIELD_LITERAL(0x002c88e93527da0eULL, 0x0077c78f3456aad5ULL,
+                           0x0071087a0a389d1cULL, 0x00934dac1fb96dbdULL,
+                           0x008470e801162697ULL, 0x005bc2196cd4ad49ULL,
+                           0x00e535601d5087c3ULL, 0x00769888700f497fULL)},
+            {FIELD_LITERAL(0x00da7a4b557298adULL, 0x0019d2589ea5df76ULL,
+                           0x00ef3e38be0c6497ULL, 0x00a9644e1312609aULL,
+                           0x004592f61b2558daULL, 0x0082c1df510d7e46ULL,
+                           0x0042809a535c0023ULL, 0x00215bcb5afd7757ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x002b9df55a1a4213ULL, 0x00dcfc3b464a26beULL,
+                           0x00c4f9e07a8144d5ULL, 0x00c8e0617a92b602ULL,
+                           0x008e3c93accafae0ULL, 0x00bf1bcb95b2ca60ULL,
+                           0x004ce2426a613bf3ULL, 0x00266cac58e40921ULL)},
+            {FIELD_LITERAL(0x008456d5db76e8f0ULL, 0x0032ca9cab2ce163ULL,
+                           0x0059f2b8bf91abcfULL, 0x0063c2a021712788ULL,
+                           0x00f86155af22f72dULL, 0x00db98b2a6c005a0ULL,
+                           0x00ac6e416a693ac4ULL, 0x007a93572af53226ULL)},
+            {FIELD_LITERAL(0x0087767520f0de22ULL, 0x0091f64012279fb5ULL,
+                           0x001050f1f0644999ULL, 0x004f097a2477ad3cULL,
+                           0x006b37913a9947bdULL, 0x001a3d78645af241ULL,
+                           0x0057832bbb3008a7ULL, 0x002c1d902b80dc20ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x001a6002bf178877ULL, 0x009bce168aa5af50ULL,
+                           0x005fc318ff04a7f5ULL, 0x0052818f55c36461ULL,
+                           0x008768f5d4b24afbULL, 0x0037ffbae7b69c85ULL,
+                           0x0018195a4b61edc0ULL, 0x001e12ea088434b2ULL)},
+            {FIELD_LITERAL(0x0047d3f804e7ab07ULL, 0x00a809ab5f905260ULL,
+                           0x00b3ffc7cdaf306dULL, 0x00746e8ec2d6e509ULL,
+                           0x00d0dade8887a645ULL, 0x00acceeebde0dd37ULL,
+                           0x009bc2579054686bULL, 0x0023804f97f1c2bfULL)},
+            {FIELD_LITERAL(0x0043e2e2e50b80d7ULL, 0x00143aafe4427e0fULL,
+                           0x005594aaecab855bULL, 0x008b12ccaaecbc01ULL,
+                           0x002deeb091082bc3ULL, 0x009cca4be2ae7514ULL,
+                           0x00142b96e696d047ULL, 0x00ad2a2b1c05256aULL)},
+        }}, {{
+            {FIELD_LITERAL(0x003914f2f144b78bULL, 0x007a95dd8bee6f68ULL,
+                           0x00c7f4384d61c8e6ULL, 0x004e51eb60f1bdb2ULL,
+                           0x00f64be7aa4621d8ULL, 0x006797bfec2f0ac0ULL,
+                           0x007d17aab3c75900ULL, 0x001893e73cac8bc5ULL)},
+            {FIELD_LITERAL(0x00140360b768665bULL, 0x00b68aca4967f977ULL,
+                           0x0001089b66195ae4ULL, 0x00fe71122185e725ULL,
+                           0x000bca2618d49637ULL, 0x00a54f0557d7e98aULL,
+                           0x00cdcd2f91d6f417ULL, 0x00ab8c13741fd793ULL)},
+            {FIELD_LITERAL(0x00725ee6b1e549e0ULL, 0x007124a0769777faULL,
+                           0x000b68fdad07ae42ULL, 0x0085b909cd4952dfULL,
+                           0x0092d2e3c81606f4ULL, 0x009f22f6cac099a0ULL,
+                           0x00f59da57f2799a8ULL, 0x00f06c090122f777ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00ce0bed0a3532bcULL, 0x001a5048a22df16bULL,
+                           0x00e31db4cbad8bf1ULL, 0x00e89292120cf00eULL,
+                           0x007d1dd1a9b00034ULL, 0x00e2a9041ff8f680ULL,
+                           0x006a4c837ae596e7ULL, 0x00713af1068070b3ULL)},
+            {FIELD_LITERAL(0x00c4fe64ce66d04bULL, 0x00b095d52e09b3d7ULL,
+                           0x00758bbecb1a3a8eULL, 0x00f35cce8d0650c0ULL,
+                           0x002b878aa5984473ULL, 0x0062e0a3b7544ddcULL,
+                           0x00b25b290ed116feULL, 0x007b0f6abe0bebf2ULL)},
+            {FIELD_LITERAL(0x0081d4e3addae0a8ULL, 0x003410c836c7ffccULL,
+                           0x00c8129ad89e4314ULL, 0x000e3d5a23922dcdULL,
+                           0x00d91e46f29c31f3ULL, 0x006c728cde8c5947ULL,
+                           0x002bc655ba2566c0ULL, 0x002ca94721533108ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0051e4b3f764d8a9ULL, 0x0019792d46e904a0ULL,
+                           0x00853bc13dbc8227ULL, 0x000840208179f12dULL,
+                           0x0068243474879235ULL, 0x0013856fbfe374d0ULL,
+                           0x00bda12fe8676424ULL, 0x00bbb43635926eb2ULL)},
+            {FIELD_LITERAL(0x0012cdc880a93982ULL, 0x003c495b21cd1b58ULL,
+                           0x00b7e5c93f22a26eULL, 0x0044aa82dfb99458ULL,
+                           0x009ba092cdffe9c0ULL, 0x00a14b3ab2083b73ULL,
+                           0x000271c2f70e1c4bULL, 0x00eea9cac0f66eb8ULL)},
+            {FIELD_LITERAL(0x001a1847c4ac5480ULL, 0x00b1b412935bb03aULL,
+                           0x00f74285983bf2b2ULL, 0x00624138b5b5d0f1ULL,
+                           0x008820c0b03d38bfULL, 0x00b94e50a18c1572ULL,
+                           0x0060f6934841798fULL, 0x00c52f5d66d6ebe2ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00da23d59f9bcea6ULL, 0x00e0f27007a06a4bULL,
+                           0x00128b5b43a6758cULL, 0x000cf50190fa8b56ULL,
+                           0x00fc877aba2b2d72ULL, 0x00623bef52edf53fULL,
+                           0x00e6af6b819669e2ULL, 0x00e314dc34fcaa4fULL)},
+            {FIELD_LITERAL(0x0066e5eddd164d1eULL, 0x00418a7c6fe28238ULL,
+                           0x0002e2f37e962c25ULL, 0x00f01f56b5975306ULL,
+                           0x0048842fa503875cULL, 0x0057b0e968078143ULL,
+                           0x00ff683024f3d134ULL, 0x0082ae28fcad12e4ULL)},
+            {FIELD_LITERAL(0x0011ddfd21260e42ULL, 0x00d05b0319a76892ULL,
+                           0x00183ea4368e9b8fULL, 0x00b0815662affc96ULL,
+                           0x00b466a5e7ce7c88ULL, 0x00db93b07506e6eeULL,
+                           0x0033885f82f62401ULL, 0x0086f9090ec9b419ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00d95d1c5fcb435aULL, 0x0016d1ed6b5086f9ULL,
+                           0x00792aa0b7e54d71ULL, 0x0067b65715f1925dULL,
+                           0x00a219755ec6176bULL, 0x00bc3f026b12c28fULL,
+                           0x00700c897ffeb93eULL, 0x0089b83f6ec50b46ULL)},
+            {FIELD_LITERAL(0x003c97e6384da36eULL, 0x00423d53eac81a09ULL,
+                           0x00b70d68f3cdce35ULL, 0x00ee7959b354b92cULL,
+                           0x00f4e9718819c8caULL, 0x009349f12acbffe9ULL,
+                           0x005aee7b62cb7da6ULL, 0x00d97764154ffc86ULL)},
+            {FIELD_LITERAL(0x00526324babb46dcULL, 0x002ee99b38d7bf9eULL,
+                           0x007ea51794706ef4ULL, 0x00abeb04da6e3c39ULL,
+                           0x006b457c1d281060ULL, 0x00fe243e9a66c793ULL,
+                           0x00378de0fb6c6ee4ULL, 0x003e4194b9c3cb93ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00fed3cd80ca2292ULL, 0x0015b043a73ca613ULL,
+                           0x000a9fd7bf9be227ULL, 0x003b5e03de2db983ULL,
+                           0x005af72d46904ef7ULL, 0x00c0f1b5c49faa99ULL,
+                           0x00dc86fc3bd305e1ULL, 0x00c92f08c1cb1797ULL)},
+            {FIELD_LITERAL(0x0079680ce111ed3bULL, 0x001a1ed82806122cULL,
+                           0x000c2e7466d15df3ULL, 0x002c407f6f7150fdULL,
+                           0x00c5e7c96b1b0ce3ULL, 0x009aa44626863ff9ULL,
+                           0x00887b8b5b80be42ULL, 0x00b6023cec964825ULL)},
+            {FIELD_LITERAL(0x00e4a8e1048970c8ULL, 0x0062887b7830a302ULL,
+                           0x00bcf1c8cd81402bULL, 0x0056dbb81a68f5beULL,
+                           0x0014eced83f12452ULL, 0x00139e1a510150dfULL,
+                           0x00bb81140a82d1a3ULL, 0x000febcc1aaf1aa7ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00a7527958238159ULL, 0x0013ec9537a84cd6ULL,
+                           0x001d7fee7d562525ULL, 0x00b9eefa6191d5e5ULL,
+                           0x00dbc97db70bcb8aULL, 0x00481affc7a4d395ULL,
+                           0x006f73d3e70c31bbULL, 0x00183f324ed96a61ULL)},
+            {FIELD_LITERAL(0x0039dd7ce7fc6860ULL, 0x00d64f6425653da1ULL,
+                           0x003e037c7f57d0afULL, 0x0063477a06e2bcf2ULL,
+                           0x001727dbb7ac67e6ULL, 0x0049589f5efafe2eULL,
+                           0x00fc0fef2e813d54ULL, 0x008baa5d087fb50dULL)},
+            {FIELD_LITERAL(0x0024fb59d9b457c7ULL, 0x00a7d4e060223e4cULL,
+                           0x00c118d1b555fd80ULL, 0x0082e216c732f22aULL,
+                           0x00cd2a2993089504ULL, 0x003638e836a3e13dULL,
+                           0x000d855ee89b4729ULL, 0x008ec5b7d4810c91ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x001bf51f7d65cdfdULL, 0x00d14cdafa16a97dULL,
+                           0x002c38e60fcd10e7ULL, 0x00a27446e393efbdULL,
+                           0x000b5d8946a71fddULL, 0x0063df2cde128f2fULL,
+                           0x006c8679569b1888ULL, 0x0059ffc4925d732dULL)},
+            {FIELD_LITERAL(0x00ece96f95f2b66fULL, 0x00ece7952813a27bULL,
+                           0x0026fc36592e489eULL, 0x007157d1a2de0f66ULL,
+                           0x00759dc111d86ddfULL, 0x0012881e5780bb0fULL,
+                           0x00c8ccc83ad29496ULL, 0x0012b9bd1929eb71ULL)},
+            {FIELD_LITERAL(0x000fa15a20da5df0ULL, 0x00349ddb1a46cd31ULL,
+                           0x002c512ad1d8e726ULL, 0x00047611f669318dULL,
+                           0x009e68fba591e17eULL, 0x004320dffa803906ULL,
+                           0x00a640874951a3d3ULL, 0x00b6353478baa24fULL)},
+        }}, {{
+            {FIELD_LITERAL(0x009696510000d333ULL, 0x00ec2f788bc04826ULL,
+                           0x000e4d02b1f67ba5ULL, 0x00659aa8dace08b6ULL,
+                           0x00d7a38a3a3ae533ULL, 0x008856defa8c746bULL,
+                           0x004d7a4402d3da1aULL, 0x00ea82e06229260fULL)},
+            {FIELD_LITERAL(0x006a15bb20f75c0cULL, 0x0079a144027a5d0cULL,
+                           0x00d19116ce0b4d70ULL, 0x0059b83bcb0b268eULL,
+                           0x005f58f63f16c127ULL, 0x0079958318ee2c37ULL,
+                           0x00defbb063d07f82ULL, 0x00f1f0b931d2d446ULL)},
+            {FIELD_LITERAL(0x00cb5e4c3c35d422ULL, 0x008df885ca43577fULL,
+                           0x00fa50b16ca3e471ULL, 0x005a0e58e17488c8ULL,
+                           0x00b2ceccd6d34d19ULL, 0x00f01d5d235e36e9ULL,
+                           0x00db2e7e4be6ca44ULL, 0x00260ab77f35fccdULL)},
+        }}, {{
+            {FIELD_LITERAL(0x006f6fd9baac61d5ULL, 0x002a7710a020a895ULL,
+                           0x009de0db7fc03d4dULL, 0x00cdedcb1875f40bULL,
+                           0x00050caf9b6b1e22ULL, 0x005e3a6654456ab0ULL,
+                           0x00775fdf8c4423d4ULL, 0x0028701ea5738b5dULL)},
+            {FIELD_LITERAL(0x009ffd90abfeae96ULL, 0x00cba3c2b624a516ULL,
+                           0x005ef08bcee46c91ULL, 0x00e6fde30afb6185ULL,
+                           0x00f0b4db4f818ce4ULL, 0x006c54f45d2127f5ULL,
+                           0x00040125035854c7ULL, 0x00372658a3287e13ULL)},
+            {FIELD_LITERAL(0x00d7070fb1beb2abULL, 0x0078fc845a93896bULL,
+                           0x006894a4b2f224a6ULL, 0x005bdd8192b9dbdeULL,
+                           0x00b38839874b3a9eULL, 0x00f93618b04b7a57ULL,
+                           0x003e3ec75fd2c67eULL, 0x00bf5e6bfc29494aULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00f19224ebba2aa5ULL, 0x0074f89d358e694dULL,
+                           0x00eea486597135adULL, 0x0081579a4555c7e1ULL,
+                           0x0010b9b872930a9dULL, 0x00f002e87a30ecc0ULL,
+                           0x009b9d66b6de56e2ULL, 0x00a3c4f45e8004ebULL)},
+            {FIELD_LITERAL(0x0045e8dda9400888ULL, 0x002ff12e5fc05db7ULL,
+                           0x00a7098d54afe69cULL, 0x00cdbe846a500585ULL,
+                           0x00879c1593ca1882ULL, 0x003f7a7fea76c8b0ULL,
+                           0x002cd73dd0c8e0a1ULL, 0x00645d6ce96f51feULL)},
+            {FIELD_LITERAL(0x002b7e83e123d6d6ULL, 0x00398346f7419c80ULL,
+                           0x0042922e55940163ULL, 0x005e7fc5601886a3ULL,
+                           0x00e88f2cee1d3103ULL, 0x00e7fab135f2e377ULL,
+                           0x00b059984dbf0dedULL, 0x0009ce080faa5bb8ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0085e78af7758979ULL, 0x00275a4ee1631a3aULL,
+                           0x00d26bc0ed78b683ULL, 0x004f8355ea21064fULL,
+                           0x00d618e1a32696e5ULL, 0x008d8d7b150e5680ULL,
+                           0x00a74cd854b278d2ULL, 0x001dd62702203ea0ULL)},
+            {FIELD_LITERAL(0x00f89335c2a59286ULL, 0x00a0f5c905d55141ULL,
+                           0x00b41fb836ee9382ULL, 0x00e235d51730ca43ULL,
+                           0x00a5cb37b5c0a69aULL, 0x009b966ffe136c45ULL,
+                           0x00cb2ea10bf80ed1ULL, 0x00fb2b370b40dc35ULL)},
+            {FIELD_LITERAL(0x00d687d16d4ee8baULL, 0x0071520bdd069dffULL,
+                           0x00de85c60d32355dULL, 0x0087d2e3565102f4ULL,
+                           0x00cde391b8dfc9aaULL, 0x00e18d69efdfefe5ULL,
+                           0x004a9d0591954e91ULL, 0x00fa36dd8b50eee5ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x002e788749a865f7ULL, 0x006e4dc3116861eaULL,
+                           0x009f1428c37276e6ULL, 0x00e7d2e0fc1e1226ULL,
+                           0x003aeebc6b6c45f6ULL, 0x0071a8073bf500c9ULL,
+                           0x004b22ad986b530cULL, 0x00f439e63c0d79d4ULL)},
+            {FIELD_LITERAL(0x006bc3d53011f470ULL, 0x00032d6e692b83e8ULL,
+                           0x00059722f497cd0bULL, 0x0009b4e6f0c497ccULL,
+                           0x0058a804b7cce6c0ULL, 0x002b71d3302bbd5dULL,
+                           0x00e2f82a36765fceULL, 0x008dded99524c703ULL)},
+            {FIELD_LITERAL(0x004d058953747d64ULL, 0x00701940fe79aa6fULL,
+                           0x00a620ac71c760bfULL, 0x009532b611158b75ULL,
+                           0x00547ed7f466f300ULL, 0x003cb5ab53a8401aULL,
+                           0x00c7763168ce3120ULL, 0x007e48e33e4b9ab2ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x001b2fc57bf3c738ULL, 0x006a3f918993fb80ULL,
+                           0x0026f7a14fdec288ULL, 0x0075a2cdccef08dbULL,
+                           0x00d3ecbc9eecdbf1ULL, 0x0048c40f06e5bf7fULL,
+                           0x00d63e423009896bULL, 0x000598bc99c056a8ULL)},
+            {FIELD_LITERAL(0x002f194eaafa46dcULL, 0x008e38f57fe87613ULL,
+                           0x00dc8e5ae25f4ab2ULL, 0x000a17809575e6bdULL,
+                           0x00d3ec7923ba366aULL, 0x003a7e72e0ad75e3ULL,
+                           0x0010024b88436e0aULL, 0x00ed3c5444b64051ULL)},
+            {FIELD_LITERAL(0x00831fc1340af342ULL, 0x00c9645669466d35ULL,
+                           0x007692b4cc5a080fULL, 0x009fd4a47ac9259fULL,
+                           0x001eeddf7d45928bULL, 0x003c0446fc45f28bULL,
+                           0x002c0713aa3e2507ULL, 0x0095706935f0f41eULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00766ae4190ec6d8ULL, 0x0065768cabc71380ULL,
+                           0x00b902598416cdc2ULL, 0x00380021ad38df52ULL,
+                           0x008f0b89d6551134ULL, 0x004254d4cc62c5a5ULL,
+                           0x000d79f4484b9b94ULL, 0x00b516732ae3c50eULL)},
+            {FIELD_LITERAL(0x001fb73475c45509ULL, 0x00d2b2e5ea43345aULL,
+                           0x00cb3c3842077bd1ULL, 0x0029f90ad820946eULL,
+                           0x007c11b2380778aaULL, 0x009e54ece62c1704ULL,
+                           0x004bc60c41ca01c3ULL, 0x004525679a5a0b03ULL)},
+            {FIELD_LITERAL(0x00c64fbddbed87b3ULL, 0x0040601d11731faaULL,
+                           0x009c22475b6f9d67ULL, 0x0024b79dae875f15ULL,
+                           0x00616fed3f02c3b0ULL, 0x0000cf39f6af2d3bULL,
+                           0x00c46bac0aa9a688ULL, 0x00ab23e2800da204ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x000b3a37617632b0ULL, 0x00597199fe1cfb6cULL,
+                           0x0042a7ccdfeafdd6ULL, 0x004cc9f15ebcea17ULL,
+                           0x00f436e596a6b4a4ULL, 0x00168861142df0d8ULL,
+                           0x000753edfec26af5ULL, 0x000c495d7e388116ULL)},
+            {FIELD_LITERAL(0x0017085f4a346148ULL, 0x00c7cf7a37f62272ULL,
+                           0x001776e129bc5c30ULL, 0x009955134c9eef2aULL,
+                           0x001ba5bdf1df07beULL, 0x00ec39497103a55cULL,
+                           0x006578354fda6cfbULL, 0x005f02719d4f15eeULL)},
+            {FIELD_LITERAL(0x0052b9d9b5d9655dULL, 0x00d4ec7ba1b461c3ULL,
+                           0x00f95df4974f280bULL, 0x003d8e5ca11aeb51ULL,
+                           0x00d4981eb5a70b26ULL, 0x000af9a4f6659f29ULL,
+                           0x004598c846faeb43ULL, 0x0049d9a183a47670ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x000a72d23dcb3f1fULL, 0x00a3737f84011727ULL,
+                           0x00f870c0fbbf4a47ULL, 0x00a7aadd04b5c9caULL,
+                           0x000c7715c67bd072ULL, 0x00015a136afcd74eULL,
+                           0x0080d5caea499634ULL, 0x0026b448ec7514b7ULL)},
+            {FIELD_LITERAL(0x00b60167d9e7d065ULL, 0x00e60ba0d07381e8ULL,
+                           0x003a4f17b725c2d4ULL, 0x006c19fe176b64faULL,
+                           0x003b57b31af86ccbULL, 0x0021047c286180fdULL,
+                           0x00bdc8fb00c6dbb6ULL, 0x00fe4a9f4bab4f3fULL)},
+            {FIELD_LITERAL(0x0088ffc3a16111f7ULL, 0x009155e4245d0bc8ULL,
+                           0x00851d68220572d5ULL, 0x00557ace1e514d29ULL,
+                           0x0031d7c339d91022ULL, 0x00101d0ae2eaceeaULL,
+                           0x00246ab3f837b66aULL, 0x00d5216d381ff530ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0057e7ea35f36daeULL, 0x00f47d7ad15de22eULL,
+                           0x00d757ea4b105115ULL, 0x008311457d579d7eULL,
+                           0x00b49b75b1edd4ebULL, 0x0081c7ff742fd63aULL,
+                           0x00ddda3187433df6ULL, 0x00475727d55f9c66ULL)},
+            {FIELD_LITERAL(0x00a6295218dc136aULL, 0x00563b3af0e9c012ULL,
+                           0x00d3753b0145db1bULL, 0x004550389c043dc1ULL,
+                           0x00ea94ae27401bdfULL, 0x002b0b949f2b7956ULL,
+                           0x00c63f780ad8e23cULL, 0x00e591c47d6bab15ULL)},
+            {FIELD_LITERAL(0x00416c582b058eb6ULL, 0x004107da5b2cc695ULL,
+                           0x00b3cd2556aeec64ULL, 0x00c0b418267e57a1ULL,
+                           0x001799293579bd2eULL, 0x0046ed44590e4d07ULL,
+                           0x001d7459b3630a1eULL, 0x00c6afba8b6696aaULL)},
+        }}, {{
+            {FIELD_LITERAL(0x008d6009b26da3f8ULL, 0x00898e88ca06b1caULL,
+                           0x00edb22b2ed7fe62ULL, 0x00fbc93516aabe80ULL,
+                           0x008b4b470c42ce0dULL, 0x00e0032ba7d0dcbbULL,
+                           0x00d76da3a956ecc8ULL, 0x007f20fe74e3852aULL)},
+            {FIELD_LITERAL(0x002419222c607674ULL, 0x00a7f23af89188b3ULL,
+                           0x00ad127284e73d1cULL, 0x008bba582fae1c51ULL,
+                           0x00fc6aa7ca9ecab1ULL, 0x003df5319eb6c2baULL,
+                           0x002a05af8a8b199aULL, 0x004bf8354558407cULL)},
+            {FIELD_LITERAL(0x00ce7d4a30f0fcbfULL, 0x00d02c272629f03dULL,
+                           0x0048c001f7400bc2ULL, 0x002c21368011958dULL,
+                           0x0098a550391e96b5ULL, 0x002d80b66390f379ULL,
+                           0x001fa878760cc785ULL, 0x001adfce54b613d5ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x001ed4dc71fa2523ULL, 0x005d0bff19bf9b5cULL,
+                           0x00c3801cee065a64ULL, 0x001ed0b504323fbfULL,
+                           0x0003ab9fdcbbc593ULL, 0x00df82070178b8d2ULL,
+                           0x00a2bcaa9c251f85ULL, 0x00c628a3674bd02eULL)},
+            {FIELD_LITERAL(0x006b7a0674f9f8deULL, 0x00a742414e5c7cffULL,
+                           0x0041cbf3c6e13221ULL, 0x00e3a64fd207af24ULL,
+                           0x0087c05f15fbe8d1ULL, 0x004c50936d9e8a33ULL,
+                           0x001306ec21042b6dULL, 0x00a4f4137d1141c2ULL)},
+            {FIELD_LITERAL(0x0009e6fb921568b0ULL, 0x00b3c60120219118ULL,
+                           0x002a6c3460dd503aULL, 0x009db1ef11654b54ULL,
+                           0x0063e4bf0be79601ULL, 0x00670d34bb2592b9ULL,
+                           0x00dcee2f6c4130ceULL, 0x00b2682e88e77f54ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x000d5b4b3da135abULL, 0x00838f3e5064d81dULL,
+                           0x00d44eb50f6d94edULL, 0x0008931ab502ac6dULL,
+                           0x00debe01ca3d3586ULL, 0x0025c206775f0641ULL,
+                           0x005ad4b6ae912763ULL, 0x007e2c318ad8f247ULL)},
+            {FIELD_LITERAL(0x00ddbe0750dd1addULL, 0x004b3c7b885844b8ULL,
+                           0x00363e7ecf12f1aeULL, 0x0062e953e6438f9dULL,
+                           0x0023cc73b076afe9ULL, 0x00b09fa083b4da32ULL,
+                           0x00c7c3d2456c541dULL, 0x005b591ec6b694d4ULL)},
+            {FIELD_LITERAL(0x0028656e19d62fcfULL, 0x0052a4af03df148dULL,
+                           0x00122765ddd14e42ULL, 0x00f2252904f67157ULL,
+                           0x004741965b636f3aULL, 0x006441d296132cb9ULL,
+                           0x005e2106f956a5b7ULL, 0x00247029592d335cULL)},
+        }}, {{
+            {FIELD_LITERAL(0x003fe038eb92f894ULL, 0x000e6da1b72e8e32ULL,
+                           0x003a1411bfcbe0faULL, 0x00b55d473164a9e4ULL,
+                           0x00b9a775ac2df48dULL, 0x0002ddf350659e21ULL,
+                           0x00a279a69eb19cb3ULL, 0x00f844eab25cba44ULL)},
+            {FIELD_LITERAL(0x00c41d1f9c1f1ac1ULL, 0x007b2df4e9f19146ULL,
+                           0x00b469355fd5ba7aULL, 0x00b5e1965afc852aULL,
+                           0x00388d5f1e2d8217ULL, 0x0022079e4c09ae93ULL,
+                           0x0014268acd4ef518ULL, 0x00c1dd8d9640464cULL)},
+            {FIELD_LITERAL(0x0038526adeed0c55ULL, 0x00dd68c607e3fe85ULL,
+                           0x00f746ddd48a5d57ULL, 0x0042f2952b963b7cULL,
+                           0x001cbbd6876d5ec2ULL, 0x005e341470bca5c2ULL,
+                           0x00871d41e085f413ULL, 0x00e53ab098f45732ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x004d51124797c831ULL, 0x008f5ae3750347adULL,
+                           0x0070ced94c1a0c8eULL, 0x00f6db2043898e64ULL,
+                           0x000d00c9a5750cd0ULL, 0x000741ec59bad712ULL,
+                           0x003c9d11aab37b7fULL, 0x00a67ba169807714ULL)},
+            {FIELD_LITERAL(0x00adb2c1566e8b8fULL, 0x0096c68a35771a9aULL,
+                           0x00869933356f334aULL, 0x00ba9c93459f5962ULL,
+                           0x009ec73fb6e8ca4bULL, 0x003c3802c27202e1ULL,
+                           0x0031f5b733e0c008ULL, 0x00f9058c19611fa9ULL)},
+            {FIELD_LITERAL(0x00238f01814a3421ULL, 0x00c325a44b6cce28ULL,
+                           0x002136f97aeb0e73ULL, 0x000cac8268a4afe2ULL,
+                           0x0022fd218da471b3ULL, 0x009dcd8dfff8def9ULL,
+                           0x00cb9f8181d999bbULL, 0x00143ae56edea349ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0000623bf87622c5ULL, 0x00a1966fdd069496ULL,
+                           0x00c315b7b812f9fcULL, 0x00bdf5efcd128b97ULL,
+                           0x001d464f532e3e16ULL, 0x003cd94f081bfd7eULL,
+                           0x00ed9dae12ce4009ULL, 0x002756f5736eee70ULL)},
+            {FIELD_LITERAL(0x00a5187e6ee7341bULL, 0x00e6d52e82d83b6eULL,
+                           0x00df3c41323094a7ULL, 0x00b3324f444e9de9ULL,
+                           0x00689eb21a35bfe5ULL, 0x00f16363becd548dULL,
+                           0x00e187cc98e7f60fULL, 0x00127d9062f0ccabULL)},
+            {FIELD_LITERAL(0x004ad71b31c29e40ULL, 0x00a5fcace12fae29ULL,
+                           0x004425b5597280edULL, 0x00e7ef5d716c3346ULL,
+                           0x0010b53ada410ac8ULL, 0x0092310226060c9bULL,
+                           0x0091c26128729c7eULL, 0x0088b42900f8ec3bULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00f1e26e9762d4a8ULL, 0x00d9d74082183414ULL,
+                           0x00ffec9bd57a0282ULL, 0x000919e128fd497aULL,
+                           0x00ab7ae7d00fe5f8ULL, 0x0054dc442851ff68ULL,
+                           0x00c9ebeb3b861687ULL, 0x00507f7cab8b698fULL)},
+            {FIELD_LITERAL(0x00c13c5aae3ae341ULL, 0x009c6c9ed98373e7ULL,
+                           0x00098f26864577a8ULL, 0x0015b886e9488b45ULL,
+                           0x0037692c42aadba5ULL, 0x00b83170b8e7791cULL,
+                           0x001670952ece1b44ULL, 0x00fd932a39276da2ULL)},
+            {FIELD_LITERAL(0x0081a3259bef3398ULL, 0x005480fff416107bULL,
+                           0x00ce4f607d21be98ULL, 0x003ffc084b41df9bULL,
+                           0x0043d0bb100502d1ULL, 0x00ec35f575ba3261ULL,
+                           0x00ca18f677300ef3ULL, 0x00e8bb0a827d8548ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00df76b3328ada72ULL, 0x002e20621604a7c2ULL,
+                           0x00f910638a105b09ULL, 0x00ef4724d96ef2cdULL,
+                           0x00377d83d6b8a2f7ULL, 0x00b4f48805ade324ULL,
+                           0x001cd5da8b152018ULL, 0x0045af671a20ca7fULL)},
+            {FIELD_LITERAL(0x009ae3b93a56c404ULL, 0x004a410b7a456699ULL,
+                           0x00023a619355e6b2ULL, 0x009cdc7297387257ULL,
+                           0x0055b94d4ae70d04ULL, 0x002cbd607f65b005ULL,
+                           0x003208b489697166ULL, 0x00ea2aa058867370ULL)},
+            {FIELD_LITERAL(0x00f29d2598ee3f32ULL, 0x00b4ac5385d82adcULL,
+                           0x007633eaf04df19bULL, 0x00aa2d3d77ceab01ULL,
+                           0x004a2302fcbb778aULL, 0x00927f225d5afa34ULL,
+                           0x004a8e9d5047f237ULL, 0x008224ae9dbce530ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x001cf640859b02f8ULL, 0x00758d1d5d5ce427ULL,
+                           0x00763c784ef4604cULL, 0x005fa81aee205270ULL,
+                           0x00ac537bfdfc44cbULL, 0x004b919bd342d670ULL,
+                           0x00238508d9bf4b7aULL, 0x00154888795644f3ULL)},
+            {FIELD_LITERAL(0x00c845923c084294ULL, 0x00072419a201bc25ULL,
+                           0x0045f408b5f8e669ULL, 0x00e9d6a186b74dfeULL,
+                           0x00e19108c68fa075ULL, 0x0017b91d874177b7ULL,
+                           0x002f0ca2c7912c5aULL, 0x009400aa385a90a2ULL)},
+            {FIELD_LITERAL(0x0071110b01482184ULL, 0x00cfed0044f2bef8ULL,
+                           0x0034f2901cf4662eULL, 0x003b4ae2a67f9834ULL,
+                           0x00cca9b96fe94810ULL, 0x00522507ae77abd0ULL,
+                           0x00bac7422721e73eULL, 0x0066622b0f3a62b0ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00f8ac5cf4705b6aULL, 0x00867d82dcb457e3ULL,
+                           0x007e13ab2ccc2ce9ULL, 0x009ee9a018d3930eULL,
+                           0x008370f8ecb42df8ULL, 0x002d9f019add263eULL,
+                           0x003302385b92d196ULL, 0x00a15654536e2c0cULL)},
+            {FIELD_LITERAL(0x0026ef1614e160afULL, 0x00c023f9edfc9c76ULL,
+                           0x00cff090da5f57baULL, 0x0076db7a66643ae9ULL,
+                           0x0019462f8c646999ULL, 0x008fec00b3854b22ULL,
+                           0x00d55041692a0a1cULL, 0x0065db894215ca00ULL)},
+            {FIELD_LITERAL(0x00a925036e0a451cULL, 0x002a0390c36b6cc1ULL,
+                           0x00f27020d90894f4ULL, 0x008d90d52cbd3d7fULL,
+                           0x00e1d0137392f3b8ULL, 0x00f017c158b51a8fULL,
+                           0x00cac313d3ed7dbcULL, 0x00b99a81e3eb42d3ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00b54850275fe626ULL, 0x0053a3fd1ec71140ULL,
+                           0x00e3d2d7dbe096faULL, 0x00e4ac7b595cce4cULL,
+                           0x0077bad449c0a494ULL, 0x00b7c98814afd5b3ULL,
+                           0x0057226f58486cf9ULL, 0x00b1557154f0cc57ULL)},
+            {FIELD_LITERAL(0x008cc9cd236315c0ULL, 0x0031d9c5b39fda54ULL,
+                           0x00a5713ef37e1171ULL, 0x00293d5ae2886325ULL,
+                           0x00c4aba3e05015e1ULL, 0x0003f35ef78e4fc6ULL,
+                           0x0039d6bd3ac1527bULL, 0x0019d7c3afb77106ULL)},
+            {FIELD_LITERAL(0x007b162931a985afULL, 0x00ad40a2e0daa713ULL,
+                           0x006df27c4009f118ULL, 0x00503e9f4e2e8becULL,
+                           0x00751a77c82c182dULL, 0x000298937769245bULL,
+                           0x00ffb1e8fabf9ee5ULL, 0x0008334706e09abeULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00dbca4e98a7dcd9ULL, 0x00ee29cfc78bde99ULL,
+                           0x00e4a3b6995f52e9ULL, 0x0045d70189ae8096ULL,
+                           0x00fd2a8a3b9b0d1bULL, 0x00af1793b107d8e1ULL,
+                           0x00dbf92cbe4afa20ULL, 0x00da60f798e3681dULL)},
+            {FIELD_LITERAL(0x004246bfcecc627aULL, 0x004ba431246c03a4ULL,
+                           0x00bd1d101872d497ULL, 0x003b73d3f185ee16ULL,
+                           0x001feb2e2678c0e3ULL, 0x00ff13c5a89dec76ULL,
+                           0x00ed06042e771d8fULL, 0x00a4fd2a897a83ddULL)},
+            {FIELD_LITERAL(0x009a4a3be50d6597ULL, 0x00de3165fc5a1096ULL,
+                           0x004f3f56e345b0c7ULL, 0x00f7bf721d5ab8bcULL,
+                           0x004313e47b098c50ULL, 0x00e4c7d5c0e1adbbULL,
+                           0x002e3e3db365051eULL, 0x00a480c2cd6a96fbULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00417fa30a7119edULL, 0x00af257758419751ULL,
+                           0x00d358a487b463d4ULL, 0x0089703cc720b00dULL,
+                           0x00ce56314ff7f271ULL, 0x0064db171ade62c1ULL,
+                           0x00640b36d4a22fedULL, 0x00424eb88696d23fULL)},
+            {FIELD_LITERAL(0x004ede34af2813f3ULL, 0x00d4a8e11c9e8216ULL,
+                           0x004796d5041de8a5ULL, 0x00c4c6b4d21cc987ULL,
+                           0x00e8a433ee07fa1eULL, 0x0055720b5abcc5a1ULL,
+                           0x008873ea9c74b080ULL, 0x005b3fec1ab65d48ULL)},
+            {FIELD_LITERAL(0x0047e5277db70ec5ULL, 0x000a096c66db7d6bULL,
+                           0x00b4164cc1730159ULL, 0x004a9f783fe720feULL,
+                           0x00a8177b94449dbcULL, 0x0095a24ff49a599fULL,
+                           0x0069c1c578250cbcULL, 0x00452019213debf4ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0021ce99e09ebda3ULL, 0x00fcbd9f91875ad0ULL,
+                           0x009bbf6b7b7a0b5fULL, 0x00388886a69b1940ULL,
+                           0x00926a56d0f81f12ULL, 0x00e12903c3358d46ULL,
+                           0x005dfce4e8e1ce9dULL, 0x0044cfa94e2f7e23ULL)},
+            {FIELD_LITERAL(0x001bd59c09e982eaULL, 0x00f72daeb937b289ULL,
+                           0x0018b76dca908e0eULL, 0x00edb498512384adULL,
+                           0x00ce0243b6cc9538ULL, 0x00f96ff690cb4e70ULL,
+                           0x007c77bf9f673c8dULL, 0x005bf704c088a528ULL)},
+            {FIELD_LITERAL(0x0093d4628dcb33beULL, 0x0095263d51d42582ULL,
+                           0x0049b3222458fe06ULL, 0x00e7fce73b653a7fULL,
+                           0x003ca2ebce60b369ULL, 0x00c5de239a32bea4ULL,
+                           0x0063b8b3d71fb6bfULL, 0x0039aeeb78a1a839ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x007dc52da400336cULL, 0x001fded1e15b9457ULL,
+                           0x00902e00f5568e3aULL, 0x00219bef40456d2dULL,
+                           0x005684161fb3dbc9ULL, 0x004a4e9be49a76eaULL,
+                           0x006e685ae88b78ffULL, 0x0021c42f13042d3cULL)},
+            {FIELD_LITERAL(0x00fb22bb5fd3ce50ULL, 0x0017b48aada7ae54ULL,
+                           0x00fd5c44ad19a536ULL, 0x000ccc4e4e55e45cULL,
+                           0x00fd637d45b4c3f5ULL, 0x0038914e023c37cfULL,
+                           0x00ac1881d6a8d898ULL, 0x00611ed8d3d943a8ULL)},
+            {FIELD_LITERAL(0x0056e2259d113d2bULL, 0x00594819b284ec16ULL,
+                           0x00c7bf794bb36696ULL, 0x00721ee75097cdc6ULL,
+                           0x00f71be9047a2892ULL, 0x00df6ba142564edfULL,
+                           0x0069580b7a184e8dULL, 0x00f056e38fca0feeULL)},
+        }}, {{
+            {FIELD_LITERAL(0x009df98566a18c6dULL, 0x00cf3a200968f219ULL,
+                           0x0044ba60da6d9086ULL, 0x00dbc9c0e344da03ULL,
+                           0x000f9401c4466855ULL, 0x00d46a57c5b0a8d1ULL,
+                           0x00875a635d7ac7c6ULL, 0x00ef4a933b7e0ae6ULL)},
+            {FIELD_LITERAL(0x005e8694077a1535ULL, 0x008bef75f71c8f1dULL,
+                           0x000a7c1316423511ULL, 0x00906e1d70604320ULL,
+                           0x003fc46c1a2ffbd6ULL, 0x00d1d5022e68f360ULL,
+                           0x002515fba37bbf46ULL, 0x00ca16234e023b44ULL)},
+            {FIELD_LITERAL(0x00787c99561f4690ULL, 0x00a857a8c1561f27ULL,
+                           0x00a10df9223c09feULL, 0x00b98a9562e3b154ULL,
+                           0x004330b8744c3ed2ULL, 0x00e06812807ec5c4ULL,
+                           0x00e4cf6a7db9f1e3ULL, 0x00d95b089f132a34ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x002922b39ca33eecULL, 0x0090d12a5f3ab194ULL,
+                           0x00ab60c02fb5f8edULL, 0x00188d292abba1cfULL,
+                           0x00e10edec9698f6eULL, 0x0069a4d9934133c8ULL,
+                           0x0024aac40e6d3d06ULL, 0x001702c2177661b0ULL)},
+            {FIELD_LITERAL(0x00139078397030bdULL, 0x000e3c447e859a00ULL,
+                           0x0064a5b334c82393ULL, 0x00b8aabeb7358093ULL,
+                           0x00020778bb9ae73bULL, 0x0032ee94c7892a18ULL,
+                           0x008215253cb41bdaULL, 0x005e2797593517aeULL)},
+            {FIELD_LITERAL(0x0083765a5f855d4aULL, 0x0051b6d1351b8ee2ULL,
+                           0x00116de548b0f7bbULL, 0x0087bd88703affa0ULL,
+                           0x0095b2cc34d7fdd2ULL, 0x0084cd81b53f0bc8ULL,
+                           0x008562fc995350edULL, 0x00a39abb193651e3ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0019e23f0474b114ULL, 0x00eb94c2ad3b437eULL,
+                           0x006ddb34683b75acULL, 0x00391f9209b564c6ULL,
+                           0x00083b3bb3bff7aaULL, 0x00eedcd0f6dceefcULL,
+                           0x00b50817f794fe01ULL, 0x0036474deaaa75c9ULL)},
+            {FIELD_LITERAL(0x0091868594265aa2ULL, 0x00797accae98ca6dULL,
+                           0x0008d8c5f0f8a184ULL, 0x00d1f4f1c2b2fe6eULL,
+                           0x0036783dfb48a006ULL, 0x008c165120503527ULL,
+                           0x0025fd780058ce9bULL, 0x0068beb007be7d27ULL)},
+            {FIELD_LITERAL(0x00d0ff88aa7c90c2ULL, 0x00b2c60dacf53394ULL,
+                           0x0094a7284d9666d6ULL, 0x00bed9022ce7a19dULL,
+                           0x00c51553f0cd7682ULL, 0x00c3fb870b124992ULL,
+                           0x008d0bc539956c9bULL, 0x00fc8cf258bb8885ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x003667bf998406f8ULL, 0x0000115c43a12975ULL,
+                           0x001e662f3b20e8fdULL, 0x0019ffa534cb24ebULL,
+                           0x00016be0dc8efb45ULL, 0x00ff76a8b26243f5ULL,
+                           0x00ae20d241a541e3ULL, 0x0069bd6af13cd430ULL)},
+            {FIELD_LITERAL(0x0045fdc16487cda3ULL, 0x00b2d8e844cf2ed7ULL,
+                           0x00612c50e88c1607ULL, 0x00a08aabc66c1672ULL,
+                           0x006031fdcbb24d97ULL, 0x001b639525744b93ULL,
+                           0x004409d62639ab17ULL, 0x00a1853d0347ab1dULL)},
+            {FIELD_LITERAL(0x0075a1a56ebf5c21ULL, 0x00a3e72be9ac53edULL,
+                           0x00efcde1629170c2ULL, 0x0004225fe91ef535ULL,
+                           0x0088049fc73dfda7ULL, 0x004abc74857e1288ULL,
+                           0x0024e2434657317cULL, 0x00d98cb3d3e5543cULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00b4b53eab6bdb19ULL, 0x009b22d8b43711d0ULL,
+                           0x00d948b9d961785dULL, 0x00cb167b6f279eadULL,
+                           0x00191de3a678e1c9ULL, 0x00d9dd9511095c2eULL,
+                           0x00f284324cd43067ULL, 0x00ed74fa535151ddULL)},
+            {FIELD_LITERAL(0x007e32c049b5c477ULL, 0x009d2bfdbd9bcfd8ULL,
+                           0x00636e93045938c6ULL, 0x007fde4af7687298ULL,
+                           0x0046a5184fafa5d3ULL, 0x0079b1e7f13a359bULL,
+                           0x00875adf1fb927d6ULL, 0x00333e21c61bcad2ULL)},
+            {FIELD_LITERAL(0x00048014f73d8b8dULL, 0x0075684aa0966388ULL,
+                           0x0092be7df06dc47cULL, 0x0097cebcd0f5568aULL,
+                           0x005a7004d9c4c6a9ULL, 0x00b0ecbb659924c7ULL,
+                           0x00d90332dd492a7cULL, 0x0057fc14df11493dULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0008ed8ea0ad95beULL, 0x0041d324b9709645ULL,
+                           0x00e25412257a19b4ULL, 0x0058df9f3423d8d2ULL,
+                           0x00a9ab20def71304ULL, 0x009ae0dbf8ac4a81ULL,
+                           0x00c9565977e4392aULL, 0x003c9269444baf55ULL)},
+            {FIELD_LITERAL(0x007df6cbb926830bULL, 0x00d336058ae37865ULL,
+                           0x007af47dac696423ULL, 0x0048d3011ec64ac8ULL,
+                           0x006b87666e40049fULL, 0x0036a2e0e51303d7ULL,
+                           0x00ba319bd79dbc55ULL, 0x003e2737ecc94f53ULL)},
+            {FIELD_LITERAL(0x00d296ff726272d9ULL, 0x00f6d097928fcf57ULL,
+                           0x00e0e616a55d7013ULL, 0x00deaf454ed9eac7ULL,
+                           0x0073a56bedef4d92ULL, 0x006ccfdf6fc92e19ULL,
+                           0x009d1ee1371a7218ULL, 0x00ee3c2ee4462d80ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00437bce9bccdf9dULL, 0x00e0c8e2f85dc0a3ULL,
+                           0x00c91a7073995a19ULL, 0x00856ec9fe294559ULL,
+                           0x009e4b33394b156eULL, 0x00e245b0dc497e5cULL,
+                           0x006a54e687eeaeffULL, 0x00f1cd1cd00fdb7cULL)},
+            {FIELD_LITERAL(0x008132ae5c5d8cd1ULL, 0x00121d68324a1d9fULL,
+                           0x00d6be9dafcb8c76ULL, 0x00684d9070edf745ULL,
+                           0x00519fbc96d7448eULL, 0x00388182fdc1f27eULL,
+                           0x000235baed41f158ULL, 0x00bf6cf6f1a1796aULL)},
+            {FIELD_LITERAL(0x002adc4b4d148219ULL, 0x003084ada0d3a90aULL,
+                           0x0046de8aab0f2e4eULL, 0x00452d342a67b5fdULL,
+                           0x00d4b50f01d4de21ULL, 0x00db6d9fc0cefb79ULL,
+                           0x008c184c86a462cdULL, 0x00e17c83764d42daULL)},
+        }}, {{
+            {FIELD_LITERAL(0x007b2743b9a1e01aULL, 0x007847ffd42688c4ULL,
+                           0x006c7844d610a316ULL, 0x00f0cb8b250aa4b0ULL,
+                           0x00a19060143b3ae6ULL, 0x0014eb10b77cfd80ULL,
+                           0x000170905729dd06ULL, 0x00063b5b9cd72477ULL)},
+            {FIELD_LITERAL(0x00ce382dc7993d92ULL, 0x00021153e938b4c8ULL,
+                           0x00096f7567f48f51ULL, 0x0058f81ddfe4b0d5ULL,
+                           0x00cc379a56b355c7ULL, 0x002c760770d3e819ULL,
+                           0x00ee22d1d26e5a40ULL, 0x00de6d93d5b082d7ULL)},
+            {FIELD_LITERAL(0x000a91a42c52e056ULL, 0x00185f6b77fce7eaULL,
+                           0x000803c51962f6b5ULL, 0x0022528582ba563dULL,
+                           0x0043f8040e9856d6ULL, 0x0085a29ec81fb860ULL,
+                           0x005f9a611549f5ffULL, 0x00c1f974ecbd4b06ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x005b64c6fd65ec97ULL, 0x00c1fdd7f877bc7fULL,
+                           0x000d9cc6c89f841cULL, 0x005c97b7f1aff9adULL,
+                           0x0075e3c61475d47eULL, 0x001ecb1ba8153011ULL,
+                           0x00fe7f1c8d71d40dULL, 0x003fa9757a229832ULL)},
+            {FIELD_LITERAL(0x00ffc5c89d2b0cbaULL, 0x00d363d42e3e6fc3ULL,
+                           0x0019a1a0118e2e8aULL, 0x00f7baeff48882e1ULL,
+                           0x001bd5af28c6b514ULL, 0x0055476ca2253cb2ULL,
+                           0x00d8eb1977e2ddf3ULL, 0x00b173b1adb228a1ULL)},
+            {FIELD_LITERAL(0x00f2cb99dd0ad707ULL, 0x00e1e08b6859ddd8ULL,
+                           0x000008f2d0650bccULL, 0x00d7ed392f8615c3ULL,
+                           0x00976750a94da27fULL, 0x003e83bb0ecb69baULL,
+                           0x00df8e8d15c14ac6ULL, 0x00f9f7174295d9c2ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00f11cc8e0e70bcbULL, 0x00e5dc689974e7ddULL,
+                           0x0014e409f9ee5870ULL, 0x00826e6689acbd63ULL,
+                           0x008a6f4e3d895d88ULL, 0x00b26a8da41fd4adULL,
+                           0x000fb7723f83efd7ULL, 0x009c749db0a5f6c3ULL)},
+            {FIELD_LITERAL(0x002389319450f9baULL, 0x003677f31aa1250aULL,
+                           0x0092c3db642f38cbULL, 0x00f8b64c0dfc9773ULL,
+                           0x00cd49fe3505b795ULL, 0x0068105a4090a510ULL,
+                           0x00df0ba2072a8bb6ULL, 0x00eb396143afd8beULL)},
+            {FIELD_LITERAL(0x00a0d4ecfb24cdffULL, 0x00ddaf8008ba6479ULL,
+                           0x00f0b3e36d4b0f44ULL, 0x003734bd3af1f146ULL,
+                           0x00b87e2efc75527eULL, 0x00d230df55ddab50ULL,
+                           0x002613257ae56c1dULL, 0x00bc0946d135934dULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00468711bd994651ULL, 0x0033108fa67561bfULL,
+                           0x0089d760192a54b4ULL, 0x00adc433de9f1871ULL,
+                           0x000467d05f36e050ULL, 0x007847e0f0579f7fULL,
+                           0x00a2314ad320052dULL, 0x00b3a93649f0b243ULL)},
+            {FIELD_LITERAL(0x0067f8f0c4fe26c9ULL, 0x0079c4a3cc8f67b9ULL,
+                           0x0082b1e62f23550dULL, 0x00f2d409caefd7f5ULL,
+                           0x0080e67dcdb26e81ULL, 0x0087ae993ea1f98aULL,
+                           0x00aa108becf61d03ULL, 0x001acf11efb608a3ULL)},
+            {FIELD_LITERAL(0x008225febbab50d9ULL, 0x00f3b605e4dd2083ULL,
+                           0x00a32b28189e23d2ULL, 0x00d507e5e5eb4c97ULL,
+                           0x005a1a84e302821fULL, 0x0006f54c1c5f08c7ULL,
+                           0x00a347c8cb2843f0ULL, 0x0009f73e9544bfa5ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x006c59c9ae744185ULL, 0x009fc32f1b4282cdULL,
+                           0x004d6348ca59b1acULL, 0x00105376881be067ULL,
+                           0x00af4096013147dcULL, 0x004abfb5a5cb3124ULL,
+                           0x000d2a7f8626c354ULL, 0x009c6ed568e07431ULL)},
+            {FIELD_LITERAL(0x00e828333c297f8bULL, 0x009ef3cf8c3f7e1fULL,
+                           0x00ab45f8fff31cb9ULL, 0x00c8b4178cb0b013ULL,
+                           0x00d0c50dd3260a3fULL, 0x0097126ac257f5bcULL,
+                           0x0042376cc90c705aULL, 0x001d96fdb4a1071eULL)},
+            {FIELD_LITERAL(0x00542d44d89ee1a8ULL, 0x00306642e0442d98ULL,
+                           0x0090853872b87338ULL, 0x002362cbf22dc044ULL,
+                           0x002c222adff663b8ULL, 0x0067c924495fcb79ULL,
+                           0x000e621d983c977cULL, 0x00df77a9eccb66fbULL)},
+        }}, {{
+            {FIELD_LITERAL(0x002809e4bbf1814aULL, 0x00b9e854f9fafb32ULL,
+                           0x00d35e67c10f7a67ULL, 0x008f1bcb76e748cfULL,
+                           0x004224d9515687d2ULL, 0x005ba0b774e620c4ULL,
+                           0x00b5e57db5d54119ULL, 0x00e15babe5683282ULL)},
+            {FIELD_LITERAL(0x00832d02369b482cULL, 0x00cba52ff0d93450ULL,
+                           0x003fa9c908d554dbULL, 0x008d1e357b54122fULL,
+                           0x00abd91c2dc950c6ULL, 0x007eff1df4c0ec69ULL,
+                           0x003f6aeb13fb2d31ULL, 0x00002d6179fc5b2cULL)},
+            {FIELD_LITERAL(0x0046c9eda81c9c89ULL, 0x00b60cb71c8f62fcULL,
+                           0x0022f5a683baa558ULL, 0x00f87319fccdf997ULL,
+                           0x009ca09b51ce6a22ULL, 0x005b12baf4af7d77ULL,
+                           0x008a46524a1e33e2ULL, 0x00035a77e988be0dULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00a7efe46a7dbe2fULL, 0x002f66fd55014fe7ULL,
+                           0x006a428afa1ff026ULL, 0x0056caaa9604ab72ULL,
+                           0x0033f3bcd7fac8aeULL, 0x00ccb1aa01c86764ULL,
+                           0x00158d1edf13bf40ULL, 0x009848ee76fcf3b4ULL)},
+            {FIELD_LITERAL(0x00a9e7730a819691ULL, 0x00d9cc73c4992b70ULL,
+                           0x00e299bde067de5aULL, 0x008c314eb705192aULL,
+                           0x00e7226f17e8a3ccULL, 0x0029dfd956e65a47ULL,
+                           0x0053a8e839073b12ULL, 0x006f942b2ab1597eULL)},
+            {FIELD_LITERAL(0x001c3d780ecd5e39ULL, 0x0094f247fbdcc5feULL,
+                           0x00d5c786fd527764ULL, 0x00b6f4da74f0db2aULL,
+                           0x0080f1f8badcd5fcULL, 0x00f36a373ad2e23bULL,
+                           0x00f804f9f4343bf2ULL, 0x00d1af40ec623982ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0082aeace5f1b144ULL, 0x00f68b3108cf4dd3ULL,
+                           0x00634af01dde3020ULL, 0x000beab5df5c2355ULL,
+                           0x00e8b790d1b49b0bULL, 0x00e48d15854e36f4ULL,
+                           0x0040ab2d95f3db9fULL, 0x002711c4ed9e899aULL)},
+            {FIELD_LITERAL(0x0039343746531ebeULL, 0x00c8509d835d429dULL,
+                           0x00e79eceff6b0018ULL, 0x004abfd31e8efce5ULL,
+                           0x007bbfaaa1e20210ULL, 0x00e3be89c193e179ULL,
+                           0x001c420f4c31d585ULL, 0x00f414a315bef5aeULL)},
+            {FIELD_LITERAL(0x007c296a24990df8ULL, 0x00d5d07525a75588ULL,
+                           0x00dd8e113e94b7e7ULL, 0x007bbc58febe0cc8ULL,
+                           0x0029f51af9bfcad3ULL, 0x007e9311ec7ab6f3ULL,
+                           0x009a884de1676343ULL, 0x0050d5f2dce84be9ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x005fa020cca2450aULL, 0x00491c29db6416d8ULL,
+                           0x0037cefe3f9f9a85ULL, 0x003d405230647066ULL,
+                           0x0049e835f0fdbe89ULL, 0x00feb78ac1a0815cULL,
+                           0x00828e4b32dc9724ULL, 0x00db84f2dc8d6fd4ULL)},
+            {FIELD_LITERAL(0x0098cddc8b39549aULL, 0x006da37e3b05d22cULL,
+                           0x00ce633cfd4eb3cbULL, 0x00fda288ef526acdULL,
+                           0x0025338878c5d30aULL, 0x00f34438c4e5a1b4ULL,
+                           0x00584efea7c310f1ULL, 0x0041a551f1b660adULL)},
+            {FIELD_LITERAL(0x00d7f7a8fbd6437aULL, 0x0062872413bf3753ULL,
+                           0x00ad4bbcb43c584bULL, 0x007fe49be601d7e3ULL,
+                           0x0077c659789babf4ULL, 0x00eb45fcb06a741bULL,
+                           0x005ce244913f9708ULL, 0x0088426401736326ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x007bf562ca768d7cULL, 0x006c1f3a174e387cULL,
+                           0x00f024b447fee939ULL, 0x007e7af75f01143fULL,
+                           0x003adb70b4eed89dULL, 0x00e43544021ad79aULL,
+                           0x0091f7f7042011f6ULL, 0x0093c1a1ee3a0ddcULL)},
+            {FIELD_LITERAL(0x00a0b68ec1eb72d2ULL, 0x002c03235c0d45a0ULL,
+                           0x00553627323fe8c5ULL, 0x006186e94b17af94ULL,
+                           0x00a9906196e29f14ULL, 0x0025b3aee6567733ULL,
+                           0x007e0dd840080517ULL, 0x0018eb5801a4ba93ULL)},
+            {FIELD_LITERAL(0x00d7fe7017bf6a40ULL, 0x006e3f0624be0c42ULL,
+                           0x00ffbba205358245ULL, 0x00f9fc2cf8194239ULL,
+                           0x008d93b37bf15b4eULL, 0x006ddf2e38be8e95ULL,
+                           0x002b6e79bf5fcff9ULL, 0x00ab355da425e2deULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00938f97e20be973ULL, 0x0099141a36aaf306ULL,
+                           0x0057b0ca29e545a1ULL, 0x0085db571f9fbc13ULL,
+                           0x008b333c554b4693ULL, 0x0043ab6ef3e241cbULL,
+                           0x0054fb20aa1e5c70ULL, 0x00be0ff852760adfULL)},
+            {FIELD_LITERAL(0x003973d8938971d6ULL, 0x002aca26fa80c1f5ULL,
+                           0x00108af1faa6b513ULL, 0x00daae275d7924e6ULL,
+                           0x0053634ced721308ULL, 0x00d2355fe0bbd443ULL,
+                           0x00357612b2d22095ULL, 0x00f9bb9dd4136cf3ULL)},
+            {FIELD_LITERAL(0x002bff12cf5e03a5ULL, 0x001bdb1fa8a19cf8ULL,
+                           0x00c91c6793f84d39ULL, 0x00f869f1b2eba9afULL,
+                           0x0059bc547dc3236bULL, 0x00d91611d6d38689ULL,
+                           0x00e062daaa2c0214ULL, 0x00ed3c047cc2bc82ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x000050d70c32b31aULL, 0x001939d576d437b3ULL,
+                           0x00d709e598bf9fe6ULL, 0x00a885b34bd2ee9eULL,
+                           0x00dd4b5c08ab1a50ULL, 0x0091bebd50b55639ULL,
+                           0x00cf79ff64acdbc6ULL, 0x006067a39d826336ULL)},
+            {FIELD_LITERAL(0x0062dd0fb31be374ULL, 0x00fcc96b84c8e727ULL,
+                           0x003f64f1375e6ae3ULL, 0x0057d9b6dd1af004ULL,
+                           0x00d6a167b1103c7bULL, 0x00dd28f3180fb537ULL,
+                           0x004ff27ad7167128ULL, 0x008934c33461f2acULL)},
+            {FIELD_LITERAL(0x0065b472b7900043ULL, 0x00ba7efd2ff1064bULL,
+                           0x000b67d6c4c3020fULL, 0x0012d28469f4e46dULL,
+                           0x0031c32939703ec7ULL, 0x00b49f0bce133066ULL,
+                           0x00f7e10416181d47ULL, 0x005c90f51867eeccULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0051207abd179101ULL, 0x00fc2a5c20d9c5daULL,
+                           0x00fb9d5f2701b6dfULL, 0x002dd040fdea82b8ULL,
+                           0x00f163b0738442ffULL, 0x00d9736bd68855b8ULL,
+                           0x00e0d8e93005e61cULL, 0x00df5a40b3988570ULL)},
+            {FIELD_LITERAL(0x0006918f5dfce6dcULL, 0x00d4bf1c793c57fbULL,
+                           0x0069a3f649435364ULL, 0x00e89a50e5b0cd6eULL,
+                           0x00b9f6a237e973afULL, 0x006d4ed8b104e41dULL,
+                           0x00498946a3924cd2ULL, 0x00c136ec5ac9d4f7ULL)},
+            {FIELD_LITERAL(0x0011a9c290ac5336ULL, 0x002b9a2d4a6a6533ULL,
+                           0x009a8a68c445d937ULL, 0x00361b27b07e5e5cULL,
+                           0x003c043b1755b974ULL, 0x00b7eb66cf1155eeULL,
+                           0x0077af5909eefff2ULL, 0x0098f609877cc806ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00ab13af436bf8f4ULL, 0x000bcf0a0dac8574ULL,
+                           0x00d50c864f705045ULL, 0x00c40e611debc842ULL,
+                           0x0085010489bd5caaULL, 0x007c5050acec026fULL,
+                           0x00f67d943c8da6d1ULL, 0x00de1da0278074c6ULL)},
+            {FIELD_LITERAL(0x00b373076597455fULL, 0x00e83f1af53ac0f5ULL,
+                           0x0041f63c01dc6840ULL, 0x0097dea19b0c6f4bULL,
+                           0x007f9d63b4c1572cULL, 0x00e692d492d0f5f0ULL,
+                           0x00cbcb392e83b4adULL, 0x0069c0f39ed9b1a8ULL)},
+            {FIELD_LITERAL(0x00861030012707c9ULL, 0x009fbbdc7fd4aafbULL,
+                           0x008f591d6b554822ULL, 0x00df08a41ea18adeULL,
+                           0x009d7d83e642abeaULL, 0x0098c71bda3b78ffULL,
+                           0x0022c89e7021f005ULL, 0x0044d29a3fe1e3c4ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00e748cd7b5c52f2ULL, 0x00ea9df883f89cc3ULL,
+                           0x0018970df156b6c7ULL, 0x00c5a46c2a33a847ULL,
+                           0x00cbde395e32aa09ULL, 0x0072474ebb423140ULL,
+                           0x00fb00053086a23dULL, 0x001dafcfe22d4e1fULL)},
+            {FIELD_LITERAL(0x00c903ee6d825540ULL, 0x00add6c4cf98473eULL,
+                           0x007636efed4227f1ULL, 0x00905124ae55e772ULL,
+                           0x00e6b38fab12ed53ULL, 0x0045e132b863fe55ULL,
+                           0x003974662edb366aULL, 0x00b1787052be8208ULL)},
+            {FIELD_LITERAL(0x00a614b00d775c7cULL, 0x00d7c78941cc7754ULL,
+                           0x00422dd68b5dabc4ULL, 0x00a6110f0167d28bULL,
+                           0x00685a309c252886ULL, 0x00b439ffd5143660ULL,
+                           0x003656e29ee7396fULL, 0x00c7c9b9ed5ad854ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0040f7e7c5b37bf2ULL, 0x0064e4dc81181bbaULL,
+                           0x00a8767ae2a366b6ULL, 0x001496b4f90546f2ULL,
+                           0x002a28493f860441ULL, 0x0021f59513049a3aULL,
+                           0x00852d369a8b7ee3ULL, 0x00dd2e7d8b7d30a9ULL)},
+            {FIELD_LITERAL(0x00006e34a35d9fbcULL, 0x00eee4e48b2f019aULL,
+                           0x006b344743003a5fULL, 0x00541d514f04a7e3ULL,
+                           0x00e81f9ee7647455ULL, 0x005e2b916c438f81ULL,
+                           0x00116f8137b7eff0ULL, 0x009bd3decc7039d1ULL)},
+            {FIELD_LITERAL(0x0005d226f434110dULL, 0x00af8288b8ef21d5ULL,
+                           0x004a7a52ef181c8cULL, 0x00be0b781b4b06deULL,
+                           0x00e6e3627ded07e1ULL, 0x00e43aa342272b8bULL,
+                           0x00e86ab424577d84ULL, 0x00fb292c566e35bbULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00334f5303ea1222ULL, 0x00dfb3dbeb0a5d3eULL,
+                           0x002940d9592335c1ULL, 0x00706a7a63e8938aULL,
+                           0x005a533558bc4cafULL, 0x00558e33192022a9ULL,
+                           0x00970d9faf74c133ULL, 0x002979fcb63493caULL)},
+            {FIELD_LITERAL(0x00e38abece3c82abULL, 0x005a51f18a2c7a86ULL,
+                           0x009dafa2e86d592eULL, 0x00495a62eb688678ULL,
+                           0x00b79df74c0eb212ULL, 0x0023e8cc78b75982ULL,
+                           0x005998cb91075e13ULL, 0x00735aa9ba61bc76ULL)},
+            {FIELD_LITERAL(0x00d9f7a82ddbe628ULL, 0x00a1fc782889ae0fULL,
+                           0x0071ffda12d14b66ULL, 0x0037cf4eca7fb3d5ULL,
+                           0x00c80bc242c58808ULL, 0x0075bf8c2d08c863ULL,
+                           0x008d41f31afc52a7ULL, 0x00197962ecf38741ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x006e9f475cccf2eeULL, 0x00454b9cd506430cULL,
+                           0x00224a4fb79ee479ULL, 0x0062e3347ef0b5e2ULL,
+                           0x0034fd2a3512232aULL, 0x00b8b3cb0f457046ULL,
+                           0x00eb20165daa38ecULL, 0x00128eebc2d9c0f7ULL)},
+            {FIELD_LITERAL(0x00bfc5fa1e4ea21fULL, 0x00c21d7b6bb892e6ULL,
+                           0x00cf043f3acf0291ULL, 0x00c13f2f849b3c90ULL,
+                           0x00d1a97ebef10891ULL, 0x0061e130a445e7feULL,
+                           0x0019513fdedbf22bULL, 0x001d60c813bff841ULL)},
+            {FIELD_LITERAL(0x0019561c7fcf0213ULL, 0x00e3dca6843ebd77ULL,
+                           0x0068ea95b9ca920eULL, 0x009bdfb70f253595ULL,
+                           0x00c68f59186aa02aULL, 0x005aee1cca1c3039ULL,
+                           0x00ab79a8a937a1ceULL, 0x00b9a0e549959e6fULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00c79e0b6d97dfbdULL, 0x00917c71fd2bc6e8ULL,
+                           0x00db7529ccfb63d8ULL, 0x00be5be957f17866ULL,
+                           0x00a9e11fdc2cdac1ULL, 0x007b91a8e1f44443ULL,
+                           0x00a3065e4057d80fULL, 0x004825f5b8d5f6d4ULL)},
+            {FIELD_LITERAL(0x003e4964fa8a8fc8ULL, 0x00f6a1cdbcf41689ULL,
+                           0x00943cb18fe7fda7ULL, 0x00606dafbf34440aULL,
+                           0x005d37a86399c789ULL, 0x00e79a2a69417403ULL,
+                           0x00fe34f7e68b8866ULL, 0x0011f448ed2df10eULL)},
+            {FIELD_LITERAL(0x00f1f57efcc1fcc4ULL, 0x00513679117de154ULL,
+                           0x002e5b5b7c86d8c3ULL, 0x009f6486561f9cfbULL,
+                           0x00169e74b0170cf7ULL, 0x00900205af4af696ULL,
+                           0x006acfddb77853f3ULL, 0x00df184c90f31068ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00b37396c3320791ULL, 0x00fc7b67175c5783ULL,
+                           0x00c36d2cd73ecc38ULL, 0x0080ebcc0b328fc5ULL,
+                           0x0043a5b22b35d35dULL, 0x00466c9f1713c9daULL,
+                           0x0026ad346dcaa8daULL, 0x007c684e701183a6ULL)},
+            {FIELD_LITERAL(0x00fd579ffb691713ULL, 0x00b76af4f81c412dULL,
+                           0x00f239de96110f82ULL, 0x00e965fb437f0306ULL,
+                           0x00ca7e9436900921ULL, 0x00e487f1325fa24aULL,
+                           0x00633907de476380ULL, 0x00721c62ac5b8ea0ULL)},
+            {FIELD_LITERAL(0x00c0d54e542eb4f9ULL, 0x004ed657171c8dcfULL,
+                           0x00b743a4f7c2a39bULL, 0x00fd9f93ed6cc567ULL,
+                           0x00307fae3113e58bULL, 0x0058aa577c93c319ULL,
+                           0x00d254556f35b346ULL, 0x00491aada2203f0dULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00dff3103786ff34ULL, 0x000144553b1f20c3ULL,
+                           0x0095613baeb930e4ULL, 0x00098058275ea5d4ULL,
+                           0x007cd1402b046756ULL, 0x0074d74e4d58aee3ULL,
+                           0x005f93fc343ff69bULL, 0x00873df17296b3b0ULL)},
+            {FIELD_LITERAL(0x00c4a1fb48635413ULL, 0x00b5dd54423ad59fULL,
+                           0x009ff5d53fd24a88ULL, 0x003c98d267fc06a7ULL,
+                           0x002db7cb20013641ULL, 0x00bd1d6716e191f2ULL,
+                           0x006dbc8b29094241ULL, 0x0044bbf233dafa2cULL)},
+            {FIELD_LITERAL(0x0055838d41f531e6ULL, 0x00bf6a2dd03c81b2ULL,
+                           0x005827a061c4839eULL, 0x0000de2cbb36aac3ULL,
+                           0x002efa29d9717478ULL, 0x00f9e928cc8a77baULL,
+                           0x00c134b458def9efULL, 0x00958a182223fc48ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x000a9ee23c06881fULL, 0x002c727d3d871945ULL,
+                           0x00f47d971512d24aULL, 0x00671e816f9ef31aULL,
+                           0x00883af2cfaad673ULL, 0x00601f98583d6c9aULL,
+                           0x00b435f5adc79655ULL, 0x00ad87b71c04bff2ULL)},
+            {FIELD_LITERAL(0x007860d99db787cfULL, 0x00fda8983018f4a8ULL,
+                           0x008c8866bac4743cULL, 0x00ef471f84c82a3fULL,
+                           0x00abea5976d3b8e7ULL, 0x00714882896cd015ULL,
+                           0x00b49fae584ddac5ULL, 0x008e33a1a0b69c81ULL)},
+            {FIELD_LITERAL(0x007b6ee2c9e8a9ecULL, 0x002455dbbd89d622ULL,
+                           0x006490cf4eaab038ULL, 0x00d925f6c3081561ULL,
+                           0x00153b3047de7382ULL, 0x003b421f8bdceb6fULL,
+                           0x00761a4a5049da78ULL, 0x00980348c5202433ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x007f8a43da97dd5cULL, 0x00058539c800fc7bULL,
+                           0x0040f3cf5a28414aULL, 0x00d68dd0d95283d6ULL,
+                           0x004adce9da90146eULL, 0x00befa41c7d4f908ULL,
+                           0x007603bc2e3c3060ULL, 0x00bdf360ab3545dbULL)},
+            {FIELD_LITERAL(0x00eebfd4e2312cc3ULL, 0x00474b2564e4fc8cULL,
+                           0x003303ef14b1da9bULL, 0x003c93e0e66beb1dULL,
+                           0x0013619b0566925aULL, 0x008817c24d901bf3ULL,
+                           0x00b62bd8898d218bULL, 0x0075a7716f1e88a2ULL)},
+            {FIELD_LITERAL(0x0009218da1e6890fULL, 0x0026907f5fd02575ULL,
+                           0x004dabed5f19d605ULL, 0x003abf181870249dULL,
+                           0x00b52fd048cc92c4ULL, 0x00b6dd51e415a5c5ULL,
+                           0x00d9eb82bd2b4014ULL, 0x002c865a43b46b43ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0070047189452f4cULL, 0x00f7ad12e1ce78d5ULL,
+                           0x00af1ba51ec44a8bULL, 0x005f39f63e667cd6ULL,
+                           0x00058eac4648425eULL, 0x00d7fdab42bea03bULL,
+                           0x0028576a5688de15ULL, 0x00af973209e77c10ULL)},
+            {FIELD_LITERAL(0x00c338b915d8fef0ULL, 0x00a893292045c39aULL,
+                           0x0028ab4f2eba6887ULL, 0x0060743cb519fd61ULL,
+                           0x0006213964093ac0ULL, 0x007c0b7a43f6266dULL,
+                           0x008e3557c4fa5bdaULL, 0x002da976de7b8d9dULL)},
+            {FIELD_LITERAL(0x0048729f8a8b6dcdULL, 0x00fe23b85cc4d323ULL,
+                           0x00e7384d16e4db0eULL, 0x004a423970678942ULL,
+                           0x00ec0b763345d4baULL, 0x00c477b9f99ed721ULL,
+                           0x00c29dad3777b230ULL, 0x001c517b466f7df6ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x006366c380f7b574ULL, 0x001c7d1f09ff0438ULL,
+                           0x003e20a7301f5b22ULL, 0x00d3efb1916d28f6ULL,
+                           0x0049f4f81060ce83ULL, 0x00c69d91ea43ced1ULL,
+                           0x002b6f3e5cd269edULL, 0x005b0fb22ce9ec65ULL)},
+            {FIELD_LITERAL(0x00aa2261022d883fULL, 0x00ebcca4548010acULL,
+                           0x002528512e28a437ULL, 0x0070ca7676b66082ULL,
+                           0x0084bda170f7c6d3ULL, 0x00581b4747c9b8bbULL,
+                           0x005c96a01061c7e2ULL, 0x00fb7c4a362b5273ULL)},
+            {FIELD_LITERAL(0x00c30020eb512d02ULL, 0x0060f288283a4d26ULL,
+                           0x00b7ed13becde260ULL, 0x0075ebb74220f6e9ULL,
+                           0x00701079fcfe8a1fULL, 0x001c28fcdff58938ULL,
+                           0x002e4544b8f4df6bULL, 0x0060c5bc4f1a7d73ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x00ae307cf069f701ULL, 0x005859f222dd618bULL,
+                           0x00212d6c46ec0b0dULL, 0x00a0fe4642afb62dULL,
+                           0x00420d8e4a0a8903ULL, 0x00a80ff639bdf7b0ULL,
+                           0x0019bee1490b5d8eULL, 0x007439e4b9c27a86ULL)},
+            {FIELD_LITERAL(0x00a94700032a093fULL, 0x0076e96c225216e7ULL,
+                           0x00a63a4316e45f91ULL, 0x007d8bbb4645d3b2ULL,
+                           0x00340a6ff22793ebULL, 0x006f935d4572aeb7ULL,
+                           0x00b1fb69f00afa28ULL, 0x009e8f3423161ed3ULL)},
+            {FIELD_LITERAL(0x009ef49c6b5ced17ULL, 0x00a555e6269e9f0aULL,
+                           0x007e6f1d79ec73b5ULL, 0x009ac78695a32ac4ULL,
+                           0x0001d77fbbcd5682ULL, 0x008cea1fee0aaeedULL,
+                           0x00f42bea82a53462ULL, 0x002e46ab96cafcc9ULL)},
+        }}, {{
+            {FIELD_LITERAL(0x0051cfcc5885377aULL, 0x00dce566cb1803caULL,
+                           0x00430c7643f2c7d4ULL, 0x00dce1a1337bdcc0ULL,
+                           0x0010d5bd7283c128ULL, 0x003b1b547f9b46feULL,
+                           0x000f245e37e770abULL, 0x007b72511f022b37ULL)},
+            {FIELD_LITERAL(0x0060db815bc4786cULL, 0x006fab25beedc434ULL,
+                           0x00c610d06084797cULL, 0x000c48f08537bec0ULL,
+                           0x0031aba51c5b93daULL, 0x007968fa6e01f347ULL,
+                           0x0030070da52840c6ULL, 0x00c043c225a4837fULL)},
+            {FIELD_LITERAL(0x001bcfd00649ee93ULL, 0x006dceb47e2a0fd5ULL,
+                           0x00f2cebda0cf8fd0ULL, 0x00b6b9d9d1fbdec3ULL,
+                           0x00815262e6490611ULL, 0x00ef7f5ce3176760ULL,
+                           0x00e49cd0c998d58bULL, 0x005fc6cc269ba57cULL)},
+        }}, {{
+            {FIELD_LITERAL(0x008940211aa0d633ULL, 0x00addae28136571dULL,
+                           0x00d68fdbba20d673ULL, 0x003bc6129bc9e21aULL,
+                           0x000346cf184ebe9aULL, 0x0068774d741ebc7fULL,
+                           0x0019d5e9e6966557ULL, 0x0003cbd7f981b651ULL)},
+            {FIELD_LITERAL(0x004a2902926f8d3fULL, 0x00ad79b42637ab75ULL,
+                           0x0088f60b90f2d4e8ULL, 0x0030f54ef0e398c4ULL,
+                           0x00021dc9bf99681eULL, 0x007ebf66fde74ee3ULL,
+                           0x004ade654386e9a4ULL, 0x00e7485066be4c27ULL)},
+            {FIELD_LITERAL(0x00445f1263983be0ULL, 0x004cf371dda45e6aULL,
+                           0x00744a89d5a310e7ULL, 0x001f20ce4f904833ULL,
+                           0x00e746edebe66e29ULL, 0x000912ab1f6c153dULL,
+                           0x00f61d77d9b2444cULL, 0x0001499cd6647610ULL)},
+        }}
+    }
+};
+const struct curve448_precomputed_s *curve448_precomputed_base
+    = &curve448_precomputed_base_table;
+
+static const niels_t curve448_wnaf_base_table[32] = {
+    {{
+        {FIELD_LITERAL(0x00303cda6feea532ULL, 0x00860f1d5a3850e4ULL,
+                       0x00226b9fa4728ccdULL, 0x00e822938a0a0c0cULL,
+                       0x00263a61c9ea9216ULL, 0x001204029321b828ULL,
+                       0x006a468360983c65ULL, 0x0002846f0a782143ULL)},
+        {FIELD_LITERAL(0x00303cda6feea532ULL, 0x00860f1d5a3850e4ULL,
+                       0x00226b9fa4728ccdULL, 0x006822938a0a0c0cULL,
+                       0x00263a61c9ea9215ULL, 0x001204029321b828ULL,
+                       0x006a468360983c65ULL, 0x0082846f0a782143ULL)},
+        {FIELD_LITERAL(0x00ef8e22b275198dULL, 0x00b0eb141a0b0e8bULL,
+                       0x001f6789da3cb38cULL, 0x006d2ff8ed39073eULL,
+                       0x00610bdb69a167f3ULL, 0x00571f306c9689b4ULL,
+                       0x00f557e6f84b2df8ULL, 0x002affd38b2c86dbULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00cea0fc8d2e88b5ULL, 0x00821612d69f1862ULL,
+                       0x0074c283b3e67522ULL, 0x005a195ba05a876dULL,
+                       0x000cddfe557feea4ULL, 0x008046c795bcc5e5ULL,
+                       0x00540969f4d6e119ULL, 0x00d27f96d6b143d5ULL)},
+        {FIELD_LITERAL(0x000c3b1019d474e8ULL, 0x00e19533e4952284ULL,
+                       0x00cc9810ba7c920aULL, 0x00f103d2785945acULL,
+                       0x00bfa5696cc69b34ULL, 0x00a8d3d51e9ca839ULL,
+                       0x005623cb459586b9ULL, 0x00eae7ce1cd52e9eULL)},
+        {FIELD_LITERAL(0x0005a178751dd7d8ULL, 0x002cc3844c69c42fULL,
+                       0x00acbfe5efe10539ULL, 0x009c20f43431a65aULL,
+                       0x008435d96374a7b3ULL, 0x009ee57566877bd3ULL,
+                       0x0044691725ed4757ULL, 0x001e87bb2fe2c6b2ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x000cedc4debf7a04ULL, 0x002ffa45000470acULL,
+                       0x002e9f9678201915ULL, 0x0017da1208c4fe72ULL,
+                       0x007d558cc7d656cbULL, 0x0037a827287cf289ULL,
+                       0x00142472d3441819ULL, 0x009c21f166cf8dd1ULL)},
+        {FIELD_LITERAL(0x003ef83af164b2f2ULL, 0x000949a5a0525d0dULL,
+                       0x00f4498186cac051ULL, 0x00e77ac09ef126d2ULL,
+                       0x0073ae0b2c9296e9ULL, 0x001c163f6922e3edULL,
+                       0x0062946159321beaULL, 0x00cfb79b22990b39ULL)},
+        {FIELD_LITERAL(0x00b001431ca9e654ULL, 0x002d7e5eabcc9a3aULL,
+                       0x0052e8114c2f6747ULL, 0x0079ac4f94487f92ULL,
+                       0x00bffd919b5d749cULL, 0x00261f92ad15e620ULL,
+                       0x00718397b7a97895ULL, 0x00c1443e6ebbc0c4ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00eacd90c1e0a049ULL, 0x008977935b149fbeULL,
+                       0x0004cb9ba11c93dcULL, 0x009fbd5b3470844dULL,
+                       0x004bc18c9bfc22cfULL, 0x0057679a991839f3ULL,
+                       0x00ef15b76fb4092eULL, 0x0074a5173a225041ULL)},
+        {FIELD_LITERAL(0x003f5f9d7ec4777bULL, 0x00ab2e733c919c94ULL,
+                       0x001bb6c035245ae5ULL, 0x00a325a49a883630ULL,
+                       0x0033e9a9ea3cea2fULL, 0x00e442a1eaa0e844ULL,
+                       0x00b2116d5b0e71b8ULL, 0x00c16abed6d64047ULL)},
+        {FIELD_LITERAL(0x00c560b5ed051165ULL, 0x001945adc5d65094ULL,
+                       0x00e221865710f910ULL, 0x00cc12bc9e9b8cebULL,
+                       0x004faa9518914e35ULL, 0x0017476d89d42f6dULL,
+                       0x00b8f637c8fa1c8bULL, 0x0088c7d2790864b8ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00ef7eafc1c69be6ULL, 0x0085d3855778fbeaULL,
+                       0x002c8d5b450cb6f5ULL, 0x004e77de5e1e7fecULL,
+                       0x0047c057893abdedULL, 0x001b430b85d51e16ULL,
+                       0x00965c7b45640c3cULL, 0x00487b2bb1162b97ULL)},
+        {FIELD_LITERAL(0x0099c73a311beec2ULL, 0x00a3eff38d8912adULL,
+                       0x002efa9d1d7e8972ULL, 0x00f717ae1e14d126ULL,
+                       0x002833f795850c8bULL, 0x0066c12ad71486bdULL,
+                       0x00ae9889da4820ebULL, 0x00d6044309555c08ULL)},
+        {FIELD_LITERAL(0x004b1c5283d15e41ULL, 0x00669d8ea308ff75ULL,
+                       0x0004390233f762a1ULL, 0x00e1d67b83cb6cecULL,
+                       0x003eebaa964c78b1ULL, 0x006b0aff965eb664ULL,
+                       0x00b313d4470bdc37ULL, 0x008814ffcb3cb9d8ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x009724b8ce68db70ULL, 0x007678b5ed006f3dULL,
+                       0x00bdf4b89c0abd73ULL, 0x00299748e04c7c6dULL,
+                       0x00ddd86492c3c977ULL, 0x00c5a7febfa30a99ULL,
+                       0x00ed84715b4b02bbULL, 0x00319568adf70486ULL)},
+        {FIELD_LITERAL(0x0070ff2d864de5bbULL, 0x005a37eeb637ee95ULL,
+                       0x0033741c258de160ULL, 0x00e6ca5cb1988f46ULL,
+                       0x001ceabd92a24661ULL, 0x0030957bd500fe40ULL,
+                       0x001c3362afe912c5ULL, 0x005187889f678bd2ULL)},
+        {FIELD_LITERAL(0x0086835fc62bbdc7ULL, 0x009c3516ca4910a1ULL,
+                       0x00956c71f8d00783ULL, 0x0095c78fcf63235fULL,
+                       0x00fc7ff6ba05c222ULL, 0x00cdd8b3f8d74a52ULL,
+                       0x00ac5ae16de8256eULL, 0x00e9d4be8ed48624ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00c0ce11405df2d8ULL, 0x004e3f37b293d7b6ULL,
+                       0x002410172e1ac6dbULL, 0x00b8dbff4bf8143dULL,
+                       0x003a7b409d56eb66ULL, 0x003e0f6a0dfef9afULL,
+                       0x0081c4e4d3645be1ULL, 0x00ce76076b127623ULL)},
+        {FIELD_LITERAL(0x00f6ee0f98974239ULL, 0x0042d89af07d3a4fULL,
+                       0x00846b7fe84346b5ULL, 0x006a21fc6a8d39a1ULL,
+                       0x00ac8bc2541ff2d9ULL, 0x006d4e2a77732732ULL,
+                       0x009a39b694cc3f2fULL, 0x0085c0aa2a404c8fULL)},
+        {FIELD_LITERAL(0x00b261101a218548ULL, 0x00c1cae96424277bULL,
+                       0x00869da0a77dd268ULL, 0x00bc0b09f8ec83eaULL,
+                       0x00d61027f8e82ba9ULL, 0x00aa4c85999dce67ULL,
+                       0x00eac3132b9f3fe1ULL, 0x00fb9b0cf1c695d2ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x0043079295512f0dULL, 0x0046a009861758e0ULL,
+                       0x003ee2842a807378ULL, 0x0034cc9d1298e4faULL,
+                       0x009744eb4d31b3eeULL, 0x00afacec96650cd0ULL,
+                       0x00ac891b313761aeULL, 0x00e864d6d26e708aULL)},
+        {FIELD_LITERAL(0x00a84d7c8a23b491ULL, 0x0088e19aa868b27fULL,
+                       0x0005986d43e78ce9ULL, 0x00f28012f0606d28ULL,
+                       0x0017ded7e10249b3ULL, 0x005ed4084b23af9bULL,
+                       0x00b9b0a940564472ULL, 0x00ad9056cceeb1f4ULL)},
+        {FIELD_LITERAL(0x00db91b357fe755eULL, 0x00a1aa544b15359cULL,
+                       0x00af4931a0195574ULL, 0x007686124fe11aefULL,
+                       0x00d1ead3c7b9ef7eULL, 0x00aaf5fc580f8c15ULL,
+                       0x00e727be147ee1ecULL, 0x003c61c1e1577b86ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x009d3fca983220cfULL, 0x00cd11acbc853dc4ULL,
+                       0x0017590409d27f1dULL, 0x00d2176698082802ULL,
+                       0x00fa01251b2838c8ULL, 0x00dd297a0d9b51c6ULL,
+                       0x00d76c92c045820aULL, 0x00534bc7c46c9033ULL)},
+        {FIELD_LITERAL(0x0080ed9bc9b07338ULL, 0x00fceac7745d2652ULL,
+                       0x008a9d55f5f2cc69ULL, 0x0096ce72df301ac5ULL,
+                       0x00f53232e7974d87ULL, 0x0071728c7ae73947ULL,
+                       0x0090507602570778ULL, 0x00cb81cfd883b1b2ULL)},
+        {FIELD_LITERAL(0x005011aadea373daULL, 0x003a8578ec896034ULL,
+                       0x00f20a6535fa6d71ULL, 0x005152d31e5a87cfULL,
+                       0x002bac1c8e68ca31ULL, 0x00b0e323db4c1381ULL,
+                       0x00f1d596b7d5ae25ULL, 0x00eae458097cb4e0ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00920ac80f9b0d21ULL, 0x00f80f7f73401246ULL,
+                       0x0086d37849b557d6ULL, 0x0002bd4b317b752eULL,
+                       0x00b26463993a42bbULL, 0x002070422a73b129ULL,
+                       0x00341acaa0380cb3ULL, 0x00541914dd66a1b2ULL)},
+        {FIELD_LITERAL(0x00c1513cd66abe8cULL, 0x000139e01118944dULL,
+                       0x0064abbcb8080bbbULL, 0x00b3b08202473142ULL,
+                       0x00c629ef25da2403ULL, 0x00f0aec3310d9b7fULL,
+                       0x0050b2227472d8cdULL, 0x00f6c8a922d41fb4ULL)},
+        {FIELD_LITERAL(0x001075ccf26b7b1fULL, 0x00bb6bb213170433ULL,
+                       0x00e9491ad262da79ULL, 0x009ef4f48d2d384cULL,
+                       0x008992770766f09dULL, 0x001584396b6b1101ULL,
+                       0x00af3f8676c9feefULL, 0x0024603c40269118ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x009dd7b31319527cULL, 0x001e7ac948d873a9ULL,
+                       0x00fa54b46ef9673aULL, 0x0066efb8d5b02fe6ULL,
+                       0x00754b1d3928aeaeULL, 0x0004262ac72a6f6bULL,
+                       0x0079b7d49a6eb026ULL, 0x003126a753540102ULL)},
+        {FIELD_LITERAL(0x009666e24f693947ULL, 0x00f714311269d45fULL,
+                       0x0010ffac1d0c851cULL, 0x0066e80c37363497ULL,
+                       0x00f1f4ad010c60b0ULL, 0x0015c87408470ff7ULL,
+                       0x00651d5e9c7766a4ULL, 0x008138819d7116deULL)},
+        {FIELD_LITERAL(0x003934b11c57253bULL, 0x00ef308edf21f46eULL,
+                       0x00e54e99c7a16198ULL, 0x0080d57135764e63ULL,
+                       0x00751c27b946bc24ULL, 0x00dd389ce4e9e129ULL,
+                       0x00a1a2bfd1cd84dcULL, 0x002fae73e5149b32ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00911657dffb4cddULL, 0x00c100b7cc553d06ULL,
+                       0x00449d075ec467ccULL, 0x007062100bc64e70ULL,
+                       0x0043cf86f7bd21e7ULL, 0x00f401dc4b797deaULL,
+                       0x005224afb2f62e65ULL, 0x00d1ede3fb5a42beULL)},
+        {FIELD_LITERAL(0x00f2ba36a41aa144ULL, 0x00a0c22d946ee18fULL,
+                       0x008aae8ef9a14f99ULL, 0x00eef4d79b19bb36ULL,
+                       0x008e75ce3d27b1fcULL, 0x00a65daa03b29a27ULL,
+                       0x00d9cc83684eb145ULL, 0x009e1ed80cc2ed74ULL)},
+        {FIELD_LITERAL(0x00bed953d1997988ULL, 0x00b93ed175a24128ULL,
+                       0x00871c5963fb6365ULL, 0x00ca2df20014a787ULL,
+                       0x00f5d9c1d0b34322ULL, 0x00f6f5942818db0aULL,
+                       0x004cc091f49c9906ULL, 0x00e8a188a60bff9fULL)},
+    }}, {{
+        {FIELD_LITERAL(0x0032c7762032fae8ULL, 0x00e4087232e0bc21ULL,
+                       0x00f767344b6e8d85ULL, 0x00bbf369b76c2aa2ULL,
+                       0x008a1f46c6e1570cULL, 0x001368cd9780369fULL,
+                       0x007359a39d079430ULL, 0x0003646512921434ULL)},
+        {FIELD_LITERAL(0x007c4b47ca7c73e7ULL, 0x005396221039734bULL,
+                       0x008b64ddf0e45d7eULL, 0x00bfad5af285e6c2ULL,
+                       0x008ec711c5b1a1a8ULL, 0x00cf663301237f98ULL,
+                       0x00917ee3f1655126ULL, 0x004152f337efedd8ULL)},
+        {FIELD_LITERAL(0x0007c7edc9305daaULL, 0x000a6664f273701cULL,
+                       0x00f6e78795e200b1ULL, 0x005d05b9ecd2473eULL,
+                       0x0014f5f17c865786ULL, 0x00c7fd2d166fa995ULL,
+                       0x004939a2d8eb80e0ULL, 0x002244ba0942c199ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00321e767f0262cfULL, 0x002e57d776caf68eULL,
+                       0x00bf2c94814f0437ULL, 0x00c339196acd622fULL,
+                       0x001db4cce71e2770ULL, 0x001ded5ddba6eee2ULL,
+                       0x0078608ab1554c8dULL, 0x00067fe0ab76365bULL)},
+        {FIELD_LITERAL(0x00f09758e11e3985ULL, 0x00169efdbd64fad3ULL,
+                       0x00e8889b7d6dacd6ULL, 0x0035cdd58ea88209ULL,
+                       0x00bcda47586d7f49ULL, 0x003cdddcb2879088ULL,
+                       0x0016da70187e954bULL, 0x009556ea2e92aacdULL)},
+        {FIELD_LITERAL(0x008cab16bd1ff897ULL, 0x00b389972cdf753fULL,
+                       0x00ea8ed1e46dfdc0ULL, 0x004fe7ef94c589f4ULL,
+                       0x002b8ae9b805ecf3ULL, 0x0025c08d892874a5ULL,
+                       0x0023938e98d44c4cULL, 0x00f759134cabf69cULL)},
+    }}, {{
+        {FIELD_LITERAL(0x006c2a84678e4b3bULL, 0x007a194aacd1868fULL,
+                       0x00ed0225af424761ULL, 0x00da0a6f293c64b8ULL,
+                       0x001062ac5c6a7a18ULL, 0x0030f5775a8aeef4ULL,
+                       0x0002acaad76b7af0ULL, 0x00410b8fd63a579fULL)},
+        {FIELD_LITERAL(0x001ec59db3d9590eULL, 0x001e9e3f1c3f182dULL,
+                       0x0045a9c3ec2cab14ULL, 0x0008198572aeb673ULL,
+                       0x00773b74068bd167ULL, 0x0012535eaa395434ULL,
+                       0x0044dba9e3bbb74aULL, 0x002fba4d3c74bd0eULL)},
+        {FIELD_LITERAL(0x0042bf08fe66922cULL, 0x003318b8fbb49e8cULL,
+                       0x00d75946004aa14cULL, 0x00f601586b42bf1cULL,
+                       0x00c74cf1d912fe66ULL, 0x00abcb36974b30adULL,
+                       0x007eb78720c9d2b8ULL, 0x009f54ab7bd4df85ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00db9fc948f73826ULL, 0x00fa8b3746ed8ee9ULL,
+                       0x00132cb65aafbeb2ULL, 0x00c36ff3fe7925b8ULL,
+                       0x00837daed353d2feULL, 0x00ec661be0667cf4ULL,
+                       0x005beb8ed2e90204ULL, 0x00d77dd69e564967ULL)},
+        {FIELD_LITERAL(0x0042e6268b861751ULL, 0x0008dd0469500c16ULL,
+                       0x00b51b57c338a3fdULL, 0x00cc4497d85cff6bULL,
+                       0x002f13d6b57c34a4ULL, 0x0083652eaf301105ULL,
+                       0x00cc344294cc93a8ULL, 0x0060f4d02810e270ULL)},
+        {FIELD_LITERAL(0x00a8954363cd518bULL, 0x00ad171124bccb7bULL,
+                       0x0065f46a4adaae00ULL, 0x001b1a5b2a96e500ULL,
+                       0x0043fe24f8233285ULL, 0x0066996d8ae1f2c3ULL,
+                       0x00c530f3264169f9ULL, 0x00c0f92d07cf6a57ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x0036a55c6815d943ULL, 0x008c8d1def993db3ULL,
+                       0x002e0e1e8ff7318fULL, 0x00d883a4b92db00aULL,
+                       0x002f5e781ae33906ULL, 0x001a72adb235c06dULL,
+                       0x00f2e59e736e9caaULL, 0x001a4b58e3031914ULL)},
+        {FIELD_LITERAL(0x00d73bfae5e00844ULL, 0x00bf459766fb5f52ULL,
+                       0x0061b4f5a5313cdeULL, 0x004392d4c3b95514ULL,
+                       0x000d3551b1077523ULL, 0x0000998840ee5d71ULL,
+                       0x006de6e340448b7bULL, 0x00251aa504875d6eULL)},
+        {FIELD_LITERAL(0x003bf343427ac342ULL, 0x00adc0a78642b8c5ULL,
+                       0x0003b893175a8314ULL, 0x0061a34ade5703bcULL,
+                       0x00ea3ea8bb71d632ULL, 0x00be0df9a1f198c2ULL,
+                       0x0046dd8e7c1635fbULL, 0x00f1523fdd25d5e5ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00633f63fc9dd406ULL, 0x00e713ff80e04a43ULL,
+                       0x0060c6e970f2d621ULL, 0x00a57cd7f0df1891ULL,
+                       0x00f2406a550650bbULL, 0x00b064290efdc684ULL,
+                       0x001eab0144d17916ULL, 0x00cd15f863c293abULL)},
+        {FIELD_LITERAL(0x0029cec55273f70dULL, 0x007044ee275c6340ULL,
+                       0x0040f637a93015e2ULL, 0x00338bb78db5aae9ULL,
+                       0x001491b2a6132147ULL, 0x00a125d6cfe6bde3ULL,
+                       0x005f7ac561ba8669ULL, 0x001d5eaea3fbaacfULL)},
+        {FIELD_LITERAL(0x00054e9635e3be31ULL, 0x000e43f31e2872beULL,
+                       0x00d05b1c9e339841ULL, 0x006fac50bd81fd98ULL,
+                       0x00cdc7852eaebb09ULL, 0x004ff519b061991bULL,
+                       0x009099e8107d4c85ULL, 0x00273e24c36a4a61ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00070b4441ef2c46ULL, 0x00efa5b02801a109ULL,
+                       0x00bf0b8c3ee64adfULL, 0x008a67e0b3452e98ULL,
+                       0x001916b1f2fa7a74ULL, 0x00d781a78ff6cdc3ULL,
+                       0x008682ce57e5c919ULL, 0x00cc1109dd210da3ULL)},
+        {FIELD_LITERAL(0x00cae8aaff388663ULL, 0x005e983a35dda1c7ULL,
+                       0x007ab1030d8e37f4ULL, 0x00e48940f5d032feULL,
+                       0x006a36f9ef30b331ULL, 0x009be6f03958c757ULL,
+                       0x0086231ceba91400ULL, 0x008bd0f7b823e7aaULL)},
+        {FIELD_LITERAL(0x00cf881ebef5a45aULL, 0x004ebea78e7c6f2cULL,
+                       0x0090da9209cf26a0ULL, 0x00de2b2e4c775b84ULL,
+                       0x0071d6031c3c15aeULL, 0x00d9e927ef177d70ULL,
+                       0x00894ee8c23896fdULL, 0x00e3b3b401e41aadULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00204fef26864170ULL, 0x00819269c5dee0f8ULL,
+                       0x00bfb4713ec97966ULL, 0x0026339a6f34df78ULL,
+                       0x001f26e64c761dc2ULL, 0x00effe3af313cb60ULL,
+                       0x00e17b70138f601bULL, 0x00f16e1ccd9ede5eULL)},
+        {FIELD_LITERAL(0x005d9a8353fdb2dbULL, 0x0055cc2048c698f0ULL,
+                       0x00f6c4ac89657218ULL, 0x00525034d73faeb2ULL,
+                       0x00435776fbda3c7dULL, 0x0070ea5312323cbcULL,
+                       0x007a105d44d069fbULL, 0x006dbc8d6dc786aaULL)},
+        {FIELD_LITERAL(0x0017cff19cd394ecULL, 0x00fef7b810922587ULL,
+                       0x00e6483970dff548ULL, 0x00ddf36ad6874264ULL,
+                       0x00e61778523fcce2ULL, 0x0093a66c0c93b24aULL,
+                       0x00fd367114db7f86ULL, 0x007652d7ddce26ddULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00d92ced7ba12843ULL, 0x00aea9c7771e86e7ULL,
+                       0x0046639693354f7bULL, 0x00a628dbb6a80c47ULL,
+                       0x003a0b0507372953ULL, 0x00421113ab45c0d9ULL,
+                       0x00e545f08362ab7aULL, 0x0028ce087b4d6d96ULL)},
+        {FIELD_LITERAL(0x00a67ee7cf9f99ebULL, 0x005713b275f2ff68ULL,
+                       0x00f1d536a841513dULL, 0x00823b59b024712eULL,
+                       0x009c46b9d0d38cecULL, 0x00cdb1595aa2d7d4ULL,
+                       0x008375b3423d9af8ULL, 0x000ab0b516d978f7ULL)},
+        {FIELD_LITERAL(0x00428dcb3c510b0fULL, 0x00585607ea24bb4eULL,
+                       0x003736bf1603687aULL, 0x00c47e568c4fe3c7ULL,
+                       0x003cd00282848605ULL, 0x0043a487c3b91939ULL,
+                       0x004ffc04e1095a06ULL, 0x00a4c989a3d4b918ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00a8778d0e429f7aULL, 0x004c02b059105a68ULL,
+                       0x0016653b609da3ffULL, 0x00d5107bd1a12d27ULL,
+                       0x00b4708f9a771cabULL, 0x00bb63b662033f69ULL,
+                       0x0072f322240e7215ULL, 0x0019445b59c69222ULL)},
+        {FIELD_LITERAL(0x00cf4f6069a658e6ULL, 0x0053ca52859436a6ULL,
+                       0x0064b994d7e3e117ULL, 0x00cb469b9a07f534ULL,
+                       0x00cfb68f399e9d47ULL, 0x00f0dcb8dac1c6e7ULL,
+                       0x00f2ab67f538b3a5ULL, 0x0055544f178ab975ULL)},
+        {FIELD_LITERAL(0x0099b7a2685d538cULL, 0x00e2f1897b7c0018ULL,
+                       0x003adac8ce48dae3ULL, 0x00089276d5c50c0cULL,
+                       0x00172fca07ad6717ULL, 0x00cb1a72f54069e5ULL,
+                       0x004ee42f133545b3ULL, 0x00785f8651362f16ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x0049cbac38509e11ULL, 0x0015234505d42cdfULL,
+                       0x00794fb0b5840f1cULL, 0x00496437344045a5ULL,
+                       0x0031b6d944e4f9b0ULL, 0x00b207318ac1f5d8ULL,
+                       0x0000c840da7f5c5dULL, 0x00526f373a5c8814ULL)},
+        {FIELD_LITERAL(0x002c7b7742d1dfd9ULL, 0x002cabeb18623c01ULL,
+                       0x00055f5e3e044446ULL, 0x006c20f3b4ef54baULL,
+                       0x00c600141ec6b35fULL, 0x00354f437f1a32a3ULL,
+                       0x00bac4624a3520f9ULL, 0x00c483f734a90691ULL)},
+        {FIELD_LITERAL(0x0053a737d422918dULL, 0x00f7fca1d8758625ULL,
+                       0x00c360336dadb04cULL, 0x00f38e3d9158a1b8ULL,
+                       0x0069ce3b418e84c6ULL, 0x005d1697eca16eadULL,
+                       0x00f8bd6a35ece13dULL, 0x007885dfc2b5afeaULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00c3617ae260776cULL, 0x00b20dc3e96922d7ULL,
+                       0x00a1a7802246706aULL, 0x00ca6505a5240244ULL,
+                       0x002246b62d919782ULL, 0x001439102d7aa9b3ULL,
+                       0x00e8af1139e6422cULL, 0x00c888d1b52f2b05ULL)},
+        {FIELD_LITERAL(0x005b67690ffd41d9ULL, 0x005294f28df516f9ULL,
+                       0x00a879272412fcb9ULL, 0x00098b629a6d1c8dULL,
+                       0x00fabd3c8050865aULL, 0x00cd7e5b0a3879c5ULL,
+                       0x00153238210f3423ULL, 0x00357cac101e9f42ULL)},
+        {FIELD_LITERAL(0x008917b454444fb7ULL, 0x00f59247c97e441bULL,
+                       0x00a6200a6815152dULL, 0x0009a4228601d254ULL,
+                       0x001c0360559bd374ULL, 0x007563362039cb36ULL,
+                       0x00bd75b48d74e32bULL, 0x0017f515ac3499e8ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x001532a7ffe41c5aULL, 0x00eb1edce358d6bfULL,
+                       0x00ddbacc7b678a7bULL, 0x008a7b70f3c841a3ULL,
+                       0x00f1923bf27d3f4cULL, 0x000b2713ed8f7873ULL,
+                       0x00aaf67e29047902ULL, 0x0044994a70b3976dULL)},
+        {FIELD_LITERAL(0x00d54e802082d42cULL, 0x00a55aa0dce7cc6cULL,
+                       0x006477b96073f146ULL, 0x0082efe4ceb43594ULL,
+                       0x00a922bcba026845ULL, 0x0077f19d1ab75182ULL,
+                       0x00c2bb2737846e59ULL, 0x0004d7eec791dd33ULL)},
+        {FIELD_LITERAL(0x0044588d1a81d680ULL, 0x00b0a9097208e4f8ULL,
+                       0x00212605350dc57eULL, 0x0028717cd2871123ULL,
+                       0x00fb083c100fd979ULL, 0x0045a056ce063fdfULL,
+                       0x00a5d604b4dd6a41ULL, 0x001dabc08ba4e236ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00c4887198d7a7faULL, 0x00244f98fb45784aULL,
+                       0x0045911e15a15d01ULL, 0x001d323d374c0966ULL,
+                       0x00967c3915196562ULL, 0x0039373abd2f3c67ULL,
+                       0x000d2c5614312423ULL, 0x0041cf2215442ce3ULL)},
+        {FIELD_LITERAL(0x008ede889ada7f06ULL, 0x001611e91de2e135ULL,
+                       0x00fdb9a458a471b9ULL, 0x00563484e03710d1ULL,
+                       0x0031cc81925e3070ULL, 0x0062c97b3af80005ULL,
+                       0x00fa733eea28edebULL, 0x00e82457e1ebbc88ULL)},
+        {FIELD_LITERAL(0x006a0df5fe9b6f59ULL, 0x00a0d4ff46040d92ULL,
+                       0x004a7cedb6f93250ULL, 0x00d1df8855b8c357ULL,
+                       0x00e73a46086fd058ULL, 0x0048fb0add6dfe59ULL,
+                       0x001e03a28f1b4e3dULL, 0x00a871c993308d76ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x0030dbb2d1766ec8ULL, 0x00586c0ad138555eULL,
+                       0x00d1a34f9e91c77cULL, 0x0063408ad0e89014ULL,
+                       0x00d61231b05f6f5bULL, 0x0009abf569f5fd8aULL,
+                       0x00aec67a110f1c43ULL, 0x0031d1a790938dd7ULL)},
+        {FIELD_LITERAL(0x006cded841e2a862ULL, 0x00198d60af0ab6fbULL,
+                       0x0018f09db809e750ULL, 0x004e6ac676016263ULL,
+                       0x00eafcd1620969cbULL, 0x002c9784ca34917dULL,
+                       0x0054f00079796de7ULL, 0x00d9fab5c5972204ULL)},
+        {FIELD_LITERAL(0x004bd0fee2438a83ULL, 0x00b571e62b0f83bdULL,
+                       0x0059287d7ce74800ULL, 0x00fb3631b645c3f0ULL,
+                       0x00a018e977f78494ULL, 0x0091e27065c27b12ULL,
+                       0x007696c1817165e0ULL, 0x008c40be7c45ba3aULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00a0f326327cb684ULL, 0x001c7d0f672680ffULL,
+                       0x008c1c81ffb112d1ULL, 0x00f8f801674eddc8ULL,
+                       0x00e926d5d48c2a9dULL, 0x005bd6d954c6fe9aULL,
+                       0x004c6b24b4e33703ULL, 0x00d05eb5c09105ccULL)},
+        {FIELD_LITERAL(0x00d61731caacf2cfULL, 0x002df0c7609e01c5ULL,
+                       0x00306172208b1e2bULL, 0x00b413fe4fb2b686ULL,
+                       0x00826d360902a221ULL, 0x003f8d056e67e7f7ULL,
+                       0x0065025b0175e989ULL, 0x00369add117865ebULL)},
+        {FIELD_LITERAL(0x00aaf895aec2fa11ULL, 0x000f892bc313eb52ULL,
+                       0x005b1c794dad050bULL, 0x003f8ec4864cec14ULL,
+                       0x00af81058d0b90e5ULL, 0x00ebe43e183997bbULL,
+                       0x00a9d610f9f3e615ULL, 0x007acd8eec2e88d3ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x0049b2fab13812a3ULL, 0x00846db32cd60431ULL,
+                       0x000177fa578c8d6cULL, 0x00047d0e2ad4bc51ULL,
+                       0x00b158ba38d1e588ULL, 0x006a45daad79e3f3ULL,
+                       0x000997b93cab887bULL, 0x00c47ea42fa23dc3ULL)},
+        {FIELD_LITERAL(0x0012b6fef7aeb1caULL, 0x009412768194b6a7ULL,
+                       0x00ff0d351f23ab93ULL, 0x007e8a14c1aff71bULL,
+                       0x006c1c0170c512bcULL, 0x0016243ea02ab2e5ULL,
+                       0x007bb6865b303f3eULL, 0x0015ce6b29b159f4ULL)},
+        {FIELD_LITERAL(0x009961cd02e68108ULL, 0x00e2035d3a1d0836ULL,
+                       0x005d51f69b5e1a1dULL, 0x004bccb4ea36edcdULL,
+                       0x0069be6a7aeef268ULL, 0x0063f4dd9de8d5a7ULL,
+                       0x006283783092ca35ULL, 0x0075a31af2c35409ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00c412365162e8cfULL, 0x00012283fb34388aULL,
+                       0x003e6543babf39e2ULL, 0x00eead6b3a804978ULL,
+                       0x0099c0314e8b326fULL, 0x00e98e0a8d477a4fULL,
+                       0x00d2eb96b127a687ULL, 0x00ed8d7df87571bbULL)},
+        {FIELD_LITERAL(0x00777463e308cacfULL, 0x00c8acb93950132dULL,
+                       0x00ebddbf4ca48b2cULL, 0x0026ad7ca0795a0aULL,
+                       0x00f99a3d9a715064ULL, 0x000d60bcf9d4dfccULL,
+                       0x005e65a73a437a06ULL, 0x0019d536a8db56c8ULL)},
+        {FIELD_LITERAL(0x00192d7dd558d135ULL, 0x0027cd6a8323ffa7ULL,
+                       0x00239f1a412dc1e7ULL, 0x0046b4b3be74fc5cULL,
+                       0x0020c47a2bef5bceULL, 0x00aa17e48f43862bULL,
+                       0x00f7e26c96342e5fULL, 0x0008011c530f39a9ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x00aad4ac569bf0f1ULL, 0x00a67adc90b27740ULL,
+                       0x0048551369a5751aULL, 0x0031252584a3306aULL,
+                       0x0084e15df770e6fcULL, 0x00d7bba1c74b5805ULL,
+                       0x00a80ef223af1012ULL, 0x0089c85ceb843a34ULL)},
+        {FIELD_LITERAL(0x00c4545be4a54004ULL, 0x0099e11f60357e6cULL,
+                       0x001f3936d19515a6ULL, 0x007793df84341a6eULL,
+                       0x0051061886717ffaULL, 0x00e9b0a660b28f85ULL,
+                       0x0044ea685892de0dULL, 0x000257d2a1fda9d9ULL)},
+        {FIELD_LITERAL(0x007e8b01b24ac8a8ULL, 0x006cf3b0b5ca1337ULL,
+                       0x00f1607d3e36a570ULL, 0x0039b7fab82991a1ULL,
+                       0x00231777065840c5ULL, 0x00998e5afdd346f9ULL,
+                       0x00b7dc3e64acc85fULL, 0x00baacc748013ad6ULL)},
+    }}, {{
+        {FIELD_LITERAL(0x008ea6a4177580bfULL, 0x005fa1953e3f0378ULL,
+                       0x005fe409ac74d614ULL, 0x00452327f477e047ULL,
+                       0x00a4018507fb6073ULL, 0x007b6e71951caac8ULL,
+                       0x0012b42ab8a6ce91ULL, 0x0080eca677294ab7ULL)},
+        {FIELD_LITERAL(0x00a53edc023ba69bULL, 0x00c6afa83ddde2e8ULL,
+                       0x00c3f638b307b14eULL, 0x004a357a64414062ULL,
+                       0x00e4d94d8b582dc9ULL, 0x001739caf71695b7ULL,
+                       0x0012431b2ae28de1ULL, 0x003b6bc98682907cULL)},
+        {FIELD_LITERAL(0x008a9a93be1f99d6ULL, 0x0079fa627cc699c8ULL,
+                       0x00b0cfb134ba84c8ULL, 0x001c4b778249419aULL,
+                       0x00df4ab3d9c44f40ULL, 0x009f596e6c1a9e3cULL,
+                       0x001979c0df237316ULL, 0x00501e953a919b87ULL)},
+    }}
+};
+const niels_t *curve448_wnaf_base = curve448_wnaf_base_table;
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448utils.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448utils.h
new file mode 100644
index 000000000..86c258e74
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/curve448utils.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448UTILS_H
+# define OSSL_CRYPTO_EC_CURVE448UTILS_H
+
+# include <openssl/e_os2.h>
+
+/*
+ * Internal word types. Somewhat tricky.  This could be decided separately per
+ * platform.  However, the structs do need to be all the same size and
+ * alignment on a given platform to support dynamic linking, since even if you
+ * header was built with eg arch_neon, you might end up linking a library built
+ * with arch_arm32.
+ */
+# ifndef C448_WORD_BITS
+#  if (defined(__SIZEOF_INT128__) && (__SIZEOF_INT128__ == 16)) \
+      && !defined(__sparc__) \
+      && (!defined(__SIZEOF_LONG__) || (__SIZEOF_LONG__ == 8))
+
+#   define C448_WORD_BITS 64      /* The number of bits in a word */
+#  else
+#   define C448_WORD_BITS 32      /* The number of bits in a word */
+#  endif
+# endif
+
+# if C448_WORD_BITS == 64
+/* Word size for internal computations */
+typedef uint64_t c448_word_t;
+/* Signed word size for internal computations */
+typedef int64_t c448_sword_t;
+/* "Boolean" type, will be set to all-zero or all-one (i.e. -1u) */
+typedef uint64_t c448_bool_t;
+/* Double-word size for internal computations */
+typedef __uint128_t c448_dword_t;
+/* Signed double-word size for internal computations */
+typedef __int128_t c448_dsword_t;
+# elif C448_WORD_BITS == 32
+/* Word size for internal computations */
+typedef uint32_t c448_word_t;
+/* Signed word size for internal computations */
+typedef int32_t c448_sword_t;
+/* "Boolean" type, will be set to all-zero or all-one (i.e. -1u) */
+typedef uint32_t c448_bool_t;
+/* Double-word size for internal computations */
+typedef uint64_t c448_dword_t;
+/* Signed double-word size for internal computations */
+typedef int64_t c448_dsword_t;
+# else
+#  error "Only supporting C448_WORD_BITS = 32 or 64 for now"
+# endif
+
+/* C448_TRUE = -1 so that C448_TRUE & x = x */
+# define C448_TRUE      (0 - (c448_bool_t)1)
+
+/* C448_FALSE = 0 so that C448_FALSE & x = 0 */
+# define C448_FALSE     0
+
+/* Another boolean type used to indicate success or failure. */
+typedef enum {
+    C448_SUCCESS = -1, /**< The operation succeeded. */
+    C448_FAILURE = 0   /**< The operation failed. */
+} c448_error_t;
+
+/* Return success if x is true */
+static ossl_inline c448_error_t c448_succeed_if(c448_bool_t x)
+{
+    return (c448_error_t) x;
+}
+
+#endif                          /* __C448_COMMON_H__ */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/ed448.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/ed448.h
new file mode 100644
index 000000000..c1e5c2832
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/ed448.h
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448_ED448_H
+# define OSSL_CRYPTO_EC_CURVE448_ED448_H
+
+# include "point_448.h"
+
+/* Number of bytes in an EdDSA public key. */
+# define EDDSA_448_PUBLIC_BYTES 57
+
+/* Number of bytes in an EdDSA private key. */
+# define EDDSA_448_PRIVATE_BYTES EDDSA_448_PUBLIC_BYTES
+
+/* Number of bytes in an EdDSA private key. */
+# define EDDSA_448_SIGNATURE_BYTES (EDDSA_448_PUBLIC_BYTES + \
+                                    EDDSA_448_PRIVATE_BYTES)
+
+/* EdDSA encoding ratio. */
+# define C448_EDDSA_ENCODE_RATIO 4
+
+/* EdDSA decoding ratio. */
+# define C448_EDDSA_DECODE_RATIO (4 / 4)
+
+/*
+ * EdDSA key generation.  This function uses a different (non-Decaf) encoding.
+ *
+ * pubkey (out): The public key.
+ * privkey (in): The private key.
+ */
+c448_error_t c448_ed448_derive_public_key(
+                        uint8_t pubkey [EDDSA_448_PUBLIC_BYTES],
+                        const uint8_t privkey [EDDSA_448_PRIVATE_BYTES]);
+
+/*
+ * EdDSA signing.
+ *
+ * signature (out): The signature.
+ * privkey (in): The private key.
+ * pubkey (in):  The public key.
+ * message (in):  The message to sign.
+ * message_len (in):  The length of the message.
+ * prehashed (in):  Nonzero if the message is actually the hash of something
+ *                  you want to sign.
+ * context (in):  A "context" for this signature of up to 255 bytes.
+ * context_len (in):  Length of the context.
+ *
+ * For Ed25519, it is unsafe to use the same key for both prehashed and
+ * non-prehashed messages, at least without some very careful protocol-level
+ * disambiguation.  For Ed448 it is safe.
+ */
+c448_error_t c448_ed448_sign(
+                        uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                        const uint8_t privkey[EDDSA_448_PRIVATE_BYTES],
+                        const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                        const uint8_t *message, size_t message_len,
+                        uint8_t prehashed, const uint8_t *context,
+                        size_t context_len);
+
+/*
+ * EdDSA signing with prehash.
+ *
+ * signature (out): The signature.
+ * privkey (in): The private key.
+ * pubkey (in): The public key.
+ * hash (in): The hash of the message.  This object will not be modified by the
+ *            call.
+ * context (in): A "context" for this signature of up to 255 bytes.  Must be the
+ *               same as what was used for the prehash.
+ * context_len (in): Length of the context.
+ *
+ * For Ed25519, it is unsafe to use the same key for both prehashed and
+ * non-prehashed messages, at least without some very careful protocol-level
+ * disambiguation.  For Ed448 it is safe.
+ */
+c448_error_t c448_ed448_sign_prehash(
+                        uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                        const uint8_t privkey[EDDSA_448_PRIVATE_BYTES],
+                        const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                        const uint8_t hash[64],
+                        const uint8_t *context,
+                        size_t context_len);
+
+/*
+ * EdDSA signature verification.
+ *
+ * Uses the standard (i.e. less-strict) verification formula.
+ *
+ * signature (in): The signature.
+ * pubkey (in): The public key.
+ * message (in): The message to verify.
+ * message_len (in): The length of the message.
+ * prehashed (in): Nonzero if the message is actually the hash of something you
+ *                 want to verify.
+ * context (in): A "context" for this signature of up to 255 bytes.
+ * context_len (in): Length of the context.
+ *
+ * For Ed25519, it is unsafe to use the same key for both prehashed and
+ * non-prehashed messages, at least without some very careful protocol-level
+ * disambiguation.  For Ed448 it is safe.
+ */
+c448_error_t c448_ed448_verify(const uint8_t
+                                 signature[EDDSA_448_SIGNATURE_BYTES],
+                                 const uint8_t
+                                 pubkey[EDDSA_448_PUBLIC_BYTES],
+                                 const uint8_t *message, size_t message_len,
+                                 uint8_t prehashed, const uint8_t *context,
+                                 uint8_t context_len);
+
+/*
+ * EdDSA signature verification.
+ *
+ * Uses the standard (i.e. less-strict) verification formula.
+ *
+ * signature (in): The signature.
+ * pubkey (in): The public key.
+ * hash (in): The hash of the message.  This object will not be modified by the
+ *            call.
+ * context (in): A "context" for this signature of up to 255 bytes.  Must be the
+ *               same as what was used for the prehash.
+ * context_len (in): Length of the context.
+ *
+ * For Ed25519, it is unsafe to use the same key for both prehashed and
+ * non-prehashed messages, at least without some very careful protocol-level
+ * disambiguation.  For Ed448 it is safe.
+ */
+c448_error_t c448_ed448_verify_prehash(
+                    const uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                    const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                    const uint8_t hash[64],
+                    const uint8_t *context,
+                    uint8_t context_len);
+
+/*
+ * EdDSA point encoding.  Used internally, exposed externally.
+ * Multiplies by C448_EDDSA_ENCODE_RATIO first.
+ *
+ * The multiplication is required because the EdDSA encoding represents
+ * the cofactor information, but the Decaf encoding ignores it (which
+ * is the whole point).  So if you decode from EdDSA and re-encode to
+ * EdDSA, the cofactor info must get cleared, because the intermediate
+ * representation doesn't track it.
+ *
+ * The way we handle this is to multiply by C448_EDDSA_DECODE_RATIO when
+ * decoding, and by C448_EDDSA_ENCODE_RATIO when encoding.  The product of
+ * these ratios is always exactly the cofactor 4, so the cofactor ends up
+ * cleared one way or another.  But exactly how that shakes out depends on the
+ * base points specified in RFC 8032.
+ *
+ * The upshot is that if you pass the Decaf/Ristretto base point to
+ * this function, you will get C448_EDDSA_ENCODE_RATIO times the
+ * EdDSA base point.
+ *
+ * enc (out): The encoded point.
+ * p (in): The point.
+ */
+void curve448_point_mul_by_ratio_and_encode_like_eddsa(
+                                    uint8_t enc [EDDSA_448_PUBLIC_BYTES],
+                                    const curve448_point_t p);
+
+/*
+ * EdDSA point decoding.  Multiplies by C448_EDDSA_DECODE_RATIO, and
+ * ignores cofactor information.
+ *
+ * See notes on curve448_point_mul_by_ratio_and_encode_like_eddsa
+ *
+ * enc (out): The encoded point.
+ * p (in): The point.
+ */
+c448_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
+                            curve448_point_t p,
+                            const uint8_t enc[EDDSA_448_PUBLIC_BYTES]);
+
+/*
+ * EdDSA to ECDH private key conversion
+ * Using the appropriate hash function, hash the EdDSA private key
+ * and keep only the lower bytes to get the ECDH private key
+ *
+ * x (out): The ECDH private key as in RFC7748
+ * ed (in): The EdDSA private key
+ */
+c448_error_t c448_ed448_convert_private_key_to_x448(
+                            uint8_t x[X448_PRIVATE_BYTES],
+                            const uint8_t ed[EDDSA_448_PRIVATE_BYTES]);
+
+#endif                          /* OSSL_CRYPTO_EC_CURVE448_ED448_H */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/eddsa.c b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/eddsa.c
new file mode 100644
index 000000000..82741f543
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/eddsa.c
@@ -0,0 +1,377 @@
+/*
+ * Copyright 2017-2020 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+#include <string.h>
+#include <openssl/crypto.h>
+#include <openssl/evp.h>
+#include "curve448_local.h"
+#include "word.h"
+#include "ed448.h"
+#include "internal/numbers.h"
+
+#define COFACTOR 4
+
+static c448_error_t oneshot_hash(uint8_t *out, size_t outlen,
+                                 const uint8_t *in, size_t inlen)
+{
+    EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
+
+    if (hashctx == NULL)
+        return C448_FAILURE;
+
+    if (!EVP_DigestInit_ex(hashctx, EVP_shake256(), NULL)
+            || !EVP_DigestUpdate(hashctx, in, inlen)
+            || !EVP_DigestFinalXOF(hashctx, out, outlen)) {
+        EVP_MD_CTX_free(hashctx);
+        return C448_FAILURE;
+    }
+
+    EVP_MD_CTX_free(hashctx);
+    return C448_SUCCESS;
+}
+
+static void clamp(uint8_t secret_scalar_ser[EDDSA_448_PRIVATE_BYTES])
+{
+    secret_scalar_ser[0] &= -COFACTOR;
+    secret_scalar_ser[EDDSA_448_PRIVATE_BYTES - 1] = 0;
+    secret_scalar_ser[EDDSA_448_PRIVATE_BYTES - 2] |= 0x80;
+}
+
+static c448_error_t hash_init_with_dom(EVP_MD_CTX *hashctx, uint8_t prehashed,
+                                       uint8_t for_prehash,
+                                       const uint8_t *context,
+                                       size_t context_len)
+{
+#ifdef CHARSET_EBCDIC
+    const char dom_s[] = {0x53, 0x69, 0x67, 0x45,
+                          0x64, 0x34, 0x34, 0x38, 0x00};
+#else
+    const char dom_s[] = "SigEd448";
+#endif
+    uint8_t dom[2];
+
+    if (context_len > UINT8_MAX)
+        return C448_FAILURE;
+
+    dom[0] = (uint8_t)(2 - (prehashed == 0 ? 1 : 0)
+                       - (for_prehash == 0 ? 1 : 0));
+    dom[1] = (uint8_t)context_len;
+
+    if (!EVP_DigestInit_ex(hashctx, EVP_shake256(), NULL)
+            || !EVP_DigestUpdate(hashctx, dom_s, strlen(dom_s))
+            || !EVP_DigestUpdate(hashctx, dom, sizeof(dom))
+            || !EVP_DigestUpdate(hashctx, context, context_len))
+        return C448_FAILURE;
+
+    return C448_SUCCESS;
+}
+
+/* In this file because it uses the hash */
+c448_error_t c448_ed448_convert_private_key_to_x448(
+                            uint8_t x[X448_PRIVATE_BYTES],
+                            const uint8_t ed [EDDSA_448_PRIVATE_BYTES])
+{
+    /* pass the private key through oneshot_hash function */
+    /* and keep the first X448_PRIVATE_BYTES bytes */
+    return oneshot_hash(x, X448_PRIVATE_BYTES, ed,
+                        EDDSA_448_PRIVATE_BYTES);
+}
+
+c448_error_t c448_ed448_derive_public_key(
+                        uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                        const uint8_t privkey[EDDSA_448_PRIVATE_BYTES])
+{
+    /* only this much used for keygen */
+    uint8_t secret_scalar_ser[EDDSA_448_PRIVATE_BYTES];
+    curve448_scalar_t secret_scalar;
+    unsigned int c;
+    curve448_point_t p;
+
+    if (!oneshot_hash(secret_scalar_ser, sizeof(secret_scalar_ser), privkey,
+                      EDDSA_448_PRIVATE_BYTES))
+        return C448_FAILURE;
+
+    clamp(secret_scalar_ser);
+
+    curve448_scalar_decode_long(secret_scalar, secret_scalar_ser,
+                                sizeof(secret_scalar_ser));
+
+    /*
+     * Since we are going to mul_by_cofactor during encoding, divide by it
+     * here. However, the EdDSA base point is not the same as the decaf base
+     * point if the sigma isogeny is in use: the EdDSA base point is on
+     * Etwist_d/(1-d) and the decaf base point is on Etwist_d, and when
+     * converted it effectively picks up a factor of 2 from the isogenies.  So
+     * we might start at 2 instead of 1.
+     */
+    for (c = 1; c < C448_EDDSA_ENCODE_RATIO; c <<= 1)
+        curve448_scalar_halve(secret_scalar, secret_scalar);
+
+    curve448_precomputed_scalarmul(p, curve448_precomputed_base, secret_scalar);
+
+    curve448_point_mul_by_ratio_and_encode_like_eddsa(pubkey, p);
+
+    /* Cleanup */
+    curve448_scalar_destroy(secret_scalar);
+    curve448_point_destroy(p);
+    OPENSSL_cleanse(secret_scalar_ser, sizeof(secret_scalar_ser));
+
+    return C448_SUCCESS;
+}
+
+c448_error_t c448_ed448_sign(
+                        uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                        const uint8_t privkey[EDDSA_448_PRIVATE_BYTES],
+                        const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                        const uint8_t *message, size_t message_len,
+                        uint8_t prehashed, const uint8_t *context,
+                        size_t context_len)
+{
+    curve448_scalar_t secret_scalar;
+    EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
+    c448_error_t ret = C448_FAILURE;
+    curve448_scalar_t nonce_scalar;
+    uint8_t nonce_point[EDDSA_448_PUBLIC_BYTES] = { 0 };
+    unsigned int c;
+    curve448_scalar_t challenge_scalar;
+
+    if (hashctx == NULL)
+        return C448_FAILURE;
+
+    {
+        /*
+         * Schedule the secret key, First EDDSA_448_PRIVATE_BYTES is serialised
+         * secret scalar,next EDDSA_448_PRIVATE_BYTES bytes is the seed.
+         */
+        uint8_t expanded[EDDSA_448_PRIVATE_BYTES * 2];
+
+        if (!oneshot_hash(expanded, sizeof(expanded), privkey,
+                          EDDSA_448_PRIVATE_BYTES))
+            goto err;
+        clamp(expanded);
+        curve448_scalar_decode_long(secret_scalar, expanded,
+                                    EDDSA_448_PRIVATE_BYTES);
+
+        /* Hash to create the nonce */
+        if (!hash_init_with_dom(hashctx, prehashed, 0, context, context_len)
+                || !EVP_DigestUpdate(hashctx,
+                                     expanded + EDDSA_448_PRIVATE_BYTES,
+                                     EDDSA_448_PRIVATE_BYTES)
+                || !EVP_DigestUpdate(hashctx, message, message_len)) {
+            OPENSSL_cleanse(expanded, sizeof(expanded));
+            goto err;
+        }
+        OPENSSL_cleanse(expanded, sizeof(expanded));
+    }
+
+    /* Decode the nonce */
+    {
+        uint8_t nonce[2 * EDDSA_448_PRIVATE_BYTES];
+
+        if (!EVP_DigestFinalXOF(hashctx, nonce, sizeof(nonce)))
+            goto err;
+        curve448_scalar_decode_long(nonce_scalar, nonce, sizeof(nonce));
+        OPENSSL_cleanse(nonce, sizeof(nonce));
+    }
+
+    {
+        /* Scalarmul to create the nonce-point */
+        curve448_scalar_t nonce_scalar_2;
+        curve448_point_t p;
+
+        curve448_scalar_halve(nonce_scalar_2, nonce_scalar);
+        for (c = 2; c < C448_EDDSA_ENCODE_RATIO; c <<= 1)
+            curve448_scalar_halve(nonce_scalar_2, nonce_scalar_2);
+
+        curve448_precomputed_scalarmul(p, curve448_precomputed_base,
+                                       nonce_scalar_2);
+        curve448_point_mul_by_ratio_and_encode_like_eddsa(nonce_point, p);
+        curve448_point_destroy(p);
+        curve448_scalar_destroy(nonce_scalar_2);
+    }
+
+    {
+        uint8_t challenge[2 * EDDSA_448_PRIVATE_BYTES];
+
+        /* Compute the challenge */
+        if (!hash_init_with_dom(hashctx, prehashed, 0, context, context_len)
+                || !EVP_DigestUpdate(hashctx, nonce_point, sizeof(nonce_point))
+                || !EVP_DigestUpdate(hashctx, pubkey, EDDSA_448_PUBLIC_BYTES)
+                || !EVP_DigestUpdate(hashctx, message, message_len)
+                || !EVP_DigestFinalXOF(hashctx, challenge, sizeof(challenge)))
+            goto err;
+
+        curve448_scalar_decode_long(challenge_scalar, challenge,
+                                    sizeof(challenge));
+        OPENSSL_cleanse(challenge, sizeof(challenge));
+    }
+
+    curve448_scalar_mul(challenge_scalar, challenge_scalar, secret_scalar);
+    curve448_scalar_add(challenge_scalar, challenge_scalar, nonce_scalar);
+
+    OPENSSL_cleanse(signature, EDDSA_448_SIGNATURE_BYTES);
+    memcpy(signature, nonce_point, sizeof(nonce_point));
+    curve448_scalar_encode(&signature[EDDSA_448_PUBLIC_BYTES],
+                           challenge_scalar);
+
+    curve448_scalar_destroy(secret_scalar);
+    curve448_scalar_destroy(nonce_scalar);
+    curve448_scalar_destroy(challenge_scalar);
+
+    ret = C448_SUCCESS;
+ err:
+    EVP_MD_CTX_free(hashctx);
+    return ret;
+}
+
+c448_error_t c448_ed448_sign_prehash(
+                        uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                        const uint8_t privkey[EDDSA_448_PRIVATE_BYTES],
+                        const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                        const uint8_t hash[64], const uint8_t *context,
+                        size_t context_len)
+{
+    return c448_ed448_sign(signature, privkey, pubkey, hash, 64, 1, context,
+                           context_len);
+}
+
+c448_error_t c448_ed448_verify(
+                    const uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                    const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                    const uint8_t *message, size_t message_len,
+                    uint8_t prehashed, const uint8_t *context,
+                    uint8_t context_len)
+{
+    curve448_point_t pk_point, r_point;
+    c448_error_t error;
+    curve448_scalar_t challenge_scalar;
+    curve448_scalar_t response_scalar;
+    /* Order in little endian format */
+    static const uint8_t order[] = {
+        0xF3, 0x44, 0x58, 0xAB, 0x92, 0xC2, 0x78, 0x23, 0x55, 0x8F, 0xC5, 0x8D,
+        0x72, 0xC2, 0x6C, 0x21, 0x90, 0x36, 0xD6, 0xAE, 0x49, 0xDB, 0x4E, 0xC4,
+        0xE9, 0x23, 0xCA, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00
+    };
+    int i;
+
+    /*
+     * Check that s (second 57 bytes of the sig) is less than the order. Both
+     * s and the order are in little-endian format. This can be done in
+     * variable time, since if this is not the case the signature if publicly
+     * invalid.
+     */
+    for (i = EDDSA_448_PUBLIC_BYTES - 1; i >= 0; i--) {
+        if (signature[i + EDDSA_448_PUBLIC_BYTES] > order[i])
+            return C448_FAILURE;
+        if (signature[i + EDDSA_448_PUBLIC_BYTES] < order[i])
+            break;
+    }
+    if (i < 0)
+        return C448_FAILURE;
+
+    error =
+        curve448_point_decode_like_eddsa_and_mul_by_ratio(pk_point, pubkey);
+
+    if (C448_SUCCESS != error)
+        return error;
+
+    error =
+        curve448_point_decode_like_eddsa_and_mul_by_ratio(r_point, signature);
+    if (C448_SUCCESS != error)
+        return error;
+
+    {
+        /* Compute the challenge */
+        EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
+        uint8_t challenge[2 * EDDSA_448_PRIVATE_BYTES];
+
+        if (hashctx == NULL
+                || !hash_init_with_dom(hashctx, prehashed, 0, context,
+                                       context_len)
+                || !EVP_DigestUpdate(hashctx, signature, EDDSA_448_PUBLIC_BYTES)
+                || !EVP_DigestUpdate(hashctx, pubkey, EDDSA_448_PUBLIC_BYTES)
+                || !EVP_DigestUpdate(hashctx, message, message_len)
+                || !EVP_DigestFinalXOF(hashctx, challenge, sizeof(challenge))) {
+            EVP_MD_CTX_free(hashctx);
+            return C448_FAILURE;
+        }
+
+        EVP_MD_CTX_free(hashctx);
+        curve448_scalar_decode_long(challenge_scalar, challenge,
+                                    sizeof(challenge));
+        OPENSSL_cleanse(challenge, sizeof(challenge));
+    }
+    curve448_scalar_sub(challenge_scalar, curve448_scalar_zero,
+                        challenge_scalar);
+
+    curve448_scalar_decode_long(response_scalar,
+                                &signature[EDDSA_448_PUBLIC_BYTES],
+                                EDDSA_448_PRIVATE_BYTES);
+
+    /* pk_point = -c(x(P)) + (cx + k)G = kG */
+    curve448_base_double_scalarmul_non_secret(pk_point,
+                                              response_scalar,
+                                              pk_point, challenge_scalar);
+    return c448_succeed_if(curve448_point_eq(pk_point, r_point));
+}
+
+c448_error_t c448_ed448_verify_prehash(
+                    const uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
+                    const uint8_t pubkey[EDDSA_448_PUBLIC_BYTES],
+                    const uint8_t hash[64], const uint8_t *context,
+                    uint8_t context_len)
+{
+    return c448_ed448_verify(signature, pubkey, hash, 64, 1, context,
+                             context_len);
+}
+
+int ED448_sign(uint8_t *out_sig, const uint8_t *message, size_t message_len,
+               const uint8_t public_key[57], const uint8_t private_key[57],
+               const uint8_t *context, size_t context_len)
+{
+    return c448_ed448_sign(out_sig, private_key, public_key, message,
+                           message_len, 0, context, context_len)
+        == C448_SUCCESS;
+}
+
+int ED448_verify(const uint8_t *message, size_t message_len,
+                 const uint8_t signature[114], const uint8_t public_key[57],
+                 const uint8_t *context, size_t context_len)
+{
+    return c448_ed448_verify(signature, public_key, message, message_len, 0,
+                             context, (uint8_t)context_len) == C448_SUCCESS;
+}
+
+int ED448ph_sign(uint8_t *out_sig, const uint8_t hash[64],
+                 const uint8_t public_key[57], const uint8_t private_key[57],
+                 const uint8_t *context, size_t context_len)
+{
+    return c448_ed448_sign_prehash(out_sig, private_key, public_key, hash,
+                                   context, context_len) == C448_SUCCESS;
+
+}
+
+int ED448ph_verify(const uint8_t hash[64], const uint8_t signature[114],
+                   const uint8_t public_key[57], const uint8_t *context,
+                   size_t context_len)
+{
+    return c448_ed448_verify_prehash(signature, public_key, hash, context,
+                                     (uint8_t)context_len) == C448_SUCCESS;
+}
+
+int ED448_public_from_private(uint8_t out_public_key[57],
+                              const uint8_t private_key[57])
+{
+    return c448_ed448_derive_public_key(out_public_key, private_key)
+        == C448_SUCCESS;
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/f_generic.c b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/f_generic.c
new file mode 100644
index 000000000..09d08165e
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/f_generic.c
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+#include "field.h"
+
+static const gf MODULUS = {
+    FIELD_LITERAL(0xffffffffffffffULL, 0xffffffffffffffULL, 0xffffffffffffffULL,
+                  0xffffffffffffffULL, 0xfffffffffffffeULL, 0xffffffffffffffULL,
+                  0xffffffffffffffULL, 0xffffffffffffffULL)
+};
+
+/* Serialize to wire format. */
+void gf_serialize(uint8_t serial[SER_BYTES], const gf x, int with_hibit)
+{
+    unsigned int j = 0, fill = 0;
+    dword_t buffer = 0;
+    int i;
+    gf red;
+
+    gf_copy(red, x);
+    gf_strong_reduce(red);
+    if (!with_hibit)
+        assert(gf_hibit(red) == 0);
+
+    for (i = 0; i < (with_hibit ? X_SER_BYTES : SER_BYTES); i++) {
+        if (fill < 8 && j < NLIMBS) {
+            buffer |= ((dword_t) red->limb[LIMBPERM(j)]) << fill;
+            fill += LIMB_PLACE_VALUE(LIMBPERM(j));
+            j++;
+        }
+        serial[i] = (uint8_t)buffer;
+        fill -= 8;
+        buffer >>= 8;
+    }
+}
+
+/* Return high bit of x = low bit of 2x mod p */
+mask_t gf_hibit(const gf x)
+{
+    gf y;
+
+    gf_add(y, x, x);
+    gf_strong_reduce(y);
+    return 0 - (y->limb[0] & 1);
+}
+
+/* Return high bit of x = low bit of 2x mod p */
+mask_t gf_lobit(const gf x)
+{
+    gf y;
+
+    gf_copy(y, x);
+    gf_strong_reduce(y);
+    return 0 - (y->limb[0] & 1);
+}
+
+/* Deserialize from wire format; return -1 on success and 0 on failure. */
+mask_t gf_deserialize(gf x, const uint8_t serial[SER_BYTES], int with_hibit,
+                      uint8_t hi_nmask)
+{
+    unsigned int j = 0, fill = 0;
+    dword_t buffer = 0;
+    dsword_t scarry = 0;
+    const unsigned nbytes = with_hibit ? X_SER_BYTES : SER_BYTES;
+    unsigned int i;
+    mask_t succ;
+
+    for (i = 0; i < NLIMBS; i++) {
+        while (fill < LIMB_PLACE_VALUE(LIMBPERM(i)) && j < nbytes) {
+            uint8_t sj;
+
+            sj = serial[j];
+            if (j == nbytes - 1)
+                sj &= ~hi_nmask;
+            buffer |= ((dword_t) sj) << fill;
+            fill += 8;
+            j++;
+        }
+        x->limb[LIMBPERM(i)] = (word_t)
+            ((i < NLIMBS - 1) ? buffer & LIMB_MASK(LIMBPERM(i)) : buffer);
+        fill -= LIMB_PLACE_VALUE(LIMBPERM(i));
+        buffer >>= LIMB_PLACE_VALUE(LIMBPERM(i));
+        scarry =
+            (scarry + x->limb[LIMBPERM(i)] -
+             MODULUS->limb[LIMBPERM(i)]) >> (8 * sizeof(word_t));
+    }
+    succ = with_hibit ? 0 - (mask_t) 1 : ~gf_hibit(x);
+    return succ & word_is_zero((word_t)buffer) & ~word_is_zero((word_t)scarry);
+}
+
+/* Reduce to canonical form. */
+void gf_strong_reduce(gf a)
+{
+    dsword_t scarry;
+    word_t scarry_0;
+    dword_t carry = 0;
+    unsigned int i;
+
+    /* first, clear high */
+    gf_weak_reduce(a);          /* Determined to have negligible perf impact. */
+
+    /* now the total is less than 2p */
+
+    /* compute total_value - p.  No need to reduce mod p. */
+    scarry = 0;
+    for (i = 0; i < NLIMBS; i++) {
+        scarry = scarry + a->limb[LIMBPERM(i)] - MODULUS->limb[LIMBPERM(i)];
+        a->limb[LIMBPERM(i)] = scarry & LIMB_MASK(LIMBPERM(i));
+        scarry >>= LIMB_PLACE_VALUE(LIMBPERM(i));
+    }
+
+    /*
+     * uncommon case: it was >= p, so now scarry = 0 and this = x common case:
+     * it was < p, so now scarry = -1 and this = x - p + 2^255 so let's add
+     * back in p.  will carry back off the top for 2^255.
+     */
+    assert(scarry == 0 || scarry == -1);
+
+    scarry_0 = (word_t)scarry;
+
+    /* add it back */
+    for (i = 0; i < NLIMBS; i++) {
+        carry =
+            carry + a->limb[LIMBPERM(i)] +
+            (scarry_0 & MODULUS->limb[LIMBPERM(i)]);
+        a->limb[LIMBPERM(i)] = carry & LIMB_MASK(LIMBPERM(i));
+        carry >>= LIMB_PLACE_VALUE(LIMBPERM(i));
+    }
+
+    assert(carry < 2 && ((word_t)carry + scarry_0) == 0);
+}
+
+/* Subtract two gf elements d=a-b */
+void gf_sub(gf d, const gf a, const gf b)
+{
+    gf_sub_RAW(d, a, b);
+    gf_bias(d, 2);
+    gf_weak_reduce(d);
+}
+
+/* Add two field elements d = a+b */
+void gf_add(gf d, const gf a, const gf b)
+{
+    gf_add_RAW(d, a, b);
+    gf_weak_reduce(d);
+}
+
+/* Compare a==b */
+mask_t gf_eq(const gf a, const gf b)
+{
+    gf c;
+    mask_t ret = 0;
+    unsigned int i;
+
+    gf_sub(c, a, b);
+    gf_strong_reduce(c);
+
+    for (i = 0; i < NLIMBS; i++)
+        ret |= c->limb[LIMBPERM(i)];
+
+    return word_is_zero(ret);
+}
+
+mask_t gf_isr(gf a, const gf x)
+{
+    gf L0, L1, L2;
+
+    gf_sqr(L1, x);
+    gf_mul(L2, x, L1);
+    gf_sqr(L1, L2);
+    gf_mul(L2, x, L1);
+    gf_sqrn(L1, L2, 3);
+    gf_mul(L0, L2, L1);
+    gf_sqrn(L1, L0, 3);
+    gf_mul(L0, L2, L1);
+    gf_sqrn(L2, L0, 9);
+    gf_mul(L1, L0, L2);
+    gf_sqr(L0, L1);
+    gf_mul(L2, x, L0);
+    gf_sqrn(L0, L2, 18);
+    gf_mul(L2, L1, L0);
+    gf_sqrn(L0, L2, 37);
+    gf_mul(L1, L2, L0);
+    gf_sqrn(L0, L1, 37);
+    gf_mul(L1, L2, L0);
+    gf_sqrn(L0, L1, 111);
+    gf_mul(L2, L1, L0);
+    gf_sqr(L0, L2);
+    gf_mul(L1, x, L0);
+    gf_sqrn(L0, L1, 223);
+    gf_mul(L1, L2, L0);
+    gf_sqr(L2, L1);
+    gf_mul(L0, L2, x);
+    gf_copy(a, L1);
+    return gf_eq(L0, ONE);
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/field.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/field.h
new file mode 100644
index 000000000..ccd04482d
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/field.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2014 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448_FIELD_H
+# define OSSL_CRYPTO_EC_CURVE448_FIELD_H
+
+# include "internal/constant_time.h"
+# include <string.h>
+# include <assert.h>
+# include "word.h"
+
+# define NLIMBS (64/sizeof(word_t))
+# define X_SER_BYTES 56
+# define SER_BYTES 56
+
+# if defined(__GNUC__) || defined(__clang__)
+#  define INLINE_UNUSED __inline__ __attribute__((__unused__,__always_inline__))
+#  define RESTRICT __restrict__
+#  define ALIGNED __attribute__((__aligned__(16)))
+# else
+#  define INLINE_UNUSED ossl_inline
+#  define RESTRICT
+#  define ALIGNED
+# endif
+
+typedef struct gf_s {
+    word_t limb[NLIMBS];
+} ALIGNED gf_s, gf[1];
+
+/* RFC 7748 support */
+# define X_PUBLIC_BYTES  X_SER_BYTES
+# define X_PRIVATE_BYTES X_PUBLIC_BYTES
+# define X_PRIVATE_BITS  448
+
+static INLINE_UNUSED void gf_copy(gf out, const gf a)
+{
+    *out = *a;
+}
+
+static INLINE_UNUSED void gf_add_RAW(gf out, const gf a, const gf b);
+static INLINE_UNUSED void gf_sub_RAW(gf out, const gf a, const gf b);
+static INLINE_UNUSED void gf_bias(gf inout, int amount);
+static INLINE_UNUSED void gf_weak_reduce(gf inout);
+
+void gf_strong_reduce(gf inout);
+void gf_add(gf out, const gf a, const gf b);
+void gf_sub(gf out, const gf a, const gf b);
+void gf_mul(gf_s * RESTRICT out, const gf a, const gf b);
+void gf_mulw_unsigned(gf_s * RESTRICT out, const gf a, uint32_t b);
+void gf_sqr(gf_s * RESTRICT out, const gf a);
+mask_t gf_isr(gf a, const gf x); /** a^2 x = 1, QNR, or 0 if x=0.  Return true if successful */
+mask_t gf_eq(const gf x, const gf y);
+mask_t gf_lobit(const gf x);
+mask_t gf_hibit(const gf x);
+
+void gf_serialize(uint8_t *serial, const gf x, int with_highbit);
+mask_t gf_deserialize(gf x, const uint8_t serial[SER_BYTES], int with_hibit,
+                      uint8_t hi_nmask);
+
+# include "f_impl.h"            /* Bring in the inline implementations */
+
+# define LIMBPERM(i) (i)
+# define LIMB_MASK(i) (((1)<<LIMB_PLACE_VALUE(i))-1)
+
+static const gf ZERO = {{{0}}}, ONE = {{{1}}};
+
+/* Square x, n times. */
+static ossl_inline void gf_sqrn(gf_s * RESTRICT y, const gf x, int n)
+{
+    gf tmp;
+
+    assert(n > 0);
+    if (n & 1) {
+        gf_sqr(y, x);
+        n--;
+    } else {
+        gf_sqr(tmp, x);
+        gf_sqr(y, tmp);
+        n -= 2;
+    }
+    for (; n; n -= 2) {
+        gf_sqr(tmp, y);
+        gf_sqr(y, tmp);
+    }
+}
+
+# define gf_add_nr gf_add_RAW
+
+/* Subtract mod p.  Bias by 2 and don't reduce  */
+static ossl_inline void gf_sub_nr(gf c, const gf a, const gf b)
+{
+    gf_sub_RAW(c, a, b);
+    gf_bias(c, 2);
+    if (GF_HEADROOM < 3)
+        gf_weak_reduce(c);
+}
+
+/* Subtract mod p. Bias by amt but don't reduce.  */
+static ossl_inline void gf_subx_nr(gf c, const gf a, const gf b, int amt)
+{
+    gf_sub_RAW(c, a, b);
+    gf_bias(c, amt);
+    if (GF_HEADROOM < amt + 1)
+        gf_weak_reduce(c);
+}
+
+/* Mul by signed int.  Not constant-time WRT the sign of that int. */
+static ossl_inline void gf_mulw(gf c, const gf a, int32_t w)
+{
+    if (w > 0) {
+        gf_mulw_unsigned(c, a, w);
+    } else {
+        gf_mulw_unsigned(c, a, -w);
+        gf_sub(c, ZERO, c);
+    }
+}
+
+/* Constant time, x = is_z ? z : y */
+static ossl_inline void gf_cond_sel(gf x, const gf y, const gf z, mask_t is_z)
+{
+    size_t i;
+
+    for (i = 0; i < NLIMBS; i++) {
+#if ARCH_WORD_BITS == 32
+        x[0].limb[i] = constant_time_select_32(is_z, z[0].limb[i],
+                                               y[0].limb[i]);
+#else
+        /* Must be 64 bit */
+        x[0].limb[i] = constant_time_select_64(is_z, z[0].limb[i],
+                                               y[0].limb[i]);
+#endif
+    }
+}
+
+/* Constant time, if (neg) x=-x; */
+static ossl_inline void gf_cond_neg(gf x, mask_t neg)
+{
+    gf y;
+
+    gf_sub(y, ZERO, x);
+    gf_cond_sel(x, x, y, neg);
+}
+
+/* Constant time, if (swap) (x,y) = (y,x); */
+static ossl_inline void gf_cond_swap(gf x, gf_s * RESTRICT y, mask_t swap)
+{
+    size_t i;
+
+    for (i = 0; i < NLIMBS; i++) {
+#if ARCH_WORD_BITS == 32
+        constant_time_cond_swap_32(swap, &(x[0].limb[i]), &(y->limb[i]));
+#else
+        /* Must be 64 bit */
+        constant_time_cond_swap_64(swap, &(x[0].limb[i]), &(y->limb[i]));
+#endif
+    }
+}
+
+#endif                          /* OSSL_CRYPTO_EC_CURVE448_FIELD_H */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/point_448.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/point_448.h
new file mode 100644
index 000000000..93e715fd9
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/point_448.h
@@ -0,0 +1,301 @@
+/*
+ * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448_POINT_448_H
+# define OSSL_CRYPTO_EC_CURVE448_POINT_448_H
+
+# include "curve448utils.h"
+# include "field.h"
+
+/* Comb config: number of combs, n, t, s. */
+#define COMBS_N 5
+#define COMBS_T 5
+#define COMBS_S 18
+
+/* Projective Niels coordinates */
+typedef struct {
+    gf a, b, c;
+} niels_s, niels_t[1];
+typedef struct {
+    niels_t n;
+    gf z;
+} pniels_t[1];
+
+/* Precomputed base */
+struct curve448_precomputed_s {
+    niels_t table[COMBS_N << (COMBS_T - 1)];
+};
+
+# define C448_SCALAR_LIMBS ((446-1)/C448_WORD_BITS+1)
+
+/* The number of bits in a scalar */
+# define C448_SCALAR_BITS 446
+
+/* Number of bytes in a serialized scalar. */
+# define C448_SCALAR_BYTES 56
+
+/* X448 encoding ratio. */
+# define X448_ENCODE_RATIO 2
+
+/* Number of bytes in an x448 public key */
+# define X448_PUBLIC_BYTES 56
+
+/* Number of bytes in an x448 private key */
+# define X448_PRIVATE_BYTES 56
+
+/* Twisted Edwards extended homogeneous coordinates */
+typedef struct curve448_point_s {
+    gf x, y, z, t;
+} curve448_point_t[1];
+
+/* Precomputed table based on a point.  Can be trivial implementation. */
+struct curve448_precomputed_s;
+
+/* Precomputed table based on a point.  Can be trivial implementation. */
+typedef struct curve448_precomputed_s curve448_precomputed_s;
+
+/* Scalar is stored packed, because we don't need the speed. */
+typedef struct curve448_scalar_s {
+    c448_word_t limb[C448_SCALAR_LIMBS];
+} curve448_scalar_t[1];
+
+/* A scalar equal to 1. */
+extern const curve448_scalar_t curve448_scalar_one;
+
+/* A scalar equal to 0. */
+extern const curve448_scalar_t curve448_scalar_zero;
+
+/* The identity point on the curve. */
+extern const curve448_point_t curve448_point_identity;
+
+/* Precomputed table for the base point on the curve. */
+extern const struct curve448_precomputed_s *curve448_precomputed_base;
+extern const niels_t *curve448_wnaf_base;
+
+/*
+ * Read a scalar from wire format or from bytes.
+ *
+ * ser (in): Serialized form of a scalar.
+ * out (out): Deserialized form.
+ *
+ * Returns:
+ * C448_SUCCESS: The scalar was correctly encoded.
+ * C448_FAILURE: The scalar was greater than the modulus, and has been reduced
+ * modulo that modulus.
+ */
+c448_error_t curve448_scalar_decode(curve448_scalar_t out,
+                                    const unsigned char ser[C448_SCALAR_BYTES]);
+
+/*
+ * Read a scalar from wire format or from bytes.  Reduces mod scalar prime.
+ *
+ * ser (in): Serialized form of a scalar.
+ * ser_len (in): Length of serialized form.
+ * out (out): Deserialized form.
+ */
+void curve448_scalar_decode_long(curve448_scalar_t out,
+                                 const unsigned char *ser, size_t ser_len);
+
+/*
+ * Serialize a scalar to wire format.
+ *
+ * ser (out): Serialized form of a scalar.
+ * s (in): Deserialized scalar.
+ */
+void curve448_scalar_encode(unsigned char ser[C448_SCALAR_BYTES],
+                            const curve448_scalar_t s);
+
+/*
+ * Add two scalars. |a|, |b| and |out| may alias each other.
+ *
+ * a (in): One scalar.
+ * b (in): Another scalar.
+ * out (out): a+b.
+ */
+void curve448_scalar_add(curve448_scalar_t out,
+                         const curve448_scalar_t a, const curve448_scalar_t b);
+
+/*
+ * Subtract two scalars.  |a|, |b| and |out| may alias each other.
+ * a (in): One scalar.
+ * b (in): Another scalar.
+ * out (out): a-b.
+ */
+void curve448_scalar_sub(curve448_scalar_t out,
+                         const curve448_scalar_t a, const curve448_scalar_t b);
+
+/*
+ * Multiply two scalars. |a|, |b| and |out| may alias each other.
+ *
+ * a (in): One scalar.
+ * b (in): Another scalar.
+ * out (out): a*b.
+ */
+void curve448_scalar_mul(curve448_scalar_t out,
+                         const curve448_scalar_t a, const curve448_scalar_t b);
+
+/*
+* Halve a scalar.  |a| and |out| may alias each other.
+*
+* a (in): A scalar.
+* out (out): a/2.
+*/
+void curve448_scalar_halve(curve448_scalar_t out, const curve448_scalar_t a);
+
+/*
+ * Copy a scalar.  The scalars may alias each other, in which case this
+ * function does nothing.
+ *
+ * a (in): A scalar.
+ * out (out): Will become a copy of a.
+ */
+static ossl_inline void curve448_scalar_copy(curve448_scalar_t out,
+                                             const curve448_scalar_t a)
+{
+    *out = *a;
+}
+
+/*
+ * Copy a point.  The input and output may alias, in which case this function
+ * does nothing.
+ *
+ * a (out): A copy of the point.
+ * b (in): Any point.
+ */
+static ossl_inline void curve448_point_copy(curve448_point_t a,
+                                            const curve448_point_t b)
+{
+    *a = *b;
+}
+
+/*
+ * Test whether two points are equal.  If yes, return C448_TRUE, else return
+ * C448_FALSE.
+ *
+ * a (in): A point.
+ * b (in): Another point.
+ *
+ * Returns:
+ * C448_TRUE: The points are equal.
+ * C448_FALSE: The points are not equal.
+ */
+__owur c448_bool_t curve448_point_eq(const curve448_point_t a,
+                                     const curve448_point_t b);
+
+/*
+ * Double a point. Equivalent to curve448_point_add(two_a,a,a), but potentially
+ * faster.
+ *
+ * two_a (out): The sum a+a.
+ * a (in): A point.
+ */
+void curve448_point_double(curve448_point_t two_a, const curve448_point_t a);
+
+/*
+ * RFC 7748 Diffie-Hellman scalarmul.  This function uses a different
+ * (non-Decaf) encoding.
+ *
+ * out (out): The scaled point base*scalar
+ * base (in): The point to be scaled.
+ * scalar (in): The scalar to multiply by.
+ *
+ * Returns:
+ * C448_SUCCESS: The scalarmul succeeded.
+ * C448_FAILURE: The scalarmul didn't succeed, because the base point is in a
+ * small subgroup.
+ */
+__owur c448_error_t x448_int(uint8_t out[X448_PUBLIC_BYTES],
+                             const uint8_t base[X448_PUBLIC_BYTES],
+                             const uint8_t scalar[X448_PRIVATE_BYTES]);
+
+/*
+ * Multiply a point by X448_ENCODE_RATIO, then encode it like RFC 7748.
+ *
+ * This function is mainly used internally, but is exported in case
+ * it will be useful.
+ *
+ * The ratio is necessary because the internal representation doesn't
+ * track the cofactor information, so on output we must clear the cofactor.
+ * This would multiply by the cofactor, but in fact internally points are always
+ * even, so it multiplies by half the cofactor instead.
+ *
+ * As it happens, this aligns with the base point definitions; that is,
+ * if you pass the Decaf/Ristretto base point to this function, the result
+ * will be X448_ENCODE_RATIO times the X448
+ * base point.
+ *
+ * out (out): The scaled and encoded point.
+ * p (in): The point to be scaled and encoded.
+ */
+void curve448_point_mul_by_ratio_and_encode_like_x448(
+                                        uint8_t out[X448_PUBLIC_BYTES],
+                                        const curve448_point_t p);
+
+/*
+ * RFC 7748 Diffie-Hellman base point scalarmul.  This function uses a different
+ * (non-Decaf) encoding.
+ *
+ * out (out): The scaled point base*scalar
+ * scalar (in): The scalar to multiply by.
+ */
+void x448_derive_public_key(uint8_t out[X448_PUBLIC_BYTES],
+                            const uint8_t scalar[X448_PRIVATE_BYTES]);
+
+/*
+ * Multiply a precomputed base point by a scalar: out = scalar*base.
+ *
+ * scaled (out): The scaled point base*scalar
+ * base (in): The point to be scaled.
+ * scalar (in): The scalar to multiply by.
+ */
+void curve448_precomputed_scalarmul(curve448_point_t scaled,
+                                    const curve448_precomputed_s * base,
+                                    const curve448_scalar_t scalar);
+
+/*
+ * Multiply two base points by two scalars:
+ * combo = scalar1*curve448_point_base + scalar2*base2.
+ *
+ * Otherwise equivalent to curve448_point_double_scalarmul, but may be
+ * faster at the expense of being variable time.
+ *
+ * combo (out): The linear combination scalar1*base + scalar2*base2.
+ * scalar1 (in): A first scalar to multiply by.
+ * base2 (in): A second point to be scaled.
+ * scalar2 (in) A second scalar to multiply by.
+ *
+ * Warning: This function takes variable time, and may leak the scalars used.
+ * It is designed for signature verification.
+ */
+void curve448_base_double_scalarmul_non_secret(curve448_point_t combo,
+                                               const curve448_scalar_t scalar1,
+                                               const curve448_point_t base2,
+                                               const curve448_scalar_t scalar2);
+
+/*
+ * Test that a point is valid, for debugging purposes.
+ *
+ * to_test (in): The point to test.
+ *
+ * Returns:
+ * C448_TRUE The point is valid.
+ * C448_FALSE The point is invalid.
+ */
+__owur c448_bool_t curve448_point_valid(const curve448_point_t to_test);
+
+/* Overwrite scalar with zeros. */
+void curve448_scalar_destroy(curve448_scalar_t scalar);
+
+/* Overwrite point with zeros. */
+void curve448_point_destroy(curve448_point_t point);
+
+#endif                          /* OSSL_CRYPTO_EC_CURVE448_POINT_448_H */
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/scalar.c b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/scalar.c
new file mode 100644
index 000000000..347794bba
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/scalar.c
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2016 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+#include <openssl/crypto.h>
+
+#include "word.h"
+#include "point_448.h"
+
+static const c448_word_t MONTGOMERY_FACTOR = (c448_word_t) 0x3bd440fae918bc5ULL;
+static const curve448_scalar_t sc_p = {
+    {
+        {
+            SC_LIMB(0x2378c292ab5844f3ULL), SC_LIMB(0x216cc2728dc58f55ULL),
+            SC_LIMB(0xc44edb49aed63690ULL), SC_LIMB(0xffffffff7cca23e9ULL),
+            SC_LIMB(0xffffffffffffffffULL), SC_LIMB(0xffffffffffffffffULL),
+            SC_LIMB(0x3fffffffffffffffULL)
+        }
+    }
+}, sc_r2 = {
+    {
+        {
+
+            SC_LIMB(0xe3539257049b9b60ULL), SC_LIMB(0x7af32c4bc1b195d9ULL),
+            SC_LIMB(0x0d66de2388ea1859ULL), SC_LIMB(0xae17cf725ee4d838ULL),
+            SC_LIMB(0x1a9cc14ba3c47c44ULL), SC_LIMB(0x2052bcb7e4d070afULL),
+            SC_LIMB(0x3402a939f823b729ULL)
+        }
+    }
+};
+
+#define WBITS C448_WORD_BITS   /* NB this may be different from ARCH_WORD_BITS */
+
+const curve448_scalar_t curve448_scalar_one = {{{1}}};
+const curve448_scalar_t curve448_scalar_zero = {{{0}}};
+
+/*
+ * {extra,accum} - sub +? p
+ * Must have extra <= 1
+ */
+static void sc_subx(curve448_scalar_t out,
+                    const c448_word_t accum[C448_SCALAR_LIMBS],
+                    const curve448_scalar_t sub,
+                    const curve448_scalar_t p, c448_word_t extra)
+{
+    c448_dsword_t chain = 0;
+    unsigned int i;
+    c448_word_t borrow;
+
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        chain = (chain + accum[i]) - sub->limb[i];
+        out->limb[i] = (c448_word_t)chain;
+        chain >>= WBITS;
+    }
+    borrow = (c448_word_t)chain + extra;     /* = 0 or -1 */
+
+    chain = 0;
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        chain = (chain + out->limb[i]) + (p->limb[i] & borrow);
+        out->limb[i] = (c448_word_t)chain;
+        chain >>= WBITS;
+    }
+}
+
+static void sc_montmul(curve448_scalar_t out, const curve448_scalar_t a,
+                       const curve448_scalar_t b)
+{
+    unsigned int i, j;
+    c448_word_t accum[C448_SCALAR_LIMBS + 1] = { 0 };
+    c448_word_t hi_carry = 0;
+
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        c448_word_t mand = a->limb[i];
+        const c448_word_t *mier = b->limb;
+
+        c448_dword_t chain = 0;
+        for (j = 0; j < C448_SCALAR_LIMBS; j++) {
+            chain += ((c448_dword_t) mand) * mier[j] + accum[j];
+            accum[j] = (c448_word_t)chain;
+            chain >>= WBITS;
+        }
+        accum[j] = (c448_word_t)chain;
+
+        mand = accum[0] * MONTGOMERY_FACTOR;
+        chain = 0;
+        mier = sc_p->limb;
+        for (j = 0; j < C448_SCALAR_LIMBS; j++) {
+            chain += (c448_dword_t) mand *mier[j] + accum[j];
+            if (j)
+                accum[j - 1] = (c448_word_t)chain;
+            chain >>= WBITS;
+        }
+        chain += accum[j];
+        chain += hi_carry;
+        accum[j - 1] = (c448_word_t)chain;
+        hi_carry = chain >> WBITS;
+    }
+
+    sc_subx(out, accum, sc_p, sc_p, hi_carry);
+}
+
+void curve448_scalar_mul(curve448_scalar_t out, const curve448_scalar_t a,
+                         const curve448_scalar_t b)
+{
+    sc_montmul(out, a, b);
+    sc_montmul(out, out, sc_r2);
+}
+
+void curve448_scalar_sub(curve448_scalar_t out, const curve448_scalar_t a,
+                         const curve448_scalar_t b)
+{
+    sc_subx(out, a->limb, b, sc_p, 0);
+}
+
+void curve448_scalar_add(curve448_scalar_t out, const curve448_scalar_t a,
+                         const curve448_scalar_t b)
+{
+    c448_dword_t chain = 0;
+    unsigned int i;
+
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        chain = (chain + a->limb[i]) + b->limb[i];
+        out->limb[i] = (c448_word_t)chain;
+        chain >>= WBITS;
+    }
+    sc_subx(out, out->limb, sc_p, sc_p, (c448_word_t)chain);
+}
+
+static ossl_inline void scalar_decode_short(curve448_scalar_t s,
+                                            const unsigned char *ser,
+                                            size_t nbytes)
+{
+    size_t i, j, k = 0;
+
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        c448_word_t out = 0;
+
+        for (j = 0; j < sizeof(c448_word_t) && k < nbytes; j++, k++)
+            out |= ((c448_word_t) ser[k]) << (8 * j);
+        s->limb[i] = out;
+    }
+}
+
+c448_error_t curve448_scalar_decode(
+                                curve448_scalar_t s,
+                                const unsigned char ser[C448_SCALAR_BYTES])
+{
+    unsigned int i;
+    c448_dsword_t accum = 0;
+
+    scalar_decode_short(s, ser, C448_SCALAR_BYTES);
+    for (i = 0; i < C448_SCALAR_LIMBS; i++)
+        accum = (accum + s->limb[i] - sc_p->limb[i]) >> WBITS;
+    /* Here accum == 0 or -1 */
+
+    curve448_scalar_mul(s, s, curve448_scalar_one); /* ham-handed reduce */
+
+    return c448_succeed_if(~word_is_zero((uint32_t)accum));
+}
+
+void curve448_scalar_destroy(curve448_scalar_t scalar)
+{
+    OPENSSL_cleanse(scalar, sizeof(curve448_scalar_t));
+}
+
+void curve448_scalar_decode_long(curve448_scalar_t s,
+                                 const unsigned char *ser, size_t ser_len)
+{
+    size_t i;
+    curve448_scalar_t t1, t2;
+
+    if (ser_len == 0) {
+        curve448_scalar_copy(s, curve448_scalar_zero);
+        return;
+    }
+
+    i = ser_len - (ser_len % C448_SCALAR_BYTES);
+    if (i == ser_len)
+        i -= C448_SCALAR_BYTES;
+
+    scalar_decode_short(t1, &ser[i], ser_len - i);
+
+    if (ser_len == sizeof(curve448_scalar_t)) {
+        assert(i == 0);
+        /* ham-handed reduce */
+        curve448_scalar_mul(s, t1, curve448_scalar_one);
+        curve448_scalar_destroy(t1);
+        return;
+    }
+
+    while (i) {
+        i -= C448_SCALAR_BYTES;
+        sc_montmul(t1, t1, sc_r2);
+        (void)curve448_scalar_decode(t2, ser + i);
+        curve448_scalar_add(t1, t1, t2);
+    }
+
+    curve448_scalar_copy(s, t1);
+    curve448_scalar_destroy(t1);
+    curve448_scalar_destroy(t2);
+}
+
+void curve448_scalar_encode(unsigned char ser[C448_SCALAR_BYTES],
+                            const curve448_scalar_t s)
+{
+    unsigned int i, j, k = 0;
+
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        for (j = 0; j < sizeof(c448_word_t); j++, k++)
+            ser[k] = s->limb[i] >> (8 * j);
+    }
+}
+
+void curve448_scalar_halve(curve448_scalar_t out, const curve448_scalar_t a)
+{
+    c448_word_t mask = 0 - (a->limb[0] & 1);
+    c448_dword_t chain = 0;
+    unsigned int i;
+
+    for (i = 0; i < C448_SCALAR_LIMBS; i++) {
+        chain = (chain + a->limb[i]) + (sc_p->limb[i] & mask);
+        out->limb[i] = (c448_word_t)chain;
+        chain >>= C448_WORD_BITS;
+    }
+    for (i = 0; i < C448_SCALAR_LIMBS - 1; i++)
+        out->limb[i] = out->limb[i] >> 1 | out->limb[i + 1] << (WBITS - 1);
+    out->limb[i] = out->limb[i] >> 1 | (c448_word_t)(chain << (WBITS - 1));
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/word.h b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/word.h
new file mode 100644
index 000000000..237cc9b63
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/crypto/ec/curve448/word.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2014 Cryptography Research, Inc.
+ *
+ * Licensed under the OpenSSL license (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
+ *
+ * Originally written by Mike Hamburg
+ */
+
+#ifndef OSSL_CRYPTO_EC_CURVE448_WORD_H
+# define OSSL_CRYPTO_EC_CURVE448_WORD_H
+
+# include <string.h>
+# include <assert.h>
+# include <stdlib.h>
+# include <openssl/e_os2.h>
+# include "arch_intrinsics.h"
+# include "curve448utils.h"
+
+# if (ARCH_WORD_BITS == 64)
+typedef uint64_t word_t, mask_t;
+typedef __uint128_t dword_t;
+typedef int32_t hsword_t;
+typedef int64_t sword_t;
+typedef __int128_t dsword_t;
+# elif (ARCH_WORD_BITS == 32)
+typedef uint32_t word_t, mask_t;
+typedef uint64_t dword_t;
+typedef int16_t hsword_t;
+typedef int32_t sword_t;
+typedef int64_t dsword_t;
+# else
+#  error "For now, we only support 32- and 64-bit architectures."
+# endif
+
+/*
+ * Scalar limbs are keyed off of the API word size instead of the arch word
+ * size.
+ */
+# if C448_WORD_BITS == 64
+#  define SC_LIMB(x) (x)
+# elif C448_WORD_BITS == 32
+#  define SC_LIMB(x) ((uint32_t)(x)),((x) >> 32)
+# else
+#  error "For now we only support 32- and 64-bit architectures."
+# endif
+
+/*
+ * The plan on booleans: The external interface uses c448_bool_t, but this
+ * might be a different size than our particular arch's word_t (and thus
+ * mask_t).  Also, the caller isn't guaranteed to pass it as nonzero.  So
+ * bool_to_mask converts word sizes and checks nonzero. On the flip side,
+ * mask_t is always -1 or 0, but it might be a different size than
+ * c448_bool_t. On the third hand, we have success vs boolean types, but
+ * that's handled in common.h: it converts between c448_bool_t and
+ * c448_error_t.
+ */
+static ossl_inline c448_bool_t mask_to_bool(mask_t m)
+{
+    return (c448_sword_t)(sword_t)m;
+}
+
+static ossl_inline mask_t bool_to_mask(c448_bool_t m)
+{
+    /* On most arches this will be optimized to a simple cast. */
+    mask_t ret = 0;
+    unsigned int i;
+    unsigned int limit = sizeof(c448_bool_t) / sizeof(mask_t);
+
+    if (limit < 1)
+        limit = 1;
+    for (i = 0; i < limit; i++)
+        ret |= ~word_is_zero(m >> (i * 8 * sizeof(word_t)));
+
+    return ret;
+}
+
+#endif                          /* OSSL_CRYPTO_EC_CURVE448_WORD_H */