lib/crypto: tests: Migrate ChaCha20Poly1305 self-test to KUnit

Move the ChaCha20Poly1305 test from an ad-hoc self-test to a KUnit test.

Keep the same test logic for now, just translated to KUnit.

Moving to KUnit has multiple benefits, such as:

- Consistency with the rest of the lib/crypto/ tests.

- Kernel developers familiar with KUnit, which is used kernel-wide, can
  quickly understand the test and how to enable and run it.

- The test will be automatically run by anyone using
  lib/crypto/.kunitconfig or KUnit's all_tests.config.

- Results are reported using the standard KUnit mechanism.

- It eliminates one of the few remaining back-references to crypto/ from
  lib/crypto/, specifically a reference to CONFIG_CRYPTO_SELFTESTS.

Acked-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20260327224229.137532-1-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>

diff --git a/include/crypto/chacha20poly1305.h b/include/crypto/chacha20poly1305.h
index 0f71b037702da2378b1d24d34659852e7f48cb12..0f6d99170aaf16bd29e5bd254409d508af4f79d4 100644 (file)
--- a/include/crypto/chacha20poly1305.h
+++ b/include/crypto/chacha20poly1305.h
@@ -46,6 +46,4 @@ bool chacha20poly1305_decrypt_sg_inplace(struct scatterlist *src, size_t src_len
                                         const u64 nonce,
                                         const u8 key[at_least CHACHA20POLY1305_KEY_SIZE]);
 
-bool chacha20poly1305_selftest(void);
-
 #endif /* __CHACHA20POLY1305_H */

diff --git a/lib/crypto/.kunitconfig b/lib/crypto/.kunitconfig
index f8a3c6e6367cc9203f9c3c6c4d12331e21df8303..3efc854a2c08b85838ae27c9fefa25b354511e25 100644 (file)
--- a/lib/crypto/.kunitconfig
+++ b/lib/crypto/.kunitconfig
@@ -5,6 +5,7 @@ CONFIG_CRYPTO_LIB_ENABLE_ALL_FOR_KUNIT=y
 CONFIG_CRYPTO_LIB_AES_CBC_MACS_KUNIT_TEST=y
 CONFIG_CRYPTO_LIB_BLAKE2B_KUNIT_TEST=y
 CONFIG_CRYPTO_LIB_BLAKE2S_KUNIT_TEST=y
+CONFIG_CRYPTO_LIB_CHACHA20POLY1305_KUNIT_TEST=y
 CONFIG_CRYPTO_LIB_CURVE25519_KUNIT_TEST=y
 CONFIG_CRYPTO_LIB_GHASH_KUNIT_TEST=y
 CONFIG_CRYPTO_LIB_MD5_KUNIT_TEST=y

diff --git a/lib/crypto/Makefile b/lib/crypto/Makefile
index 4b47a2e5c67c1e22817af2d7cf1c4f74500075be..477aec03c65120841b710056fa7bb79c9bcbeb90 100644 (file)
--- a/lib/crypto/Makefile
+++ b/lib/crypto/Makefile
@@ -122,7 +122,6 @@ endif # CONFIG_CRYPTO_LIB_CHACHA_ARCH
 
 obj-$(CONFIG_CRYPTO_LIB_CHACHA20POLY1305)      += libchacha20poly1305.o
 libchacha20poly1305-y                          += chacha20poly1305.o
-libchacha20poly1305-$(CONFIG_CRYPTO_SELFTESTS) += chacha20poly1305-selftest.o
 
 ################################################################################
 

diff --git a/lib/crypto/chacha20poly1305.c b/lib/crypto/chacha20poly1305.c
index 212ce33562afd51284d996c62ea63ca6cd6556cb..ea42a28f4ff7d1e689f0158232d21ef48b2e854b 100644 (file)
--- a/lib/crypto/chacha20poly1305.c
+++ b/lib/crypto/chacha20poly1305.c
@@ -356,20 +356,6 @@ bool chacha20poly1305_decrypt_sg_inplace(struct scatterlist *src, size_t src_len
 }
 EXPORT_SYMBOL(chacha20poly1305_decrypt_sg_inplace);
 
-static int __init chacha20poly1305_init(void)
-{
-       if (IS_ENABLED(CONFIG_CRYPTO_SELFTESTS) &&
-           WARN_ON(!chacha20poly1305_selftest()))
-               return -ENODEV;
-       return 0;
-}
-
-static void __exit chacha20poly1305_exit(void)
-{
-}
-
-module_init(chacha20poly1305_init);
-module_exit(chacha20poly1305_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("ChaCha20Poly1305 AEAD construction");
 MODULE_AUTHOR("Jason A. Donenfeld <Jason@zx2c4.com>");

diff --git a/lib/crypto/tests/Kconfig b/lib/crypto/tests/Kconfig
index 7a5ad109aefc9fa05fce9e768c8d2993afa56319..9409c1a935c37ab2349a716e7f63649eb006169c 100644 (file)
--- a/lib/crypto/tests/Kconfig
+++ b/lib/crypto/tests/Kconfig
@@ -27,6 +27,15 @@ config CRYPTO_LIB_BLAKE2S_KUNIT_TEST
        help
          KUnit tests for the BLAKE2s cryptographic hash function.
 
+config CRYPTO_LIB_CHACHA20POLY1305_KUNIT_TEST
+       tristate "KUnit tests for ChaCha20Poly1305" if !KUNIT_ALL_TESTS
+       depends on KUNIT && CRYPTO_LIB_CHACHA20POLY1305
+       default KUNIT_ALL_TESTS
+       select CRYPTO_LIB_BENCHMARK_VISIBLE
+       help
+         KUnit tests for the ChaCha20Poly1305 authenticated encryption
+         algorithm.
+
 config CRYPTO_LIB_CURVE25519_KUNIT_TEST
        tristate "KUnit tests for Curve25519" if !KUNIT_ALL_TESTS
        depends on KUNIT && CRYPTO_LIB_CURVE25519
@@ -137,6 +146,7 @@ config CRYPTO_LIB_ENABLE_ALL_FOR_KUNIT
        depends on KUNIT
        select CRYPTO_LIB_AES_CBC_MACS
        select CRYPTO_LIB_BLAKE2B
+       select CRYPTO_LIB_CHACHA20POLY1305
        select CRYPTO_LIB_CURVE25519
        select CRYPTO_LIB_GF128HASH
        select CRYPTO_LIB_MD5

diff --git a/lib/crypto/tests/Makefile b/lib/crypto/tests/Makefile
index ad1cbb88132f4166498d698235472313954ae4e1..a739413500b64bbfeffb8da44eb99c7c1acfccc3 100644 (file)
--- a/lib/crypto/tests/Makefile
+++ b/lib/crypto/tests/Makefile
@@ -3,6 +3,7 @@
 obj-$(CONFIG_CRYPTO_LIB_AES_CBC_MACS_KUNIT_TEST) += aes_cbc_macs_kunit.o
 obj-$(CONFIG_CRYPTO_LIB_BLAKE2B_KUNIT_TEST) += blake2b_kunit.o
 obj-$(CONFIG_CRYPTO_LIB_BLAKE2S_KUNIT_TEST) += blake2s_kunit.o
+obj-$(CONFIG_CRYPTO_LIB_CHACHA20POLY1305_KUNIT_TEST) += chacha20poly1305_kunit.o
 obj-$(CONFIG_CRYPTO_LIB_CURVE25519_KUNIT_TEST) += curve25519_kunit.o
 obj-$(CONFIG_CRYPTO_LIB_GHASH_KUNIT_TEST) += ghash_kunit.o
 obj-$(CONFIG_CRYPTO_LIB_MD5_KUNIT_TEST) += md5_kunit.o

diff --git a/lib/crypto/chacha20poly1305-selftest.c b/lib/crypto/tests/chacha20poly1305_kunit.c
similarity index 91%
rename from lib/crypto/chacha20poly1305-selftest.c
rename to lib/crypto/tests/chacha20poly1305_kunit.c
index e4c85bc5a6d7ba7c0a75317856dc446a54764515..97a68fab88a77d2501b1e4027ad80c79cb7f4412 100644 (file)
--- a/lib/crypto/chacha20poly1305-selftest.c
+++ b/lib/crypto/tests/chacha20poly1305_kunit.c
@@ -6,9 +6,8 @@
 #include <crypto/chacha20poly1305.h>
 #include <crypto/chacha.h>
 #include <crypto/poly1305.h>
-
+#include <kunit/test.h>
 #include <linux/unaligned.h>
-#include <linux/bug.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/kernel.h>
@@ -27,7 +26,7 @@ struct chacha20poly1305_testvec {
  * chapoly construction.
  */
 
-static const u8 enc_input001[] __initconst = {
+static const u8 enc_input001[] = {
        0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
        0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20,
        0x61, 0x72, 0x65, 0x20, 0x64, 0x72, 0x61, 0x66,
@@ -63,7 +62,7 @@ static const u8 enc_input001[] __initconst = {
        0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80,
        0x9d
 };
-static const u8 enc_output001[] __initconst = {
+static const u8 enc_output001[] = {
        0x64, 0xa0, 0x86, 0x15, 0x75, 0x86, 0x1a, 0xf4,
        0x60, 0xf0, 0x62, 0xc7, 0x9b, 0xe6, 0x43, 0xbd,
        0x5e, 0x80, 0x5c, 0xfd, 0x34, 0x5c, 0xf3, 0x89,
@@ -101,95 +100,95 @@ static const u8 enc_output001[] __initconst = {
        0x22, 0x39, 0x23, 0x36, 0xfe, 0xa1, 0x85, 0x1f,
        0x38
 };
-static const u8 enc_assoc001[] __initconst = {
+static const u8 enc_assoc001[] = {
        0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x4e, 0x91
 };
-static const u8 enc_nonce001[] __initconst = {
+static const u8 enc_nonce001[] = {
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
 };
-static const u8 enc_key001[] __initconst = {
+static const u8 enc_key001[] = {
        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a,
        0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09,
        0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
 };
 
-static const u8 enc_input002[] __initconst = { };
-static const u8 enc_output002[] __initconst = {
+static const u8 enc_input002[] = { };
+static const u8 enc_output002[] = {
        0xea, 0xe0, 0x1e, 0x9e, 0x2c, 0x91, 0xaa, 0xe1,
        0xdb, 0x5d, 0x99, 0x3f, 0x8a, 0xf7, 0x69, 0x92
 };
-static const u8 enc_assoc002[] __initconst = { };
-static const u8 enc_nonce002[] __initconst = {
+static const u8 enc_assoc002[] = { };
+static const u8 enc_nonce002[] = {
        0xca, 0xbf, 0x33, 0x71, 0x32, 0x45, 0x77, 0x8e
 };
-static const u8 enc_key002[] __initconst = {
+static const u8 enc_key002[] = {
        0x4c, 0xf5, 0x96, 0x83, 0x38, 0xe6, 0xae, 0x7f,
        0x2d, 0x29, 0x25, 0x76, 0xd5, 0x75, 0x27, 0x86,
        0x91, 0x9a, 0x27, 0x7a, 0xfb, 0x46, 0xc5, 0xef,
        0x94, 0x81, 0x79, 0x57, 0x14, 0x59, 0x40, 0x68
 };
 
-static const u8 enc_input003[] __initconst = { };
-static const u8 enc_output003[] __initconst = {
+static const u8 enc_input003[] = { };
+static const u8 enc_output003[] = {
        0xdd, 0x6b, 0x3b, 0x82, 0xce, 0x5a, 0xbd, 0xd6,
        0xa9, 0x35, 0x83, 0xd8, 0x8c, 0x3d, 0x85, 0x77
 };
-static const u8 enc_assoc003[] __initconst = {
+static const u8 enc_assoc003[] = {
        0x33, 0x10, 0x41, 0x12, 0x1f, 0xf3, 0xd2, 0x6b
 };
-static const u8 enc_nonce003[] __initconst = {
+static const u8 enc_nonce003[] = {
        0x3d, 0x86, 0xb5, 0x6b, 0xc8, 0xa3, 0x1f, 0x1d
 };
-static const u8 enc_key003[] __initconst = {
+static const u8 enc_key003[] = {
        0x2d, 0xb0, 0x5d, 0x40, 0xc8, 0xed, 0x44, 0x88,
        0x34, 0xd1, 0x13, 0xaf, 0x57, 0xa1, 0xeb, 0x3a,
        0x2a, 0x80, 0x51, 0x36, 0xec, 0x5b, 0xbc, 0x08,
        0x93, 0x84, 0x21, 0xb5, 0x13, 0x88, 0x3c, 0x0d
 };
 
-static const u8 enc_input004[] __initconst = {
+static const u8 enc_input004[] = {
        0xa4
 };
-static const u8 enc_output004[] __initconst = {
+static const u8 enc_output004[] = {
        0xb7, 0x1b, 0xb0, 0x73, 0x59, 0xb0, 0x84, 0xb2,
        0x6d, 0x8e, 0xab, 0x94, 0x31, 0xa1, 0xae, 0xac,
        0x89
 };
-static const u8 enc_assoc004[] __initconst = {
+static const u8 enc_assoc004[] = {
        0x6a, 0xe2, 0xad, 0x3f, 0x88, 0x39, 0x5a, 0x40
 };
-static const u8 enc_nonce004[] __initconst = {
+static const u8 enc_nonce004[] = {
        0xd2, 0x32, 0x1f, 0x29, 0x28, 0xc6, 0xc4, 0xc4
 };
-static const u8 enc_key004[] __initconst = {
+static const u8 enc_key004[] = {
        0x4b, 0x28, 0x4b, 0xa3, 0x7b, 0xbe, 0xe9, 0xf8,
        0x31, 0x80, 0x82, 0xd7, 0xd8, 0xe8, 0xb5, 0xa1,
        0xe2, 0x18, 0x18, 0x8a, 0x9c, 0xfa, 0xa3, 0x3d,
        0x25, 0x71, 0x3e, 0x40, 0xbc, 0x54, 0x7a, 0x3e
 };
 
-static const u8 enc_input005[] __initconst = {
+static const u8 enc_input005[] = {
        0x2d
 };
-static const u8 enc_output005[] __initconst = {
+static const u8 enc_output005[] = {
        0xbf, 0xe1, 0x5b, 0x0b, 0xdb, 0x6b, 0xf5, 0x5e,
        0x6c, 0x5d, 0x84, 0x44, 0x39, 0x81, 0xc1, 0x9c,
        0xac
 };
-static const u8 enc_assoc005[] __initconst = { };
-static const u8 enc_nonce005[] __initconst = {
+static const u8 enc_assoc005[] = { };
+static const u8 enc_nonce005[] = {
        0x20, 0x1c, 0xaa, 0x5f, 0x9c, 0xbf, 0x92, 0x30
 };
-static const u8 enc_key005[] __initconst = {
+static const u8 enc_key005[] = {
        0x66, 0xca, 0x9c, 0x23, 0x2a, 0x4b, 0x4b, 0x31,
        0x0e, 0x92, 0x89, 0x8b, 0xf4, 0x93, 0xc7, 0x87,
        0x98, 0xa3, 0xd8, 0x39, 0xf8, 0xf4, 0xa7, 0x01,
        0xc0, 0x2e, 0x0a, 0xa6, 0x7e, 0x5a, 0x78, 0x87
 };
 
-static const u8 enc_input006[] __initconst = {
+static const u8 enc_input006[] = {
        0x33, 0x2f, 0x94, 0xc1, 0xa4, 0xef, 0xcc, 0x2a,
        0x5b, 0xa6, 0xe5, 0x8f, 0x1d, 0x40, 0xf0, 0x92,
        0x3c, 0xd9, 0x24, 0x11, 0xa9, 0x71, 0xf9, 0x37,
@@ -208,7 +207,7 @@ static const u8 enc_input006[] __initconst = {
        0x69, 0x21, 0x70, 0xd8, 0xa4, 0x4b, 0xc8, 0xde,
        0x8f
 };
-static const u8 enc_output006[] __initconst = {
+static const u8 enc_output006[] = {
        0x8b, 0x06, 0xd3, 0x31, 0xb0, 0x93, 0x45, 0xb1,
        0x75, 0x6e, 0x26, 0xf9, 0x67, 0xbc, 0x90, 0x15,
        0x81, 0x2c, 0xb5, 0xf0, 0xc6, 0x2b, 0xc7, 0x8c,
@@ -229,20 +228,20 @@ static const u8 enc_output006[] __initconst = {
        0x8d, 0x31, 0xf7, 0x7a, 0x39, 0x4d, 0x8f, 0x9a,
        0xeb
 };
-static const u8 enc_assoc006[] __initconst = {
+static const u8 enc_assoc006[] = {
        0x70, 0xd3, 0x33, 0xf3, 0x8b, 0x18, 0x0b
 };
-static const u8 enc_nonce006[] __initconst = {
+static const u8 enc_nonce006[] = {
        0xdf, 0x51, 0x84, 0x82, 0x42, 0x0c, 0x75, 0x9c
 };
-static const u8 enc_key006[] __initconst = {
+static const u8 enc_key006[] = {
        0x68, 0x7b, 0x8d, 0x8e, 0xe3, 0xc4, 0xdd, 0xae,
        0xdf, 0x72, 0x7f, 0x53, 0x72, 0x25, 0x1e, 0x78,
        0x91, 0xcb, 0x69, 0x76, 0x1f, 0x49, 0x93, 0xf9,
        0x6f, 0x21, 0xcc, 0x39, 0x9c, 0xad, 0xb1, 0x01
 };
 
-static const u8 enc_input007[] __initconst = {
+static const u8 enc_input007[] = {
        0x9b, 0x18, 0xdb, 0xdd, 0x9a, 0x0f, 0x3e, 0xa5,
        0x15, 0x17, 0xde, 0xdf, 0x08, 0x9d, 0x65, 0x0a,
        0x67, 0x30, 0x12, 0xe2, 0x34, 0x77, 0x4b, 0xc1,
@@ -276,7 +275,7 @@ static const u8 enc_input007[] __initconst = {
        0x40, 0x5f, 0x99, 0xb7, 0x73, 0xec, 0x9b, 0x2b,
        0xf0, 0x65, 0x11, 0xc8, 0xd0, 0x0a, 0x9f, 0xd3
 };
-static const u8 enc_output007[] __initconst = {
+static const u8 enc_output007[] = {
        0x85, 0x04, 0xc2, 0xed, 0x8d, 0xfd, 0x97, 0x5c,
        0xd2, 0xb7, 0xe2, 0xc1, 0x6b, 0xa3, 0xba, 0xf8,
        0xc9, 0x50, 0xc3, 0xc6, 0xa5, 0xe3, 0xa4, 0x7c,
@@ -312,18 +311,18 @@ static const u8 enc_output007[] __initconst = {
        0x7a, 0x4b, 0xbc, 0xb0, 0x10, 0x5c, 0x96, 0x42,
        0x3a, 0x00, 0x98, 0xcd, 0x15, 0xe8, 0xb7, 0x53
 };
-static const u8 enc_assoc007[] __initconst = { };
-static const u8 enc_nonce007[] __initconst = {
+static const u8 enc_assoc007[] = { };
+static const u8 enc_nonce007[] = {
        0xde, 0x7b, 0xef, 0xc3, 0x65, 0x1b, 0x68, 0xb0
 };
-static const u8 enc_key007[] __initconst = {
+static const u8 enc_key007[] = {
        0x8d, 0xb8, 0x91, 0x48, 0xf0, 0xe7, 0x0a, 0xbd,
        0xf9, 0x3f, 0xcd, 0xd9, 0xa0, 0x1e, 0x42, 0x4c,
        0xe7, 0xde, 0x25, 0x3d, 0xa3, 0xd7, 0x05, 0x80,
        0x8d, 0xf2, 0x82, 0xac, 0x44, 0x16, 0x51, 0x01
 };
 
-static const u8 enc_input008[] __initconst = {
+static const u8 enc_input008[] = {
        0xc3, 0x09, 0x94, 0x62, 0xe6, 0x46, 0x2e, 0x10,
        0xbe, 0x00, 0xe4, 0xfc, 0xf3, 0x40, 0xa3, 0xe2,
        0x0f, 0xc2, 0x8b, 0x28, 0xdc, 0xba, 0xb4, 0x3c,
@@ -389,7 +388,7 @@ static const u8 enc_input008[] __initconst = {
        0x2e, 0x79, 0xb5, 0xe2, 0xb8, 0xe8, 0xb9, 0x7b,
        0xd5, 0x10, 0xcb, 0xff, 0x5d, 0x14, 0x73, 0xf3
 };
-static const u8 enc_output008[] __initconst = {
+static const u8 enc_output008[] = {
        0x14, 0xf6, 0x41, 0x37, 0xa6, 0xd4, 0x27, 0xcd,
        0xdb, 0x06, 0x3e, 0x9a, 0x4e, 0xab, 0xd5, 0xb1,
        0x1e, 0x6b, 0xd2, 0xbc, 0x11, 0xf4, 0x28, 0x93,
@@ -457,18 +456,18 @@ static const u8 enc_output008[] __initconst = {
        0x54, 0xfd, 0x0d, 0x98, 0x1c, 0x5a, 0x6f, 0x1f,
        0x9a, 0x40, 0xcd, 0xa2, 0xff, 0x6a, 0xf1, 0x54
 };
-static const u8 enc_assoc008[] __initconst = { };
-static const u8 enc_nonce008[] __initconst = {
+static const u8 enc_assoc008[] = { };
+static const u8 enc_nonce008[] = {
        0x0e, 0x0d, 0x57, 0xbb, 0x7b, 0x40, 0x54, 0x02
 };
-static const u8 enc_key008[] __initconst = {
+static const u8 enc_key008[] = {
        0xf2, 0xaa, 0x4f, 0x99, 0xfd, 0x3e, 0xa8, 0x53,
        0xc1, 0x44, 0xe9, 0x81, 0x18, 0xdc, 0xf5, 0xf0,
        0x3e, 0x44, 0x15, 0x59, 0xe0, 0xc5, 0x44, 0x86,
        0xc3, 0x91, 0xa8, 0x75, 0xc0, 0x12, 0x46, 0xba
 };
 
-static const u8 enc_input009[] __initconst = {
+static const u8 enc_input009[] = {
        0xe6, 0xc3, 0xdb, 0x63, 0x55, 0x15, 0xe3, 0x5b,
        0xb7, 0x4b, 0x27, 0x8b, 0x5a, 0xdd, 0xc2, 0xe8,
        0x3a, 0x6b, 0xd7, 0x81, 0x96, 0x35, 0x97, 0xca,
@@ -535,7 +534,7 @@ static const u8 enc_input009[] __initconst = {
        0x74, 0xb9, 0xe2, 0xd6, 0x1c, 0x80, 0x2c, 0x52,
        0x65
 };
-static const u8 enc_output009[] __initconst = {
+static const u8 enc_output009[] = {
        0xfd, 0x81, 0x8d, 0xd0, 0x3d, 0xb4, 0xd5, 0xdf,
        0xd3, 0x42, 0x47, 0x5a, 0x6d, 0x19, 0x27, 0x66,
        0x4b, 0x2e, 0x0c, 0x27, 0x9c, 0x96, 0x4c, 0x72,
@@ -604,21 +603,21 @@ static const u8 enc_output009[] __initconst = {
        0x43, 0xb5, 0xd9, 0x90, 0xe1, 0x85, 0xf5, 0xa8,
        0xae
 };
-static const u8 enc_assoc009[] __initconst = {
+static const u8 enc_assoc009[] = {
        0x5a, 0x27, 0xff, 0xeb, 0xdf, 0x84, 0xb2, 0x9e,
        0xef
 };
-static const u8 enc_nonce009[] __initconst = {
+static const u8 enc_nonce009[] = {
        0xef, 0x2d, 0x63, 0xee, 0x6b, 0x80, 0x8b, 0x78
 };
-static const u8 enc_key009[] __initconst = {
+static const u8 enc_key009[] = {
        0xea, 0xbc, 0x56, 0x99, 0xe3, 0x50, 0xff, 0xc5,
        0xcc, 0x1a, 0xd7, 0xc1, 0x57, 0x72, 0xea, 0x86,
        0x5b, 0x89, 0x88, 0x61, 0x3d, 0x2f, 0x9b, 0xb2,
        0xe7, 0x9c, 0xec, 0x74, 0x6e, 0x3e, 0xf4, 0x3b
 };
 
-static const u8 enc_input010[] __initconst = {
+static const u8 enc_input010[] = {
        0x42, 0x93, 0xe4, 0xeb, 0x97, 0xb0, 0x57, 0xbf,
        0x1a, 0x8b, 0x1f, 0xe4, 0x5f, 0x36, 0x20, 0x3c,
        0xef, 0x0a, 0xa9, 0x48, 0x5f, 0x5f, 0x37, 0x22,
@@ -748,7 +747,7 @@ static const u8 enc_input010[] __initconst = {
        0x5a, 0xc0, 0x33, 0x1f, 0xcb, 0x05, 0x6d, 0x5c,
        0x06, 0x87, 0x52, 0xa2, 0x8f, 0x26, 0xd5, 0x4f
 };
-static const u8 enc_output010[] __initconst = {
+static const u8 enc_output010[] = {
        0xe5, 0x26, 0xa4, 0x3d, 0xbd, 0x33, 0xd0, 0x4b,
        0x6f, 0x05, 0xa7, 0x6e, 0x12, 0x7a, 0xd2, 0x74,
        0xa6, 0xdd, 0xbd, 0x95, 0xeb, 0xf9, 0xa4, 0xf1,
@@ -880,21 +879,21 @@ static const u8 enc_output010[] __initconst = {
        0x80, 0x6b, 0xf6, 0x1f, 0xc3, 0xcc, 0x97, 0xc9,
        0x24, 0x9f, 0xf3, 0xaf, 0x43, 0x14, 0xd5, 0xa0
 };
-static const u8 enc_assoc010[] __initconst = {
+static const u8 enc_assoc010[] = {
        0xd2, 0xa1, 0x70, 0xdb, 0x7a, 0xf8, 0xfa, 0x27,
        0xba, 0x73, 0x0f, 0xbf, 0x3d, 0x1e, 0x82, 0xb2
 };
-static const u8 enc_nonce010[] __initconst = {
+static const u8 enc_nonce010[] = {
        0xdb, 0x92, 0x0f, 0x7f, 0x17, 0x54, 0x0c, 0x30
 };
-static const u8 enc_key010[] __initconst = {
+static const u8 enc_key010[] = {
        0x47, 0x11, 0xeb, 0x86, 0x2b, 0x2c, 0xab, 0x44,
        0x34, 0xda, 0x7f, 0x57, 0x03, 0x39, 0x0c, 0xaf,
        0x2c, 0x14, 0xfd, 0x65, 0x23, 0xe9, 0x8e, 0x74,
        0xd5, 0x08, 0x68, 0x08, 0xe7, 0xb4, 0x72, 0xd7
 };
 
-static const u8 enc_input011[] __initconst = {
+static const u8 enc_input011[] = {
        0x7a, 0x57, 0xf2, 0xc7, 0x06, 0x3f, 0x50, 0x7b,
        0x36, 0x1a, 0x66, 0x5c, 0xb9, 0x0e, 0x5e, 0x3b,
        0x45, 0x60, 0xbe, 0x9a, 0x31, 0x9f, 0xff, 0x5d,
@@ -1138,7 +1137,7 @@ static const u8 enc_input011[] __initconst = {
        0x5c, 0x42, 0x16, 0xb8, 0x28, 0xeb, 0x1b, 0x61,
        0x10, 0x1e, 0xbf, 0xec, 0xa8
 };
-static const u8 enc_output011[] __initconst = {
+static const u8 enc_output011[] = {
        0x6a, 0xfc, 0x4b, 0x25, 0xdf, 0xc0, 0xe4, 0xe8,
        0x17, 0x4d, 0x4c, 0xc9, 0x7e, 0xde, 0x3a, 0xcc,
        0x3c, 0xba, 0x6a, 0x77, 0x47, 0xdb, 0xe3, 0x74,
@@ -1384,20 +1383,20 @@ static const u8 enc_output011[] __initconst = {
        0x86, 0xc4, 0xfc, 0x97, 0xae, 0x3f, 0x8f, 0x1e,
        0x2b, 0xdf, 0xcd, 0xf9, 0x3c
 };
-static const u8 enc_assoc011[] __initconst = {
+static const u8 enc_assoc011[] = {
        0xd6, 0x31, 0xda, 0x5d, 0x42, 0x5e, 0xd7
 };
-static const u8 enc_nonce011[] __initconst = {
+static const u8 enc_nonce011[] = {
        0xfd, 0x87, 0xd4, 0xd8, 0x62, 0xfd, 0xec, 0xaa
 };
-static const u8 enc_key011[] __initconst = {
+static const u8 enc_key011[] = {
        0x35, 0x4e, 0xb5, 0x70, 0x50, 0x42, 0x8a, 0x85,
        0xf2, 0xfb, 0xed, 0x7b, 0xd0, 0x9e, 0x97, 0xca,
        0xfa, 0x98, 0x66, 0x63, 0xee, 0x37, 0xcc, 0x52,
        0xfe, 0xd1, 0xdf, 0x95, 0x15, 0x34, 0x29, 0x38
 };
 
-static const u8 enc_input012[] __initconst = {
+static const u8 enc_input012[] = {
        0x74, 0xa6, 0x3e, 0xe4, 0xb1, 0xcb, 0xaf, 0xb0,
        0x40, 0xe5, 0x0f, 0x9e, 0xf1, 0xf2, 0x89, 0xb5,
        0x42, 0x34, 0x8a, 0xa1, 0x03, 0xb7, 0xe9, 0x57,
@@ -1651,7 +1650,7 @@ static const u8 enc_input012[] __initconst = {
        0x3b, 0xd0, 0x84, 0x8e, 0x67, 0xa6, 0xa3, 0x7d,
        0x78, 0xec, 0x00
 };
-static const u8 enc_output012[] __initconst = {
+static const u8 enc_output012[] = {
        0x52, 0x34, 0xb3, 0x65, 0x3b, 0xb7, 0xe5, 0xd3,
        0xab, 0x49, 0x17, 0x60, 0xd2, 0x52, 0x56, 0xdf,
        0xdf, 0x34, 0x56, 0x82, 0xe2, 0xbe, 0xe5, 0xe1,
@@ -1907,7 +1906,7 @@ static const u8 enc_output012[] __initconst = {
        0xa3, 0x19, 0x8e, 0xa9, 0xb1, 0x13, 0x67, 0x62,
        0x70, 0xcf, 0xd6
 };
-static const u8 enc_assoc012[] __initconst = {
+static const u8 enc_assoc012[] = {
        0xb1, 0x69, 0x83, 0x87, 0x30, 0xaa, 0x5d, 0xb8,
        0x77, 0xe8, 0x21, 0xff, 0x06, 0x59, 0x35, 0xce,
        0x75, 0xfe, 0x38, 0xef, 0xb8, 0x91, 0x43, 0x8c,
@@ -1917,10 +1916,10 @@ static const u8 enc_assoc012[] __initconst = {
        0x01, 0xae, 0x9c, 0xb6, 0xe4, 0x88, 0x6d, 0x2b,
        0x76, 0x75, 0xe0, 0xf3, 0x74, 0xe2, 0xc9
 };
-static const u8 enc_nonce012[] __initconst = {
+static const u8 enc_nonce012[] = {
        0x05, 0xa3, 0x93, 0xed, 0x30, 0xc5, 0xa2, 0x06
 };
-static const u8 enc_key012[] __initconst = {
+static const u8 enc_key012[] = {
        0xb3, 0x35, 0x50, 0x03, 0x54, 0x2e, 0x40, 0x5e,
        0x8f, 0x59, 0x8e, 0xc5, 0x90, 0xd5, 0x27, 0x2d,
        0xba, 0x29, 0x2e, 0xcb, 0x1b, 0x70, 0x44, 0x1e,
@@ -1928,7 +1927,7 @@ static const u8 enc_key012[] __initconst = {
 };
 
 /* wycheproof - rfc7539 */
-static const u8 enc_input013[] __initconst = {
+static const u8 enc_input013[] = {
        0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61,
        0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c,
        0x65, 0x6d, 0x65, 0x6e, 0x20, 0x6f, 0x66, 0x20,
@@ -1945,7 +1944,7 @@ static const u8 enc_input013[] __initconst = {
        0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69,
        0x74, 0x2e
 };
-static const u8 enc_output013[] __initconst = {
+static const u8 enc_output013[] = {
        0xd3, 0x1a, 0x8d, 0x34, 0x64, 0x8e, 0x60, 0xdb,
        0x7b, 0x86, 0xaf, 0xbc, 0x53, 0xef, 0x7e, 0xc2,
        0xa4, 0xad, 0xed, 0x51, 0x29, 0x6e, 0x08, 0xfe,
@@ -1964,15 +1963,15 @@ static const u8 enc_output013[] __initconst = {
        0xe2, 0x6a, 0x7e, 0x90, 0x2e, 0xcb, 0xd0, 0x60,
        0x06, 0x91
 };
-static const u8 enc_assoc013[] __initconst = {
+static const u8 enc_assoc013[] = {
        0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3,
        0xc4, 0xc5, 0xc6, 0xc7
 };
-static const u8 enc_nonce013[] __initconst = {
+static const u8 enc_nonce013[] = {
        0x07, 0x00, 0x00, 0x00, 0x40, 0x41, 0x42, 0x43,
        0x44, 0x45, 0x46, 0x47
 };
-static const u8 enc_key013[] __initconst = {
+static const u8 enc_key013[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -1980,17 +1979,17 @@ static const u8 enc_key013[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input014[] __initconst = { };
-static const u8 enc_output014[] __initconst = {
+static const u8 enc_input014[] = { };
+static const u8 enc_output014[] = {
        0x76, 0xac, 0xb3, 0x42, 0xcf, 0x31, 0x66, 0xa5,
        0xb6, 0x3c, 0x0c, 0x0e, 0xa1, 0x38, 0x3c, 0x8d
 };
-static const u8 enc_assoc014[] __initconst = { };
-static const u8 enc_nonce014[] __initconst = {
+static const u8 enc_assoc014[] = { };
+static const u8 enc_nonce014[] = {
        0x4d, 0xa5, 0xbf, 0x8d, 0xfd, 0x58, 0x52, 0xc1,
        0xea, 0x12, 0x37, 0x9d
 };
-static const u8 enc_key014[] __initconst = {
+static const u8 enc_key014[] = {
        0x80, 0xba, 0x31, 0x92, 0xc8, 0x03, 0xce, 0x96,
        0x5e, 0xa3, 0x71, 0xd5, 0xff, 0x07, 0x3c, 0xf0,
        0xf4, 0x3b, 0x6a, 0x2a, 0xb5, 0x76, 0xb2, 0x08,
@@ -1998,19 +1997,19 @@ static const u8 enc_key014[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input015[] __initconst = { };
-static const u8 enc_output015[] __initconst = {
+static const u8 enc_input015[] = { };
+static const u8 enc_output015[] = {
        0x90, 0x6f, 0xa6, 0x28, 0x4b, 0x52, 0xf8, 0x7b,
        0x73, 0x59, 0xcb, 0xaa, 0x75, 0x63, 0xc7, 0x09
 };
-static const u8 enc_assoc015[] __initconst = {
+static const u8 enc_assoc015[] = {
        0xbd, 0x50, 0x67, 0x64, 0xf2, 0xd2, 0xc4, 0x10
 };
-static const u8 enc_nonce015[] __initconst = {
+static const u8 enc_nonce015[] = {
        0xa9, 0x2e, 0xf0, 0xac, 0x99, 0x1d, 0xd5, 0x16,
        0xa3, 0xc6, 0xf6, 0x89
 };
-static const u8 enc_key015[] __initconst = {
+static const u8 enc_key015[] = {
        0x7a, 0x4c, 0xd7, 0x59, 0x17, 0x2e, 0x02, 0xeb,
        0x20, 0x4d, 0xb2, 0xc3, 0xf5, 0xc7, 0x46, 0x22,
        0x7d, 0xf5, 0x84, 0xfc, 0x13, 0x45, 0x19, 0x63,
@@ -2018,20 +2017,20 @@ static const u8 enc_key015[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input016[] __initconst = {
+static const u8 enc_input016[] = {
        0x2a
 };
-static const u8 enc_output016[] __initconst = {
+static const u8 enc_output016[] = {
        0x3a, 0xca, 0xc2, 0x7d, 0xec, 0x09, 0x68, 0x80,
        0x1e, 0x9f, 0x6e, 0xde, 0xd6, 0x9d, 0x80, 0x75,
        0x22
 };
-static const u8 enc_assoc016[] __initconst = { };
-static const u8 enc_nonce016[] __initconst = {
+static const u8 enc_assoc016[] = { };
+static const u8 enc_nonce016[] = {
        0x99, 0xe2, 0x3e, 0xc4, 0x89, 0x85, 0xbc, 0xcd,
        0xee, 0xab, 0x60, 0xf1
 };
-static const u8 enc_key016[] __initconst = {
+static const u8 enc_key016[] = {
        0xcc, 0x56, 0xb6, 0x80, 0x55, 0x2e, 0xb7, 0x50,
        0x08, 0xf5, 0x48, 0x4b, 0x4c, 0xb8, 0x03, 0xfa,
        0x50, 0x63, 0xeb, 0xd6, 0xea, 0xb9, 0x1f, 0x6a,
@@ -2039,22 +2038,22 @@ static const u8 enc_key016[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input017[] __initconst = {
+static const u8 enc_input017[] = {
        0x51
 };
-static const u8 enc_output017[] __initconst = {
+static const u8 enc_output017[] = {
        0xc4, 0x16, 0x83, 0x10, 0xca, 0x45, 0xb1, 0xf7,
        0xc6, 0x6c, 0xad, 0x4e, 0x99, 0xe4, 0x3f, 0x72,
        0xb9
 };
-static const u8 enc_assoc017[] __initconst = {
+static const u8 enc_assoc017[] = {
        0x91, 0xca, 0x6c, 0x59, 0x2c, 0xbc, 0xca, 0x53
 };
-static const u8 enc_nonce017[] __initconst = {
+static const u8 enc_nonce017[] = {
        0xab, 0x0d, 0xca, 0x71, 0x6e, 0xe0, 0x51, 0xd2,
        0x78, 0x2f, 0x44, 0x03
 };
-static const u8 enc_key017[] __initconst = {
+static const u8 enc_key017[] = {
        0x46, 0xf0, 0x25, 0x49, 0x65, 0xf7, 0x69, 0xd5,
        0x2b, 0xdb, 0x4a, 0x70, 0xb4, 0x43, 0x19, 0x9f,
        0x8e, 0xf2, 0x07, 0x52, 0x0d, 0x12, 0x20, 0xc5,
@@ -2062,20 +2061,20 @@ static const u8 enc_key017[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input018[] __initconst = {
+static const u8 enc_input018[] = {
        0x5c, 0x60
 };
-static const u8 enc_output018[] __initconst = {
+static const u8 enc_output018[] = {
        0x4d, 0x13, 0x91, 0xe8, 0xb6, 0x1e, 0xfb, 0x39,
        0xc1, 0x22, 0x19, 0x54, 0x53, 0x07, 0x7b, 0x22,
        0xe5, 0xe2
 };
-static const u8 enc_assoc018[] __initconst = { };
-static const u8 enc_nonce018[] __initconst = {
+static const u8 enc_assoc018[] = { };
+static const u8 enc_nonce018[] = {
        0x46, 0x1a, 0xf1, 0x22, 0xe9, 0xf2, 0xe0, 0x34,
        0x7e, 0x03, 0xf2, 0xdb
 };
-static const u8 enc_key018[] __initconst = {
+static const u8 enc_key018[] = {
        0x2f, 0x7f, 0x7e, 0x4f, 0x59, 0x2b, 0xb3, 0x89,
        0x19, 0x49, 0x89, 0x74, 0x35, 0x07, 0xbf, 0x3e,
        0xe9, 0xcb, 0xde, 0x17, 0x86, 0xb6, 0x69, 0x5f,
@@ -2083,22 +2082,22 @@ static const u8 enc_key018[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input019[] __initconst = {
+static const u8 enc_input019[] = {
        0xdd, 0xf2
 };
-static const u8 enc_output019[] __initconst = {
+static const u8 enc_output019[] = {
        0xb6, 0x0d, 0xea, 0xd0, 0xfd, 0x46, 0x97, 0xec,
        0x2e, 0x55, 0x58, 0x23, 0x77, 0x19, 0xd0, 0x24,
        0x37, 0xa2
 };
-static const u8 enc_assoc019[] __initconst = {
+static const u8 enc_assoc019[] = {
        0x88, 0x36, 0x4f, 0xc8, 0x06, 0x05, 0x18, 0xbf
 };
-static const u8 enc_nonce019[] __initconst = {
+static const u8 enc_nonce019[] = {
        0x61, 0x54, 0x6b, 0xa5, 0xf1, 0x72, 0x05, 0x90,
        0xb6, 0x04, 0x0a, 0xc6
 };
-static const u8 enc_key019[] __initconst = {
+static const u8 enc_key019[] = {
        0xc8, 0x83, 0x3d, 0xce, 0x5e, 0xa9, 0xf2, 0x48,
        0xaa, 0x20, 0x30, 0xea, 0xcf, 0xe7, 0x2b, 0xff,
        0xe6, 0x9a, 0x62, 0x0c, 0xaf, 0x79, 0x33, 0x44,
@@ -2106,20 +2105,20 @@ static const u8 enc_key019[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input020[] __initconst = {
+static const u8 enc_input020[] = {
        0xab, 0x85, 0xe9, 0xc1, 0x57, 0x17, 0x31
 };
-static const u8 enc_output020[] __initconst = {
+static const u8 enc_output020[] = {
        0x5d, 0xfe, 0x34, 0x40, 0xdb, 0xb3, 0xc3, 0xed,
        0x7a, 0x43, 0x4e, 0x26, 0x02, 0xd3, 0x94, 0x28,
        0x1e, 0x0a, 0xfa, 0x9f, 0xb7, 0xaa, 0x42
 };
-static const u8 enc_assoc020[] __initconst = { };
-static const u8 enc_nonce020[] __initconst = {
+static const u8 enc_assoc020[] = { };
+static const u8 enc_nonce020[] = {
        0x3c, 0x4e, 0x65, 0x4d, 0x66, 0x3f, 0xa4, 0x59,
        0x6d, 0xc5, 0x5b, 0xb7
 };
-static const u8 enc_key020[] __initconst = {
+static const u8 enc_key020[] = {
        0x55, 0x56, 0x81, 0x58, 0xd3, 0xa6, 0x48, 0x3f,
        0x1f, 0x70, 0x21, 0xea, 0xb6, 0x9b, 0x70, 0x3f,
        0x61, 0x42, 0x51, 0xca, 0xdc, 0x1a, 0xf5, 0xd3,
@@ -2127,22 +2126,22 @@ static const u8 enc_key020[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input021[] __initconst = {
+static const u8 enc_input021[] = {
        0x4e, 0xe5, 0xcd, 0xa2, 0x0d, 0x42, 0x90
 };
-static const u8 enc_output021[] __initconst = {
+static const u8 enc_output021[] = {
        0x4b, 0xd4, 0x72, 0x12, 0x94, 0x1c, 0xe3, 0x18,
        0x5f, 0x14, 0x08, 0xee, 0x7f, 0xbf, 0x18, 0xf5,
        0xab, 0xad, 0x6e, 0x22, 0x53, 0xa1, 0xba
 };
-static const u8 enc_assoc021[] __initconst = {
+static const u8 enc_assoc021[] = {
        0x84, 0xe4, 0x6b, 0xe8, 0xc0, 0x91, 0x90, 0x53
 };
-static const u8 enc_nonce021[] __initconst = {
+static const u8 enc_nonce021[] = {
        0x58, 0x38, 0x93, 0x75, 0xc6, 0x9e, 0xe3, 0x98,
        0xde, 0x94, 0x83, 0x96
 };
-static const u8 enc_key021[] __initconst = {
+static const u8 enc_key021[] = {
        0xe3, 0xc0, 0x9e, 0x7f, 0xab, 0x1a, 0xef, 0xb5,
        0x16, 0xda, 0x6a, 0x33, 0x02, 0x2a, 0x1d, 0xd4,
        0xeb, 0x27, 0x2c, 0x80, 0xd5, 0x40, 0xc5, 0xda,
@@ -2150,20 +2149,20 @@ static const u8 enc_key021[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input022[] __initconst = {
+static const u8 enc_input022[] = {
        0xbe, 0x33, 0x08, 0xf7, 0x2a, 0x2c, 0x6a, 0xed
 };
-static const u8 enc_output022[] __initconst = {
+static const u8 enc_output022[] = {
        0x8e, 0x94, 0x39, 0xa5, 0x6e, 0xee, 0xc8, 0x17,
        0xfb, 0xe8, 0xa6, 0xed, 0x8f, 0xab, 0xb1, 0x93,
        0x75, 0x39, 0xdd, 0x6c, 0x00, 0xe9, 0x00, 0x21
 };
-static const u8 enc_assoc022[] __initconst = { };
-static const u8 enc_nonce022[] __initconst = {
+static const u8 enc_assoc022[] = { };
+static const u8 enc_nonce022[] = {
        0x4f, 0x07, 0xaf, 0xed, 0xfd, 0xc3, 0xb6, 0xc2,
        0x36, 0x18, 0x23, 0xd3
 };
-static const u8 enc_key022[] __initconst = {
+static const u8 enc_key022[] = {
        0x51, 0xe4, 0xbf, 0x2b, 0xad, 0x92, 0xb7, 0xaf,
        0xf1, 0xa4, 0xbc, 0x05, 0x55, 0x0b, 0xa8, 0x1d,
        0xf4, 0xb9, 0x6f, 0xab, 0xf4, 0x1c, 0x12, 0xc7,
@@ -2171,22 +2170,22 @@ static const u8 enc_key022[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input023[] __initconst = {
+static const u8 enc_input023[] = {
        0xa4, 0xc9, 0xc2, 0x80, 0x1b, 0x71, 0xf7, 0xdf
 };
-static const u8 enc_output023[] __initconst = {
+static const u8 enc_output023[] = {
        0xb9, 0xb9, 0x10, 0x43, 0x3a, 0xf0, 0x52, 0xb0,
        0x45, 0x30, 0xf5, 0x1a, 0xee, 0xe0, 0x24, 0xe0,
        0xa4, 0x45, 0xa6, 0x32, 0x8f, 0xa6, 0x7a, 0x18
 };
-static const u8 enc_assoc023[] __initconst = {
+static const u8 enc_assoc023[] = {
        0x66, 0xc0, 0xae, 0x70, 0x07, 0x6c, 0xb1, 0x4d
 };
-static const u8 enc_nonce023[] __initconst = {
+static const u8 enc_nonce023[] = {
        0xb4, 0xea, 0x66, 0x6e, 0xe1, 0x19, 0x56, 0x33,
        0x66, 0x48, 0x4a, 0x78
 };
-static const u8 enc_key023[] __initconst = {
+static const u8 enc_key023[] = {
        0x11, 0x31, 0xc1, 0x41, 0x85, 0x77, 0xa0, 0x54,
        0xde, 0x7a, 0x4a, 0xc5, 0x51, 0x95, 0x0f, 0x1a,
        0x05, 0x3f, 0x9a, 0xe4, 0x6e, 0x5b, 0x75, 0xfe,
@@ -2194,22 +2193,22 @@ static const u8 enc_key023[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input024[] __initconst = {
+static const u8 enc_input024[] = {
        0x42, 0xba, 0xae, 0x59, 0x78, 0xfe, 0xaf, 0x5c,
        0x36, 0x8d, 0x14, 0xe0
 };
-static const u8 enc_output024[] __initconst = {
+static const u8 enc_output024[] = {
        0xff, 0x7d, 0xc2, 0x03, 0xb2, 0x6c, 0x46, 0x7a,
        0x6b, 0x50, 0xdb, 0x33, 0x57, 0x8c, 0x0f, 0x27,
        0x58, 0xc2, 0xe1, 0x4e, 0x36, 0xd4, 0xfc, 0x10,
        0x6d, 0xcb, 0x29, 0xb4
 };
-static const u8 enc_assoc024[] __initconst = { };
-static const u8 enc_nonce024[] __initconst = {
+static const u8 enc_assoc024[] = { };
+static const u8 enc_nonce024[] = {
        0x9a, 0x59, 0xfc, 0xe2, 0x6d, 0xf0, 0x00, 0x5e,
        0x07, 0x53, 0x86, 0x56
 };
-static const u8 enc_key024[] __initconst = {
+static const u8 enc_key024[] = {
        0x99, 0xb6, 0x2b, 0xd5, 0xaf, 0xbe, 0x3f, 0xb0,
        0x15, 0xbd, 0xe9, 0x3f, 0x0a, 0xbf, 0x48, 0x39,
        0x57, 0xa1, 0xc3, 0xeb, 0x3c, 0xa5, 0x9c, 0xb5,
@@ -2217,24 +2216,24 @@ static const u8 enc_key024[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input025[] __initconst = {
+static const u8 enc_input025[] = {
        0xfd, 0xc8, 0x5b, 0x94, 0xa4, 0xb2, 0xa6, 0xb7,
        0x59, 0xb1, 0xa0, 0xda
 };
-static const u8 enc_output025[] __initconst = {
+static const u8 enc_output025[] = {
        0x9f, 0x88, 0x16, 0xde, 0x09, 0x94, 0xe9, 0x38,
        0xd9, 0xe5, 0x3f, 0x95, 0xd0, 0x86, 0xfc, 0x6c,
        0x9d, 0x8f, 0xa9, 0x15, 0xfd, 0x84, 0x23, 0xa7,
        0xcf, 0x05, 0x07, 0x2f
 };
-static const u8 enc_assoc025[] __initconst = {
+static const u8 enc_assoc025[] = {
        0xa5, 0x06, 0xe1, 0xa5, 0xc6, 0x90, 0x93, 0xf9
 };
-static const u8 enc_nonce025[] __initconst = {
+static const u8 enc_nonce025[] = {
        0x58, 0xdb, 0xd4, 0xad, 0x2c, 0x4a, 0xd3, 0x5d,
        0xd9, 0x06, 0xe9, 0xce
 };
-static const u8 enc_key025[] __initconst = {
+static const u8 enc_key025[] = {
        0x85, 0xf3, 0x5b, 0x62, 0x82, 0xcf, 0xf4, 0x40,
        0xbc, 0x10, 0x20, 0xc8, 0x13, 0x6f, 0xf2, 0x70,
        0x31, 0x11, 0x0f, 0xa6, 0x3e, 0xc1, 0x6f, 0x1e,
@@ -2242,22 +2241,22 @@ static const u8 enc_key025[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input026[] __initconst = {
+static const u8 enc_input026[] = {
        0x51, 0xf8, 0xc1, 0xf7, 0x31, 0xea, 0x14, 0xac,
        0xdb, 0x21, 0x0a, 0x6d, 0x97, 0x3e, 0x07
 };
-static const u8 enc_output026[] __initconst = {
+static const u8 enc_output026[] = {
        0x0b, 0x29, 0x63, 0x8e, 0x1f, 0xbd, 0xd6, 0xdf,
        0x53, 0x97, 0x0b, 0xe2, 0x21, 0x00, 0x42, 0x2a,
        0x91, 0x34, 0x08, 0x7d, 0x67, 0xa4, 0x6e, 0x79,
        0x17, 0x8d, 0x0a, 0x93, 0xf5, 0xe1, 0xd2
 };
-static const u8 enc_assoc026[] __initconst = { };
-static const u8 enc_nonce026[] __initconst = {
+static const u8 enc_assoc026[] = { };
+static const u8 enc_nonce026[] = {
        0x68, 0xab, 0x7f, 0xdb, 0xf6, 0x19, 0x01, 0xda,
        0xd4, 0x61, 0xd2, 0x3c
 };
-static const u8 enc_key026[] __initconst = {
+static const u8 enc_key026[] = {
        0x67, 0x11, 0x96, 0x27, 0xbd, 0x98, 0x8e, 0xda,
        0x90, 0x62, 0x19, 0xe0, 0x8c, 0x0d, 0x0d, 0x77,
        0x9a, 0x07, 0xd2, 0x08, 0xce, 0x8a, 0x4f, 0xe0,
@@ -2265,24 +2264,24 @@ static const u8 enc_key026[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input027[] __initconst = {
+static const u8 enc_input027[] = {
        0x97, 0x46, 0x9d, 0xa6, 0x67, 0xd6, 0x11, 0x0f,
        0x9c, 0xbd, 0xa1, 0xd1, 0xa2, 0x06, 0x73
 };
-static const u8 enc_output027[] __initconst = {
+static const u8 enc_output027[] = {
        0x32, 0xdb, 0x66, 0xc4, 0xa3, 0x81, 0x9d, 0x81,
        0x55, 0x74, 0x55, 0xe5, 0x98, 0x0f, 0xed, 0xfe,
        0xae, 0x30, 0xde, 0xc9, 0x4e, 0x6a, 0xd3, 0xa9,
        0xee, 0xa0, 0x6a, 0x0d, 0x70, 0x39, 0x17
 };
-static const u8 enc_assoc027[] __initconst = {
+static const u8 enc_assoc027[] = {
        0x64, 0x53, 0xa5, 0x33, 0x84, 0x63, 0x22, 0x12
 };
-static const u8 enc_nonce027[] __initconst = {
+static const u8 enc_nonce027[] = {
        0xd9, 0x5b, 0x32, 0x43, 0xaf, 0xae, 0xf7, 0x14,
        0xc5, 0x03, 0x5b, 0x6a
 };
-static const u8 enc_key027[] __initconst = {
+static const u8 enc_key027[] = {
        0xe6, 0xf1, 0x11, 0x8d, 0x41, 0xe4, 0xb4, 0x3f,
        0xb5, 0x82, 0x21, 0xb7, 0xed, 0x79, 0x67, 0x38,
        0x34, 0xe0, 0xd8, 0xac, 0x5c, 0x4f, 0xa6, 0x0b,
@@ -2290,22 +2289,22 @@ static const u8 enc_key027[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input028[] __initconst = {
+static const u8 enc_input028[] = {
        0x54, 0x9b, 0x36, 0x5a, 0xf9, 0x13, 0xf3, 0xb0,
        0x81, 0x13, 0x1c, 0xcb, 0x6b, 0x82, 0x55, 0x88
 };
-static const u8 enc_output028[] __initconst = {
+static const u8 enc_output028[] = {
        0xe9, 0x11, 0x0e, 0x9f, 0x56, 0xab, 0x3c, 0xa4,
        0x83, 0x50, 0x0c, 0xea, 0xba, 0xb6, 0x7a, 0x13,
        0x83, 0x6c, 0xca, 0xbf, 0x15, 0xa6, 0xa2, 0x2a,
        0x51, 0xc1, 0x07, 0x1c, 0xfa, 0x68, 0xfa, 0x0c
 };
-static const u8 enc_assoc028[] __initconst = { };
-static const u8 enc_nonce028[] __initconst = {
+static const u8 enc_assoc028[] = { };
+static const u8 enc_nonce028[] = {
        0x2f, 0xcb, 0x1b, 0x38, 0xa9, 0x9e, 0x71, 0xb8,
        0x47, 0x40, 0xad, 0x9b
 };
-static const u8 enc_key028[] __initconst = {
+static const u8 enc_key028[] = {
        0x59, 0xd4, 0xea, 0xfb, 0x4d, 0xe0, 0xcf, 0xc7,
        0xd3, 0xdb, 0x99, 0xa8, 0xf5, 0x4b, 0x15, 0xd7,
        0xb3, 0x9f, 0x0a, 0xcc, 0x8d, 0xa6, 0x97, 0x63,
@@ -2313,24 +2312,24 @@ static const u8 enc_key028[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input029[] __initconst = {
+static const u8 enc_input029[] = {
        0x55, 0xa4, 0x65, 0x64, 0x4f, 0x5b, 0x65, 0x09,
        0x28, 0xcb, 0xee, 0x7c, 0x06, 0x32, 0x14, 0xd6
 };
-static const u8 enc_output029[] __initconst = {
+static const u8 enc_output029[] = {
        0xe4, 0xb1, 0x13, 0xcb, 0x77, 0x59, 0x45, 0xf3,
        0xd3, 0xa8, 0xae, 0x9e, 0xc1, 0x41, 0xc0, 0x0c,
        0x7c, 0x43, 0xf1, 0x6c, 0xe0, 0x96, 0xd0, 0xdc,
        0x27, 0xc9, 0x58, 0x49, 0xdc, 0x38, 0x3b, 0x7d
 };
-static const u8 enc_assoc029[] __initconst = {
+static const u8 enc_assoc029[] = {
        0x03, 0x45, 0x85, 0x62, 0x1a, 0xf8, 0xd7, 0xff
 };
-static const u8 enc_nonce029[] __initconst = {
+static const u8 enc_nonce029[] = {
        0x11, 0x8a, 0x69, 0x64, 0xc2, 0xd3, 0xe3, 0x80,
        0x07, 0x1f, 0x52, 0x66
 };
-static const u8 enc_key029[] __initconst = {
+static const u8 enc_key029[] = {
        0xb9, 0x07, 0xa4, 0x50, 0x75, 0x51, 0x3f, 0xe8,
        0xa8, 0x01, 0x9e, 0xde, 0xe3, 0xf2, 0x59, 0x14,
        0x87, 0xb2, 0xa0, 0x30, 0xb0, 0x3c, 0x6e, 0x1d,
@@ -2338,24 +2337,24 @@ static const u8 enc_key029[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input030[] __initconst = {
+static const u8 enc_input030[] = {
        0x3f, 0xf1, 0x51, 0x4b, 0x1c, 0x50, 0x39, 0x15,
        0x91, 0x8f, 0x0c, 0x0c, 0x31, 0x09, 0x4a, 0x6e,
        0x1f
 };
-static const u8 enc_output030[] __initconst = {
+static const u8 enc_output030[] = {
        0x02, 0xcc, 0x3a, 0xcb, 0x5e, 0xe1, 0xfc, 0xdd,
        0x12, 0xa0, 0x3b, 0xb8, 0x57, 0x97, 0x64, 0x74,
        0xd3, 0xd8, 0x3b, 0x74, 0x63, 0xa2, 0xc3, 0x80,
        0x0f, 0xe9, 0x58, 0xc2, 0x8e, 0xaa, 0x29, 0x08,
        0x13
 };
-static const u8 enc_assoc030[] __initconst = { };
-static const u8 enc_nonce030[] __initconst = {
+static const u8 enc_assoc030[] = { };
+static const u8 enc_nonce030[] = {
        0x45, 0xaa, 0xa3, 0xe5, 0xd1, 0x6d, 0x2d, 0x42,
        0xdc, 0x03, 0x44, 0x5d
 };
-static const u8 enc_key030[] __initconst = {
+static const u8 enc_key030[] = {
        0x3b, 0x24, 0x58, 0xd8, 0x17, 0x6e, 0x16, 0x21,
        0xc0, 0xcc, 0x24, 0xc0, 0xc0, 0xe2, 0x4c, 0x1e,
        0x80, 0xd7, 0x2f, 0x7e, 0xe9, 0x14, 0x9a, 0x4b,
@@ -2363,26 +2362,26 @@ static const u8 enc_key030[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input031[] __initconst = {
+static const u8 enc_input031[] = {
        0x63, 0x85, 0x8c, 0xa3, 0xe2, 0xce, 0x69, 0x88,
        0x7b, 0x57, 0x8a, 0x3c, 0x16, 0x7b, 0x42, 0x1c,
        0x9c
 };
-static const u8 enc_output031[] __initconst = {
+static const u8 enc_output031[] = {
        0x35, 0x76, 0x64, 0x88, 0xd2, 0xbc, 0x7c, 0x2b,
        0x8d, 0x17, 0xcb, 0xbb, 0x9a, 0xbf, 0xad, 0x9e,
        0x6d, 0x1f, 0x39, 0x1e, 0x65, 0x7b, 0x27, 0x38,
        0xdd, 0xa0, 0x84, 0x48, 0xcb, 0xa2, 0x81, 0x1c,
        0xeb
 };
-static const u8 enc_assoc031[] __initconst = {
+static const u8 enc_assoc031[] = {
        0x9a, 0xaf, 0x29, 0x9e, 0xee, 0xa7, 0x8f, 0x79
 };
-static const u8 enc_nonce031[] __initconst = {
+static const u8 enc_nonce031[] = {
        0xf0, 0x38, 0x4f, 0xb8, 0x76, 0x12, 0x14, 0x10,
        0x63, 0x3d, 0x99, 0x3d
 };
-static const u8 enc_key031[] __initconst = {
+static const u8 enc_key031[] = {
        0xf6, 0x0c, 0x6a, 0x1b, 0x62, 0x57, 0x25, 0xf7,
        0x6c, 0x70, 0x37, 0xb4, 0x8f, 0xe3, 0x57, 0x7f,
        0xa7, 0xf7, 0xb8, 0x7b, 0x1b, 0xd5, 0xa9, 0x82,
@@ -2390,24 +2389,24 @@ static const u8 enc_key031[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input032[] __initconst = {
+static const u8 enc_input032[] = {
        0x10, 0xf1, 0xec, 0xf9, 0xc6, 0x05, 0x84, 0x66,
        0x5d, 0x9a, 0xe5, 0xef, 0xe2, 0x79, 0xe7, 0xf7,
        0x37, 0x7e, 0xea, 0x69, 0x16, 0xd2, 0xb1, 0x11
 };
-static const u8 enc_output032[] __initconst = {
+static const u8 enc_output032[] = {
        0x42, 0xf2, 0x6c, 0x56, 0xcb, 0x4b, 0xe2, 0x1d,
        0x9d, 0x8d, 0x0c, 0x80, 0xfc, 0x99, 0xdd, 0xe0,
        0x0d, 0x75, 0xf3, 0x80, 0x74, 0xbf, 0xe7, 0x64,
        0x54, 0xaa, 0x7e, 0x13, 0xd4, 0x8f, 0xff, 0x7d,
        0x75, 0x57, 0x03, 0x94, 0x57, 0x04, 0x0a, 0x3a
 };
-static const u8 enc_assoc032[] __initconst = { };
-static const u8 enc_nonce032[] __initconst = {
+static const u8 enc_assoc032[] = { };
+static const u8 enc_nonce032[] = {
        0xe6, 0xb1, 0xad, 0xf2, 0xfd, 0x58, 0xa8, 0x76,
        0x2c, 0x65, 0xf3, 0x1b
 };
-static const u8 enc_key032[] __initconst = {
+static const u8 enc_key032[] = {
        0x02, 0x12, 0xa8, 0xde, 0x50, 0x07, 0xed, 0x87,
        0xb3, 0x3f, 0x1a, 0x70, 0x90, 0xb6, 0x11, 0x4f,
        0x9e, 0x08, 0xce, 0xfd, 0x96, 0x07, 0xf2, 0xc2,
@@ -2415,26 +2414,26 @@ static const u8 enc_key032[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input033[] __initconst = {
+static const u8 enc_input033[] = {
        0x92, 0x22, 0xf9, 0x01, 0x8e, 0x54, 0xfd, 0x6d,
        0xe1, 0x20, 0x08, 0x06, 0xa9, 0xee, 0x8e, 0x4c,
        0xc9, 0x04, 0xd2, 0x9f, 0x25, 0xcb, 0xa1, 0x93
 };
-static const u8 enc_output033[] __initconst = {
+static const u8 enc_output033[] = {
        0x12, 0x30, 0x32, 0x43, 0x7b, 0x4b, 0xfd, 0x69,
        0x20, 0xe8, 0xf7, 0xe7, 0xe0, 0x08, 0x7a, 0xe4,
        0x88, 0x9e, 0xbe, 0x7a, 0x0a, 0xd0, 0xe9, 0x00,
        0x3c, 0xf6, 0x8f, 0x17, 0x95, 0x50, 0xda, 0x63,
        0xd3, 0xb9, 0x6c, 0x2d, 0x55, 0x41, 0x18, 0x65
 };
-static const u8 enc_assoc033[] __initconst = {
+static const u8 enc_assoc033[] = {
        0x3e, 0x8b, 0xc5, 0xad, 0xe1, 0x82, 0xff, 0x08
 };
-static const u8 enc_nonce033[] __initconst = {
+static const u8 enc_nonce033[] = {
        0x6b, 0x28, 0x2e, 0xbe, 0xcc, 0x54, 0x1b, 0xcd,
        0x78, 0x34, 0xed, 0x55
 };
-static const u8 enc_key033[] __initconst = {
+static const u8 enc_key033[] = {
        0xc5, 0xbc, 0x09, 0x56, 0x56, 0x46, 0xe7, 0xed,
        0xda, 0x95, 0x4f, 0x1f, 0x73, 0x92, 0x23, 0xda,
        0xda, 0x20, 0xb9, 0x5c, 0x44, 0xab, 0x03, 0x3d,
@@ -2442,13 +2441,13 @@ static const u8 enc_key033[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input034[] __initconst = {
+static const u8 enc_input034[] = {
        0xb0, 0x53, 0x99, 0x92, 0x86, 0xa2, 0x82, 0x4f,
        0x42, 0xcc, 0x8c, 0x20, 0x3a, 0xb2, 0x4e, 0x2c,
        0x97, 0xa6, 0x85, 0xad, 0xcc, 0x2a, 0xd3, 0x26,
        0x62, 0x55, 0x8e, 0x55, 0xa5, 0xc7, 0x29
 };
-static const u8 enc_output034[] __initconst = {
+static const u8 enc_output034[] = {
        0x45, 0xc7, 0xd6, 0xb5, 0x3a, 0xca, 0xd4, 0xab,
        0xb6, 0x88, 0x76, 0xa6, 0xe9, 0x6a, 0x48, 0xfb,
        0x59, 0x52, 0x4d, 0x2c, 0x92, 0xc9, 0xd8, 0xa1,
@@ -2456,12 +2455,12 @@ static const u8 enc_output034[] __initconst = {
        0x6d, 0x3c, 0xa1, 0x0e, 0x31, 0x1b, 0x69, 0x5f,
        0x3e, 0xae, 0x15, 0x51, 0x65, 0x24, 0x93
 };
-static const u8 enc_assoc034[] __initconst = { };
-static const u8 enc_nonce034[] __initconst = {
+static const u8 enc_assoc034[] = { };
+static const u8 enc_nonce034[] = {
        0x04, 0xa9, 0xbe, 0x03, 0x50, 0x8a, 0x5f, 0x31,
        0x37, 0x1a, 0x6f, 0xd2
 };
-static const u8 enc_key034[] __initconst = {
+static const u8 enc_key034[] = {
        0x2e, 0xb5, 0x1c, 0x46, 0x9a, 0xa8, 0xeb, 0x9e,
        0x6c, 0x54, 0xa8, 0x34, 0x9b, 0xae, 0x50, 0xa2,
        0x0f, 0x0e, 0x38, 0x27, 0x11, 0xbb, 0xa1, 0x15,
@@ -2469,13 +2468,13 @@ static const u8 enc_key034[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input035[] __initconst = {
+static const u8 enc_input035[] = {
        0xf4, 0x52, 0x06, 0xab, 0xc2, 0x55, 0x52, 0xb2,
        0xab, 0xc9, 0xab, 0x7f, 0xa2, 0x43, 0x03, 0x5f,
        0xed, 0xaa, 0xdd, 0xc3, 0xb2, 0x29, 0x39, 0x56,
        0xf1, 0xea, 0x6e, 0x71, 0x56, 0xe7, 0xeb
 };
-static const u8 enc_output035[] __initconst = {
+static const u8 enc_output035[] = {
        0x46, 0xa8, 0x0c, 0x41, 0x87, 0x02, 0x47, 0x20,
        0x08, 0x46, 0x27, 0x58, 0x00, 0x80, 0xdd, 0xe5,
        0xa3, 0xf4, 0xa1, 0x10, 0x93, 0xa7, 0x07, 0x6e,
@@ -2483,14 +2482,14 @@ static const u8 enc_output035[] __initconst = {
        0x4d, 0x4a, 0xa2, 0x83, 0x5a, 0x52, 0xe7, 0x2d,
        0x14, 0xdf, 0x0e, 0x4f, 0x47, 0xf2, 0x5f
 };
-static const u8 enc_assoc035[] __initconst = {
+static const u8 enc_assoc035[] = {
        0x37, 0x46, 0x18, 0xa0, 0x6e, 0xa9, 0x8a, 0x48
 };
-static const u8 enc_nonce035[] __initconst = {
+static const u8 enc_nonce035[] = {
        0x47, 0x0a, 0x33, 0x9e, 0xcb, 0x32, 0x19, 0xb8,
        0xb8, 0x1a, 0x1f, 0x8b
 };
-static const u8 enc_key035[] __initconst = {
+static const u8 enc_key035[] = {
        0x7f, 0x5b, 0x74, 0xc0, 0x7e, 0xd1, 0xb4, 0x0f,
        0xd1, 0x43, 0x58, 0xfe, 0x2f, 0xf2, 0xa7, 0x40,
        0xc1, 0x16, 0xc7, 0x70, 0x65, 0x10, 0xe6, 0xa4,
@@ -2498,13 +2497,13 @@ static const u8 enc_key035[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input036[] __initconst = {
+static const u8 enc_input036[] = {
        0xb9, 0xc5, 0x54, 0xcb, 0xc3, 0x6a, 0xc1, 0x8a,
        0xe8, 0x97, 0xdf, 0x7b, 0xee, 0xca, 0xc1, 0xdb,
        0xeb, 0x4e, 0xaf, 0xa1, 0x56, 0xbb, 0x60, 0xce,
        0x2e, 0x5d, 0x48, 0xf0, 0x57, 0x15, 0xe6, 0x78
 };
-static const u8 enc_output036[] __initconst = {
+static const u8 enc_output036[] = {
        0xea, 0x29, 0xaf, 0xa4, 0x9d, 0x36, 0xe8, 0x76,
        0x0f, 0x5f, 0xe1, 0x97, 0x23, 0xb9, 0x81, 0x1e,
        0xd5, 0xd5, 0x19, 0x93, 0x4a, 0x44, 0x0f, 0x50,
@@ -2512,12 +2511,12 @@ static const u8 enc_output036[] __initconst = {
        0x22, 0x25, 0x41, 0xaf, 0x46, 0xb8, 0x65, 0x33,
        0xc6, 0xb6, 0x8d, 0x2f, 0xf1, 0x08, 0xa7, 0xea
 };
-static const u8 enc_assoc036[] __initconst = { };
-static const u8 enc_nonce036[] __initconst = {
+static const u8 enc_assoc036[] = { };
+static const u8 enc_nonce036[] = {
        0x72, 0xcf, 0xd9, 0x0e, 0xf3, 0x02, 0x6c, 0xa2,
        0x2b, 0x7e, 0x6e, 0x6a
 };
-static const u8 enc_key036[] __initconst = {
+static const u8 enc_key036[] = {
        0xe1, 0x73, 0x1d, 0x58, 0x54, 0xe1, 0xb7, 0x0c,
        0xb3, 0xff, 0xe8, 0xb7, 0x86, 0xa2, 0xb3, 0xeb,
        0xf0, 0x99, 0x43, 0x70, 0x95, 0x47, 0x57, 0xb9,
@@ -2525,13 +2524,13 @@ static const u8 enc_key036[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input037[] __initconst = {
+static const u8 enc_input037[] = {
        0x6b, 0x26, 0x04, 0x99, 0x6c, 0xd3, 0x0c, 0x14,
        0xa1, 0x3a, 0x52, 0x57, 0xed, 0x6c, 0xff, 0xd3,
        0xbc, 0x5e, 0x29, 0xd6, 0xb9, 0x7e, 0xb1, 0x79,
        0x9e, 0xb3, 0x35, 0xe2, 0x81, 0xea, 0x45, 0x1e
 };
-static const u8 enc_output037[] __initconst = {
+static const u8 enc_output037[] = {
        0x6d, 0xad, 0x63, 0x78, 0x97, 0x54, 0x4d, 0x8b,
        0xf6, 0xbe, 0x95, 0x07, 0xed, 0x4d, 0x1b, 0xb2,
        0xe9, 0x54, 0xbc, 0x42, 0x7e, 0x5d, 0xe7, 0x29,
@@ -2539,14 +2538,14 @@ static const u8 enc_output037[] __initconst = {
        0x7b, 0x99, 0x7d, 0x93, 0xc9, 0x82, 0x18, 0x9d,
        0x70, 0x95, 0xdc, 0x79, 0x4c, 0x74, 0x62, 0x32
 };
-static const u8 enc_assoc037[] __initconst = {
+static const u8 enc_assoc037[] = {
        0x23, 0x33, 0xe5, 0xce, 0x0f, 0x93, 0xb0, 0x59
 };
-static const u8 enc_nonce037[] __initconst = {
+static const u8 enc_nonce037[] = {
        0x26, 0x28, 0x80, 0xd4, 0x75, 0xf3, 0xda, 0xc5,
        0x34, 0x0d, 0xd1, 0xb8
 };
-static const u8 enc_key037[] __initconst = {
+static const u8 enc_key037[] = {
        0x27, 0xd8, 0x60, 0x63, 0x1b, 0x04, 0x85, 0xa4,
        0x10, 0x70, 0x2f, 0xea, 0x61, 0xbc, 0x87, 0x3f,
        0x34, 0x42, 0x26, 0x0c, 0xad, 0xed, 0x4a, 0xbd,
@@ -2554,7 +2553,7 @@ static const u8 enc_key037[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input038[] __initconst = {
+static const u8 enc_input038[] = {
        0x97, 0x3d, 0x0c, 0x75, 0x38, 0x26, 0xba, 0xe4,
        0x66, 0xcf, 0x9a, 0xbb, 0x34, 0x93, 0x15, 0x2e,
        0x9d, 0xe7, 0x81, 0x9e, 0x2b, 0xd0, 0xc7, 0x11,
@@ -2562,7 +2561,7 @@ static const u8 enc_input038[] __initconst = {
        0x1a, 0xa3, 0xce, 0xdc, 0x0d, 0xfd, 0x7b, 0x46,
        0x7e, 0x26, 0x22, 0x8b, 0xc8, 0x6c, 0x9a
 };
-static const u8 enc_output038[] __initconst = {
+static const u8 enc_output038[] = {
        0xfb, 0xa7, 0x8a, 0xe4, 0xf9, 0xd8, 0x08, 0xa6,
        0x2e, 0x3d, 0xa4, 0x0b, 0xe2, 0xcb, 0x77, 0x00,
        0xc3, 0x61, 0x3d, 0x9e, 0xb2, 0xc5, 0x29, 0xc6,
@@ -2572,12 +2571,12 @@ static const u8 enc_output038[] __initconst = {
        0x04, 0x69, 0x56, 0xdb, 0x3a, 0x51, 0x29, 0x08,
        0xbd, 0x7a, 0xfc, 0x8f, 0x2a, 0xb0, 0xa9
 };
-static const u8 enc_assoc038[] __initconst = { };
-static const u8 enc_nonce038[] __initconst = {
+static const u8 enc_assoc038[] = { };
+static const u8 enc_nonce038[] = {
        0xe7, 0x4a, 0x51, 0x5e, 0x7e, 0x21, 0x02, 0xb9,
        0x0b, 0xef, 0x55, 0xd2
 };
-static const u8 enc_key038[] __initconst = {
+static const u8 enc_key038[] = {
        0xcf, 0x0d, 0x40, 0xa4, 0x64, 0x4e, 0x5f, 0x51,
        0x81, 0x51, 0x65, 0xd5, 0x30, 0x1b, 0x22, 0x63,
        0x1f, 0x45, 0x44, 0xc4, 0x9a, 0x18, 0x78, 0xe3,
@@ -2585,7 +2584,7 @@ static const u8 enc_key038[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input039[] __initconst = {
+static const u8 enc_input039[] = {
        0xa9, 0x89, 0x95, 0x50, 0x4d, 0xf1, 0x6f, 0x74,
        0x8b, 0xfb, 0x77, 0x85, 0xff, 0x91, 0xee, 0xb3,
        0xb6, 0x60, 0xea, 0x9e, 0xd3, 0x45, 0x0c, 0x3d,
@@ -2593,7 +2592,7 @@ static const u8 enc_input039[] __initconst = {
        0xa9, 0x97, 0x8d, 0x75, 0x54, 0x2e, 0xf9, 0x1c,
        0x45, 0x67, 0x62, 0x21, 0x56, 0x40, 0xb9
 };
-static const u8 enc_output039[] __initconst = {
+static const u8 enc_output039[] = {
        0xa1, 0xff, 0xed, 0x80, 0x76, 0x18, 0x29, 0xec,
        0xce, 0x24, 0x2e, 0x0e, 0x88, 0xb1, 0x38, 0x04,
        0x90, 0x16, 0xbc, 0xa0, 0x18, 0xda, 0x2b, 0x6e,
@@ -2603,14 +2602,14 @@ static const u8 enc_output039[] __initconst = {
        0xcb, 0xf0, 0xbe, 0xfd, 0xa0, 0xb7, 0x02, 0x42,
        0xc6, 0x40, 0xd7, 0xcd, 0x02, 0xd7, 0xa3
 };
-static const u8 enc_assoc039[] __initconst = {
+static const u8 enc_assoc039[] = {
        0xb3, 0xe4, 0x06, 0x46, 0x83, 0xb0, 0x2d, 0x84
 };
-static const u8 enc_nonce039[] __initconst = {
+static const u8 enc_nonce039[] = {
        0xd4, 0xd8, 0x07, 0x34, 0x16, 0x83, 0x82, 0x5b,
        0x31, 0xcd, 0x4d, 0x95
 };
-static const u8 enc_key039[] __initconst = {
+static const u8 enc_key039[] = {
        0x6c, 0xbf, 0xd7, 0x1c, 0x64, 0x5d, 0x18, 0x4c,
        0xf5, 0xd2, 0x3c, 0x40, 0x2b, 0xdb, 0x0d, 0x25,
        0xec, 0x54, 0x89, 0x8c, 0x8a, 0x02, 0x73, 0xd4,
@@ -2618,7 +2617,7 @@ static const u8 enc_key039[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input040[] __initconst = {
+static const u8 enc_input040[] = {
        0xd0, 0x96, 0x80, 0x31, 0x81, 0xbe, 0xef, 0x9e,
        0x00, 0x8f, 0xf8, 0x5d, 0x5d, 0xdc, 0x38, 0xdd,
        0xac, 0xf0, 0xf0, 0x9e, 0xe5, 0xf7, 0xe0, 0x7f,
@@ -2628,7 +2627,7 @@ static const u8 enc_input040[] __initconst = {
        0x18, 0xf1, 0x18, 0x55, 0x86, 0xbf, 0xea, 0x9d,
        0x4c, 0x68, 0x5d, 0x50, 0xe4, 0xbb, 0x9a, 0x82
 };
-static const u8 enc_output040[] __initconst = {
+static const u8 enc_output040[] = {
        0x9a, 0x4e, 0xf2, 0x2b, 0x18, 0x16, 0x77, 0xb5,
        0x75, 0x5c, 0x08, 0xf7, 0x47, 0xc0, 0xf8, 0xd8,
        0xe8, 0xd4, 0xc1, 0x8a, 0x9c, 0xc2, 0x40, 0x5c,
@@ -2640,12 +2639,12 @@ static const u8 enc_output040[] __initconst = {
        0x9f, 0xf3, 0x42, 0x7a, 0x0f, 0x32, 0xfa, 0x56,
        0x6d, 0x9c, 0xa0, 0xa7, 0x8a, 0xef, 0xc0, 0x13
 };
-static const u8 enc_assoc040[] __initconst = { };
-static const u8 enc_nonce040[] __initconst = {
+static const u8 enc_assoc040[] = { };
+static const u8 enc_nonce040[] = {
        0xd6, 0x10, 0x40, 0xa3, 0x13, 0xed, 0x49, 0x28,
        0x23, 0xcc, 0x06, 0x5b
 };
-static const u8 enc_key040[] __initconst = {
+static const u8 enc_key040[] = {
        0x5b, 0x1d, 0x10, 0x35, 0xc0, 0xb1, 0x7e, 0xe0,
        0xb0, 0x44, 0x47, 0x67, 0xf8, 0x0a, 0x25, 0xb8,
        0xc1, 0xb7, 0x41, 0xf4, 0xb5, 0x0a, 0x4d, 0x30,
@@ -2653,7 +2652,7 @@ static const u8 enc_key040[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input041[] __initconst = {
+static const u8 enc_input041[] = {
        0x94, 0xee, 0x16, 0x6d, 0x6d, 0x6e, 0xcf, 0x88,
        0x32, 0x43, 0x71, 0x36, 0xb4, 0xae, 0x80, 0x5d,
        0x42, 0x88, 0x64, 0x35, 0x95, 0x86, 0xd9, 0x19,
@@ -2663,7 +2662,7 @@ static const u8 enc_input041[] __initconst = {
        0x4a, 0x10, 0x8c, 0x7d, 0x7c, 0xe3, 0x4e, 0x6c,
        0x6f, 0x8e, 0xa1, 0xbe, 0xc0, 0x56, 0x73, 0x17
 };
-static const u8 enc_output041[] __initconst = {
+static const u8 enc_output041[] = {
        0x5f, 0xbb, 0xde, 0xcc, 0x34, 0xbe, 0x20, 0x16,
        0x14, 0xf6, 0x36, 0x03, 0x1e, 0xeb, 0x42, 0xf1,
        0xca, 0xce, 0x3c, 0x79, 0xa1, 0x2c, 0xff, 0xd8,
@@ -2675,14 +2674,14 @@ static const u8 enc_output041[] __initconst = {
        0x09, 0x26, 0x3d, 0xa7, 0xb4, 0xcb, 0x92, 0x14,
        0x52, 0xf9, 0x7d, 0xca, 0x40, 0xf5, 0x80, 0xec
 };
-static const u8 enc_assoc041[] __initconst = {
+static const u8 enc_assoc041[] = {
        0x71, 0x93, 0xf6, 0x23, 0x66, 0x33, 0x21, 0xa2
 };
-static const u8 enc_nonce041[] __initconst = {
+static const u8 enc_nonce041[] = {
        0xd3, 0x1c, 0x21, 0xab, 0xa1, 0x75, 0xb7, 0x0d,
        0xe4, 0xeb, 0xb1, 0x9c
 };
-static const u8 enc_key041[] __initconst = {
+static const u8 enc_key041[] = {
        0x97, 0xd6, 0x35, 0xc4, 0xf4, 0x75, 0x74, 0xd9,
        0x99, 0x8a, 0x90, 0x87, 0x5d, 0xa1, 0xd3, 0xa2,
        0x84, 0xb7, 0x55, 0xb2, 0xd3, 0x92, 0x97, 0xa5,
@@ -2690,7 +2689,7 @@ static const u8 enc_key041[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input042[] __initconst = {
+static const u8 enc_input042[] = {
        0xb4, 0x29, 0xeb, 0x80, 0xfb, 0x8f, 0xe8, 0xba,
        0xed, 0xa0, 0xc8, 0x5b, 0x9c, 0x33, 0x34, 0x58,
        0xe7, 0xc2, 0x99, 0x2e, 0x55, 0x84, 0x75, 0x06,
@@ -2705,7 +2704,7 @@ static const u8 enc_input042[] __initconst = {
        0xc3, 0xea, 0x46, 0xc8, 0x76, 0x1d, 0x50, 0xf5,
        0x92
 };
-static const u8 enc_output042[] __initconst = {
+static const u8 enc_output042[] = {
        0xd0, 0x10, 0x2f, 0x6c, 0x25, 0x8b, 0xf4, 0x97,
        0x42, 0xce, 0xc3, 0x4c, 0xf2, 0xd0, 0xfe, 0xdf,
        0x23, 0xd1, 0x05, 0xfb, 0x4c, 0x84, 0xcf, 0x98,
@@ -2722,12 +2721,12 @@ static const u8 enc_output042[] __initconst = {
        0x19, 0x61, 0x21, 0x27, 0xce, 0x49, 0x99, 0x3b,
        0xb0
 };
-static const u8 enc_assoc042[] __initconst = { };
-static const u8 enc_nonce042[] __initconst = {
+static const u8 enc_assoc042[] = { };
+static const u8 enc_nonce042[] = {
        0x17, 0xc8, 0x6a, 0x8a, 0xbb, 0xb7, 0xe0, 0x03,
        0xac, 0xde, 0x27, 0x99
 };
-static const u8 enc_key042[] __initconst = {
+static const u8 enc_key042[] = {
        0xfe, 0x6e, 0x55, 0xbd, 0xae, 0xd1, 0xf7, 0x28,
        0x4c, 0xa5, 0xfc, 0x0f, 0x8c, 0x5f, 0x2b, 0x8d,
        0xf5, 0x6d, 0xc0, 0xf4, 0x9e, 0x8c, 0xa6, 0x6a,
@@ -2735,7 +2734,7 @@ static const u8 enc_key042[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input043[] __initconst = {
+static const u8 enc_input043[] = {
        0xce, 0xb5, 0x34, 0xce, 0x50, 0xdc, 0x23, 0xff,
        0x63, 0x8a, 0xce, 0x3e, 0xf6, 0x3a, 0xb2, 0xcc,
        0x29, 0x73, 0xee, 0xad, 0xa8, 0x07, 0x85, 0xfc,
@@ -2750,7 +2749,7 @@ static const u8 enc_input043[] __initconst = {
        0xdc, 0x47, 0x97, 0x0d, 0x84, 0xa6, 0xad, 0x31,
        0x76
 };
-static const u8 enc_output043[] __initconst = {
+static const u8 enc_output043[] = {
        0x75, 0x45, 0x39, 0x1b, 0x51, 0xde, 0x01, 0xd5,
        0xc5, 0x3d, 0xfa, 0xca, 0x77, 0x79, 0x09, 0x06,
        0x3e, 0x58, 0xed, 0xee, 0x4b, 0xb1, 0x22, 0x7e,
@@ -2767,14 +2766,14 @@ static const u8 enc_output043[] __initconst = {
        0xc7, 0xbb, 0xf1, 0x0d, 0xca, 0xdd, 0x7f, 0xac,
        0xf6
 };
-static const u8 enc_assoc043[] __initconst = {
+static const u8 enc_assoc043[] = {
        0xa1, 0x1c, 0x40, 0xb6, 0x03, 0x76, 0x73, 0x30
 };
-static const u8 enc_nonce043[] __initconst = {
+static const u8 enc_nonce043[] = {
        0x46, 0x36, 0x2f, 0x45, 0xd6, 0x37, 0x9e, 0x63,
        0xe5, 0x22, 0x94, 0x60
 };
-static const u8 enc_key043[] __initconst = {
+static const u8 enc_key043[] = {
        0xaa, 0xbc, 0x06, 0x34, 0x74, 0xe6, 0x5c, 0x4c,
        0x3e, 0x9b, 0xdc, 0x48, 0x0d, 0xea, 0x97, 0xb4,
        0x51, 0x10, 0xc8, 0x61, 0x88, 0x46, 0xff, 0x6b,
@@ -2782,24 +2781,24 @@ static const u8 enc_key043[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input044[] __initconst = {
+static const u8 enc_input044[] = {
        0xe5, 0xcc, 0xaa, 0x44, 0x1b, 0xc8, 0x14, 0x68,
        0x8f, 0x8f, 0x6e, 0x8f, 0x28, 0xb5, 0x00, 0xb2
 };
-static const u8 enc_output044[] __initconst = {
+static const u8 enc_output044[] = {
        0x7e, 0x72, 0xf5, 0xa1, 0x85, 0xaf, 0x16, 0xa6,
        0x11, 0x92, 0x1b, 0x43, 0x8f, 0x74, 0x9f, 0x0b,
        0x12, 0x42, 0xc6, 0x70, 0x73, 0x23, 0x34, 0x02,
        0x9a, 0xdf, 0xe1, 0xc5, 0x00, 0x16, 0x51, 0xe4
 };
-static const u8 enc_assoc044[] __initconst = {
+static const u8 enc_assoc044[] = {
        0x02
 };
-static const u8 enc_nonce044[] __initconst = {
+static const u8 enc_nonce044[] = {
        0x87, 0x34, 0x5f, 0x10, 0x55, 0xfd, 0x9e, 0x21,
        0x02, 0xd5, 0x06, 0x56
 };
-static const u8 enc_key044[] __initconst = {
+static const u8 enc_key044[] = {
        0x7d, 0x00, 0xb4, 0x80, 0x95, 0xad, 0xfa, 0x32,
        0x72, 0x05, 0x06, 0x07, 0xb2, 0x64, 0x18, 0x50,
        0x02, 0xba, 0x99, 0x95, 0x7c, 0x49, 0x8b, 0xe0,
@@ -2807,24 +2806,24 @@ static const u8 enc_key044[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input045[] __initconst = {
+static const u8 enc_input045[] = {
        0x02, 0xcd, 0xe1, 0x68, 0xfb, 0xa3, 0xf5, 0x44,
        0xbb, 0xd0, 0x33, 0x2f, 0x7a, 0xde, 0xad, 0xa8
 };
-static const u8 enc_output045[] __initconst = {
+static const u8 enc_output045[] = {
        0x85, 0xf2, 0x9a, 0x71, 0x95, 0x57, 0xcd, 0xd1,
        0x4d, 0x1f, 0x8f, 0xff, 0xab, 0x6d, 0x9e, 0x60,
        0x73, 0x2c, 0xa3, 0x2b, 0xec, 0xd5, 0x15, 0xa1,
        0xed, 0x35, 0x3f, 0x54, 0x2e, 0x99, 0x98, 0x58
 };
-static const u8 enc_assoc045[] __initconst = {
+static const u8 enc_assoc045[] = {
        0xb6, 0x48
 };
-static const u8 enc_nonce045[] __initconst = {
+static const u8 enc_nonce045[] = {
        0x87, 0xa3, 0x16, 0x3e, 0xc0, 0x59, 0x8a, 0xd9,
        0x5b, 0x3a, 0xa7, 0x13
 };
-static const u8 enc_key045[] __initconst = {
+static const u8 enc_key045[] = {
        0x64, 0x32, 0x71, 0x7f, 0x1d, 0xb8, 0x5e, 0x41,
        0xac, 0x78, 0x36, 0xbc, 0xe2, 0x51, 0x85, 0xa0,
        0x80, 0xd5, 0x76, 0x2b, 0x9e, 0x2b, 0x18, 0x44,
@@ -2832,25 +2831,25 @@ static const u8 enc_key045[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input046[] __initconst = {
+static const u8 enc_input046[] = {
        0x16, 0xdd, 0xd2, 0x3f, 0xf5, 0x3f, 0x3d, 0x23,
        0xc0, 0x63, 0x34, 0x48, 0x70, 0x40, 0xeb, 0x47
 };
-static const u8 enc_output046[] __initconst = {
+static const u8 enc_output046[] = {
        0xc1, 0xb2, 0x95, 0x93, 0x6d, 0x56, 0xfa, 0xda,
        0xc0, 0x3e, 0x5f, 0x74, 0x2b, 0xff, 0x73, 0xa1,
        0x39, 0xc4, 0x57, 0xdb, 0xab, 0x66, 0x38, 0x2b,
        0xab, 0xb3, 0xb5, 0x58, 0x00, 0xcd, 0xa5, 0xb8
 };
-static const u8 enc_assoc046[] __initconst = {
+static const u8 enc_assoc046[] = {
        0xbd, 0x4c, 0xd0, 0x2f, 0xc7, 0x50, 0x2b, 0xbd,
        0xbd, 0xf6, 0xc9, 0xa3, 0xcb, 0xe8, 0xf0
 };
-static const u8 enc_nonce046[] __initconst = {
+static const u8 enc_nonce046[] = {
        0x6f, 0x57, 0x3a, 0xa8, 0x6b, 0xaa, 0x49, 0x2b,
        0xa4, 0x65, 0x96, 0xdf
 };
-static const u8 enc_key046[] __initconst = {
+static const u8 enc_key046[] = {
        0x8e, 0x34, 0xcf, 0x73, 0xd2, 0x45, 0xa1, 0x08,
        0x2a, 0x92, 0x0b, 0x86, 0x36, 0x4e, 0xb8, 0x96,
        0xc4, 0x94, 0x64, 0x67, 0xbc, 0xb3, 0xd5, 0x89,
@@ -2858,25 +2857,25 @@ static const u8 enc_key046[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input047[] __initconst = {
+static const u8 enc_input047[] = {
        0x62, 0x3b, 0x78, 0x50, 0xc3, 0x21, 0xe2, 0xcf,
        0x0c, 0x6f, 0xbc, 0xc8, 0xdf, 0xd1, 0xaf, 0xf2
 };
-static const u8 enc_output047[] __initconst = {
+static const u8 enc_output047[] = {
        0xc8, 0x4c, 0x9b, 0xb7, 0xc6, 0x1c, 0x1b, 0xcb,
        0x17, 0x77, 0x2a, 0x1c, 0x50, 0x0c, 0x50, 0x95,
        0xdb, 0xad, 0xf7, 0xa5, 0x13, 0x8c, 0xa0, 0x34,
        0x59, 0xa2, 0xcd, 0x65, 0x83, 0x1e, 0x09, 0x2f
 };
-static const u8 enc_assoc047[] __initconst = {
+static const u8 enc_assoc047[] = {
        0x89, 0xcc, 0xe9, 0xfb, 0x47, 0x44, 0x1d, 0x07,
        0xe0, 0x24, 0x5a, 0x66, 0xfe, 0x8b, 0x77, 0x8b
 };
-static const u8 enc_nonce047[] __initconst = {
+static const u8 enc_nonce047[] = {
        0x1a, 0x65, 0x18, 0xf0, 0x2e, 0xde, 0x1d, 0xa6,
        0x80, 0x92, 0x66, 0xd9
 };
-static const u8 enc_key047[] __initconst = {
+static const u8 enc_key047[] = {
        0xcb, 0x55, 0x75, 0xf5, 0xc7, 0xc4, 0x5c, 0x91,
        0xcf, 0x32, 0x0b, 0x13, 0x9f, 0xb5, 0x94, 0x23,
        0x75, 0x60, 0xd0, 0xa3, 0xe6, 0xf8, 0x65, 0xa6,
@@ -2884,26 +2883,26 @@ static const u8 enc_key047[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input048[] __initconst = {
+static const u8 enc_input048[] = {
        0x87, 0xb3, 0xa4, 0xd7, 0xb2, 0x6d, 0x8d, 0x32,
        0x03, 0xa0, 0xde, 0x1d, 0x64, 0xef, 0x82, 0xe3
 };
-static const u8 enc_output048[] __initconst = {
+static const u8 enc_output048[] = {
        0x94, 0xbc, 0x80, 0x62, 0x1e, 0xd1, 0xe7, 0x1b,
        0x1f, 0xd2, 0xb5, 0xc3, 0xa1, 0x5e, 0x35, 0x68,
        0x33, 0x35, 0x11, 0x86, 0x17, 0x96, 0x97, 0x84,
        0x01, 0x59, 0x8b, 0x96, 0x37, 0x22, 0xf5, 0xb3
 };
-static const u8 enc_assoc048[] __initconst = {
+static const u8 enc_assoc048[] = {
        0xd1, 0x9f, 0x2d, 0x98, 0x90, 0x95, 0xf7, 0xab,
        0x03, 0xa5, 0xfd, 0xe8, 0x44, 0x16, 0xe0, 0x0c,
        0x0e
 };
-static const u8 enc_nonce048[] __initconst = {
+static const u8 enc_nonce048[] = {
        0x56, 0x4d, 0xee, 0x49, 0xab, 0x00, 0xd2, 0x40,
        0xfc, 0x10, 0x68, 0xc3
 };
-static const u8 enc_key048[] __initconst = {
+static const u8 enc_key048[] = {
        0xa5, 0x56, 0x9e, 0x72, 0x9a, 0x69, 0xb2, 0x4b,
        0xa6, 0xe0, 0xff, 0x15, 0xc4, 0x62, 0x78, 0x97,
        0x43, 0x68, 0x24, 0xc9, 0x41, 0xe9, 0xd0, 0x0b,
@@ -2911,27 +2910,27 @@ static const u8 enc_key048[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input049[] __initconst = {
+static const u8 enc_input049[] = {
        0xe6, 0x01, 0xb3, 0x85, 0x57, 0x79, 0x7d, 0xa2,
        0xf8, 0xa4, 0x10, 0x6a, 0x08, 0x9d, 0x1d, 0xa6
 };
-static const u8 enc_output049[] __initconst = {
+static const u8 enc_output049[] = {
        0x29, 0x9b, 0x5d, 0x3f, 0x3d, 0x03, 0xc0, 0x87,
        0x20, 0x9a, 0x16, 0xe2, 0x85, 0x14, 0x31, 0x11,
        0x4b, 0x45, 0x4e, 0xd1, 0x98, 0xde, 0x11, 0x7e,
        0x83, 0xec, 0x49, 0xfa, 0x8d, 0x85, 0x08, 0xd6
 };
-static const u8 enc_assoc049[] __initconst = {
+static const u8 enc_assoc049[] = {
        0x5e, 0x64, 0x70, 0xfa, 0xcd, 0x99, 0xc1, 0xd8,
        0x1e, 0x37, 0xcd, 0x44, 0x01, 0x5f, 0xe1, 0x94,
        0x80, 0xa2, 0xa4, 0xd3, 0x35, 0x2a, 0x4f, 0xf5,
        0x60, 0xc0, 0x64, 0x0f, 0xdb, 0xda
 };
-static const u8 enc_nonce049[] __initconst = {
+static const u8 enc_nonce049[] = {
        0xdf, 0x87, 0x13, 0xe8, 0x7e, 0xc3, 0xdb, 0xcf,
        0xad, 0x14, 0xd5, 0x3e
 };
-static const u8 enc_key049[] __initconst = {
+static const u8 enc_key049[] = {
        0x56, 0x20, 0x74, 0x65, 0xb4, 0xe4, 0x8e, 0x6d,
        0x04, 0x63, 0x0f, 0x4a, 0x42, 0xf3, 0x5c, 0xfc,
        0x16, 0x3a, 0xb2, 0x89, 0xc2, 0x2a, 0x2b, 0x47,
@@ -2939,27 +2938,27 @@ static const u8 enc_key049[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input050[] __initconst = {
+static const u8 enc_input050[] = {
        0xdc, 0x9e, 0x9e, 0xaf, 0x11, 0xe3, 0x14, 0x18,
        0x2d, 0xf6, 0xa4, 0xeb, 0xa1, 0x7a, 0xec, 0x9c
 };
-static const u8 enc_output050[] __initconst = {
+static const u8 enc_output050[] = {
        0x60, 0x5b, 0xbf, 0x90, 0xae, 0xb9, 0x74, 0xf6,
        0x60, 0x2b, 0xc7, 0x78, 0x05, 0x6f, 0x0d, 0xca,
        0x38, 0xea, 0x23, 0xd9, 0x90, 0x54, 0xb4, 0x6b,
        0x42, 0xff, 0xe0, 0x04, 0x12, 0x9d, 0x22, 0x04
 };
-static const u8 enc_assoc050[] __initconst = {
+static const u8 enc_assoc050[] = {
        0xba, 0x44, 0x6f, 0x6f, 0x9a, 0x0c, 0xed, 0x22,
        0x45, 0x0f, 0xeb, 0x10, 0x73, 0x7d, 0x90, 0x07,
        0xfd, 0x69, 0xab, 0xc1, 0x9b, 0x1d, 0x4d, 0x90,
        0x49, 0xa5, 0x55, 0x1e, 0x86, 0xec, 0x2b, 0x37
 };
-static const u8 enc_nonce050[] __initconst = {
+static const u8 enc_nonce050[] = {
        0x8d, 0xf4, 0xb1, 0x5a, 0x88, 0x8c, 0x33, 0x28,
        0x6a, 0x7b, 0x76, 0x51
 };
-static const u8 enc_key050[] __initconst = {
+static const u8 enc_key050[] = {
        0x39, 0x37, 0x98, 0x6a, 0xf8, 0x6d, 0xaf, 0xc1,
        0xba, 0x0c, 0x46, 0x72, 0xd8, 0xab, 0xc4, 0x6c,
        0x20, 0x70, 0x62, 0x68, 0x2d, 0x9c, 0x26, 0x4a,
@@ -2967,28 +2966,28 @@ static const u8 enc_key050[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input051[] __initconst = {
+static const u8 enc_input051[] = {
        0x81, 0xce, 0x84, 0xed, 0xe9, 0xb3, 0x58, 0x59,
        0xcc, 0x8c, 0x49, 0xa8, 0xf6, 0xbe, 0x7d, 0xc6
 };
-static const u8 enc_output051[] __initconst = {
+static const u8 enc_output051[] = {
        0x7b, 0x7c, 0xe0, 0xd8, 0x24, 0x80, 0x9a, 0x70,
        0xde, 0x32, 0x56, 0x2c, 0xcf, 0x2c, 0x2b, 0xbd,
        0x15, 0xd4, 0x4a, 0x00, 0xce, 0x0d, 0x19, 0xb4,
        0x23, 0x1f, 0x92, 0x1e, 0x22, 0xbc, 0x0a, 0x43
 };
-static const u8 enc_assoc051[] __initconst = {
+static const u8 enc_assoc051[] = {
        0xd4, 0x1a, 0x82, 0x8d, 0x5e, 0x71, 0x82, 0x92,
        0x47, 0x02, 0x19, 0x05, 0x40, 0x2e, 0xa2, 0x57,
        0xdc, 0xcb, 0xc3, 0xb8, 0x0f, 0xcd, 0x56, 0x75,
        0x05, 0x6b, 0x68, 0xbb, 0x59, 0xe6, 0x2e, 0x88,
        0x73
 };
-static const u8 enc_nonce051[] __initconst = {
+static const u8 enc_nonce051[] = {
        0xbe, 0x40, 0xe5, 0xf1, 0xa1, 0x18, 0x17, 0xa0,
        0xa8, 0xfa, 0x89, 0x49
 };
-static const u8 enc_key051[] __initconst = {
+static const u8 enc_key051[] = {
        0x36, 0x37, 0x2a, 0xbc, 0xdb, 0x78, 0xe0, 0x27,
        0x96, 0x46, 0xac, 0x3d, 0x17, 0x6b, 0x96, 0x74,
        0xe9, 0x15, 0x4e, 0xec, 0xf0, 0xd5, 0x46, 0x9c,
@@ -2996,17 +2995,17 @@ static const u8 enc_key051[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input052[] __initconst = {
+static const u8 enc_input052[] = {
        0xa6, 0x67, 0x47, 0xc8, 0x9e, 0x85, 0x7a, 0xf3,
        0xa1, 0x8e, 0x2c, 0x79, 0x50, 0x00, 0x87, 0xed
 };
-static const u8 enc_output052[] __initconst = {
+static const u8 enc_output052[] = {
        0xca, 0x82, 0xbf, 0xf3, 0xe2, 0xf3, 0x10, 0xcc,
        0xc9, 0x76, 0x67, 0x2c, 0x44, 0x15, 0xe6, 0x9b,
        0x57, 0x63, 0x8c, 0x62, 0xa5, 0xd8, 0x5d, 0xed,
        0x77, 0x4f, 0x91, 0x3c, 0x81, 0x3e, 0xa0, 0x32
 };
-static const u8 enc_assoc052[] __initconst = {
+static const u8 enc_assoc052[] = {
        0x3f, 0x2d, 0xd4, 0x9b, 0xbf, 0x09, 0xd6, 0x9a,
        0x78, 0xa3, 0xd8, 0x0e, 0xa2, 0x56, 0x66, 0x14,
        0xfc, 0x37, 0x94, 0x74, 0x19, 0x6c, 0x1a, 0xae,
@@ -3014,11 +3013,11 @@ static const u8 enc_assoc052[] __initconst = {
        0x6f, 0x42, 0xca, 0x42, 0x05, 0x6a, 0x97, 0x92,
        0xcc, 0x1b, 0x9f, 0xb3, 0xc7, 0xd2, 0x61
 };
-static const u8 enc_nonce052[] __initconst = {
+static const u8 enc_nonce052[] = {
        0x84, 0xc8, 0x7d, 0xae, 0x4e, 0xee, 0x27, 0x73,
        0x0e, 0xc3, 0x5d, 0x12
 };
-static const u8 enc_key052[] __initconst = {
+static const u8 enc_key052[] = {
        0x9f, 0x14, 0x79, 0xed, 0x09, 0x7d, 0x7f, 0xe5,
        0x29, 0xc1, 0x1f, 0x2f, 0x5a, 0xdd, 0x9a, 0xaf,
        0xf4, 0xa1, 0xca, 0x0b, 0x68, 0x99, 0x7a, 0x2c,
@@ -3026,13 +3025,13 @@ static const u8 enc_key052[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input053[] __initconst = {
+static const u8 enc_input053[] = {
        0x25, 0x6d, 0x40, 0x88, 0x80, 0x94, 0x17, 0x83,
        0x55, 0xd3, 0x04, 0x84, 0x64, 0x43, 0xfe, 0xe8,
        0xdf, 0x99, 0x47, 0x03, 0x03, 0xfb, 0x3b, 0x7b,
        0x80, 0xe0, 0x30, 0xbe, 0xeb, 0xd3, 0x29, 0xbe
 };
-static const u8 enc_output053[] __initconst = {
+static const u8 enc_output053[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -3040,14 +3039,14 @@ static const u8 enc_output053[] __initconst = {
        0xe6, 0xd3, 0xd7, 0x32, 0x4a, 0x1c, 0xbb, 0xa7,
        0x77, 0xbb, 0xb0, 0xec, 0xdd, 0xa3, 0x78, 0x07
 };
-static const u8 enc_assoc053[] __initconst = {
+static const u8 enc_assoc053[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_nonce053[] __initconst = {
+static const u8 enc_nonce053[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key053[] __initconst = {
+static const u8 enc_key053[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3055,7 +3054,7 @@ static const u8 enc_key053[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input054[] __initconst = {
+static const u8 enc_input054[] = {
        0x25, 0x6d, 0x40, 0x88, 0x80, 0x94, 0x17, 0x83,
        0x55, 0xd3, 0x04, 0x84, 0x64, 0x43, 0xfe, 0xe8,
        0xdf, 0x99, 0x47, 0x03, 0x03, 0xfb, 0x3b, 0x7b,
@@ -3065,7 +3064,7 @@ static const u8 enc_input054[] __initconst = {
        0x08, 0x69, 0xff, 0xd2, 0xec, 0x5e, 0x26, 0xe5,
        0x53, 0xb7, 0xb2, 0x27, 0xfe, 0x87, 0xfd, 0xbd
 };
-static const u8 enc_output054[] __initconst = {
+static const u8 enc_output054[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -3077,14 +3076,14 @@ static const u8 enc_output054[] __initconst = {
        0x06, 0x2d, 0xe6, 0x79, 0x5f, 0x27, 0x4f, 0xd2,
        0xa3, 0x05, 0xd7, 0x69, 0x80, 0xbc, 0x9c, 0xce
 };
-static const u8 enc_assoc054[] __initconst = {
+static const u8 enc_assoc054[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_nonce054[] __initconst = {
+static const u8 enc_nonce054[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key054[] __initconst = {
+static const u8 enc_key054[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3092,7 +3091,7 @@ static const u8 enc_key054[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input055[] __initconst = {
+static const u8 enc_input055[] = {
        0x25, 0x6d, 0x40, 0x88, 0x80, 0x94, 0x17, 0x83,
        0x55, 0xd3, 0x04, 0x84, 0x64, 0x43, 0xfe, 0xe8,
        0xdf, 0x99, 0x47, 0x03, 0x03, 0xfb, 0x3b, 0x7b,
@@ -3110,7 +3109,7 @@ static const u8 enc_input055[] __initconst = {
        0x77, 0xd3, 0x0b, 0xc5, 0x76, 0x92, 0xed, 0x38,
        0xfb, 0xac, 0x01, 0x88, 0x38, 0x04, 0x88, 0xc7
 };
-static const u8 enc_output055[] __initconst = {
+static const u8 enc_output055[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -3130,14 +3129,14 @@ static const u8 enc_output055[] __initconst = {
        0xd8, 0xb4, 0x79, 0x02, 0xba, 0xae, 0xaf, 0xb3,
        0x42, 0x03, 0x05, 0x15, 0x29, 0xaf, 0x28, 0x2e
 };
-static const u8 enc_assoc055[] __initconst = {
+static const u8 enc_assoc055[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_nonce055[] __initconst = {
+static const u8 enc_nonce055[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key055[] __initconst = {
+static const u8 enc_key055[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3145,13 +3144,13 @@ static const u8 enc_key055[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input056[] __initconst = {
+static const u8 enc_input056[] = {
        0xda, 0x92, 0xbf, 0x77, 0x7f, 0x6b, 0xe8, 0x7c,
        0xaa, 0x2c, 0xfb, 0x7b, 0x9b, 0xbc, 0x01, 0x17,
        0x20, 0x66, 0xb8, 0xfc, 0xfc, 0x04, 0xc4, 0x84,
        0x7f, 0x1f, 0xcf, 0x41, 0x14, 0x2c, 0xd6, 0x41
 };
-static const u8 enc_output056[] __initconst = {
+static const u8 enc_output056[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3159,14 +3158,14 @@ static const u8 enc_output056[] __initconst = {
        0xb3, 0x89, 0x1c, 0x84, 0x9c, 0xb5, 0x2c, 0x27,
        0x74, 0x7e, 0xdf, 0xcf, 0x31, 0x21, 0x3b, 0xb6
 };
-static const u8 enc_assoc056[] __initconst = {
+static const u8 enc_assoc056[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce056[] __initconst = {
+static const u8 enc_nonce056[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key056[] __initconst = {
+static const u8 enc_key056[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3174,7 +3173,7 @@ static const u8 enc_key056[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input057[] __initconst = {
+static const u8 enc_input057[] = {
        0xda, 0x92, 0xbf, 0x77, 0x7f, 0x6b, 0xe8, 0x7c,
        0xaa, 0x2c, 0xfb, 0x7b, 0x9b, 0xbc, 0x01, 0x17,
        0x20, 0x66, 0xb8, 0xfc, 0xfc, 0x04, 0xc4, 0x84,
@@ -3184,7 +3183,7 @@ static const u8 enc_input057[] __initconst = {
        0xf7, 0x96, 0x00, 0x2d, 0x13, 0xa1, 0xd9, 0x1a,
        0xac, 0x48, 0x4d, 0xd8, 0x01, 0x78, 0x02, 0x42
 };
-static const u8 enc_output057[] __initconst = {
+static const u8 enc_output057[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3196,14 +3195,14 @@ static const u8 enc_output057[] __initconst = {
        0xf0, 0xc1, 0x2d, 0x26, 0xef, 0x03, 0x02, 0x9b,
        0x62, 0xc0, 0x08, 0xda, 0x27, 0xc5, 0xdc, 0x68
 };
-static const u8 enc_assoc057[] __initconst = {
+static const u8 enc_assoc057[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce057[] __initconst = {
+static const u8 enc_nonce057[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key057[] __initconst = {
+static const u8 enc_key057[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3211,7 +3210,7 @@ static const u8 enc_key057[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input058[] __initconst = {
+static const u8 enc_input058[] = {
        0xda, 0x92, 0xbf, 0x77, 0x7f, 0x6b, 0xe8, 0x7c,
        0xaa, 0x2c, 0xfb, 0x7b, 0x9b, 0xbc, 0x01, 0x17,
        0x20, 0x66, 0xb8, 0xfc, 0xfc, 0x04, 0xc4, 0x84,
@@ -3229,7 +3228,7 @@ static const u8 enc_input058[] __initconst = {
        0x88, 0x2c, 0xf4, 0x3a, 0x89, 0x6d, 0x12, 0xc7,
        0x04, 0x53, 0xfe, 0x77, 0xc7, 0xfb, 0x77, 0x38
 };
-static const u8 enc_output058[] __initconst = {
+static const u8 enc_output058[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3249,14 +3248,14 @@ static const u8 enc_output058[] __initconst = {
        0xee, 0x65, 0x78, 0x30, 0x01, 0xc2, 0x56, 0x91,
        0xfa, 0x28, 0xd0, 0xf5, 0xf1, 0xc1, 0xd7, 0x62
 };
-static const u8 enc_assoc058[] __initconst = {
+static const u8 enc_assoc058[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce058[] __initconst = {
+static const u8 enc_nonce058[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key058[] __initconst = {
+static const u8 enc_key058[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3264,13 +3263,13 @@ static const u8 enc_key058[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input059[] __initconst = {
+static const u8 enc_input059[] = {
        0x25, 0x6d, 0x40, 0x08, 0x80, 0x94, 0x17, 0x03,
        0x55, 0xd3, 0x04, 0x04, 0x64, 0x43, 0xfe, 0x68,
        0xdf, 0x99, 0x47, 0x83, 0x03, 0xfb, 0x3b, 0xfb,
        0x80, 0xe0, 0x30, 0x3e, 0xeb, 0xd3, 0x29, 0x3e
 };
-static const u8 enc_output059[] __initconst = {
+static const u8 enc_output059[] = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
@@ -3278,14 +3277,14 @@ static const u8 enc_output059[] __initconst = {
        0x79, 0xba, 0x7a, 0x29, 0xf5, 0xa7, 0xbb, 0x75,
        0x79, 0x7a, 0xf8, 0x7a, 0x61, 0x01, 0x29, 0xa4
 };
-static const u8 enc_assoc059[] __initconst = {
+static const u8 enc_assoc059[] = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80
 };
-static const u8 enc_nonce059[] __initconst = {
+static const u8 enc_nonce059[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key059[] __initconst = {
+static const u8 enc_key059[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3293,7 +3292,7 @@ static const u8 enc_key059[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input060[] __initconst = {
+static const u8 enc_input060[] = {
        0x25, 0x6d, 0x40, 0x08, 0x80, 0x94, 0x17, 0x03,
        0x55, 0xd3, 0x04, 0x04, 0x64, 0x43, 0xfe, 0x68,
        0xdf, 0x99, 0x47, 0x83, 0x03, 0xfb, 0x3b, 0xfb,
@@ -3303,7 +3302,7 @@ static const u8 enc_input060[] __initconst = {
        0x08, 0x69, 0xff, 0x52, 0xec, 0x5e, 0x26, 0x65,
        0x53, 0xb7, 0xb2, 0xa7, 0xfe, 0x87, 0xfd, 0x3d
 };
-static const u8 enc_output060[] __initconst = {
+static const u8 enc_output060[] = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
@@ -3315,14 +3314,14 @@ static const u8 enc_output060[] __initconst = {
        0x36, 0xb1, 0x74, 0x38, 0x19, 0xe1, 0xb9, 0xba,
        0x15, 0x51, 0xe8, 0xed, 0x92, 0x2a, 0x95, 0x9a
 };
-static const u8 enc_assoc060[] __initconst = {
+static const u8 enc_assoc060[] = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80
 };
-static const u8 enc_nonce060[] __initconst = {
+static const u8 enc_nonce060[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key060[] __initconst = {
+static const u8 enc_key060[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3330,7 +3329,7 @@ static const u8 enc_key060[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input061[] __initconst = {
+static const u8 enc_input061[] = {
        0x25, 0x6d, 0x40, 0x08, 0x80, 0x94, 0x17, 0x03,
        0x55, 0xd3, 0x04, 0x04, 0x64, 0x43, 0xfe, 0x68,
        0xdf, 0x99, 0x47, 0x83, 0x03, 0xfb, 0x3b, 0xfb,
@@ -3348,7 +3347,7 @@ static const u8 enc_input061[] __initconst = {
        0x77, 0xd3, 0x0b, 0x45, 0x76, 0x92, 0xed, 0xb8,
        0xfb, 0xac, 0x01, 0x08, 0x38, 0x04, 0x88, 0x47
 };
-static const u8 enc_output061[] __initconst = {
+static const u8 enc_output061[] = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
@@ -3368,14 +3367,14 @@ static const u8 enc_output061[] __initconst = {
        0xfe, 0xac, 0x49, 0x55, 0x55, 0x4e, 0x80, 0x6f,
        0x3a, 0x19, 0x02, 0xe2, 0x44, 0x32, 0xc0, 0x8a
 };
-static const u8 enc_assoc061[] __initconst = {
+static const u8 enc_assoc061[] = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80
 };
-static const u8 enc_nonce061[] __initconst = {
+static const u8 enc_nonce061[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key061[] __initconst = {
+static const u8 enc_key061[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3383,13 +3382,13 @@ static const u8 enc_key061[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input062[] __initconst = {
+static const u8 enc_input062[] = {
        0xda, 0x92, 0xbf, 0xf7, 0x7f, 0x6b, 0xe8, 0xfc,
        0xaa, 0x2c, 0xfb, 0xfb, 0x9b, 0xbc, 0x01, 0x97,
        0x20, 0x66, 0xb8, 0x7c, 0xfc, 0x04, 0xc4, 0x04,
        0x7f, 0x1f, 0xcf, 0xc1, 0x14, 0x2c, 0xd6, 0xc1
 };
-static const u8 enc_output062[] __initconst = {
+static const u8 enc_output062[] = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
@@ -3397,14 +3396,14 @@ static const u8 enc_output062[] __initconst = {
        0x20, 0xa3, 0x79, 0x8d, 0xf1, 0x29, 0x2c, 0x59,
        0x72, 0xbf, 0x97, 0x41, 0xae, 0xc3, 0x8a, 0x19
 };
-static const u8 enc_assoc062[] __initconst = {
+static const u8 enc_assoc062[] = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f
 };
-static const u8 enc_nonce062[] __initconst = {
+static const u8 enc_nonce062[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key062[] __initconst = {
+static const u8 enc_key062[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3412,7 +3411,7 @@ static const u8 enc_key062[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input063[] __initconst = {
+static const u8 enc_input063[] = {
        0xda, 0x92, 0xbf, 0xf7, 0x7f, 0x6b, 0xe8, 0xfc,
        0xaa, 0x2c, 0xfb, 0xfb, 0x9b, 0xbc, 0x01, 0x97,
        0x20, 0x66, 0xb8, 0x7c, 0xfc, 0x04, 0xc4, 0x04,
@@ -3422,7 +3421,7 @@ static const u8 enc_input063[] __initconst = {
        0xf7, 0x96, 0x00, 0xad, 0x13, 0xa1, 0xd9, 0x9a,
        0xac, 0x48, 0x4d, 0x58, 0x01, 0x78, 0x02, 0xc2
 };
-static const u8 enc_output063[] __initconst = {
+static const u8 enc_output063[] = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
@@ -3434,14 +3433,14 @@ static const u8 enc_output063[] __initconst = {
        0xc0, 0x3d, 0x9f, 0x67, 0x35, 0x4a, 0x97, 0xb2,
        0xf0, 0x74, 0xf7, 0x55, 0x15, 0x57, 0xe4, 0x9c
 };
-static const u8 enc_assoc063[] __initconst = {
+static const u8 enc_assoc063[] = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f
 };
-static const u8 enc_nonce063[] __initconst = {
+static const u8 enc_nonce063[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key063[] __initconst = {
+static const u8 enc_key063[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3449,7 +3448,7 @@ static const u8 enc_key063[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input064[] __initconst = {
+static const u8 enc_input064[] = {
        0xda, 0x92, 0xbf, 0xf7, 0x7f, 0x6b, 0xe8, 0xfc,
        0xaa, 0x2c, 0xfb, 0xfb, 0x9b, 0xbc, 0x01, 0x97,
        0x20, 0x66, 0xb8, 0x7c, 0xfc, 0x04, 0xc4, 0x04,
@@ -3467,7 +3466,7 @@ static const u8 enc_input064[] __initconst = {
        0x88, 0x2c, 0xf4, 0xba, 0x89, 0x6d, 0x12, 0x47,
        0x04, 0x53, 0xfe, 0xf7, 0xc7, 0xfb, 0x77, 0xb8
 };
-static const u8 enc_output064[] __initconst = {
+static const u8 enc_output064[] = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
@@ -3487,14 +3486,14 @@ static const u8 enc_output064[] __initconst = {
        0xc8, 0x6d, 0xa8, 0xdd, 0x65, 0x22, 0x86, 0xd5,
        0x02, 0x13, 0xd3, 0x28, 0xd6, 0x3e, 0x40, 0x06
 };
-static const u8 enc_assoc064[] __initconst = {
+static const u8 enc_assoc064[] = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f
 };
-static const u8 enc_nonce064[] __initconst = {
+static const u8 enc_nonce064[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key064[] __initconst = {
+static const u8 enc_key064[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3502,13 +3501,13 @@ static const u8 enc_key064[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input065[] __initconst = {
+static const u8 enc_input065[] = {
        0x5a, 0x92, 0xbf, 0x77, 0xff, 0x6b, 0xe8, 0x7c,
        0x2a, 0x2c, 0xfb, 0x7b, 0x1b, 0xbc, 0x01, 0x17,
        0xa0, 0x66, 0xb8, 0xfc, 0x7c, 0x04, 0xc4, 0x84,
        0xff, 0x1f, 0xcf, 0x41, 0x94, 0x2c, 0xd6, 0x41
 };
-static const u8 enc_output065[] __initconst = {
+static const u8 enc_output065[] = {
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
@@ -3516,14 +3515,14 @@ static const u8 enc_output065[] __initconst = {
        0xbe, 0xde, 0x90, 0x83, 0xce, 0xb3, 0x6d, 0xdf,
        0xe5, 0xfa, 0x81, 0x1f, 0x95, 0x47, 0x1c, 0x67
 };
-static const u8 enc_assoc065[] __initconst = {
+static const u8 enc_assoc065[] = {
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce065[] __initconst = {
+static const u8 enc_nonce065[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key065[] __initconst = {
+static const u8 enc_key065[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3531,7 +3530,7 @@ static const u8 enc_key065[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input066[] __initconst = {
+static const u8 enc_input066[] = {
        0x5a, 0x92, 0xbf, 0x77, 0xff, 0x6b, 0xe8, 0x7c,
        0x2a, 0x2c, 0xfb, 0x7b, 0x1b, 0xbc, 0x01, 0x17,
        0xa0, 0x66, 0xb8, 0xfc, 0x7c, 0x04, 0xc4, 0x84,
@@ -3541,7 +3540,7 @@ static const u8 enc_input066[] __initconst = {
        0x77, 0x96, 0x00, 0x2d, 0x93, 0xa1, 0xd9, 0x1a,
        0x2c, 0x48, 0x4d, 0xd8, 0x81, 0x78, 0x02, 0x42
 };
-static const u8 enc_output066[] __initconst = {
+static const u8 enc_output066[] = {
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
@@ -3553,14 +3552,14 @@ static const u8 enc_output066[] __initconst = {
        0x30, 0x08, 0x74, 0xbb, 0x06, 0x92, 0xb6, 0x89,
        0xde, 0xad, 0x9a, 0xe1, 0x5b, 0x06, 0x73, 0x90
 };
-static const u8 enc_assoc066[] __initconst = {
+static const u8 enc_assoc066[] = {
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce066[] __initconst = {
+static const u8 enc_nonce066[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key066[] __initconst = {
+static const u8 enc_key066[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3568,7 +3567,7 @@ static const u8 enc_key066[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input067[] __initconst = {
+static const u8 enc_input067[] = {
        0x5a, 0x92, 0xbf, 0x77, 0xff, 0x6b, 0xe8, 0x7c,
        0x2a, 0x2c, 0xfb, 0x7b, 0x1b, 0xbc, 0x01, 0x17,
        0xa0, 0x66, 0xb8, 0xfc, 0x7c, 0x04, 0xc4, 0x84,
@@ -3586,7 +3585,7 @@ static const u8 enc_input067[] __initconst = {
        0x08, 0x2c, 0xf4, 0x3a, 0x09, 0x6d, 0x12, 0xc7,
        0x84, 0x53, 0xfe, 0x77, 0x47, 0xfb, 0x77, 0x38
 };
-static const u8 enc_output067[] __initconst = {
+static const u8 enc_output067[] = {
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
@@ -3606,14 +3605,14 @@ static const u8 enc_output067[] __initconst = {
        0x99, 0xca, 0xd8, 0x5f, 0x45, 0xca, 0x40, 0x94,
        0x2d, 0x0d, 0x4d, 0x5e, 0x95, 0x0a, 0xde, 0x22
 };
-static const u8 enc_assoc067[] __initconst = {
+static const u8 enc_assoc067[] = {
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff,
        0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce067[] __initconst = {
+static const u8 enc_nonce067[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key067[] __initconst = {
+static const u8 enc_key067[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3621,13 +3620,13 @@ static const u8 enc_key067[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input068[] __initconst = {
+static const u8 enc_input068[] = {
        0x25, 0x6d, 0x40, 0x88, 0x7f, 0x6b, 0xe8, 0x7c,
        0x55, 0xd3, 0x04, 0x84, 0x9b, 0xbc, 0x01, 0x17,
        0xdf, 0x99, 0x47, 0x03, 0xfc, 0x04, 0xc4, 0x84,
        0x80, 0xe0, 0x30, 0xbe, 0x14, 0x2c, 0xd6, 0x41
 };
-static const u8 enc_output068[] __initconst = {
+static const u8 enc_output068[] = {
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
@@ -3635,14 +3634,14 @@ static const u8 enc_output068[] __initconst = {
        0x8b, 0xbe, 0x14, 0x52, 0x72, 0xe7, 0xc2, 0xd9,
        0xa1, 0x89, 0x1a, 0x3a, 0xb0, 0x98, 0x3d, 0x9d
 };
-static const u8 enc_assoc068[] __initconst = {
+static const u8 enc_assoc068[] = {
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce068[] __initconst = {
+static const u8 enc_nonce068[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key068[] __initconst = {
+static const u8 enc_key068[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3650,7 +3649,7 @@ static const u8 enc_key068[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input069[] __initconst = {
+static const u8 enc_input069[] = {
        0x25, 0x6d, 0x40, 0x88, 0x7f, 0x6b, 0xe8, 0x7c,
        0x55, 0xd3, 0x04, 0x84, 0x9b, 0xbc, 0x01, 0x17,
        0xdf, 0x99, 0x47, 0x03, 0xfc, 0x04, 0xc4, 0x84,
@@ -3660,7 +3659,7 @@ static const u8 enc_input069[] __initconst = {
        0x08, 0x69, 0xff, 0xd2, 0x13, 0xa1, 0xd9, 0x1a,
        0x53, 0xb7, 0xb2, 0x27, 0x01, 0x78, 0x02, 0x42
 };
-static const u8 enc_output069[] __initconst = {
+static const u8 enc_output069[] = {
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
@@ -3672,14 +3671,14 @@ static const u8 enc_output069[] __initconst = {
        0x3b, 0x41, 0x86, 0x19, 0x13, 0xa8, 0xf6, 0xde,
        0x7f, 0x61, 0xe2, 0x25, 0x63, 0x1b, 0xc3, 0x82
 };
-static const u8 enc_assoc069[] __initconst = {
+static const u8 enc_assoc069[] = {
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce069[] __initconst = {
+static const u8 enc_nonce069[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key069[] __initconst = {
+static const u8 enc_key069[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3687,7 +3686,7 @@ static const u8 enc_key069[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input070[] __initconst = {
+static const u8 enc_input070[] = {
        0x25, 0x6d, 0x40, 0x88, 0x7f, 0x6b, 0xe8, 0x7c,
        0x55, 0xd3, 0x04, 0x84, 0x9b, 0xbc, 0x01, 0x17,
        0xdf, 0x99, 0x47, 0x03, 0xfc, 0x04, 0xc4, 0x84,
@@ -3705,7 +3704,7 @@ static const u8 enc_input070[] __initconst = {
        0x77, 0xd3, 0x0b, 0xc5, 0x89, 0x6d, 0x12, 0xc7,
        0xfb, 0xac, 0x01, 0x88, 0xc7, 0xfb, 0x77, 0x38
 };
-static const u8 enc_output070[] __initconst = {
+static const u8 enc_output070[] = {
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
@@ -3725,14 +3724,14 @@ static const u8 enc_output070[] __initconst = {
        0x84, 0x28, 0xbc, 0xf0, 0x23, 0xec, 0x6b, 0xf3,
        0x1f, 0xd9, 0xef, 0xb2, 0x03, 0xff, 0x08, 0x71
 };
-static const u8 enc_assoc070[] __initconst = {
+static const u8 enc_assoc070[] = {
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce070[] __initconst = {
+static const u8 enc_nonce070[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key070[] __initconst = {
+static const u8 enc_key070[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3740,13 +3739,13 @@ static const u8 enc_key070[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input071[] __initconst = {
+static const u8 enc_input071[] = {
        0xda, 0x92, 0xbf, 0x77, 0x80, 0x94, 0x17, 0x83,
        0xaa, 0x2c, 0xfb, 0x7b, 0x64, 0x43, 0xfe, 0xe8,
        0x20, 0x66, 0xb8, 0xfc, 0x03, 0xfb, 0x3b, 0x7b,
        0x7f, 0x1f, 0xcf, 0x41, 0xeb, 0xd3, 0x29, 0xbe
 };
-static const u8 enc_output071[] __initconst = {
+static const u8 enc_output071[] = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
@@ -3754,14 +3753,14 @@ static const u8 enc_output071[] __initconst = {
        0x13, 0x9f, 0xdf, 0x64, 0x74, 0xea, 0x24, 0xf5,
        0x49, 0xb0, 0x75, 0x82, 0x5f, 0x2c, 0x76, 0x20
 };
-static const u8 enc_assoc071[] __initconst = {
+static const u8 enc_assoc071[] = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_nonce071[] __initconst = {
+static const u8 enc_nonce071[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key071[] __initconst = {
+static const u8 enc_key071[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3769,7 +3768,7 @@ static const u8 enc_key071[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input072[] __initconst = {
+static const u8 enc_input072[] = {
        0xda, 0x92, 0xbf, 0x77, 0x80, 0x94, 0x17, 0x83,
        0xaa, 0x2c, 0xfb, 0x7b, 0x64, 0x43, 0xfe, 0xe8,
        0x20, 0x66, 0xb8, 0xfc, 0x03, 0xfb, 0x3b, 0x7b,
@@ -3779,7 +3778,7 @@ static const u8 enc_input072[] __initconst = {
        0xf7, 0x96, 0x00, 0x2d, 0xec, 0x5e, 0x26, 0xe5,
        0xac, 0x48, 0x4d, 0xd8, 0xfe, 0x87, 0xfd, 0xbd
 };
-static const u8 enc_output072[] __initconst = {
+static const u8 enc_output072[] = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
@@ -3791,14 +3790,14 @@ static const u8 enc_output072[] __initconst = {
        0xbb, 0xad, 0x8d, 0x86, 0x3b, 0x83, 0x5a, 0x8e,
        0x86, 0x64, 0xfd, 0x1d, 0x45, 0x66, 0xb6, 0xb4
 };
-static const u8 enc_assoc072[] __initconst = {
+static const u8 enc_assoc072[] = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_nonce072[] __initconst = {
+static const u8 enc_nonce072[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key072[] __initconst = {
+static const u8 enc_key072[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3806,7 +3805,7 @@ static const u8 enc_key072[] __initconst = {
 };
 
 /* wycheproof - misc */
-static const u8 enc_input073[] __initconst = {
+static const u8 enc_input073[] = {
        0xda, 0x92, 0xbf, 0x77, 0x80, 0x94, 0x17, 0x83,
        0xaa, 0x2c, 0xfb, 0x7b, 0x64, 0x43, 0xfe, 0xe8,
        0x20, 0x66, 0xb8, 0xfc, 0x03, 0xfb, 0x3b, 0x7b,
@@ -3824,7 +3823,7 @@ static const u8 enc_input073[] __initconst = {
        0x88, 0x2c, 0xf4, 0x3a, 0x76, 0x92, 0xed, 0x38,
        0x04, 0x53, 0xfe, 0x77, 0x38, 0x04, 0x88, 0xc7
 };
-static const u8 enc_output073[] __initconst = {
+static const u8 enc_output073[] = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
@@ -3844,14 +3843,14 @@ static const u8 enc_output073[] __initconst = {
        0x42, 0xf2, 0x35, 0x42, 0x97, 0x84, 0x9a, 0x51,
        0x1d, 0x53, 0xe5, 0x57, 0x17, 0x72, 0xf7, 0x1f
 };
-static const u8 enc_assoc073[] __initconst = {
+static const u8 enc_assoc073[] = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_nonce073[] __initconst = {
+static const u8 enc_nonce073[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0xee, 0x32, 0x00
 };
-static const u8 enc_key073[] __initconst = {
+static const u8 enc_key073[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -3859,7 +3858,7 @@ static const u8 enc_key073[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input074[] __initconst = {
+static const u8 enc_input074[] = {
        0xd4, 0x50, 0x0b, 0xf0, 0x09, 0x49, 0x35, 0x51,
        0xc3, 0x80, 0xad, 0xf5, 0x2c, 0x57, 0x3a, 0x69,
        0xdf, 0x7e, 0x8b, 0x76, 0x24, 0x63, 0x33, 0x0f,
@@ -3877,7 +3876,7 @@ static const u8 enc_input074[] __initconst = {
        0x93, 0x76, 0x71, 0xa0, 0x62, 0x9b, 0xd9, 0x5c,
        0x99, 0x15, 0xc7, 0x85, 0x55, 0x77, 0x1e, 0x7a
 };
-static const u8 enc_output074[] __initconst = {
+static const u8 enc_output074[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3897,7 +3896,7 @@ static const u8 enc_output074[] __initconst = {
        0x0b, 0x30, 0x0d, 0x8d, 0xa5, 0x6c, 0x21, 0x85,
        0x75, 0x52, 0x79, 0x55, 0x3c, 0x4c, 0x82, 0xca
 };
-static const u8 enc_assoc074[] __initconst = {
+static const u8 enc_assoc074[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3907,11 +3906,11 @@ static const u8 enc_assoc074[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce074[] __initconst = {
+static const u8 enc_nonce074[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x00, 0x02, 0x50, 0x6e
 };
-static const u8 enc_key074[] __initconst = {
+static const u8 enc_key074[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -3919,7 +3918,7 @@ static const u8 enc_key074[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input075[] __initconst = {
+static const u8 enc_input075[] = {
        0x7d, 0xe8, 0x7f, 0x67, 0x29, 0x94, 0x52, 0x75,
        0xd0, 0x65, 0x5d, 0xa4, 0xc7, 0xfd, 0xe4, 0x56,
        0x9e, 0x16, 0xf1, 0x11, 0xb5, 0xeb, 0x26, 0xc2,
@@ -3937,7 +3936,7 @@ static const u8 enc_input075[] __initconst = {
        0x3a, 0xc1, 0xee, 0x54, 0xc2, 0x9e, 0xe4, 0xc1,
        0x70, 0xde, 0x40, 0x8f, 0x66, 0x69, 0x21, 0x94
 };
-static const u8 enc_output075[] __initconst = {
+static const u8 enc_output075[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3957,7 +3956,7 @@ static const u8 enc_output075[] __initconst = {
        0xc5, 0x78, 0xe2, 0xaa, 0x44, 0xd3, 0x09, 0xb7,
        0xb6, 0xa5, 0x19, 0x3b, 0xdc, 0x61, 0x18, 0xf5
 };
-static const u8 enc_assoc075[] __initconst = {
+static const u8 enc_assoc075[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -3967,11 +3966,11 @@ static const u8 enc_assoc075[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce075[] __initconst = {
+static const u8 enc_nonce075[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x00, 0x03, 0x18, 0xa5
 };
-static const u8 enc_key075[] __initconst = {
+static const u8 enc_key075[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -3979,7 +3978,7 @@ static const u8 enc_key075[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input076[] __initconst = {
+static const u8 enc_input076[] = {
        0x1b, 0x99, 0x6f, 0x9a, 0x3c, 0xcc, 0x67, 0x85,
        0xde, 0x22, 0xff, 0x5b, 0x8a, 0xdd, 0x95, 0x02,
        0xce, 0x03, 0xa0, 0xfa, 0xf5, 0x99, 0x2a, 0x09,
@@ -3997,7 +3996,7 @@ static const u8 enc_input076[] __initconst = {
        0xc3, 0x53, 0xd0, 0xcf, 0x93, 0x8d, 0xcc, 0xb9,
        0xef, 0xad, 0x8f, 0xed, 0xbe, 0x46, 0xda, 0xa5
 };
-static const u8 enc_output076[] __initconst = {
+static const u8 enc_output076[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4017,7 +4016,7 @@ static const u8 enc_output076[] __initconst = {
        0x4b, 0x0b, 0xda, 0x8a, 0xd0, 0x43, 0x83, 0x0d,
        0x83, 0x19, 0xab, 0x82, 0xc5, 0x0c, 0x76, 0x63
 };
-static const u8 enc_assoc076[] __initconst = {
+static const u8 enc_assoc076[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4027,10 +4026,10 @@ static const u8 enc_assoc076[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce076[] __initconst = {
+static const u8 enc_nonce076[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xb4, 0xf0
 };
-static const u8 enc_key076[] __initconst = {
+static const u8 enc_key076[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -4038,7 +4037,7 @@ static const u8 enc_key076[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input077[] __initconst = {
+static const u8 enc_input077[] = {
        0x86, 0xcb, 0xac, 0xae, 0x4d, 0x3f, 0x74, 0xae,
        0x01, 0x21, 0x3e, 0x05, 0x51, 0xcc, 0x15, 0x16,
        0x0e, 0xa1, 0xbe, 0x84, 0x08, 0xe3, 0xd5, 0xd7,
@@ -4056,7 +4055,7 @@ static const u8 enc_input077[] __initconst = {
        0x0e, 0x76, 0x2b, 0x43, 0x0c, 0x4d, 0x51, 0x7c,
        0x97, 0x10, 0x70, 0x68, 0xf4, 0x98, 0xef, 0x7f
 };
-static const u8 enc_output077[] __initconst = {
+static const u8 enc_output077[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4076,7 +4075,7 @@ static const u8 enc_output077[] __initconst = {
        0x4b, 0xc9, 0x8f, 0x72, 0xc4, 0x94, 0xc2, 0xa4,
        0x3c, 0x2b, 0x15, 0xa1, 0x04, 0x3f, 0x1c, 0xfa
 };
-static const u8 enc_assoc077[] __initconst = {
+static const u8 enc_assoc077[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4086,10 +4085,10 @@ static const u8 enc_assoc077[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce077[] __initconst = {
+static const u8 enc_nonce077[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xfb, 0x66
 };
-static const u8 enc_key077[] __initconst = {
+static const u8 enc_key077[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -4097,7 +4096,7 @@ static const u8 enc_key077[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input078[] __initconst = {
+static const u8 enc_input078[] = {
        0xfa, 0xb1, 0xcd, 0xdf, 0x4f, 0xe1, 0x98, 0xef,
        0x63, 0xad, 0xd8, 0x81, 0xd6, 0xea, 0xd6, 0xc5,
        0x76, 0x37, 0xbb, 0xe9, 0x20, 0x18, 0xca, 0x7c,
@@ -4115,7 +4114,7 @@ static const u8 enc_input078[] __initconst = {
        0xc3, 0x24, 0x60, 0x41, 0x43, 0x21, 0x43, 0xe9,
        0xab, 0x3a, 0x6d, 0x2c, 0xcc, 0x2f, 0x4d, 0x62
 };
-static const u8 enc_output078[] __initconst = {
+static const u8 enc_output078[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4135,7 +4134,7 @@ static const u8 enc_output078[] __initconst = {
        0xf7, 0xe9, 0xe1, 0x51, 0xb0, 0x25, 0x33, 0xc7,
        0x46, 0x58, 0xbf, 0xc7, 0x73, 0x7c, 0x68, 0x0d
 };
-static const u8 enc_assoc078[] __initconst = {
+static const u8 enc_assoc078[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4145,10 +4144,10 @@ static const u8 enc_assoc078[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce078[] __initconst = {
+static const u8 enc_nonce078[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xbb, 0x90
 };
-static const u8 enc_key078[] __initconst = {
+static const u8 enc_key078[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -4156,7 +4155,7 @@ static const u8 enc_key078[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input079[] __initconst = {
+static const u8 enc_input079[] = {
        0x22, 0x72, 0x02, 0xbe, 0x7f, 0x35, 0x15, 0xe9,
        0xd1, 0xc0, 0x2e, 0xea, 0x2f, 0x19, 0x50, 0xb6,
        0x48, 0x1b, 0x04, 0x8a, 0x4c, 0x91, 0x50, 0x6c,
@@ -4174,7 +4173,7 @@ static const u8 enc_input079[] __initconst = {
        0xfb, 0xe1, 0xee, 0x45, 0xb1, 0xb2, 0x1f, 0x71,
        0x62, 0xe2, 0xfc, 0xaa, 0x74, 0x2a, 0xbe, 0xfd
 };
-static const u8 enc_output079[] __initconst = {
+static const u8 enc_output079[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4194,7 +4193,7 @@ static const u8 enc_output079[] __initconst = {
        0x79, 0x5b, 0xcf, 0xf6, 0x47, 0xc5, 0x53, 0xc2,
        0xe4, 0xeb, 0x6e, 0x0e, 0xaf, 0xd9, 0xe0, 0x4e
 };
-static const u8 enc_assoc079[] __initconst = {
+static const u8 enc_assoc079[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4204,10 +4203,10 @@ static const u8 enc_assoc079[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce079[] __initconst = {
+static const u8 enc_nonce079[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x48, 0x4a
 };
-static const u8 enc_key079[] __initconst = {
+static const u8 enc_key079[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -4215,7 +4214,7 @@ static const u8 enc_key079[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input080[] __initconst = {
+static const u8 enc_input080[] = {
        0xfa, 0xe5, 0x83, 0x45, 0xc1, 0x6c, 0xb0, 0xf5,
        0xcc, 0x53, 0x7f, 0x2b, 0x1b, 0x34, 0x69, 0xc9,
        0x69, 0x46, 0x3b, 0x3e, 0xa7, 0x1b, 0xcf, 0x6b,
@@ -4233,7 +4232,7 @@ static const u8 enc_input080[] __initconst = {
        0x18, 0x01, 0xce, 0x33, 0xc4, 0xe4, 0xa7, 0x7d,
        0x83, 0x1d, 0x3c, 0xe3, 0x4e, 0x84, 0x10, 0xe1
 };
-static const u8 enc_output080[] __initconst = {
+static const u8 enc_output080[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4253,7 +4252,7 @@ static const u8 enc_output080[] __initconst = {
        0x19, 0x46, 0xd6, 0x53, 0x96, 0x0f, 0x94, 0x7a,
        0x74, 0xd3, 0xe8, 0x09, 0x3c, 0xf4, 0x85, 0x02
 };
-static const u8 enc_assoc080[] __initconst = {
+static const u8 enc_assoc080[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4263,10 +4262,10 @@ static const u8 enc_assoc080[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce080[] __initconst = {
+static const u8 enc_nonce080[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x93, 0x2f, 0x40
 };
-static const u8 enc_key080[] __initconst = {
+static const u8 enc_key080[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -4274,7 +4273,7 @@ static const u8 enc_key080[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input081[] __initconst = {
+static const u8 enc_input081[] = {
        0xeb, 0xb2, 0x16, 0xdd, 0xd7, 0xca, 0x70, 0x92,
        0x15, 0xf5, 0x03, 0xdf, 0x9c, 0xe6, 0x3c, 0x5c,
        0xd2, 0x19, 0x4e, 0x7d, 0x90, 0x99, 0xe8, 0xa9,
@@ -4292,7 +4291,7 @@ static const u8 enc_input081[] __initconst = {
        0x83, 0xfd, 0xca, 0x39, 0xd2, 0xe1, 0x4f, 0x23,
        0xd0, 0x0a, 0x58, 0x26, 0x64, 0xf4, 0xec, 0xb1
 };
-static const u8 enc_output081[] __initconst = {
+static const u8 enc_output081[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4312,7 +4311,7 @@ static const u8 enc_output081[] __initconst = {
        0x36, 0xc3, 0x00, 0x29, 0x85, 0xdd, 0x21, 0xba,
        0xf8, 0x95, 0xd6, 0x33, 0x57, 0x3f, 0x12, 0xc0
 };
-static const u8 enc_assoc081[] __initconst = {
+static const u8 enc_assoc081[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4322,10 +4321,10 @@ static const u8 enc_assoc081[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce081[] __initconst = {
+static const u8 enc_nonce081[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x93, 0x35
 };
-static const u8 enc_key081[] __initconst = {
+static const u8 enc_key081[] = {
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
        0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
@@ -4333,7 +4332,7 @@ static const u8 enc_key081[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input082[] __initconst = {
+static const u8 enc_input082[] = {
        0x40, 0x8a, 0xe6, 0xef, 0x1c, 0x7e, 0xf0, 0xfb,
        0x2c, 0x2d, 0x61, 0x08, 0x16, 0xfc, 0x78, 0x49,
        0xef, 0xa5, 0x8f, 0x78, 0x27, 0x3f, 0x5f, 0x16,
@@ -4351,7 +4350,7 @@ static const u8 enc_input082[] __initconst = {
        0x2b, 0x68, 0x9f, 0x93, 0x55, 0xd9, 0xc1, 0x83,
        0x80, 0x1f, 0x6a, 0xcc, 0x31, 0x3f, 0x89, 0x07
 };
-static const u8 enc_output082[] __initconst = {
+static const u8 enc_output082[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4371,7 +4370,7 @@ static const u8 enc_output082[] __initconst = {
        0x65, 0x14, 0x51, 0x8e, 0x0a, 0x26, 0x41, 0x42,
        0xe0, 0xb7, 0x35, 0x1f, 0x96, 0x7f, 0xc2, 0xae
 };
-static const u8 enc_assoc082[] __initconst = {
+static const u8 enc_assoc082[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4381,10 +4380,10 @@ static const u8 enc_assoc082[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce082[] __initconst = {
+static const u8 enc_nonce082[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf7, 0xd5
 };
-static const u8 enc_key082[] __initconst = {
+static const u8 enc_key082[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4392,7 +4391,7 @@ static const u8 enc_key082[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input083[] __initconst = {
+static const u8 enc_input083[] = {
        0x0a, 0x0a, 0x24, 0x49, 0x9b, 0xca, 0xde, 0x58,
        0xcf, 0x15, 0x76, 0xc3, 0x12, 0xac, 0xa9, 0x84,
        0x71, 0x8c, 0xb4, 0xcc, 0x7e, 0x01, 0x53, 0xf5,
@@ -4410,7 +4409,7 @@ static const u8 enc_input083[] __initconst = {
        0xb3, 0x06, 0xa2, 0x1b, 0x42, 0xd4, 0xc3, 0xba,
        0x6e, 0x6f, 0x0c, 0xbc, 0xc8, 0x1e, 0x87, 0x7a
 };
-static const u8 enc_output083[] __initconst = {
+static const u8 enc_output083[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4430,7 +4429,7 @@ static const u8 enc_output083[] __initconst = {
        0x4c, 0x19, 0x4d, 0xa6, 0xa9, 0x9f, 0xd6, 0x5b,
        0x40, 0xe9, 0xca, 0xd7, 0x98, 0xf4, 0x4b, 0x19
 };
-static const u8 enc_assoc083[] __initconst = {
+static const u8 enc_assoc083[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4440,10 +4439,10 @@ static const u8 enc_assoc083[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce083[] __initconst = {
+static const u8 enc_nonce083[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xfc, 0xe4
 };
-static const u8 enc_key083[] __initconst = {
+static const u8 enc_key083[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4451,7 +4450,7 @@ static const u8 enc_key083[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input084[] __initconst = {
+static const u8 enc_input084[] = {
        0x4a, 0x0a, 0xaf, 0xf8, 0x49, 0x47, 0x29, 0x18,
        0x86, 0x91, 0x70, 0x13, 0x40, 0xf3, 0xce, 0x2b,
        0x8a, 0x78, 0xee, 0xd3, 0xa0, 0xf0, 0x65, 0x99,
@@ -4469,7 +4468,7 @@ static const u8 enc_input084[] __initconst = {
        0x5d, 0x7e, 0x51, 0x3b, 0xe5, 0xb8, 0xea, 0x97,
        0x13, 0x10, 0xd5, 0xbf, 0x16, 0xba, 0x7a, 0xee
 };
-static const u8 enc_output084[] __initconst = {
+static const u8 enc_output084[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4489,7 +4488,7 @@ static const u8 enc_output084[] __initconst = {
        0xc8, 0xae, 0x77, 0x88, 0xcd, 0x28, 0x74, 0xab,
        0xc1, 0x38, 0x54, 0x1e, 0x11, 0xfd, 0x05, 0x87
 };
-static const u8 enc_assoc084[] __initconst = {
+static const u8 enc_assoc084[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4499,10 +4498,10 @@ static const u8 enc_assoc084[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce084[] __initconst = {
+static const u8 enc_nonce084[] = {
        0x00, 0x00, 0x00, 0x00, 0x01, 0x84, 0x86, 0xa8
 };
-static const u8 enc_key084[] __initconst = {
+static const u8 enc_key084[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4510,7 +4509,7 @@ static const u8 enc_key084[] __initconst = {
 };
 
 /* wycheproof - checking for int overflows */
-static const u8 enc_input085[] __initconst = {
+static const u8 enc_input085[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x78, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -4528,7 +4527,7 @@ static const u8 enc_input085[] __initconst = {
        0xf7, 0x4d, 0x5b, 0xf8, 0x67, 0x1c, 0x5a, 0x8a,
        0x50, 0x92, 0xf6, 0x1d, 0x54, 0xc9, 0xaa, 0x5b
 };
-static const u8 enc_output085[] __initconst = {
+static const u8 enc_output085[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4548,7 +4547,7 @@ static const u8 enc_output085[] __initconst = {
        0x93, 0x3a, 0x51, 0x63, 0xc7, 0xf6, 0x23, 0x68,
        0x32, 0x7b, 0x3f, 0xbc, 0x10, 0x36, 0xc9, 0x43
 };
-static const u8 enc_assoc085[] __initconst = {
+static const u8 enc_assoc085[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4558,10 +4557,10 @@ static const u8 enc_assoc085[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce085[] __initconst = {
+static const u8 enc_nonce085[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key085[] __initconst = {
+static const u8 enc_key085[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4569,7 +4568,7 @@ static const u8 enc_key085[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input086[] __initconst = {
+static const u8 enc_input086[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4579,7 +4578,7 @@ static const u8 enc_input086[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output086[] __initconst = {
+static const u8 enc_output086[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4591,17 +4590,17 @@ static const u8 enc_output086[] __initconst = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 };
-static const u8 enc_assoc086[] __initconst = {
+static const u8 enc_assoc086[] = {
        0x85, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xa6, 0x90, 0x2f, 0xcb, 0xc8, 0x83, 0xbb, 0xc1,
        0x80, 0xb2, 0x56, 0xae, 0x34, 0xad, 0x7f, 0x00
 };
-static const u8 enc_nonce086[] __initconst = {
+static const u8 enc_nonce086[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key086[] __initconst = {
+static const u8 enc_key086[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4609,7 +4608,7 @@ static const u8 enc_key086[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input087[] __initconst = {
+static const u8 enc_input087[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4619,7 +4618,7 @@ static const u8 enc_input087[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output087[] __initconst = {
+static const u8 enc_output087[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4631,17 +4630,17 @@ static const u8 enc_output087[] __initconst = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_assoc087[] __initconst = {
+static const u8 enc_assoc087[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x24, 0x7e, 0x50, 0x64, 0x2a, 0x1c, 0x0a, 0x2f,
        0x8f, 0x77, 0x21, 0x96, 0x09, 0xdb, 0xa9, 0x58
 };
-static const u8 enc_nonce087[] __initconst = {
+static const u8 enc_nonce087[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key087[] __initconst = {
+static const u8 enc_key087[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4649,7 +4648,7 @@ static const u8 enc_key087[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input088[] __initconst = {
+static const u8 enc_input088[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4659,7 +4658,7 @@ static const u8 enc_input088[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output088[] __initconst = {
+static const u8 enc_output088[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4671,17 +4670,17 @@ static const u8 enc_output088[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_assoc088[] __initconst = {
+static const u8 enc_assoc088[] = {
        0x7c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xd9, 0xe7, 0x2c, 0x06, 0x4a, 0xc8, 0x96, 0x1f,
        0x3f, 0xa5, 0x85, 0xe0, 0xe2, 0xab, 0xd6, 0x00
 };
-static const u8 enc_nonce088[] __initconst = {
+static const u8 enc_nonce088[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key088[] __initconst = {
+static const u8 enc_key088[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4689,7 +4688,7 @@ static const u8 enc_key088[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input089[] __initconst = {
+static const u8 enc_input089[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4699,7 +4698,7 @@ static const u8 enc_input089[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output089[] __initconst = {
+static const u8 enc_output089[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4711,17 +4710,17 @@ static const u8 enc_output089[] __initconst = {
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80
 };
-static const u8 enc_assoc089[] __initconst = {
+static const u8 enc_assoc089[] = {
        0x65, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x95, 0xaf, 0x0f, 0x4d, 0x0b, 0x68, 0x6e, 0xae,
        0xcc, 0xca, 0x43, 0x07, 0xd5, 0x96, 0xf5, 0x02
 };
-static const u8 enc_nonce089[] __initconst = {
+static const u8 enc_nonce089[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key089[] __initconst = {
+static const u8 enc_key089[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4729,7 +4728,7 @@ static const u8 enc_key089[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input090[] __initconst = {
+static const u8 enc_input090[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4739,7 +4738,7 @@ static const u8 enc_input090[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output090[] __initconst = {
+static const u8 enc_output090[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4751,17 +4750,17 @@ static const u8 enc_output090[] __initconst = {
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f,
        0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f
 };
-static const u8 enc_assoc090[] __initconst = {
+static const u8 enc_assoc090[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x85, 0x40, 0xb4, 0x64, 0x35, 0x77, 0x07, 0xbe,
        0x3a, 0x39, 0xd5, 0x5c, 0x34, 0xf8, 0xbc, 0xb3
 };
-static const u8 enc_nonce090[] __initconst = {
+static const u8 enc_nonce090[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key090[] __initconst = {
+static const u8 enc_key090[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4769,7 +4768,7 @@ static const u8 enc_key090[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input091[] __initconst = {
+static const u8 enc_input091[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4779,7 +4778,7 @@ static const u8 enc_input091[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output091[] __initconst = {
+static const u8 enc_output091[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4791,17 +4790,17 @@ static const u8 enc_output091[] __initconst = {
        0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
 };
-static const u8 enc_assoc091[] __initconst = {
+static const u8 enc_assoc091[] = {
        0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x66, 0x23, 0xd9, 0x90, 0xb8, 0x98, 0xd8, 0x30,
        0xd2, 0x12, 0xaf, 0x23, 0x83, 0x33, 0x07, 0x01
 };
-static const u8 enc_nonce091[] __initconst = {
+static const u8 enc_nonce091[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key091[] __initconst = {
+static const u8 enc_key091[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4809,7 +4808,7 @@ static const u8 enc_key091[] __initconst = {
 };
 
 /* wycheproof - special case tag */
-static const u8 enc_input092[] __initconst = {
+static const u8 enc_input092[] = {
        0x9a, 0x49, 0xc4, 0x0f, 0x8b, 0x48, 0xd7, 0xc6,
        0x6d, 0x1d, 0xb4, 0xe5, 0x3f, 0x20, 0xf2, 0xdd,
        0x4a, 0xaa, 0x24, 0x1d, 0xda, 0xb2, 0x6b, 0x5b,
@@ -4819,7 +4818,7 @@ static const u8 enc_input092[] __initconst = {
        0xe7, 0x4a, 0x71, 0x52, 0x8e, 0xf5, 0x12, 0x63,
        0xce, 0x24, 0xe0, 0xd5, 0x75, 0xe0, 0xe4, 0x4d
 };
-static const u8 enc_output092[] __initconst = {
+static const u8 enc_output092[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4831,17 +4830,17 @@ static const u8 enc_output092[] __initconst = {
        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-static const u8 enc_assoc092[] __initconst = {
+static const u8 enc_assoc092[] = {
        0x83, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x5f, 0x16, 0xd0, 0x9f, 0x17, 0x78, 0x72, 0x11,
        0xb7, 0xd4, 0x84, 0xe0, 0x24, 0xf8, 0x97, 0x01
 };
-static const u8 enc_nonce092[] __initconst = {
+static const u8 enc_nonce092[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b
 };
-static const u8 enc_key092[] __initconst = {
+static const u8 enc_key092[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4849,7 +4848,7 @@ static const u8 enc_key092[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input093[] __initconst = {
+static const u8 enc_input093[] = {
        0x00, 0x52, 0x35, 0xd2, 0xa9, 0x19, 0xf2, 0x8d,
        0x3d, 0xb7, 0x66, 0x4a, 0x34, 0xae, 0x6b, 0x44,
        0x4d, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -4861,7 +4860,7 @@ static const u8 enc_input093[] __initconst = {
        0x83, 0xdc, 0xe9, 0xf3, 0x07, 0x3e, 0xfa, 0xdb,
        0x7d, 0x23, 0xb8, 0x7a, 0xce, 0x35, 0x16, 0x8c
 };
-static const u8 enc_output093[] __initconst = {
+static const u8 enc_output093[] = {
        0x00, 0x39, 0xe2, 0xfd, 0x2f, 0xd3, 0x12, 0x14,
        0x9e, 0x98, 0x98, 0x80, 0x88, 0x48, 0x13, 0xe7,
        0xca, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -4875,13 +4874,13 @@ static const u8 enc_output093[] __initconst = {
        0xa5, 0x19, 0xac, 0x1a, 0x35, 0xb4, 0xa5, 0x77,
        0x87, 0x51, 0x0a, 0xf7, 0x8d, 0x8d, 0x20, 0x0a
 };
-static const u8 enc_assoc093[] __initconst = {
+static const u8 enc_assoc093[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce093[] __initconst = {
+static const u8 enc_nonce093[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key093[] __initconst = {
+static const u8 enc_key093[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4889,7 +4888,7 @@ static const u8 enc_key093[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input094[] __initconst = {
+static const u8 enc_input094[] = {
        0xd3, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xe5, 0xda, 0x78, 0x76, 0x6f, 0xa1, 0x92, 0x90,
@@ -4903,7 +4902,7 @@ static const u8 enc_input094[] __initconst = {
        0x01, 0x49, 0xef, 0x50, 0x4b, 0x71, 0xb1, 0x20,
        0xca, 0x4f, 0xf3, 0x95, 0x19, 0xc2, 0xc2, 0x10
 };
-static const u8 enc_output094[] __initconst = {
+static const u8 enc_output094[] = {
        0xd3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x62, 0x18, 0xb2, 0x7f, 0x83, 0xb8, 0xb4, 0x66,
@@ -4919,13 +4918,13 @@ static const u8 enc_output094[] __initconst = {
        0x30, 0x2f, 0xe8, 0x2a, 0xb0, 0xa0, 0x9a, 0xf6,
        0x44, 0x00, 0xd0, 0x15, 0xae, 0x83, 0xd9, 0xcc
 };
-static const u8 enc_assoc094[] __initconst = {
+static const u8 enc_assoc094[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce094[] __initconst = {
+static const u8 enc_nonce094[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key094[] __initconst = {
+static const u8 enc_key094[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4933,7 +4932,7 @@ static const u8 enc_key094[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input095[] __initconst = {
+static const u8 enc_input095[] = {
        0xe9, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x6d, 0xf1, 0x39, 0x4e, 0xdc, 0x53, 0x9b, 0x5b,
@@ -4947,7 +4946,7 @@ static const u8 enc_input095[] __initconst = {
        0x99, 0x52, 0xae, 0x08, 0x18, 0xc3, 0x89, 0x79,
        0xc0, 0x74, 0x13, 0x71, 0x1a, 0x9a, 0xf7, 0x13
 };
-static const u8 enc_output095[] __initconst = {
+static const u8 enc_output095[] = {
        0xe9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xea, 0x33, 0xf3, 0x47, 0x30, 0x4a, 0xbd, 0xad,
@@ -4963,13 +4962,13 @@ static const u8 enc_output095[] __initconst = {
        0x98, 0xa7, 0xe8, 0x36, 0xe0, 0xee, 0x4d, 0x02,
        0x35, 0x00, 0xd0, 0x55, 0x7e, 0xc2, 0xcb, 0xe0
 };
-static const u8 enc_assoc095[] __initconst = {
+static const u8 enc_assoc095[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce095[] __initconst = {
+static const u8 enc_nonce095[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key095[] __initconst = {
+static const u8 enc_key095[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -4977,7 +4976,7 @@ static const u8 enc_key095[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input096[] __initconst = {
+static const u8 enc_input096[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x64, 0xf9, 0x0f, 0x5b, 0x26, 0x92, 0xb8, 0x60,
@@ -4987,7 +4986,7 @@ static const u8 enc_input096[] __initconst = {
        0x03, 0x35, 0x61, 0xe7, 0xca, 0xca, 0x6d, 0x94,
        0x1d, 0xc3, 0xcd, 0x69, 0x14, 0xad, 0x69, 0x04
 };
-static const u8 enc_output096[] __initconst = {
+static const u8 enc_output096[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xe3, 0x3b, 0xc5, 0x52, 0xca, 0x8b, 0x9e, 0x96,
@@ -4999,13 +4998,13 @@ static const u8 enc_output096[] __initconst = {
        0x6a, 0xb8, 0xdc, 0xe2, 0xc5, 0x9d, 0xa4, 0x73,
        0x71, 0x30, 0xb0, 0x25, 0x2f, 0x68, 0xa8, 0xd8
 };
-static const u8 enc_assoc096[] __initconst = {
+static const u8 enc_assoc096[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce096[] __initconst = {
+static const u8 enc_nonce096[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key096[] __initconst = {
+static const u8 enc_key096[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5013,7 +5012,7 @@ static const u8 enc_key096[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input097[] __initconst = {
+static const u8 enc_input097[] = {
        0x68, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xb0, 0x8f, 0x25, 0x67, 0x5b, 0x9b, 0xcb, 0xf6,
@@ -5027,7 +5026,7 @@ static const u8 enc_input097[] __initconst = {
        0x65, 0x0e, 0xc6, 0x2d, 0x75, 0x70, 0x72, 0xce,
        0xe6, 0xff, 0x23, 0x31, 0x86, 0xdd, 0x1c, 0x8f
 };
-static const u8 enc_output097[] __initconst = {
+static const u8 enc_output097[] = {
        0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x37, 0x4d, 0xef, 0x6e, 0xb7, 0x82, 0xed, 0x00,
@@ -5043,13 +5042,13 @@ static const u8 enc_output097[] __initconst = {
        0x04, 0x4d, 0xea, 0x60, 0x88, 0x80, 0x41, 0x2b,
        0xfd, 0xff, 0xcf, 0x35, 0x57, 0x9e, 0x9b, 0x26
 };
-static const u8 enc_assoc097[] __initconst = {
+static const u8 enc_assoc097[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce097[] __initconst = {
+static const u8 enc_nonce097[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key097[] __initconst = {
+static const u8 enc_key097[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5057,7 +5056,7 @@ static const u8 enc_key097[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input098[] __initconst = {
+static const u8 enc_input098[] = {
        0x6d, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xa1, 0x61, 0xb5, 0xab, 0x04, 0x09, 0x00, 0x62,
@@ -5071,7 +5070,7 @@ static const u8 enc_input098[] __initconst = {
        0x8e, 0xdc, 0x36, 0x6c, 0xd6, 0x97, 0x65, 0x6f,
        0xca, 0x81, 0xfb, 0x13, 0x3c, 0xed, 0x79, 0xa1
 };
-static const u8 enc_output098[] __initconst = {
+static const u8 enc_output098[] = {
        0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x26, 0xa3, 0x7f, 0xa2, 0xe8, 0x10, 0x26, 0x94,
@@ -5087,13 +5086,13 @@ static const u8 enc_output098[] __initconst = {
        0x1e, 0x6b, 0xea, 0x63, 0x14, 0x54, 0x2e, 0x2e,
        0xf9, 0xff, 0xcf, 0x45, 0x0b, 0x2e, 0x98, 0x2b
 };
-static const u8 enc_assoc098[] __initconst = {
+static const u8 enc_assoc098[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce098[] __initconst = {
+static const u8 enc_nonce098[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key098[] __initconst = {
+static const u8 enc_key098[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5101,7 +5100,7 @@ static const u8 enc_key098[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input099[] __initconst = {
+static const u8 enc_input099[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xfc, 0x01, 0xb8, 0x91, 0xe5, 0xf0, 0xf9, 0x12,
@@ -5111,7 +5110,7 @@ static const u8 enc_input099[] __initconst = {
        0x60, 0xcd, 0x9e, 0xa1, 0x0c, 0x29, 0xa3, 0x66,
        0x54, 0xe7, 0xa2, 0x8e, 0x76, 0x1b, 0xec, 0xd8
 };
-static const u8 enc_output099[] __initconst = {
+static const u8 enc_output099[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x7b, 0xc3, 0x72, 0x98, 0x09, 0xe9, 0xdf, 0xe4,
@@ -5123,13 +5122,13 @@ static const u8 enc_output099[] __initconst = {
        0xed, 0x20, 0x17, 0xc8, 0xdb, 0xa4, 0x77, 0x56,
        0x29, 0x04, 0x9d, 0x78, 0x6e, 0x3b, 0xce, 0xb1
 };
-static const u8 enc_assoc099[] __initconst = {
+static const u8 enc_assoc099[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce099[] __initconst = {
+static const u8 enc_nonce099[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key099[] __initconst = {
+static const u8 enc_key099[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5137,7 +5136,7 @@ static const u8 enc_key099[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input100[] __initconst = {
+static const u8 enc_input100[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x6b, 0x6d, 0xc9, 0xd2, 0x1a, 0x81, 0x9e, 0x70,
@@ -5147,7 +5146,7 @@ static const u8 enc_input100[] __initconst = {
        0x10, 0xb9, 0x2f, 0x5f, 0xfe, 0xf9, 0x8b, 0x84,
        0x7c, 0xf1, 0x7a, 0x9c, 0x98, 0xd8, 0x83, 0xe5
 };
-static const u8 enc_output100[] __initconst = {
+static const u8 enc_output100[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xec, 0xaf, 0x03, 0xdb, 0xf6, 0x98, 0xb8, 0x86,
@@ -5159,13 +5158,13 @@ static const u8 enc_output100[] __initconst = {
        0x07, 0x3f, 0x17, 0xcb, 0x67, 0x78, 0x64, 0x59,
        0x25, 0x04, 0x9d, 0x88, 0x22, 0xcb, 0xca, 0xb6
 };
-static const u8 enc_assoc100[] __initconst = {
+static const u8 enc_assoc100[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce100[] __initconst = {
+static const u8 enc_nonce100[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key100[] __initconst = {
+static const u8 enc_key100[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5173,7 +5172,7 @@ static const u8 enc_key100[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input101[] __initconst = {
+static const u8 enc_input101[] = {
        0xff, 0xcb, 0x2b, 0x11, 0x06, 0xf8, 0x23, 0x4c,
        0x5e, 0x99, 0xd4, 0xdb, 0x4c, 0x70, 0x48, 0xde,
        0x32, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5185,7 +5184,7 @@ static const u8 enc_input101[] __initconst = {
        0xce, 0xbe, 0xf5, 0xe9, 0x88, 0x5a, 0x80, 0xea,
        0x76, 0xd9, 0x75, 0xc1, 0x44, 0xa4, 0x18, 0x88
 };
-static const u8 enc_output101[] __initconst = {
+static const u8 enc_output101[] = {
        0xff, 0xa0, 0xfc, 0x3e, 0x80, 0x32, 0xc3, 0xd5,
        0xfd, 0xb6, 0x2a, 0x11, 0xf0, 0x96, 0x30, 0x7d,
        0xb5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5199,13 +5198,13 @@ static const u8 enc_output101[] __initconst = {
        0x8b, 0x9b, 0xb4, 0xb4, 0x86, 0x12, 0x89, 0x65,
        0x8c, 0x69, 0x6a, 0x83, 0x40, 0x15, 0x04, 0x05
 };
-static const u8 enc_assoc101[] __initconst = {
+static const u8 enc_assoc101[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce101[] __initconst = {
+static const u8 enc_nonce101[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key101[] __initconst = {
+static const u8 enc_key101[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5213,7 +5212,7 @@ static const u8 enc_key101[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input102[] __initconst = {
+static const u8 enc_input102[] = {
        0x6f, 0x9e, 0x70, 0xed, 0x3b, 0x8b, 0xac, 0xa0,
        0x26, 0xe4, 0x6a, 0x5a, 0x09, 0x43, 0x15, 0x8d,
        0x21, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5225,7 +5224,7 @@ static const u8 enc_input102[] __initconst = {
        0xd4, 0x36, 0x51, 0xfd, 0x14, 0x9c, 0x26, 0x0b,
        0xcb, 0xdd, 0x7b, 0x12, 0x68, 0x01, 0x31, 0x8c
 };
-static const u8 enc_output102[] __initconst = {
+static const u8 enc_output102[] = {
        0x6f, 0xf5, 0xa7, 0xc2, 0xbd, 0x41, 0x4c, 0x39,
        0x85, 0xcb, 0x94, 0x90, 0xb5, 0xa5, 0x6d, 0x2e,
        0xa6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5239,13 +5238,13 @@ static const u8 enc_output102[] __initconst = {
        0x8b, 0x3b, 0xbd, 0x51, 0x64, 0x44, 0x59, 0x56,
        0x8d, 0x81, 0xca, 0x1f, 0xa7, 0x2c, 0xe4, 0x04
 };
-static const u8 enc_assoc102[] __initconst = {
+static const u8 enc_assoc102[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce102[] __initconst = {
+static const u8 enc_nonce102[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key102[] __initconst = {
+static const u8 enc_key102[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5253,7 +5252,7 @@ static const u8 enc_key102[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input103[] __initconst = {
+static const u8 enc_input103[] = {
        0x41, 0x2b, 0x08, 0x0a, 0x3e, 0x19, 0xc1, 0x0d,
        0x44, 0xa1, 0xaf, 0x1e, 0xab, 0xde, 0xb4, 0xce,
        0x35, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5265,7 +5264,7 @@ static const u8 enc_input103[] __initconst = {
        0xb3, 0xd4, 0xe9, 0x90, 0x90, 0x34, 0xc6, 0x14,
        0xb1, 0x0a, 0xff, 0x55, 0x25, 0xd0, 0x9d, 0x8d
 };
-static const u8 enc_output103[] __initconst = {
+static const u8 enc_output103[] = {
        0x41, 0x40, 0xdf, 0x25, 0xb8, 0xd3, 0x21, 0x94,
        0xe7, 0x8e, 0x51, 0xd4, 0x17, 0x38, 0xcc, 0x6d,
        0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5279,13 +5278,13 @@ static const u8 enc_output103[] __initconst = {
        0x86, 0xfb, 0xab, 0x2b, 0x4a, 0x94, 0xf4, 0x7a,
        0xa5, 0x6f, 0x0a, 0xea, 0x65, 0xd1, 0x10, 0x08
 };
-static const u8 enc_assoc103[] __initconst = {
+static const u8 enc_assoc103[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce103[] __initconst = {
+static const u8 enc_nonce103[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key103[] __initconst = {
+static const u8 enc_key103[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5293,7 +5292,7 @@ static const u8 enc_key103[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input104[] __initconst = {
+static const u8 enc_input104[] = {
        0xb2, 0x47, 0xa7, 0x47, 0x23, 0x49, 0x1a, 0xac,
        0xac, 0xaa, 0xd7, 0x09, 0xc9, 0x1e, 0x93, 0x2b,
        0x31, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5305,7 +5304,7 @@ static const u8 enc_input104[] __initconst = {
        0x42, 0x89, 0x79, 0x44, 0xc2, 0xa2, 0x8f, 0xa1,
        0x76, 0x11, 0xd7, 0xfa, 0x5c, 0x22, 0xad, 0x8f
 };
-static const u8 enc_output104[] __initconst = {
+static const u8 enc_output104[] = {
        0xb2, 0x2c, 0x70, 0x68, 0xa5, 0x83, 0xfa, 0x35,
        0x0f, 0x85, 0x29, 0xc3, 0x75, 0xf8, 0xeb, 0x88,
        0xb6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5319,13 +5318,13 @@ static const u8 enc_output104[] __initconst = {
        0xa0, 0x19, 0xac, 0x2e, 0xd6, 0x67, 0xe1, 0x7d,
        0xa1, 0x6f, 0x0a, 0xfa, 0x19, 0x61, 0x0d, 0x0d
 };
-static const u8 enc_assoc104[] __initconst = {
+static const u8 enc_assoc104[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce104[] __initconst = {
+static const u8 enc_nonce104[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key104[] __initconst = {
+static const u8 enc_key104[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5333,7 +5332,7 @@ static const u8 enc_key104[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input105[] __initconst = {
+static const u8 enc_input105[] = {
        0x74, 0x0f, 0x9e, 0x49, 0xf6, 0x10, 0xef, 0xa5,
        0x85, 0xb6, 0x59, 0xca, 0x6e, 0xd8, 0xb4, 0x99,
        0x2d, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5345,7 +5344,7 @@ static const u8 enc_input105[] __initconst = {
        0x99, 0x7a, 0xeb, 0x0c, 0x27, 0x95, 0x62, 0x46,
        0x69, 0xc3, 0x87, 0xf9, 0x11, 0x6a, 0xc1, 0x8d
 };
-static const u8 enc_output105[] __initconst = {
+static const u8 enc_output105[] = {
        0x74, 0x64, 0x49, 0x66, 0x70, 0xda, 0x0f, 0x3c,
        0x26, 0x99, 0xa7, 0x00, 0xd2, 0x3e, 0xcc, 0x3a,
        0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5359,13 +5358,13 @@ static const u8 enc_output105[] __initconst = {
        0x73, 0x6e, 0x18, 0x18, 0x16, 0x96, 0xa5, 0x88,
        0x9c, 0x31, 0x59, 0xfa, 0xab, 0xab, 0x20, 0xfd
 };
-static const u8 enc_assoc105[] __initconst = {
+static const u8 enc_assoc105[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce105[] __initconst = {
+static const u8 enc_nonce105[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key105[] __initconst = {
+static const u8 enc_key105[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5373,7 +5372,7 @@ static const u8 enc_key105[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input106[] __initconst = {
+static const u8 enc_input106[] = {
        0xad, 0xba, 0x5d, 0x10, 0x5b, 0xc8, 0xaa, 0x06,
        0x2c, 0x23, 0x36, 0xcb, 0x88, 0x9d, 0xdb, 0xd5,
        0x37, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5385,7 +5384,7 @@ static const u8 enc_input106[] __initconst = {
        0xcf, 0x2b, 0x22, 0x5d, 0xb1, 0x60, 0x7a, 0x10,
        0xe6, 0xd5, 0x40, 0x1e, 0x53, 0xb4, 0x2a, 0x8d
 };
-static const u8 enc_output106[] __initconst = {
+static const u8 enc_output106[] = {
        0xad, 0xd1, 0x8a, 0x3f, 0xdd, 0x02, 0x4a, 0x9f,
        0x8f, 0x0c, 0xc8, 0x01, 0x34, 0x7b, 0xa3, 0x76,
        0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5399,13 +5398,13 @@ static const u8 enc_output106[] __initconst = {
        0xba, 0xd5, 0x8f, 0x10, 0xa9, 0x1e, 0x6a, 0x88,
        0x9a, 0xba, 0x32, 0xfd, 0x17, 0xd8, 0x33, 0x1a
 };
-static const u8 enc_assoc106[] __initconst = {
+static const u8 enc_assoc106[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce106[] __initconst = {
+static const u8 enc_nonce106[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key106[] __initconst = {
+static const u8 enc_key106[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5413,7 +5412,7 @@ static const u8 enc_key106[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input107[] __initconst = {
+static const u8 enc_input107[] = {
        0xfe, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xc0, 0x01, 0xed, 0xc5, 0xda, 0x44, 0x2e, 0x71,
@@ -5427,7 +5426,7 @@ static const u8 enc_input107[] __initconst = {
        0x00, 0x26, 0x6e, 0xa1, 0xe4, 0x36, 0x44, 0xa3,
        0x4d, 0x8d, 0xd1, 0xdc, 0x93, 0xf2, 0xfa, 0x13
 };
-static const u8 enc_output107[] __initconst = {
+static const u8 enc_output107[] = {
        0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x47, 0xc3, 0x27, 0xcc, 0x36, 0x5d, 0x08, 0x87,
@@ -5443,13 +5442,13 @@ static const u8 enc_output107[] __initconst = {
        0xd6, 0x8c, 0xe1, 0x74, 0x07, 0x9a, 0xdd, 0x02,
        0x8d, 0xd0, 0x5c, 0xf8, 0x14, 0x63, 0x04, 0x88
 };
-static const u8 enc_assoc107[] __initconst = {
+static const u8 enc_assoc107[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce107[] __initconst = {
+static const u8 enc_nonce107[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key107[] __initconst = {
+static const u8 enc_key107[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5457,7 +5456,7 @@ static const u8 enc_key107[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input108[] __initconst = {
+static const u8 enc_input108[] = {
        0xb5, 0x13, 0xb0, 0x6a, 0xb9, 0xac, 0x14, 0x43,
        0x5a, 0xcb, 0x8a, 0xa3, 0xa3, 0x7a, 0xfd, 0xb6,
        0x54, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5469,7 +5468,7 @@ static const u8 enc_input108[] __initconst = {
        0xb9, 0xc2, 0x7c, 0x30, 0x28, 0xaa, 0x8d, 0x69,
        0xef, 0x06, 0xaf, 0xc0, 0xb5, 0x9e, 0xda, 0x8e
 };
-static const u8 enc_output108[] __initconst = {
+static const u8 enc_output108[] = {
        0xb5, 0x78, 0x67, 0x45, 0x3f, 0x66, 0xf4, 0xda,
        0xf9, 0xe4, 0x74, 0x69, 0x1f, 0x9c, 0x85, 0x15,
        0xd3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5483,13 +5482,13 @@ static const u8 enc_output108[] __initconst = {
        0xaa, 0x48, 0xa3, 0x88, 0x7d, 0x4b, 0x05, 0x96,
        0x99, 0xc2, 0xfd, 0xf9, 0xc6, 0x78, 0x7e, 0x0a
 };
-static const u8 enc_assoc108[] __initconst = {
+static const u8 enc_assoc108[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce108[] __initconst = {
+static const u8 enc_nonce108[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key108[] __initconst = {
+static const u8 enc_key108[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5497,7 +5496,7 @@ static const u8 enc_key108[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input109[] __initconst = {
+static const u8 enc_input109[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xd4, 0xf1, 0x09, 0xe8, 0x14, 0xce, 0xa8, 0x5a,
@@ -5511,7 +5510,7 @@ static const u8 enc_input109[] __initconst = {
        0x1b, 0x64, 0x89, 0xba, 0x84, 0xd8, 0xf5, 0x59,
        0x82, 0x9e, 0xd9, 0xbd, 0xa2, 0x29, 0x0f, 0x16
 };
-static const u8 enc_output109[] __initconst = {
+static const u8 enc_output109[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x53, 0x33, 0xc3, 0xe1, 0xf8, 0xd7, 0x8e, 0xac,
@@ -5527,13 +5526,13 @@ static const u8 enc_output109[] __initconst = {
        0xb9, 0x36, 0xa8, 0x17, 0xf2, 0x21, 0x1a, 0xf1,
        0x29, 0xe2, 0xcf, 0x16, 0x0f, 0xd4, 0x2b, 0xcb
 };
-static const u8 enc_assoc109[] __initconst = {
+static const u8 enc_assoc109[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce109[] __initconst = {
+static const u8 enc_nonce109[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key109[] __initconst = {
+static const u8 enc_key109[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5541,7 +5540,7 @@ static const u8 enc_key109[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input110[] __initconst = {
+static const u8 enc_input110[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xdf, 0x4c, 0x62, 0x03, 0x2d, 0x41, 0x19, 0xb5,
@@ -5555,7 +5554,7 @@ static const u8 enc_input110[] __initconst = {
        0xb2, 0xa0, 0xc1, 0x84, 0x4b, 0x4e, 0x35, 0xd4,
        0x1e, 0x5d, 0xa2, 0x10, 0xf6, 0x2f, 0x84, 0x12
 };
-static const u8 enc_output110[] __initconst = {
+static const u8 enc_output110[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x58, 0x8e, 0xa8, 0x0a, 0xc1, 0x58, 0x3f, 0x43,
@@ -5571,13 +5570,13 @@ static const u8 enc_output110[] __initconst = {
        0x9f, 0x7a, 0xc4, 0x35, 0x1f, 0x6b, 0x91, 0xe6,
        0x30, 0x97, 0xa7, 0x13, 0x11, 0x5d, 0x05, 0xbe
 };
-static const u8 enc_assoc110[] __initconst = {
+static const u8 enc_assoc110[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce110[] __initconst = {
+static const u8 enc_nonce110[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key110[] __initconst = {
+static const u8 enc_key110[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5585,7 +5584,7 @@ static const u8 enc_key110[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input111[] __initconst = {
+static const u8 enc_input111[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x13, 0xf8, 0x0a, 0x00, 0x6d, 0xc1, 0xbb, 0xda,
@@ -5599,7 +5598,7 @@ static const u8 enc_input111[] __initconst = {
        0x2b, 0x6c, 0x89, 0x1d, 0x37, 0xc7, 0xe1, 0x1a,
        0x56, 0x41, 0x91, 0x9c, 0x49, 0x4d, 0x95, 0x16
 };
-static const u8 enc_output111[] __initconst = {
+static const u8 enc_output111[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x94, 0x3a, 0xc0, 0x09, 0x81, 0xd8, 0x9d, 0x2c,
@@ -5615,13 +5614,13 @@ static const u8 enc_output111[] __initconst = {
        0x9a, 0x18, 0xa8, 0x28, 0x07, 0x02, 0x69, 0xf4,
        0x47, 0x00, 0xd0, 0x09, 0xe7, 0x17, 0x1c, 0xc9
 };
-static const u8 enc_assoc111[] __initconst = {
+static const u8 enc_assoc111[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce111[] __initconst = {
+static const u8 enc_nonce111[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key111[] __initconst = {
+static const u8 enc_key111[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5629,7 +5628,7 @@ static const u8 enc_key111[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input112[] __initconst = {
+static const u8 enc_input112[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x82, 0xe5, 0x9b, 0x45, 0x82, 0x91, 0x50, 0x38,
@@ -5643,7 +5642,7 @@ static const u8 enc_input112[] __initconst = {
        0xfe, 0x55, 0xf9, 0x2a, 0xdc, 0x08, 0xb5, 0xaa,
        0x95, 0x48, 0xa9, 0x2d, 0x63, 0xaf, 0xe1, 0x13
 };
-static const u8 enc_output112[] __initconst = {
+static const u8 enc_output112[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x05, 0x27, 0x51, 0x4c, 0x6e, 0x88, 0x76, 0xce,
@@ -5659,13 +5658,13 @@ static const u8 enc_output112[] __initconst = {
        0xb4, 0x36, 0xa8, 0x2b, 0x93, 0xd5, 0x55, 0xf7,
        0x43, 0x00, 0xd0, 0x19, 0x9b, 0xa7, 0x18, 0xce
 };
-static const u8 enc_assoc112[] __initconst = {
+static const u8 enc_assoc112[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce112[] __initconst = {
+static const u8 enc_nonce112[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key112[] __initconst = {
+static const u8 enc_key112[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5673,7 +5672,7 @@ static const u8 enc_key112[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input113[] __initconst = {
+static const u8 enc_input113[] = {
        0xff, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0xf1, 0xd1, 0x28, 0x87, 0xb7, 0x21, 0x69, 0x86,
@@ -5687,7 +5686,7 @@ static const u8 enc_input113[] __initconst = {
        0xef, 0xe3, 0x69, 0x79, 0xed, 0x9e, 0x7d, 0x3e,
        0xc9, 0x52, 0x41, 0x4e, 0x49, 0xb1, 0x30, 0x16
 };
-static const u8 enc_output113[] __initconst = {
+static const u8 enc_output113[] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x76, 0x13, 0xe2, 0x8e, 0x5b, 0x38, 0x4f, 0x70,
@@ -5703,13 +5702,13 @@ static const u8 enc_output113[] __initconst = {
        0xce, 0x54, 0xa8, 0x2e, 0x1f, 0xa9, 0x42, 0xfa,
        0x3f, 0x00, 0xd0, 0x29, 0x4f, 0x37, 0x15, 0xd3
 };
-static const u8 enc_assoc113[] __initconst = {
+static const u8 enc_assoc113[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce113[] __initconst = {
+static const u8 enc_nonce113[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key113[] __initconst = {
+static const u8 enc_key113[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5717,7 +5716,7 @@ static const u8 enc_key113[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input114[] __initconst = {
+static const u8 enc_input114[] = {
        0xcb, 0xf1, 0xda, 0x9e, 0x0b, 0xa9, 0x37, 0x73,
        0x74, 0xe6, 0x9e, 0x1c, 0x0e, 0x60, 0x0c, 0xfc,
        0x34, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5729,7 +5728,7 @@ static const u8 enc_input114[] __initconst = {
        0x66, 0x68, 0xdb, 0xc8, 0xf5, 0xf2, 0x0e, 0xf2,
        0xb3, 0xf3, 0x8f, 0x00, 0xe2, 0x03, 0x17, 0x88
 };
-static const u8 enc_output114[] __initconst = {
+static const u8 enc_output114[] = {
        0xcb, 0x9a, 0x0d, 0xb1, 0x8d, 0x63, 0xd7, 0xea,
        0xd7, 0xc9, 0x60, 0xd6, 0xb2, 0x86, 0x74, 0x5f,
        0xb3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5743,13 +5742,13 @@ static const u8 enc_output114[] __initconst = {
        0x23, 0x83, 0xab, 0x0b, 0x79, 0x92, 0x05, 0x69,
        0x9b, 0x51, 0x0a, 0xa7, 0x09, 0xbf, 0x31, 0xf1
 };
-static const u8 enc_assoc114[] __initconst = {
+static const u8 enc_assoc114[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce114[] __initconst = {
+static const u8 enc_nonce114[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key114[] __initconst = {
+static const u8 enc_key114[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5757,7 +5756,7 @@ static const u8 enc_key114[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input115[] __initconst = {
+static const u8 enc_input115[] = {
        0x8f, 0x27, 0x86, 0x94, 0xc4, 0xe9, 0xda, 0xeb,
        0xd5, 0x8d, 0x3e, 0x5b, 0x96, 0x6e, 0x8b, 0x68,
        0x42, 0x3d, 0x35, 0xf6, 0x13, 0xe6, 0xd9, 0x09,
@@ -5769,7 +5768,7 @@ static const u8 enc_input115[] __initconst = {
        0xde, 0x04, 0x9a, 0x00, 0xa8, 0x64, 0x06, 0x4b,
        0xbc, 0xd4, 0x6f, 0xe4, 0xe4, 0x5b, 0x42, 0x8f
 };
-static const u8 enc_output115[] __initconst = {
+static const u8 enc_output115[] = {
        0x8f, 0x4c, 0x51, 0xbb, 0x42, 0x23, 0x3a, 0x72,
        0x76, 0xa2, 0xc0, 0x91, 0x2a, 0x88, 0xf3, 0xcb,
        0xc5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -5783,13 +5782,13 @@ static const u8 enc_output115[] __initconst = {
        0x8b, 0xfb, 0xab, 0x17, 0xa9, 0xe0, 0xb8, 0x74,
        0x8b, 0x51, 0x0a, 0xe7, 0xd9, 0xfd, 0x23, 0x05
 };
-static const u8 enc_assoc115[] __initconst = {
+static const u8 enc_assoc115[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce115[] __initconst = {
+static const u8 enc_nonce115[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key115[] __initconst = {
+static const u8 enc_key115[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5797,7 +5796,7 @@ static const u8 enc_key115[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input116[] __initconst = {
+static const u8 enc_input116[] = {
        0xd5, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x9a, 0x22, 0xd7, 0x0a, 0x48, 0xe2, 0x4f, 0xdd,
@@ -5811,7 +5810,7 @@ static const u8 enc_input116[] __initconst = {
        0x3f, 0x91, 0xf8, 0xe7, 0xc7, 0xb1, 0x96, 0x25,
        0x64, 0x61, 0x9c, 0x5e, 0x7e, 0x9b, 0xf6, 0x13
 };
-static const u8 enc_output116[] __initconst = {
+static const u8 enc_output116[] = {
        0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0x1d, 0xe0, 0x1d, 0x03, 0xa4, 0xfb, 0x69, 0x2b,
@@ -5827,13 +5826,13 @@ static const u8 enc_output116[] __initconst = {
        0x49, 0xbc, 0x6e, 0x9f, 0xc5, 0x1c, 0x4d, 0x50,
        0x30, 0x36, 0x64, 0x4d, 0x84, 0x27, 0x73, 0xd2
 };
-static const u8 enc_assoc116[] __initconst = {
+static const u8 enc_assoc116[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce116[] __initconst = {
+static const u8 enc_nonce116[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key116[] __initconst = {
+static const u8 enc_key116[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5841,7 +5840,7 @@ static const u8 enc_key116[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input117[] __initconst = {
+static const u8 enc_input117[] = {
        0xdb, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x75, 0xd5, 0x64, 0x3a, 0xa5, 0xaf, 0x93, 0x4d,
@@ -5855,7 +5854,7 @@ static const u8 enc_input117[] __initconst = {
        0x28, 0x3f, 0x6b, 0x32, 0x18, 0x07, 0x5f, 0xc9,
        0x5f, 0x6b, 0xb4, 0xff, 0x45, 0x6d, 0xc1, 0x11
 };
-static const u8 enc_output117[] __initconst = {
+static const u8 enc_output117[] = {
        0xdb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xf2, 0x17, 0xae, 0x33, 0x49, 0xb6, 0xb5, 0xbb,
@@ -5871,13 +5870,13 @@ static const u8 enc_output117[] __initconst = {
        0x63, 0xda, 0x6e, 0xa2, 0x51, 0xf0, 0x39, 0x53,
        0x2c, 0x36, 0x64, 0x5d, 0x38, 0xb7, 0x6f, 0xd7
 };
-static const u8 enc_assoc117[] __initconst = {
+static const u8 enc_assoc117[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce117[] __initconst = {
+static const u8 enc_nonce117[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key117[] __initconst = {
+static const u8 enc_key117[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5885,7 +5884,7 @@ static const u8 enc_key117[] __initconst = {
 };
 
 /* wycheproof - edge case intermediate sums in poly1305 */
-static const u8 enc_input118[] __initconst = {
+static const u8 enc_input118[] = {
        0x93, 0x94, 0x28, 0xd0, 0x79, 0x35, 0x1f, 0x66,
        0x5c, 0xd0, 0x01, 0x35, 0x43, 0x19, 0x87, 0x5c,
        0x62, 0x48, 0x39, 0x60, 0x42, 0x16, 0xe4, 0x03,
@@ -5899,7 +5898,7 @@ static const u8 enc_input118[] __initconst = {
        0x90, 0xec, 0xf2, 0x1a, 0x04, 0xe6, 0x30, 0x85,
        0x8b, 0xb6, 0x56, 0x52, 0xb5, 0xb1, 0x80, 0x16
 };
-static const u8 enc_output118[] __initconst = {
+static const u8 enc_output118[] = {
        0x93, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xe5, 0x8a, 0xf3, 0x69, 0xae, 0x0f, 0xc2, 0xf5,
@@ -5915,13 +5914,13 @@ static const u8 enc_output118[] __initconst = {
        0x73, 0xeb, 0x27, 0x24, 0xb5, 0xc4, 0x05, 0xf0,
        0x4d, 0x00, 0xd0, 0xf1, 0x58, 0x40, 0xa1, 0xc1
 };
-static const u8 enc_assoc118[] __initconst = {
+static const u8 enc_assoc118[] = {
        0xff, 0xff, 0xff, 0xff
 };
-static const u8 enc_nonce118[] __initconst = {
+static const u8 enc_nonce118[] = {
        0x00, 0x00, 0x00, 0x00, 0x06, 0x4c, 0x2d, 0x52
 };
-static const u8 enc_key118[] __initconst = {
+static const u8 enc_key118[] = {
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
@@ -5929,7 +5928,7 @@ static const u8 enc_key118[] __initconst = {
 };
 
 static const struct chacha20poly1305_testvec
-chacha20poly1305_enc_vectors[] __initconst = {
+chacha20poly1305_enc_vectors[] = {
        { enc_input001, enc_output001, enc_assoc001, enc_nonce001, enc_key001,
          sizeof(enc_input001), sizeof(enc_assoc001), sizeof(enc_nonce001) },
        { enc_input002, enc_output002, enc_assoc002, enc_nonce002, enc_key002,
@@ -6168,7 +6167,7 @@ chacha20poly1305_enc_vectors[] __initconst = {
          sizeof(enc_input118), sizeof(enc_assoc118), sizeof(enc_nonce118) }
 };
 
-static const u8 dec_input001[] __initconst = {
+static const u8 dec_input001[] = {
        0x64, 0xa0, 0x86, 0x15, 0x75, 0x86, 0x1a, 0xf4,
        0x60, 0xf0, 0x62, 0xc7, 0x9b, 0xe6, 0x43, 0xbd,
        0x5e, 0x80, 0x5c, 0xfd, 0x34, 0x5c, 0xf3, 0x89,
@@ -6206,7 +6205,7 @@ static const u8 dec_input001[] __initconst = {
        0x22, 0x39, 0x23, 0x36, 0xfe, 0xa1, 0x85, 0x1f,
        0x38
 };
-static const u8 dec_output001[] __initconst = {
+static const u8 dec_output001[] = {
        0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
        0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20,
        0x61, 0x72, 0x65, 0x20, 0x64, 0x72, 0x61, 0x66,
@@ -6242,95 +6241,95 @@ static const u8 dec_output001[] __initconst = {
        0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80,
        0x9d
 };
-static const u8 dec_assoc001[] __initconst = {
+static const u8 dec_assoc001[] = {
        0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x4e, 0x91
 };
-static const u8 dec_nonce001[] __initconst = {
+static const u8 dec_nonce001[] = {
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
 };
-static const u8 dec_key001[] __initconst = {
+static const u8 dec_key001[] = {
        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a,
        0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09,
        0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
 };
 
-static const u8 dec_input002[] __initconst = {
+static const u8 dec_input002[] = {
        0xea, 0xe0, 0x1e, 0x9e, 0x2c, 0x91, 0xaa, 0xe1,
        0xdb, 0x5d, 0x99, 0x3f, 0x8a, 0xf7, 0x69, 0x92
 };
-static const u8 dec_output002[] __initconst = { };
-static const u8 dec_assoc002[] __initconst = { };
-static const u8 dec_nonce002[] __initconst = {
+static const u8 dec_output002[] = { };
+static const u8 dec_assoc002[] = { };
+static const u8 dec_nonce002[] = {
        0xca, 0xbf, 0x33, 0x71, 0x32, 0x45, 0x77, 0x8e
 };
-static const u8 dec_key002[] __initconst = {
+static const u8 dec_key002[] = {
        0x4c, 0xf5, 0x96, 0x83, 0x38, 0xe6, 0xae, 0x7f,
        0x2d, 0x29, 0x25, 0x76, 0xd5, 0x75, 0x27, 0x86,
        0x91, 0x9a, 0x27, 0x7a, 0xfb, 0x46, 0xc5, 0xef,
        0x94, 0x81, 0x79, 0x57, 0x14, 0x59, 0x40, 0x68
 };
 
-static const u8 dec_input003[] __initconst = {
+static const u8 dec_input003[] = {
        0xdd, 0x6b, 0x3b, 0x82, 0xce, 0x5a, 0xbd, 0xd6,
        0xa9, 0x35, 0x83, 0xd8, 0x8c, 0x3d, 0x85, 0x77
 };
-static const u8 dec_output003[] __initconst = { };
-static const u8 dec_assoc003[] __initconst = {
+static const u8 dec_output003[] = { };
+static const u8 dec_assoc003[] = {
        0x33, 0x10, 0x41, 0x12, 0x1f, 0xf3, 0xd2, 0x6b
 };
-static const u8 dec_nonce003[] __initconst = {
+static const u8 dec_nonce003[] = {
        0x3d, 0x86, 0xb5, 0x6b, 0xc8, 0xa3, 0x1f, 0x1d
 };
-static const u8 dec_key003[] __initconst = {
+static const u8 dec_key003[] = {
        0x2d, 0xb0, 0x5d, 0x40, 0xc8, 0xed, 0x44, 0x88,
        0x34, 0xd1, 0x13, 0xaf, 0x57, 0xa1, 0xeb, 0x3a,
        0x2a, 0x80, 0x51, 0x36, 0xec, 0x5b, 0xbc, 0x08,
        0x93, 0x84, 0x21, 0xb5, 0x13, 0x88, 0x3c, 0x0d
 };
 
-static const u8 dec_input004[] __initconst = {
+static const u8 dec_input004[] = {
        0xb7, 0x1b, 0xb0, 0x73, 0x59, 0xb0, 0x84, 0xb2,
        0x6d, 0x8e, 0xab, 0x94, 0x31, 0xa1, 0xae, 0xac,
        0x89
 };
-static const u8 dec_output004[] __initconst = {
+static const u8 dec_output004[] = {
        0xa4
 };
-static const u8 dec_assoc004[] __initconst = {
+static const u8 dec_assoc004[] = {
        0x6a, 0xe2, 0xad, 0x3f, 0x88, 0x39, 0x5a, 0x40
 };
-static const u8 dec_nonce004[] __initconst = {
+static const u8 dec_nonce004[] = {
        0xd2, 0x32, 0x1f, 0x29, 0x28, 0xc6, 0xc4, 0xc4
 };
-static const u8 dec_key004[] __initconst = {
+static const u8 dec_key004[] = {
        0x4b, 0x28, 0x4b, 0xa3, 0x7b, 0xbe, 0xe9, 0xf8,
        0x31, 0x80, 0x82, 0xd7, 0xd8, 0xe8, 0xb5, 0xa1,
        0xe2, 0x18, 0x18, 0x8a, 0x9c, 0xfa, 0xa3, 0x3d,
        0x25, 0x71, 0x3e, 0x40, 0xbc, 0x54, 0x7a, 0x3e
 };
 
-static const u8 dec_input005[] __initconst = {
+static const u8 dec_input005[] = {
        0xbf, 0xe1, 0x5b, 0x0b, 0xdb, 0x6b, 0xf5, 0x5e,
        0x6c, 0x5d, 0x84, 0x44, 0x39, 0x81, 0xc1, 0x9c,
        0xac
 };
-static const u8 dec_output005[] __initconst = {
+static const u8 dec_output005[] = {
        0x2d
 };
-static const u8 dec_assoc005[] __initconst = { };
-static const u8 dec_nonce005[] __initconst = {
+static const u8 dec_assoc005[] = { };
+static const u8 dec_nonce005[] = {
        0x20, 0x1c, 0xaa, 0x5f, 0x9c, 0xbf, 0x92, 0x30
 };
-static const u8 dec_key005[] __initconst = {
+static const u8 dec_key005[] = {
        0x66, 0xca, 0x9c, 0x23, 0x2a, 0x4b, 0x4b, 0x31,
        0x0e, 0x92, 0x89, 0x8b, 0xf4, 0x93, 0xc7, 0x87,
        0x98, 0xa3, 0xd8, 0x39, 0xf8, 0xf4, 0xa7, 0x01,
        0xc0, 0x2e, 0x0a, 0xa6, 0x7e, 0x5a, 0x78, 0x87
 };
 
-static const u8 dec_input006[] __initconst = {
+static const u8 dec_input006[] = {
        0x8b, 0x06, 0xd3, 0x31, 0xb0, 0x93, 0x45, 0xb1,
        0x75, 0x6e, 0x26, 0xf9, 0x67, 0xbc, 0x90, 0x15,
        0x81, 0x2c, 0xb5, 0xf0, 0xc6, 0x2b, 0xc7, 0x8c,
@@ -6351,7 +6350,7 @@ static const u8 dec_input006[] __initconst = {
        0x8d, 0x31, 0xf7, 0x7a, 0x39, 0x4d, 0x8f, 0x9a,
        0xeb
 };
-static const u8 dec_output006[] __initconst = {
+static const u8 dec_output006[] = {
        0x33, 0x2f, 0x94, 0xc1, 0xa4, 0xef, 0xcc, 0x2a,
        0x5b, 0xa6, 0xe5, 0x8f, 0x1d, 0x40, 0xf0, 0x92,
        0x3c, 0xd9, 0x24, 0x11, 0xa9, 0x71, 0xf9, 0x37,
@@ -6370,20 +6369,20 @@ static const u8 dec_output006[] __initconst = {
        0x69, 0x21, 0x70, 0xd8, 0xa4, 0x4b, 0xc8, 0xde,
        0x8f
 };
-static const u8 dec_assoc006[] __initconst = {
+static const u8 dec_assoc006[] = {
        0x70, 0xd3, 0x33, 0xf3, 0x8b, 0x18, 0x0b
 };
-static const u8 dec_nonce006[] __initconst = {
+static const u8 dec_nonce006[] = {
        0xdf, 0x51, 0x84, 0x82, 0x42, 0x0c, 0x75, 0x9c
 };
-static const u8 dec_key006[] __initconst = {
+static const u8 dec_key006[] = {
        0x68, 0x7b, 0x8d, 0x8e, 0xe3, 0xc4, 0xdd, 0xae,
        0xdf, 0x72, 0x7f, 0x53, 0x72, 0x25, 0x1e, 0x78,
        0x91, 0xcb, 0x69, 0x76, 0x1f, 0x49, 0x93, 0xf9,
        0x6f, 0x21, 0xcc, 0x39, 0x9c, 0xad, 0xb1, 0x01
 };
 
-static const u8 dec_input007[] __initconst = {
+static const u8 dec_input007[] = {
        0x85, 0x04, 0xc2, 0xed, 0x8d, 0xfd, 0x97, 0x5c,
        0xd2, 0xb7, 0xe2, 0xc1, 0x6b, 0xa3, 0xba, 0xf8,
        0xc9, 0x50, 0xc3, 0xc6, 0xa5, 0xe3, 0xa4, 0x7c,
@@ -6419,7 +6418,7 @@ static const u8 dec_input007[] __initconst = {
        0x7a, 0x4b, 0xbc, 0xb0, 0x10, 0x5c, 0x96, 0x42,
        0x3a, 0x00, 0x98, 0xcd, 0x15, 0xe8, 0xb7, 0x53
 };
-static const u8 dec_output007[] __initconst = {
+static const u8 dec_output007[] = {
        0x9b, 0x18, 0xdb, 0xdd, 0x9a, 0x0f, 0x3e, 0xa5,
        0x15, 0x17, 0xde, 0xdf, 0x08, 0x9d, 0x65, 0x0a,
        0x67, 0x30, 0x12, 0xe2, 0x34, 0x77, 0x4b, 0xc1,
@@ -6453,18 +6452,18 @@ static const u8 dec_output007[] __initconst = {
        0x40, 0x5f, 0x99, 0xb7, 0x73, 0xec, 0x9b, 0x2b,
        0xf0, 0x65, 0x11, 0xc8, 0xd0, 0x0a, 0x9f, 0xd3
 };
-static const u8 dec_assoc007[] __initconst = { };
-static const u8 dec_nonce007[] __initconst = {
+static const u8 dec_assoc007[] = { };
+static const u8 dec_nonce007[] = {
        0xde, 0x7b, 0xef, 0xc3, 0x65, 0x1b, 0x68, 0xb0
 };
-static const u8 dec_key007[] __initconst = {
+static const u8 dec_key007[] = {
        0x8d, 0xb8, 0x91, 0x48, 0xf0, 0xe7, 0x0a, 0xbd,
        0xf9, 0x3f, 0xcd, 0xd9, 0xa0, 0x1e, 0x42, 0x4c,
        0xe7, 0xde, 0x25, 0x3d, 0xa3, 0xd7, 0x05, 0x80,
        0x8d, 0xf2, 0x82, 0xac, 0x44, 0x16, 0x51, 0x01
 };
 
-static const u8 dec_input008[] __initconst = {
+static const u8 dec_input008[] = {
        0x14, 0xf6, 0x41, 0x37, 0xa6, 0xd4, 0x27, 0xcd,
        0xdb, 0x06, 0x3e, 0x9a, 0x4e, 0xab, 0xd5, 0xb1,
        0x1e, 0x6b, 0xd2, 0xbc, 0x11, 0xf4, 0x28, 0x93,
@@ -6532,7 +6531,7 @@ static const u8 dec_input008[] __initconst = {
        0x54, 0xfd, 0x0d, 0x98, 0x1c, 0x5a, 0x6f, 0x1f,
        0x9a, 0x40, 0xcd, 0xa2, 0xff, 0x6a, 0xf1, 0x54
 };
-static const u8 dec_output008[] __initconst = {
+static const u8 dec_output008[] = {
        0xc3, 0x09, 0x94, 0x62, 0xe6, 0x46, 0x2e, 0x10,
        0xbe, 0x00, 0xe4, 0xfc, 0xf3, 0x40, 0xa3, 0xe2,
        0x0f, 0xc2, 0x8b, 0x28, 0xdc, 0xba, 0xb4, 0x3c,
@@ -6598,18 +6597,18 @@ static const u8 dec_output008[] __initconst = {
        0x2e, 0x79, 0xb5, 0xe2, 0xb8, 0xe8, 0xb9, 0x7b,
        0xd5, 0x10, 0xcb, 0xff, 0x5d, 0x14, 0x73, 0xf3
 };
-static const u8 dec_assoc008[] __initconst = { };
-static const u8 dec_nonce008[] __initconst = {
+static const u8 dec_assoc008[] = { };
+static const u8 dec_nonce008[] = {
        0x0e, 0x0d, 0x57, 0xbb, 0x7b, 0x40, 0x54, 0x02
 };
-static const u8 dec_key008[] __initconst = {
+static const u8 dec_key008[] = {
        0xf2, 0xaa, 0x4f, 0x99, 0xfd, 0x3e, 0xa8, 0x53,
        0xc1, 0x44, 0xe9, 0x81, 0x18, 0xdc, 0xf5, 0xf0,
        0x3e, 0x44, 0x15, 0x59, 0xe0, 0xc5, 0x44, 0x86,
        0xc3, 0x91, 0xa8, 0x75, 0xc0, 0x12, 0x46, 0xba
 };
 
-static const u8 dec_input009[] __initconst = {
+static const u8 dec_input009[] = {
        0xfd, 0x81, 0x8d, 0xd0, 0x3d, 0xb4, 0xd5, 0xdf,
        0xd3, 0x42, 0x47, 0x5a, 0x6d, 0x19, 0x27, 0x66,
        0x4b, 0x2e, 0x0c, 0x27, 0x9c, 0x96, 0x4c, 0x72,
@@ -6678,7 +6677,7 @@ static const u8 dec_input009[] __initconst = {
        0x43, 0xb5, 0xd9, 0x90, 0xe1, 0x85, 0xf5, 0xa8,
        0xae
 };
-static const u8 dec_output009[] __initconst = {
+static const u8 dec_output009[] = {
        0xe6, 0xc3, 0xdb, 0x63, 0x55, 0x15, 0xe3, 0x5b,
        0xb7, 0x4b, 0x27, 0x8b, 0x5a, 0xdd, 0xc2, 0xe8,
        0x3a, 0x6b, 0xd7, 0x81, 0x96, 0x35, 0x97, 0xca,
@@ -6745,21 +6744,21 @@ static const u8 dec_output009[] __initconst = {
        0x74, 0xb9, 0xe2, 0xd6, 0x1c, 0x80, 0x2c, 0x52,
        0x65
 };
-static const u8 dec_assoc009[] __initconst = {
+static const u8 dec_assoc009[] = {
        0x5a, 0x27, 0xff, 0xeb, 0xdf, 0x84, 0xb2, 0x9e,
        0xef
 };
-static const u8 dec_nonce009[] __initconst = {
+static const u8 dec_nonce009[] = {
        0xef, 0x2d, 0x63, 0xee, 0x6b, 0x80, 0x8b, 0x78
 };
-static const u8 dec_key009[] __initconst = {
+static const u8 dec_key009[] = {
        0xea, 0xbc, 0x56, 0x99, 0xe3, 0x50, 0xff, 0xc5,
        0xcc, 0x1a, 0xd7, 0xc1, 0x57, 0x72, 0xea, 0x86,
        0x5b, 0x89, 0x88, 0x61, 0x3d, 0x2f, 0x9b, 0xb2,
        0xe7, 0x9c, 0xec, 0x74, 0x6e, 0x3e, 0xf4, 0x3b
 };
 
-static const u8 dec_input010[] __initconst = {
+static const u8 dec_input010[] = {
        0xe5, 0x26, 0xa4, 0x3d, 0xbd, 0x33, 0xd0, 0x4b,
        0x6f, 0x05, 0xa7, 0x6e, 0x12, 0x7a, 0xd2, 0x74,
        0xa6, 0xdd, 0xbd, 0x95, 0xeb, 0xf9, 0xa4, 0xf1,
@@ -6891,7 +6890,7 @@ static const u8 dec_input010[] __initconst = {
        0x80, 0x6b, 0xf6, 0x1f, 0xc3, 0xcc, 0x97, 0xc9,
        0x24, 0x9f, 0xf3, 0xaf, 0x43, 0x14, 0xd5, 0xa0
 };
-static const u8 dec_output010[] __initconst = {
+static const u8 dec_output010[] = {
        0x42, 0x93, 0xe4, 0xeb, 0x97, 0xb0, 0x57, 0xbf,
        0x1a, 0x8b, 0x1f, 0xe4, 0x5f, 0x36, 0x20, 0x3c,
        0xef, 0x0a, 0xa9, 0x48, 0x5f, 0x5f, 0x37, 0x22,
@@ -7021,21 +7020,21 @@ static const u8 dec_output010[] __initconst = {
        0x5a, 0xc0, 0x33, 0x1f, 0xcb, 0x05, 0x6d, 0x5c,
        0x06, 0x87, 0x52, 0xa2, 0x8f, 0x26, 0xd5, 0x4f
 };
-static const u8 dec_assoc010[] __initconst = {
+static const u8 dec_assoc010[] = {
        0xd2, 0xa1, 0x70, 0xdb, 0x7a, 0xf8, 0xfa, 0x27,
        0xba, 0x73, 0x0f, 0xbf, 0x3d, 0x1e, 0x82, 0xb2
 };
-static const u8 dec_nonce010[] __initconst = {
+static const u8 dec_nonce010[] = {
        0xdb, 0x92, 0x0f, 0x7f, 0x17, 0x54, 0x0c, 0x30
 };
-static const u8 dec_key010[] __initconst = {
+static const u8 dec_key010[] = {
        0x47, 0x11, 0xeb, 0x86, 0x2b, 0x2c, 0xab, 0x44,
        0x34, 0xda, 0x7f, 0x57, 0x03, 0x39, 0x0c, 0xaf,
        0x2c, 0x14, 0xfd, 0x65, 0x23, 0xe9, 0x8e, 0x74,
        0xd5, 0x08, 0x68, 0x08, 0xe7, 0xb4, 0x72, 0xd7
 };
 
-static const u8 dec_input011[] __initconst = {
+static const u8 dec_input011[] = {
        0x6a, 0xfc, 0x4b, 0x25, 0xdf, 0xc0, 0xe4, 0xe8,
        0x17, 0x4d, 0x4c, 0xc9, 0x7e, 0xde, 0x3a, 0xcc,
        0x3c, 0xba, 0x6a, 0x77, 0x47, 0xdb, 0xe3, 0x74,
@@ -7281,7 +7280,7 @@ static const u8 dec_input011[] __initconst = {
        0x86, 0xc4, 0xfc, 0x97, 0xae, 0x3f, 0x8f, 0x1e,
        0x2b, 0xdf, 0xcd, 0xf9, 0x3c
 };
-static const u8 dec_output011[] __initconst = {
+static const u8 dec_output011[] = {
        0x7a, 0x57, 0xf2, 0xc7, 0x06, 0x3f, 0x50, 0x7b,
        0x36, 0x1a, 0x66, 0x5c, 0xb9, 0x0e, 0x5e, 0x3b,
        0x45, 0x60, 0xbe, 0x9a, 0x31, 0x9f, 0xff, 0x5d,
@@ -7525,20 +7524,20 @@ static const u8 dec_output011[] __initconst = {
        0x5c, 0x42, 0x16, 0xb8, 0x28, 0xeb, 0x1b, 0x61,
        0x10, 0x1e, 0xbf, 0xec, 0xa8
 };
-static const u8 dec_assoc011[] __initconst = {
+static const u8 dec_assoc011[] = {
        0xd6, 0x31, 0xda, 0x5d, 0x42, 0x5e, 0xd7
 };
-static const u8 dec_nonce011[] __initconst = {
+static const u8 dec_nonce011[] = {
        0xfd, 0x87, 0xd4, 0xd8, 0x62, 0xfd, 0xec, 0xaa
 };
-static const u8 dec_key011[] __initconst = {
+static const u8 dec_key011[] = {
        0x35, 0x4e, 0xb5, 0x70, 0x50, 0x42, 0x8a, 0x85,
        0xf2, 0xfb, 0xed, 0x7b, 0xd0, 0x9e, 0x97, 0xca,
        0xfa, 0x98, 0x66, 0x63, 0xee, 0x37, 0xcc, 0x52,
        0xfe, 0xd1, 0xdf, 0x95, 0x15, 0x34, 0x29, 0x38
 };
 
-static const u8 dec_input012[] __initconst = {
+static const u8 dec_input012[] = {
        0x52, 0x34, 0xb3, 0x65, 0x3b, 0xb7, 0xe5, 0xd3,
        0xab, 0x49, 0x17, 0x60, 0xd2, 0x52, 0x56, 0xdf,
        0xdf, 0x34, 0x56, 0x82, 0xe2, 0xbe, 0xe5, 0xe1,
@@ -7794,7 +7793,7 @@ static const u8 dec_input012[] __initconst = {
        0xa3, 0x19, 0x8e, 0xa9, 0xb1, 0x13, 0x67, 0x62,
        0x70, 0xcf, 0xd6
 };
-static const u8 dec_output012[] __initconst = {
+static const u8 dec_output012[] = {
        0x74, 0xa6, 0x3e, 0xe4, 0xb1, 0xcb, 0xaf, 0xb0,
        0x40, 0xe5, 0x0f, 0x9e, 0xf1, 0xf2, 0x89, 0xb5,
        0x42, 0x34, 0x8a, 0xa1, 0x03, 0xb7, 0xe9, 0x57,
@@ -8048,7 +8047,7 @@ static const u8 dec_output012[] __initconst = {
        0x3b, 0xd0, 0x84, 0x8e, 0x67, 0xa6, 0xa3, 0x7d,
        0x78, 0xec, 0x00
 };
-static const u8 dec_assoc012[] __initconst = {
+static const u8 dec_assoc012[] = {
        0xb1, 0x69, 0x83, 0x87, 0x30, 0xaa, 0x5d, 0xb8,
        0x77, 0xe8, 0x21, 0xff, 0x06, 0x59, 0x35, 0xce,
        0x75, 0xfe, 0x38, 0xef, 0xb8, 0x91, 0x43, 0x8c,
@@ -8058,17 +8057,17 @@ static const u8 dec_assoc012[] __initconst = {
        0x01, 0xae, 0x9c, 0xb6, 0xe4, 0x88, 0x6d, 0x2b,
        0x76, 0x75, 0xe0, 0xf3, 0x74, 0xe2, 0xc9
 };
-static const u8 dec_nonce012[] __initconst = {
+static const u8 dec_nonce012[] = {
        0x05, 0xa3, 0x93, 0xed, 0x30, 0xc5, 0xa2, 0x06
 };
-static const u8 dec_key012[] __initconst = {
+static const u8 dec_key012[] = {
        0xb3, 0x35, 0x50, 0x03, 0x54, 0x2e, 0x40, 0x5e,
        0x8f, 0x59, 0x8e, 0xc5, 0x90, 0xd5, 0x27, 0x2d,
        0xba, 0x29, 0x2e, 0xcb, 0x1b, 0x70, 0x44, 0x1e,
        0x65, 0x91, 0x6e, 0x2a, 0x79, 0x22, 0xda, 0x64
 };
 
-static const u8 dec_input013[] __initconst = {
+static const u8 dec_input013[] = {
        0x52, 0x34, 0xb3, 0x65, 0x3b, 0xb7, 0xe5, 0xd3,
        0xab, 0x49, 0x17, 0x60, 0xd2, 0x52, 0x56, 0xdf,
        0xdf, 0x34, 0x56, 0x82, 0xe2, 0xbe, 0xe5, 0xe1,
@@ -8324,7 +8323,7 @@ static const u8 dec_input013[] __initconst = {
        0xa3, 0x19, 0x8e, 0xa9, 0xb1, 0x13, 0x67, 0x62,
        0x70, 0xcf, 0xd7
 };
-static const u8 dec_output013[] __initconst = {
+static const u8 dec_output013[] = {
        0x74, 0xa6, 0x3e, 0xe4, 0xb1, 0xcb, 0xaf, 0xb0,
        0x40, 0xe5, 0x0f, 0x9e, 0xf1, 0xf2, 0x89, 0xb5,
        0x42, 0x34, 0x8a, 0xa1, 0x03, 0xb7, 0xe9, 0x57,
@@ -8578,7 +8577,7 @@ static const u8 dec_output013[] __initconst = {
        0x3b, 0xd0, 0x84, 0x8e, 0x67, 0xa6, 0xa3, 0x7d,
        0x78, 0xec, 0x00
 };
-static const u8 dec_assoc013[] __initconst = {
+static const u8 dec_assoc013[] = {
        0xb1, 0x69, 0x83, 0x87, 0x30, 0xaa, 0x5d, 0xb8,
        0x77, 0xe8, 0x21, 0xff, 0x06, 0x59, 0x35, 0xce,
        0x75, 0xfe, 0x38, 0xef, 0xb8, 0x91, 0x43, 0x8c,
@@ -8588,10 +8587,10 @@ static const u8 dec_assoc013[] __initconst = {
        0x01, 0xae, 0x9c, 0xb6, 0xe4, 0x88, 0x6d, 0x2b,
        0x76, 0x75, 0xe0, 0xf3, 0x74, 0xe2, 0xc9
 };
-static const u8 dec_nonce013[] __initconst = {
+static const u8 dec_nonce013[] = {
        0x05, 0xa3, 0x93, 0xed, 0x30, 0xc5, 0xa2, 0x06
 };
-static const u8 dec_key013[] __initconst = {
+static const u8 dec_key013[] = {
        0xb3, 0x35, 0x50, 0x03, 0x54, 0x2e, 0x40, 0x5e,
        0x8f, 0x59, 0x8e, 0xc5, 0x90, 0xd5, 0x27, 0x2d,
        0xba, 0x29, 0x2e, 0xcb, 0x1b, 0x70, 0x44, 0x1e,
@@ -8599,7 +8598,7 @@ static const u8 dec_key013[] __initconst = {
 };
 
 static const struct chacha20poly1305_testvec
-chacha20poly1305_dec_vectors[] __initconst = {
+chacha20poly1305_dec_vectors[] = {
        { dec_input001, dec_output001, dec_assoc001, dec_nonce001, dec_key001,
          sizeof(dec_input001), sizeof(dec_assoc001), sizeof(dec_nonce001) },
        { dec_input002, dec_output002, dec_assoc002, dec_nonce002, dec_key002,
@@ -8629,7 +8628,7 @@ chacha20poly1305_dec_vectors[] __initconst = {
          true }
 };
 
-static const u8 xenc_input001[] __initconst = {
+static const u8 xenc_input001[] = {
        0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
        0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20,
        0x61, 0x72, 0x65, 0x20, 0x64, 0x72, 0x61, 0x66,
@@ -8665,7 +8664,7 @@ static const u8 xenc_input001[] __initconst = {
        0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80,
        0x9d
 };
-static const u8 xenc_output001[] __initconst = {
+static const u8 xenc_output001[] = {
        0x1a, 0x6e, 0x3a, 0xd9, 0xfd, 0x41, 0x3f, 0x77,
        0x54, 0x72, 0x0a, 0x70, 0x9a, 0xa0, 0x29, 0x92,
        0x2e, 0xed, 0x93, 0xcf, 0x0f, 0x71, 0x88, 0x18,
@@ -8703,16 +8702,16 @@ static const u8 xenc_output001[] __initconst = {
        0x93, 0xa6, 0x85, 0x5b, 0x40, 0x39, 0x5c, 0xc5,
        0x9c
 };
-static const u8 xenc_assoc001[] __initconst = {
+static const u8 xenc_assoc001[] = {
        0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x4e, 0x91
 };
-static const u8 xenc_nonce001[] __initconst = {
+static const u8 xenc_nonce001[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
 };
-static const u8 xenc_key001[] __initconst = {
+static const u8 xenc_key001[] = {
        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a,
        0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09,
@@ -8720,12 +8719,12 @@ static const u8 xenc_key001[] __initconst = {
 };
 
 static const struct chacha20poly1305_testvec
-xchacha20poly1305_enc_vectors[] __initconst = {
+xchacha20poly1305_enc_vectors[] = {
        { xenc_input001, xenc_output001, xenc_assoc001, xenc_nonce001, xenc_key001,
          sizeof(xenc_input001), sizeof(xenc_assoc001), sizeof(xenc_nonce001) }
 };
 
-static const u8 xdec_input001[] __initconst = {
+static const u8 xdec_input001[] = {
        0x1a, 0x6e, 0x3a, 0xd9, 0xfd, 0x41, 0x3f, 0x77,
        0x54, 0x72, 0x0a, 0x70, 0x9a, 0xa0, 0x29, 0x92,
        0x2e, 0xed, 0x93, 0xcf, 0x0f, 0x71, 0x88, 0x18,
@@ -8763,7 +8762,7 @@ static const u8 xdec_input001[] __initconst = {
        0x93, 0xa6, 0x85, 0x5b, 0x40, 0x39, 0x5c, 0xc5,
        0x9c
 };
-static const u8 xdec_output001[] __initconst = {
+static const u8 xdec_output001[] = {
        0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
        0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20,
        0x61, 0x72, 0x65, 0x20, 0x64, 0x72, 0x61, 0x66,
@@ -8799,16 +8798,16 @@ static const u8 xdec_output001[] __initconst = {
        0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80,
        0x9d
 };
-static const u8 xdec_assoc001[] __initconst = {
+static const u8 xdec_assoc001[] = {
        0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x4e, 0x91
 };
-static const u8 xdec_nonce001[] __initconst = {
+static const u8 xdec_nonce001[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
 };
-static const u8 xdec_key001[] __initconst = {
+static const u8 xdec_key001[] = {
        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a,
        0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09,
@@ -8816,15 +8815,15 @@ static const u8 xdec_key001[] __initconst = {
 };
 
 static const struct chacha20poly1305_testvec
-xchacha20poly1305_dec_vectors[] __initconst = {
+xchacha20poly1305_dec_vectors[] = {
        { xdec_input001, xdec_output001, xdec_assoc001, xdec_nonce001, xdec_key001,
          sizeof(xdec_input001), sizeof(xdec_assoc001), sizeof(xdec_nonce001) }
 };
 
-/* This is for the selftests-only, since it is only useful for the purpose of
+/* This is for the tests only, since it is only useful for the purpose of
  * testing the underlying primitives and interactions.
  */
-static void __init
+static void
 chacha20poly1305_encrypt_bignonce(u8 *dst, const u8 *src, const size_t src_len,
                                  const u8 *ad, const size_t ad_len,
                                  const u8 nonce[12],
@@ -8858,11 +8857,12 @@ chacha20poly1305_encrypt_bignonce(u8 *dst, const u8 *src, const size_t src_len,
        poly1305_final(&poly1305_state, dst + src_len);
 }
 
-static void __init
-chacha20poly1305_selftest_encrypt(u8 *dst, const u8 *src, const size_t src_len,
-                                 const u8 *ad, const size_t ad_len,
-                                 const u8 *nonce, const size_t nonce_len,
-                                 const u8 key[CHACHA20POLY1305_KEY_SIZE])
+static void
+chacha20poly1305_test_encrypt(struct kunit *test, u8 *dst,
+                             const u8 *src, const size_t src_len,
+                             const u8 *ad, const size_t ad_len,
+                             const u8 *nonce, const size_t nonce_len,
+                             const u8 key[CHACHA20POLY1305_KEY_SIZE])
 {
        if (nonce_len == 8)
                chacha20poly1305_encrypt(dst, src, src_len, ad, ad_len,
@@ -8871,10 +8871,10 @@ chacha20poly1305_selftest_encrypt(u8 *dst, const u8 *src, const size_t src_len,
                chacha20poly1305_encrypt_bignonce(dst, src, src_len, ad,
                                                  ad_len, nonce, key);
        else
-               BUG();
+               KUNIT_FAIL(test, "bad nonce_len: %zu", nonce_len);
 }
 
-static bool __init
+static bool
 decryption_success(bool func_ret, bool expect_failure, int memcmp_result)
 {
        if (expect_failure)
@@ -8882,25 +8882,23 @@ decryption_success(bool func_ret, bool expect_failure, int memcmp_result)
        return func_ret && !memcmp_result;
 }
 
-bool __init chacha20poly1305_selftest(void)
+static void test_chacha20poly1305(struct kunit *test)
 {
        enum { MAXIMUM_TEST_BUFFER_LEN = 1UL << 12 };
        size_t i, j, k, total_len;
        u8 *computed_output = NULL, *input = NULL;
-       bool success = true, ret;
+       bool ret;
        struct scatterlist sg_src[3];
 
-       computed_output = kmalloc(MAXIMUM_TEST_BUFFER_LEN, GFP_KERNEL);
-       input = kmalloc(MAXIMUM_TEST_BUFFER_LEN, GFP_KERNEL);
-       if (!computed_output || !input) {
-               pr_err("chacha20poly1305 self-test malloc: FAIL\n");
-               success = false;
-               goto out;
-       }
+       computed_output = kunit_kmalloc(test, MAXIMUM_TEST_BUFFER_LEN,
+                                       GFP_KERNEL);
+       input = kunit_kmalloc(test, MAXIMUM_TEST_BUFFER_LEN, GFP_KERNEL);
+       KUNIT_ASSERT_NOT_NULL(test, computed_output);
+       KUNIT_ASSERT_NOT_NULL(test, input);
 
        for (i = 0; i < ARRAY_SIZE(chacha20poly1305_enc_vectors); ++i) {
                memset(computed_output, 0, MAXIMUM_TEST_BUFFER_LEN);
-               chacha20poly1305_selftest_encrypt(computed_output,
+               chacha20poly1305_test_encrypt(test, computed_output,
                                        chacha20poly1305_enc_vectors[i].input,
                                        chacha20poly1305_enc_vectors[i].ilen,
                                        chacha20poly1305_enc_vectors[i].assoc,
@@ -8908,14 +8906,13 @@ bool __init chacha20poly1305_selftest(void)
                                        chacha20poly1305_enc_vectors[i].nonce,
                                        chacha20poly1305_enc_vectors[i].nlen,
                                        chacha20poly1305_enc_vectors[i].key);
-               if (memcmp(computed_output,
-                          chacha20poly1305_enc_vectors[i].output,
-                          chacha20poly1305_enc_vectors[i].ilen +
-                                                       POLY1305_DIGEST_SIZE)) {
-                       pr_err("chacha20poly1305 encryption self-test %zu: FAIL\n",
-                              i + 1);
-                       success = false;
-               }
+               KUNIT_EXPECT_TRUE_MSG(
+                       test,
+                       memcmp(computed_output,
+                              chacha20poly1305_enc_vectors[i].output,
+                              chacha20poly1305_enc_vectors[i].ilen +
+                                      POLY1305_DIGEST_SIZE) == 0,
+                       "chacha20poly1305 encryption test %zu: FAIL", i + 1);
        }
 
        for (i = 0; i < ARRAY_SIZE(chacha20poly1305_enc_vectors); ++i) {
@@ -8931,14 +8928,13 @@ bool __init chacha20poly1305_selftest(void)
                        chacha20poly1305_enc_vectors[i].alen,
                        get_unaligned_le64(chacha20poly1305_enc_vectors[i].nonce),
                        chacha20poly1305_enc_vectors[i].key);
-               if (!ret || memcmp(computed_output,
-                                  chacha20poly1305_enc_vectors[i].output,
-                                  chacha20poly1305_enc_vectors[i].ilen +
-                                                       POLY1305_DIGEST_SIZE)) {
-                       pr_err("chacha20poly1305 sg encryption self-test %zu: FAIL\n",
-                              i + 1);
-                       success = false;
-               }
+               KUNIT_EXPECT_TRUE_MSG(
+                       test,
+                       ret && memcmp(computed_output,
+                                     chacha20poly1305_enc_vectors[i].output,
+                                     chacha20poly1305_enc_vectors[i].ilen +
+                                             POLY1305_DIGEST_SIZE) == 0,
+                       "chacha20poly1305 sg encryption test %zu: FAIL", i + 1);
        }
 
        for (i = 0; i < ARRAY_SIZE(chacha20poly1305_dec_vectors); ++i) {
@@ -8950,16 +8946,15 @@ bool __init chacha20poly1305_selftest(void)
                        chacha20poly1305_dec_vectors[i].alen,
                        get_unaligned_le64(chacha20poly1305_dec_vectors[i].nonce),
                        chacha20poly1305_dec_vectors[i].key);
-               if (!decryption_success(ret,
-                               chacha20poly1305_dec_vectors[i].failure,
+               KUNIT_EXPECT_TRUE_MSG(
+                       test,
+                       decryption_success(
+                               ret, chacha20poly1305_dec_vectors[i].failure,
                                memcmp(computed_output,
                                       chacha20poly1305_dec_vectors[i].output,
                                       chacha20poly1305_dec_vectors[i].ilen -
-                                                       POLY1305_DIGEST_SIZE))) {
-                       pr_err("chacha20poly1305 decryption self-test %zu: FAIL\n",
-                              i + 1);
-                       success = false;
-               }
+                                              POLY1305_DIGEST_SIZE)),
+                       "chacha20poly1305 decryption test %zu: FAIL", i + 1);
        }
 
        for (i = 0; i < ARRAY_SIZE(chacha20poly1305_dec_vectors); ++i) {
@@ -8973,15 +8968,15 @@ bool __init chacha20poly1305_selftest(void)
                        chacha20poly1305_dec_vectors[i].alen,
                        get_unaligned_le64(chacha20poly1305_dec_vectors[i].nonce),
                        chacha20poly1305_dec_vectors[i].key);
-               if (!decryption_success(ret,
-                       chacha20poly1305_dec_vectors[i].failure,
-                       memcmp(computed_output, chacha20poly1305_dec_vectors[i].output,
-                              chacha20poly1305_dec_vectors[i].ilen -
-                                                       POLY1305_DIGEST_SIZE))) {
-                       pr_err("chacha20poly1305 sg decryption self-test %zu: FAIL\n",
-                              i + 1);
-                       success = false;
-               }
+               KUNIT_EXPECT_TRUE_MSG(
+                       test,
+                       decryption_success(
+                               ret, chacha20poly1305_dec_vectors[i].failure,
+                               memcmp(computed_output,
+                                      chacha20poly1305_dec_vectors[i].output,
+                                      chacha20poly1305_dec_vectors[i].ilen -
+                                              POLY1305_DIGEST_SIZE)),
+                       "chacha20poly1305 sg decryption test %zu: FAIL", i + 1);
        }
 
        for (i = 0; i < ARRAY_SIZE(xchacha20poly1305_enc_vectors); ++i) {
@@ -8993,14 +8988,13 @@ bool __init chacha20poly1305_selftest(void)
                                        xchacha20poly1305_enc_vectors[i].alen,
                                        xchacha20poly1305_enc_vectors[i].nonce,
                                        xchacha20poly1305_enc_vectors[i].key);
-               if (memcmp(computed_output,
-                          xchacha20poly1305_enc_vectors[i].output,
-                          xchacha20poly1305_enc_vectors[i].ilen +
-                                                       POLY1305_DIGEST_SIZE)) {
-                       pr_err("xchacha20poly1305 encryption self-test %zu: FAIL\n",
-                              i + 1);
-                       success = false;
-               }
+               KUNIT_EXPECT_TRUE_MSG(
+                       test,
+                       memcmp(computed_output,
+                              xchacha20poly1305_enc_vectors[i].output,
+                              xchacha20poly1305_enc_vectors[i].ilen +
+                                      POLY1305_DIGEST_SIZE) == 0,
+                       "xchacha20poly1305 encryption test %zu: FAIL", i + 1);
        }
 
        for (i = 0; i < ARRAY_SIZE(xchacha20poly1305_dec_vectors); ++i) {
@@ -9012,16 +9006,15 @@ bool __init chacha20poly1305_selftest(void)
                                        xchacha20poly1305_dec_vectors[i].alen,
                                        xchacha20poly1305_dec_vectors[i].nonce,
                                        xchacha20poly1305_dec_vectors[i].key);
-               if (!decryption_success(ret,
-                               xchacha20poly1305_dec_vectors[i].failure,
+               KUNIT_EXPECT_TRUE_MSG(
+                       test,
+                       decryption_success(
+                               ret, xchacha20poly1305_dec_vectors[i].failure,
                                memcmp(computed_output,
                                       xchacha20poly1305_dec_vectors[i].output,
                                       xchacha20poly1305_dec_vectors[i].ilen -
-                                                       POLY1305_DIGEST_SIZE))) {
-                       pr_err("xchacha20poly1305 decryption self-test %zu: FAIL\n",
-                              i + 1);
-                       success = false;
-               }
+                                              POLY1305_DIGEST_SIZE)),
+                       "xchacha20poly1305 decryption test %zu: FAIL", i + 1);
        }
 
        for (total_len = POLY1305_DIGEST_SIZE; IS_ENABLED(DEBUG_CHACHA20POLY1305_SLOW_CHUNK_TEST)
@@ -9067,16 +9060,26 @@ bool __init chacha20poly1305_selftest(void)
                                continue;
 
                        chunkfail:
-                               pr_err("chacha20poly1305 chunked self-test %zu/%zu/%zu: FAIL\n",
-                                      total_len, i, j);
-                               success = false;
+                               KUNIT_FAIL(
+                                       test,
+                                       "chacha20poly1305 chunked test %zu/%zu/%zu: FAIL\n",
+                                       total_len, i, j);
                        }
 
                }
        }
-
-out:
-       kfree(computed_output);
-       kfree(input);
-       return success;
 }
+
+static struct kunit_case chacha20poly1305_test_cases[] = {
+       KUNIT_CASE(test_chacha20poly1305),
+       {},
+};
+
+static struct kunit_suite chacha20poly1305_test_suite = {
+       .name = "chacha20poly1305",
+       .test_cases = chacha20poly1305_test_cases,
+};
+kunit_test_suite(chacha20poly1305_test_suite);
+
+MODULE_DESCRIPTION("KUnit tests for ChaCha20Poly1305");
+MODULE_LICENSE("GPL");