aes ctr_drbg: add cavs tests
authorPatrick Steuer <patrick.steuer@de.ibm.com>
Sat, 10 Mar 2018 18:06:43 +0000 (19:06 +0100)
committerKurt Roeckx <kurt@roeckx.be>
Wed, 21 Mar 2018 20:32:47 +0000 (21:32 +0100)
Signed-off-by: Patrick Steuer <patrick.steuer@de.ibm.com>
Reviewed-by: Kurt Roeckx <kurt@roeckx.be>
Reviewed-by: Rich Salz <rsalz@openssl.org>
GH: #5580

test/build.info
test/drbg_cavs_data.c [new file with mode: 0644]
test/drbg_cavs_data.h [new file with mode: 0644]
test/drbg_cavs_test.c [new file with mode: 0644]
test/recipes/05-test_rand.t

index 2a7ea74..ddd3e20 100644 (file)
@@ -47,6 +47,7 @@ INCLUDE_MAIN___test_libtestutil_OLB = /INCLUDE=MAIN
           asn1_encode_test asn1_string_table_test \
           x509_time_test x509_dup_cert_test x509_check_cert_pkey_test \
           recordlentest drbgtest sslbuffertest \
+          recordlentest drbgtest drbg_cavs_test sslbuffertest \
           time_offset_test pemtest ssl_cert_table_internal_test ciphername_test \
           servername_test ocspapitest rsa_mp_test fatalerrtest tls13ccstest \
           sysdefaulttest
@@ -339,6 +340,10 @@ INCLUDE_MAIN___test_libtestutil_OLB = /INCLUDE=MAIN
   INCLUDE[drbgtest]=../include
   DEPEND[drbgtest]=../libcrypto libtestutil.a
 
+  SOURCE[drbg_cavs_test]=drbg_cavs_test.c drbg_cavs_data.c
+  INCLUDE[drbg_cavs_test]=../include . ..
+  DEPEND[drbg_cavs_test]=../libcrypto libtestutil.a
+
   SOURCE[x509_dup_cert_test]=x509_dup_cert_test.c
   INCLUDE[x509_dup_cert_test]=../include
   DEPEND[x509_dup_cert_test]=../libcrypto libtestutil.a
diff --git a/test/drbg_cavs_data.c b/test/drbg_cavs_data.c
new file mode 100644 (file)
index 0000000..07f36b8
--- /dev/null
@@ -0,0 +1,170320 @@
+/*
+ * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * DRBG test vectors from:
+ * https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/
+ */
+
+#include <openssl/obj_mac.h>
+#include "internal/nelem.h"
+#include "drbg_cavs_data.h"
+
+static const unsigned char kat1_entropyin[] = {
+    0x89, 0x0e, 0xb0, 0x67, 0xac, 0xf7, 0x38, 0x2e, 0xff, 0x80, 0xb0, 0xc7,
+    0x3b, 0xc8, 0x72, 0xc6,
+};
+static const unsigned char kat1_nonce[] = {
+    0xaa, 0xd4, 0x71, 0xef, 0x3e, 0xf1, 0xd2, 0x03,
+};
+static const unsigned char kat1_persstr[] = {0};
+static const unsigned char kat1_addin0[] = {0};
+static const unsigned char kat1_addin1[] = {0};
+static const unsigned char kat1_retbits[] = {
+    0xa5, 0x51, 0x4e, 0xd7, 0x09, 0x5f, 0x64, 0xf3, 0xd0, 0xd3, 0xa5, 0x76,
+    0x03, 0x94, 0xab, 0x42, 0x06, 0x2f, 0x37, 0x3a, 0x25, 0x07, 0x2a, 0x6e,
+    0xa6, 0xbc, 0xfd, 0x84, 0x89, 0xe9, 0x4a, 0xf6, 0xcf, 0x18, 0x65, 0x9f,
+    0xea, 0x22, 0xed, 0x1c, 0xa0, 0xa9, 0xe3, 0x3f, 0x71, 0x8b, 0x11, 0x5e,
+    0xe5, 0x36, 0xb1, 0x28, 0x09, 0xc3, 0x1b, 0x72, 0xb0, 0x8d, 0xdd, 0x8b,
+    0xe1, 0x91, 0x0f, 0xa3,
+};
+static const struct drbg_kat_no_reseed kat1_t = {
+    0, kat1_entropyin, kat1_nonce, kat1_persstr,
+    kat1_addin0, kat1_addin1, kat1_retbits
+};
+static const struct drbg_kat kat1 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat1_t
+};
+
+static const unsigned char kat2_entropyin[] = {
+    0xc4, 0x7b, 0xe8, 0xe8, 0x21, 0x9a, 0x5a, 0x87, 0xc9, 0x40, 0x64, 0xa5,
+    0x12, 0x08, 0x9f, 0x2b,
+};
+static const unsigned char kat2_nonce[] = {
+    0xf2, 0xa2, 0x3e, 0x63, 0x6a, 0xee, 0x75, 0xc6,
+};
+static const unsigned char kat2_persstr[] = {0};
+static const unsigned char kat2_addin0[] = {0};
+static const unsigned char kat2_addin1[] = {0};
+static const unsigned char kat2_retbits[] = {
+    0x5a, 0x16, 0x50, 0xbb, 0x6d, 0x6a, 0x16, 0xf6, 0x04, 0x05, 0x91, 0xd5,
+    0x6a, 0xbc, 0xd5, 0xdd, 0x3d, 0xb8, 0x77, 0x2a, 0x9c, 0x75, 0xc4, 0x4d,
+    0x9f, 0xc6, 0x4d, 0x51, 0xb7, 0x33, 0xd4, 0xa6, 0x75, 0x9b, 0xd5, 0xa6,
+    0x4e, 0xc4, 0x23, 0x1a, 0x24, 0xe6, 0x62, 0xfd, 0xd4, 0x7c, 0x82, 0xdb,
+    0x63, 0xb2, 0x00, 0xda, 0xf8, 0xd0, 0x98, 0x56, 0x0e, 0xb5, 0xba, 0x7b,
+    0xf3, 0xf9, 0xab, 0xf7,
+};
+static const struct drbg_kat_no_reseed kat2_t = {
+    1, kat2_entropyin, kat2_nonce, kat2_persstr,
+    kat2_addin0, kat2_addin1, kat2_retbits
+};
+static const struct drbg_kat kat2 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat2_t
+};
+
+static const unsigned char kat3_entropyin[] = {
+    0x13, 0x0b, 0x8c, 0x3d, 0x2d, 0x7b, 0x6e, 0x02, 0xc4, 0x10, 0xb4, 0x16,
+    0x8e, 0x12, 0x2c, 0x38,
+};
+static const unsigned char kat3_nonce[] = {
+    0x79, 0xa6, 0x74, 0xc5, 0xb2, 0xc5, 0x1a, 0xa9,
+};
+static const unsigned char kat3_persstr[] = {0};
+static const unsigned char kat3_addin0[] = {0};
+static const unsigned char kat3_addin1[] = {0};
+static const unsigned char kat3_retbits[] = {
+    0x57, 0xe8, 0xa1, 0xe5, 0x78, 0xed, 0xe1, 0xc6, 0x68, 0x79, 0xc4, 0x30,
+    0xdf, 0x72, 0x64, 0x35, 0xd5, 0x1a, 0x36, 0x9a, 0x0f, 0xe5, 0x9a, 0x03,
+    0x58, 0xd1, 0xde, 0x35, 0x2d, 0x42, 0x80, 0xfd, 0x7b, 0x22, 0x5f, 0x5f,
+    0x38, 0x6a, 0x4f, 0xcf, 0x12, 0xf7, 0x27, 0x94, 0xad, 0x0f, 0x37, 0x57,
+    0xfb, 0x25, 0xde, 0xba, 0x3c, 0x75, 0x12, 0xce, 0x4d, 0x37, 0x33, 0xc7,
+    0xee, 0x06, 0x70, 0x43,
+};
+static const struct drbg_kat_no_reseed kat3_t = {
+    2, kat3_entropyin, kat3_nonce, kat3_persstr,
+    kat3_addin0, kat3_addin1, kat3_retbits
+};
+static const struct drbg_kat kat3 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat3_t
+};
+
+static const unsigned char kat4_entropyin[] = {
+    0x04, 0xd2, 0x41, 0x45, 0x28, 0x76, 0x64, 0xf6, 0x76, 0x2b, 0x5d, 0x2a,
+    0x10, 0x2a, 0xc6, 0x03,
+};
+static const unsigned char kat4_nonce[] = {
+    0xec, 0xac, 0x63, 0xe1, 0x21, 0x7e, 0xe3, 0x35,
+};
+static const unsigned char kat4_persstr[] = {0};
+static const unsigned char kat4_addin0[] = {0};
+static const unsigned char kat4_addin1[] = {0};
+static const unsigned char kat4_retbits[] = {
+    0xfa, 0x5e, 0x74, 0x6d, 0xec, 0xd6, 0x80, 0x1e, 0xb7, 0x08, 0x3b, 0x6f,
+    0x0e, 0x72, 0x43, 0x2e, 0x1f, 0xd4, 0x24, 0x31, 0x04, 0xf7, 0x48, 0xd0,
+    0xf1, 0x90, 0x83, 0x92, 0x3b, 0x95, 0x55, 0x68, 0x8f, 0x43, 0x14, 0x6d,
+    0x5a, 0xce, 0xa9, 0x62, 0xda, 0x01, 0x23, 0x1d, 0x9e, 0x5f, 0xaf, 0xf0,
+    0xe8, 0x1f, 0x3d, 0x39, 0x4a, 0xce, 0x3a, 0x34, 0x54, 0x53, 0x6d, 0x72,
+    0x65, 0x75, 0x04, 0x1f,
+};
+static const struct drbg_kat_no_reseed kat4_t = {
+    3, kat4_entropyin, kat4_nonce, kat4_persstr,
+    kat4_addin0, kat4_addin1, kat4_retbits
+};
+static const struct drbg_kat kat4 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat4_t
+};
+
+static const unsigned char kat5_entropyin[] = {
+    0xae, 0xde, 0x4e, 0x61, 0x35, 0x56, 0xb1, 0xd5, 0xa3, 0x0f, 0xce, 0x26,
+    0x1f, 0xbb, 0x82, 0x0c,
+};
+static const unsigned char kat5_nonce[] = {
+    0x39, 0xac, 0xba, 0x03, 0xc5, 0xf1, 0x0a, 0xf4,
+};
+static const unsigned char kat5_persstr[] = {0};
+static const unsigned char kat5_addin0[] = {0};
+static const unsigned char kat5_addin1[] = {0};
+static const unsigned char kat5_retbits[] = {
+    0x23, 0x2c, 0x44, 0xb8, 0x19, 0xb8, 0x8f, 0x1a, 0xeb, 0x83, 0xf2, 0x03,
+    0x4f, 0x84, 0x2d, 0x5a, 0x00, 0xf0, 0x30, 0x15, 0x05, 0xd2, 0xaa, 0x69,
+    0xaa, 0xec, 0xb3, 0xcb, 0x14, 0xbc, 0xb1, 0x58, 0x75, 0xe0, 0xfd, 0x60,
+    0x07, 0x1a, 0x80, 0xf6, 0x26, 0x2d, 0xce, 0xbc, 0xf4, 0x1a, 0x0e, 0x14,
+    0x76, 0xd9, 0x6f, 0x40, 0x97, 0x12, 0xd8, 0x28, 0xae, 0x31, 0x3a, 0x9d,
+    0x28, 0xec, 0x2d, 0xee,
+};
+static const struct drbg_kat_no_reseed kat5_t = {
+    4, kat5_entropyin, kat5_nonce, kat5_persstr,
+    kat5_addin0, kat5_addin1, kat5_retbits
+};
+static const struct drbg_kat kat5 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat5_t
+};
+
+static const unsigned char kat6_entropyin[] = {
+    0x9f, 0x90, 0x54, 0x1c, 0x10, 0xd4, 0xb7, 0xc0, 0x89, 0xfe, 0x68, 0x8e,
+    0xa3, 0xef, 0x4f, 0xc6,
+};
+static const unsigned char kat6_nonce[] = {
+    0x1e, 0xac, 0x1c, 0x22, 0x03, 0x6e, 0x2b, 0x22,
+};
+static const unsigned char kat6_persstr[] = {0};
+static const unsigned char kat6_addin0[] = {0};
+static const unsigned char kat6_addin1[] = {0};
+static const unsigned char kat6_retbits[] = {
+    0x71, 0xaf, 0x3f, 0xdf, 0x67, 0x34, 0x04, 0x16, 0x3b, 0x06, 0x73, 0x7e,
+    0x0f, 0x39, 0x91, 0x5f, 0xae, 0xc2, 0x18, 0x21, 0x81, 0x6c, 0x31, 0x42,
+    0xe8, 0x0a, 0x50, 0x3c, 0x70, 0xcb, 0x2e, 0xdd, 0x46, 0x8c, 0x3f, 0x03,
+    0xcb, 0x1f, 0x8a, 0x2f, 0x92, 0x48, 0x63, 0x5b, 0x63, 0xd7, 0xb8, 0xf1,
+    0x9e, 0x9e, 0x11, 0xca, 0xf0, 0xab, 0x0c, 0x3d, 0x2f, 0xf9, 0xc7, 0x13,
+    0x21, 0xca, 0xc1, 0x54,
+};
+static const struct drbg_kat_no_reseed kat6_t = {
+    5, kat6_entropyin, kat6_nonce, kat6_persstr,
+    kat6_addin0, kat6_addin1, kat6_retbits
+};
+static const struct drbg_kat kat6 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat6_t
+};
+
+static const unsigned char kat7_entropyin[] = {
+    0x3b, 0x8a, 0x18, 0x1c, 0xea, 0x83, 0x90, 0xd5, 0xd7, 0xa4, 0xe6, 0x51,
+    0x5c, 0xf9, 0x2e, 0x3e,
+};
+static const unsigned char kat7_nonce[] = {
+    0x37, 0xf4, 0xd1, 0x74, 0x87, 0x14, 0x34, 0x5b,
+};
+static const unsigned char kat7_persstr[] = {0};
+static const unsigned char kat7_addin0[] = {0};
+static const unsigned char kat7_addin1[] = {0};
+static const unsigned char kat7_retbits[] = {
+    0xd6, 0xfd, 0x0f, 0xfb, 0x10, 0x85, 0x0e, 0xb6, 0xeb, 0x70, 0x50, 0xe6,
+    0x1e, 0xac, 0x00, 0xd4, 0x72, 0xf6, 0x5c, 0xd3, 0xd9, 0x35, 0x08, 0x14,
+    0x77, 0xfe, 0x44, 0xaa, 0x85, 0x69, 0x4e, 0x12, 0x0a, 0xb5, 0xa1, 0xca,
+    0x1f, 0xa1, 0x98, 0xaf, 0x76, 0xdf, 0xa8, 0xd0, 0xab, 0xdf, 0x53, 0xe8,
+    0x5a, 0xa8, 0xc8, 0x7f, 0xed, 0x0a, 0x8c, 0x24, 0x16, 0x39, 0x43, 0xb9,
+    0x6d, 0x80, 0xaa, 0xfb,
+};
+static const struct drbg_kat_no_reseed kat7_t = {
+    6, kat7_entropyin, kat7_nonce, kat7_persstr,
+    kat7_addin0, kat7_addin1, kat7_retbits
+};
+static const struct drbg_kat kat7 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat7_t
+};
+
+static const unsigned char kat8_entropyin[] = {
+    0x85, 0x4c, 0xaa, 0x2a, 0x74, 0xf3, 0xf4, 0x3b, 0x6a, 0xbd, 0x80, 0x6d,
+    0x67, 0x48, 0xed, 0x80,
+};
+static const unsigned char kat8_nonce[] = {
+    0x0c, 0xbd, 0x13, 0x72, 0xbe, 0xb6, 0x27, 0x36,
+};
+static const unsigned char kat8_persstr[] = {0};
+static const unsigned char kat8_addin0[] = {0};
+static const unsigned char kat8_addin1[] = {0};
+static const unsigned char kat8_retbits[] = {
+    0x46, 0x53, 0x40, 0x28, 0x16, 0x5f, 0xfe, 0x28, 0x45, 0xa9, 0x72, 0x62,
+    0x7e, 0x67, 0xe1, 0x53, 0x51, 0x0c, 0xa1, 0x88, 0x0e, 0x6a, 0x3a, 0xd3,
+    0x1f, 0xde, 0xe7, 0x1f, 0xf2, 0x40, 0xd3, 0x27, 0x86, 0x24, 0xb3, 0x1f,
+    0x2d, 0x38, 0x6d, 0x7b, 0x22, 0x28, 0xce, 0xd6, 0x24, 0xa4, 0x2e, 0x7a,
+    0x3b, 0x07, 0x48, 0x0b, 0x23, 0x23, 0x16, 0x6c, 0x18, 0xd1, 0xac, 0x0f,
+    0x60, 0x00, 0x2e, 0xc4,
+};
+static const struct drbg_kat_no_reseed kat8_t = {
+    7, kat8_entropyin, kat8_nonce, kat8_persstr,
+    kat8_addin0, kat8_addin1, kat8_retbits
+};
+static const struct drbg_kat kat8 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat8_t
+};
+
+static const unsigned char kat9_entropyin[] = {
+    0x87, 0xe1, 0xc5, 0x32, 0x99, 0x7f, 0x57, 0xa3, 0x5c, 0x28, 0x6d, 0xe8,
+    0x64, 0xbf, 0xf2, 0x64,
+};
+static const unsigned char kat9_nonce[] = {
+    0xa3, 0x9e, 0x98, 0xdb, 0x6c, 0x10, 0x78, 0x7f,
+};
+static const unsigned char kat9_persstr[] = {0};
+static const unsigned char kat9_addin0[] = {0};
+static const unsigned char kat9_addin1[] = {0};
+static const unsigned char kat9_retbits[] = {
+    0x2c, 0x14, 0x7e, 0x24, 0x11, 0x9a, 0xd8, 0xd4, 0xb2, 0xed, 0x61, 0xc1,
+    0x53, 0xd0, 0x50, 0xc9, 0x24, 0xff, 0x59, 0x75, 0x15, 0xf1, 0x17, 0x3a,
+    0x3d, 0xf4, 0x4b, 0x2c, 0x84, 0x28, 0xef, 0x89, 0x0e, 0xb9, 0xde, 0xf3,
+    0xe4, 0x78, 0x04, 0xb2, 0xfd, 0x9b, 0x35, 0x7f, 0xe1, 0x3f, 0x8a, 0x3e,
+    0x10, 0xc8, 0x67, 0x0a, 0xf9, 0xdf, 0x2d, 0x6c, 0x96, 0xfb, 0xb2, 0xb8,
+    0xcb, 0x2d, 0xd6, 0xb0,
+};
+static const struct drbg_kat_no_reseed kat9_t = {
+    8, kat9_entropyin, kat9_nonce, kat9_persstr,
+    kat9_addin0, kat9_addin1, kat9_retbits
+};
+static const struct drbg_kat kat9 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat9_t
+};
+
+static const unsigned char kat10_entropyin[] = {
+    0x2f, 0xc6, 0x23, 0x42, 0x90, 0x29, 0xc9, 0x6e, 0xde, 0xf6, 0x16, 0x62,
+    0x47, 0xb0, 0x8c, 0xb0,
+};
+static const unsigned char kat10_nonce[] = {
+    0x99, 0x82, 0x66, 0x33, 0x55, 0x58, 0x27, 0x88,
+};
+static const unsigned char kat10_persstr[] = {0};
+static const unsigned char kat10_addin0[] = {0};
+static const unsigned char kat10_addin1[] = {0};
+static const unsigned char kat10_retbits[] = {
+    0x55, 0x96, 0xcb, 0x16, 0xf3, 0xbe, 0x85, 0x52, 0xc1, 0xe5, 0xc1, 0x64,
+    0xd5, 0x40, 0xcb, 0x1f, 0xaf, 0x4b, 0xea, 0x87, 0x33, 0xb6, 0x0a, 0x8a,
+    0xd0, 0xc4, 0x06, 0x26, 0x25, 0x65, 0x48, 0xc7, 0xaa, 0x96, 0xd1, 0xd2,
+    0x72, 0x9d, 0x26, 0xf0, 0x08, 0x73, 0x1f, 0xc3, 0x93, 0x07, 0xbe, 0x5b,
+    0xcd, 0x20, 0x81, 0xc6, 0x9e, 0x31, 0x4e, 0x0c, 0x73, 0xe3, 0xd0, 0xfd,
+    0x1d, 0x90, 0x58, 0x28,
+};
+static const struct drbg_kat_no_reseed kat10_t = {
+    9, kat10_entropyin, kat10_nonce, kat10_persstr,
+    kat10_addin0, kat10_addin1, kat10_retbits
+};
+static const struct drbg_kat kat10 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat10_t
+};
+
+static const unsigned char kat11_entropyin[] = {
+    0x98, 0xab, 0x8b, 0x4e, 0xaf, 0xab, 0x6e, 0x53, 0x6f, 0x78, 0x45, 0xab,
+    0xec, 0x13, 0x78, 0x08,
+};
+static const unsigned char kat11_nonce[] = {
+    0xdb, 0xa9, 0x44, 0xc9, 0x8b, 0x31, 0x1d, 0x8e,
+};
+static const unsigned char kat11_persstr[] = {0};
+static const unsigned char kat11_addin0[] = {0};
+static const unsigned char kat11_addin1[] = {0};
+static const unsigned char kat11_retbits[] = {
+    0x86, 0xee, 0xd3, 0xa9, 0xfa, 0x53, 0x45, 0x2f, 0xb1, 0x1d, 0xba, 0x9c,
+    0xac, 0x8e, 0x44, 0x02, 0x52, 0x29, 0x28, 0xf2, 0x70, 0x5a, 0x5e, 0x58,
+    0x2f, 0x4d, 0x00, 0xeb, 0x8f, 0xed, 0x81, 0x8e, 0x62, 0x9c, 0x72, 0xa6,
+    0xa7, 0x79, 0xbe, 0xb4, 0xed, 0x9a, 0x23, 0x93, 0x68, 0x23, 0x3c, 0xbf,
+    0xcf, 0x55, 0x68, 0x5d, 0xbf, 0x2d, 0xe3, 0x4a, 0xb5, 0x89, 0x20, 0xcf,
+    0xac, 0xa4, 0xaa, 0xfe,
+};
+static const struct drbg_kat_no_reseed kat11_t = {
+    10, kat11_entropyin, kat11_nonce, kat11_persstr,
+    kat11_addin0, kat11_addin1, kat11_retbits
+};
+static const struct drbg_kat kat11 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat11_t
+};
+
+static const unsigned char kat12_entropyin[] = {
+    0x7d, 0xcf, 0x4f, 0xa7, 0x31, 0x13, 0x9c, 0x5b, 0xb6, 0x44, 0x2f, 0xed,
+    0x91, 0xe8, 0x9f, 0x68,
+};
+static const unsigned char kat12_nonce[] = {
+    0xff, 0xd9, 0x4f, 0xe2, 0x1a, 0x80, 0x8b, 0x15,
+};
+static const unsigned char kat12_persstr[] = {0};
+static const unsigned char kat12_addin0[] = {0};
+static const unsigned char kat12_addin1[] = {0};
+static const unsigned char kat12_retbits[] = {
+    0x8e, 0xca, 0x20, 0xe3, 0x1c, 0x98, 0x39, 0xb7, 0x41, 0xaa, 0xa9, 0xbf,
+    0x6c, 0xee, 0xe2, 0x24, 0xd3, 0x21, 0x26, 0xb3, 0x19, 0x6e, 0xef, 0x3e,
+    0xcd, 0x34, 0x3d, 0x41, 0x4d, 0x32, 0x33, 0xb9, 0xfd, 0x0e, 0xa0, 0xed,
+    0x1b, 0xc7, 0x70, 0x0c, 0x88, 0xcd, 0x7c, 0x88, 0xd3, 0xc0, 0x76, 0x13,
+    0xc4, 0x2c, 0xd1, 0xf9, 0x09, 0xfe, 0xd8, 0xc6, 0xa7, 0x08, 0xd0, 0x5d,
+    0x6b, 0x68, 0xfb, 0x2e,
+};
+static const struct drbg_kat_no_reseed kat12_t = {
+    11, kat12_entropyin, kat12_nonce, kat12_persstr,
+    kat12_addin0, kat12_addin1, kat12_retbits
+};
+static const struct drbg_kat kat12 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat12_t
+};
+
+static const unsigned char kat13_entropyin[] = {
+    0x51, 0x9c, 0x6e, 0xfe, 0xde, 0xd2, 0xa1, 0x10, 0xac, 0x41, 0x83, 0x9a,
+    0x8b, 0x8a, 0xbf, 0xce,
+};
+static const unsigned char kat13_nonce[] = {
+    0x81, 0xd9, 0x5e, 0xdc, 0x06, 0xdd, 0xe6, 0xb3,
+};
+static const unsigned char kat13_persstr[] = {0};
+static const unsigned char kat13_addin0[] = {0};
+static const unsigned char kat13_addin1[] = {0};
+static const unsigned char kat13_retbits[] = {
+    0x39, 0xcd, 0xd1, 0x0e, 0x49, 0xe0, 0x35, 0x81, 0xe3, 0x81, 0x1d, 0xdd,
+    0x07, 0xd9, 0xd0, 0xac, 0xc3, 0x40, 0x85, 0xa1, 0x2c, 0x1c, 0x6b, 0x87,
+    0xa7, 0x63, 0x86, 0xe9, 0x70, 0x32, 0xdc, 0x01, 0xf5, 0x23, 0xf6, 0x32,
+    0xec, 0x95, 0x0d, 0x04, 0x34, 0xc2, 0x59, 0x37, 0xe4, 0x32, 0xd9, 0x85,
+    0x54, 0x59, 0x9a, 0x85, 0x5d, 0xb9, 0xad, 0xf5, 0x8b, 0x9e, 0x04, 0x59,
+    0x7a, 0x21, 0xd0, 0x0d,
+};
+static const struct drbg_kat_no_reseed kat13_t = {
+    12, kat13_entropyin, kat13_nonce, kat13_persstr,
+    kat13_addin0, kat13_addin1, kat13_retbits
+};
+static const struct drbg_kat kat13 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat13_t
+};
+
+static const unsigned char kat14_entropyin[] = {
+    0x80, 0xc1, 0x9e, 0xea, 0xad, 0x1a, 0x58, 0x37, 0x94, 0x66, 0xaf, 0xae,
+    0x1d, 0x80, 0x87, 0x6d,
+};
+static const unsigned char kat14_nonce[] = {
+    0xd9, 0xa2, 0x09, 0x3f, 0x11, 0x89, 0x2b, 0x82,
+};
+static const unsigned char kat14_persstr[] = {0};
+static const unsigned char kat14_addin0[] = {0};
+static const unsigned char kat14_addin1[] = {0};
+static const unsigned char kat14_retbits[] = {
+    0xce, 0xc5, 0x1b, 0x98, 0x5e, 0xc9, 0x7b, 0x18, 0xee, 0x8e, 0xad, 0x36,
+    0x15, 0x7b, 0xea, 0xf9, 0x6f, 0x12, 0x9f, 0x28, 0x28, 0x08, 0x89, 0xec,
+    0x87, 0x3c, 0x27, 0xb5, 0x62, 0x71, 0x98, 0xc5, 0x85, 0xa6, 0xad, 0x21,
+    0xae, 0x23, 0xa9, 0x59, 0xc9, 0xfa, 0x49, 0xd9, 0x85, 0xaf, 0x0d, 0xf4,
+    0x02, 0x8f, 0xdf, 0x1f, 0x51, 0xd8, 0x2e, 0x8f, 0x2b, 0x3f, 0x02, 0x88,
+    0x53, 0xf1, 0x4e, 0x8f,
+};
+static const struct drbg_kat_no_reseed kat14_t = {
+    13, kat14_entropyin, kat14_nonce, kat14_persstr,
+    kat14_addin0, kat14_addin1, kat14_retbits
+};
+static const struct drbg_kat kat14 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat14_t
+};
+
+static const unsigned char kat15_entropyin[] = {
+    0xb7, 0x7b, 0xd2, 0x2e, 0xfe, 0xb7, 0x71, 0x58, 0x6d, 0x51, 0x6f, 0x58,
+    0x21, 0x92, 0xa3, 0x11,
+};
+static const unsigned char kat15_nonce[] = {
+    0xa6, 0x99, 0xf4, 0x2a, 0x49, 0x81, 0xfe, 0xfc,
+};
+static const unsigned char kat15_persstr[] = {0};
+static const unsigned char kat15_addin0[] = {0};
+static const unsigned char kat15_addin1[] = {0};
+static const unsigned char kat15_retbits[] = {
+    0x7f, 0xf0, 0xab, 0xea, 0xff, 0xc6, 0xec, 0x92, 0x3c, 0xeb, 0xd9, 0x10,
+    0xf5, 0x93, 0x7b, 0xf1, 0x4f, 0xc5, 0x2d, 0x2a, 0x74, 0x25, 0x83, 0x88,
+    0xc7, 0x6c, 0x1b, 0xc9, 0xe6, 0x35, 0xad, 0xf1, 0x75, 0x85, 0x8f, 0x0a,
+    0x55, 0x87, 0x7e, 0x7e, 0x9f, 0x5f, 0x86, 0x7d, 0x00, 0xb9, 0xb1, 0x36,
+    0x3d, 0xde, 0x46, 0x28, 0x8a, 0x6f, 0xff, 0x53, 0x21, 0xf4, 0x69, 0x44,
+    0x5a, 0xad, 0x41, 0x98,
+};
+static const struct drbg_kat_no_reseed kat15_t = {
+    14, kat15_entropyin, kat15_nonce, kat15_persstr,
+    kat15_addin0, kat15_addin1, kat15_retbits
+};
+static const struct drbg_kat kat15 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat15_t
+};
+
+static const unsigned char kat16_entropyin[] = {
+    0xb4, 0x08, 0xce, 0xfb, 0x5b, 0xc7, 0x15, 0x7d, 0x3f, 0x26, 0xcb, 0x95,
+    0xa8, 0xb1, 0xd7, 0xac,
+};
+static const unsigned char kat16_nonce[] = {
+    0x02, 0x6c, 0x76, 0x8f, 0xd5, 0x77, 0xb9, 0x2a,
+};
+static const unsigned char kat16_persstr[] = {0};
+static const unsigned char kat16_addin0[] = {
+    0x57, 0x37, 0xef, 0x81, 0xde, 0xe3, 0x65, 0xb6, 0xda, 0xdb, 0x3f, 0xee,
+    0xbf, 0x5d, 0x10, 0x84,
+};
+static const unsigned char kat16_addin1[] = {
+    0x33, 0x68, 0xa5, 0x16, 0xb3, 0x43, 0x1a, 0x3d, 0xaa, 0xa6, 0x0d, 0xc8,
+    0x74, 0x3c, 0x82, 0x97,
+};
+static const unsigned char kat16_retbits[] = {
+    0x4e, 0x90, 0x9e, 0xbb, 0x24, 0x14, 0x7a, 0x00, 0x04, 0x06, 0x3a, 0x5e,
+    0x47, 0xee, 0x04, 0x4f, 0xea, 0xd6, 0x10, 0xd6, 0x23, 0x24, 0xbd, 0x0f,
+    0x96, 0x3f, 0x75, 0x6f, 0xb9, 0x13, 0x61, 0xe8, 0xb8, 0x7e, 0x3a, 0x76,
+    0xa3, 0x98, 0x14, 0x3f, 0xe8, 0x81, 0x30, 0xfe, 0x1b, 0x54, 0x7b, 0x66,
+    0x1a, 0x64, 0x80, 0xc7, 0x11, 0xb7, 0x39, 0xf1, 0x8a, 0x9d, 0xf3, 0xae,
+    0x51, 0xd4, 0x1b, 0xc9,
+};
+static const struct drbg_kat_no_reseed kat16_t = {
+    0, kat16_entropyin, kat16_nonce, kat16_persstr,
+    kat16_addin0, kat16_addin1, kat16_retbits
+};
+static const struct drbg_kat kat16 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat16_t
+};
+
+static const unsigned char kat17_entropyin[] = {
+    0x71, 0xbd, 0xce, 0x35, 0x42, 0x7d, 0x20, 0xbf, 0x58, 0xcf, 0x17, 0x74,
+    0xce, 0x72, 0xd8, 0x33,
+};
+static const unsigned char kat17_nonce[] = {
+    0x34, 0x50, 0x2d, 0x8f, 0x5b, 0x14, 0xc4, 0xdd,
+};
+static const unsigned char kat17_persstr[] = {0};
+static const unsigned char kat17_addin0[] = {
+    0x66, 0xef, 0x42, 0xd6, 0x9a, 0x8c, 0x3d, 0x6d, 0x4a, 0x9e, 0x95, 0xa6,
+    0x91, 0x4d, 0x81, 0x56,
+};
+static const unsigned char kat17_addin1[] = {
+    0xe3, 0x18, 0x83, 0xd9, 0x4b, 0x5e, 0xc4, 0xcc, 0xaa, 0x61, 0x2f, 0xbb,
+    0x4a, 0x55, 0xd1, 0xc6,
+};
+static const unsigned char kat17_retbits[] = {
+    0x97, 0x33, 0xe8, 0x20, 0x12, 0xe2, 0x7b, 0xa1, 0x46, 0x8f, 0xf2, 0x34,
+    0xb3, 0xc9, 0xb6, 0x6b, 0x20, 0xb2, 0x4f, 0xee, 0x27, 0xd8, 0x0b, 0x21,
+    0x8c, 0xff, 0x63, 0x73, 0x69, 0x29, 0xfb, 0xf3, 0x85, 0xcd, 0x88, 0x8e,
+    0x43, 0x2c, 0x71, 0x8b, 0xa2, 0x55, 0xd2, 0x0f, 0x1d, 0x7f, 0xe3, 0xe1,
+    0x2a, 0xa3, 0xe9, 0x2c, 0x25, 0x89, 0xc7, 0x14, 0x52, 0x99, 0x56, 0xcc,
+    0xc3, 0xdf, 0xb3, 0x81,
+};
+static const struct drbg_kat_no_reseed kat17_t = {
+    1, kat17_entropyin, kat17_nonce, kat17_persstr,
+    kat17_addin0, kat17_addin1, kat17_retbits
+};
+static const struct drbg_kat kat17 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat17_t
+};
+
+static const unsigned char kat18_entropyin[] = {
+    0x9c, 0x0e, 0x4a, 0xea, 0xfc, 0x35, 0x7f, 0xf8, 0xe3, 0xf5, 0x40, 0xa4,
+    0x55, 0x67, 0x8d, 0x7e,
+};
+static const unsigned char kat18_nonce[] = {
+    0xef, 0xd8, 0x3d, 0xc5, 0xc5, 0x31, 0xd1, 0x67,
+};
+static const unsigned char kat18_persstr[] = {0};
+static const unsigned char kat18_addin0[] = {
+    0x58, 0xa1, 0x18, 0x14, 0x08, 0x1c, 0x1c, 0x35, 0xaf, 0x89, 0x88, 0xf1,
+    0x31, 0x40, 0xf6, 0xcc,
+};
+static const unsigned char kat18_addin1[] = {
+    0x19, 0x19, 0x22, 0x70, 0xd6, 0x1a, 0x43, 0x26, 0x4a, 0x30, 0xba, 0x9e,
+    0xbc, 0x72, 0x8a, 0x5b,
+};
+static const unsigned char kat18_retbits[] = {
+    0x1e, 0xff, 0x1c, 0xf6, 0xb5, 0x75, 0x31, 0x55, 0x90, 0x70, 0x38, 0x82,
+    0x35, 0x9b, 0x6a, 0xdb, 0x3c, 0x21, 0xeb, 0xcf, 0xda, 0x5d, 0x3b, 0x5d,
+    0x6e, 0x88, 0xac, 0xab, 0x6e, 0x87, 0x9e, 0x0a, 0x6f, 0x75, 0x37, 0x5c,
+    0x02, 0xd1, 0xd3, 0xfb, 0xae, 0x94, 0x3c, 0x34, 0x43, 0xe3, 0x9c, 0x29,
+    0x9b, 0x80, 0xe2, 0x41, 0xcd, 0x36, 0x5d, 0x4a, 0xf8, 0xcd, 0x1a, 0xd5,
+    0xd9, 0xd5, 0x4c, 0x58,
+};
+static const struct drbg_kat_no_reseed kat18_t = {
+    2, kat18_entropyin, kat18_nonce, kat18_persstr,
+    kat18_addin0, kat18_addin1, kat18_retbits
+};
+static const struct drbg_kat kat18 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat18_t
+};
+
+static const unsigned char kat19_entropyin[] = {
+    0x95, 0x07, 0x01, 0x9b, 0x1f, 0xe8, 0x79, 0x84, 0xbe, 0xc1, 0xd0, 0x9c,
+    0xec, 0xcf, 0x36, 0x35,
+};
+static const unsigned char kat19_nonce[] = {
+    0x47, 0x58, 0x62, 0x74, 0xfa, 0x75, 0x3e, 0x0d,
+};
+static const unsigned char kat19_persstr[] = {0};
+static const unsigned char kat19_addin0[] = {
+    0xf1, 0x7d, 0xe4, 0xce, 0xef, 0x9f, 0x2f, 0x23, 0x42, 0x20, 0xcb, 0x71,
+    0xd8, 0xce, 0xb7, 0x0d,
+};
+static const unsigned char kat19_addin1[] = {
+    0x99, 0xd4, 0x8d, 0x9c, 0xe2, 0xfe, 0x76, 0xdc, 0xb8, 0xd0, 0x5f, 0xa4,
+    0xec, 0x07, 0x1a, 0xec,
+};
+static const unsigned char kat19_retbits[] = {
+    0x25, 0xa0, 0xd1, 0x67, 0x8e, 0x25, 0xb1, 0x94, 0x39, 0xd8, 0x33, 0x4c,
+    0xa9, 0x02, 0xdb, 0x63, 0x47, 0xa9, 0xa4, 0x2b, 0x86, 0xf3, 0x54, 0xb9,
+    0xe0, 0xb3, 0xc4, 0xf4, 0xe8, 0xba, 0x9d, 0x19, 0x2a, 0x5d, 0x76, 0x5a,
+    0xae, 0x5f, 0x4c, 0x5a, 0x74, 0xa0, 0x17, 0x7d, 0x3e, 0xb6, 0x13, 0x70,
+    0x62, 0xe6, 0xd9, 0x8b, 0x65, 0x18, 0x22, 0x26, 0x5b, 0xfe, 0xfc, 0x92,
+    0x9a, 0x39, 0x69, 0xdd,
+};
+static const struct drbg_kat_no_reseed kat19_t = {
+    3, kat19_entropyin, kat19_nonce, kat19_persstr,
+    kat19_addin0, kat19_addin1, kat19_retbits
+};
+static const struct drbg_kat kat19 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat19_t
+};
+
+static const unsigned char kat20_entropyin[] = {
+    0x12, 0xe8, 0xb3, 0xda, 0x3a, 0x3b, 0x3e, 0x77, 0x3a, 0xfc, 0x23, 0x05,
+    0xbd, 0xa8, 0x6d, 0xb6,
+};
+static const unsigned char kat20_nonce[] = {
+    0xc4, 0x9f, 0x26, 0x1a, 0x9a, 0xb9, 0xd9, 0xf8,
+};
+static const unsigned char kat20_persstr[] = {0};
+static const unsigned char kat20_addin0[] = {
+    0x86, 0xb6, 0x38, 0x52, 0x41, 0x96, 0x15, 0x9d, 0xea, 0x01, 0x76, 0xe5,
+    0x46, 0x2a, 0xe6, 0x5c,
+};
+static const unsigned char kat20_addin1[] = {
+    0x5e, 0xad, 0xb7, 0x67, 0x72, 0xbe, 0x3c, 0xe8, 0x47, 0xaf, 0x6b, 0x77,
+    0x94, 0xe0, 0x02, 0xe3,
+};
+static const unsigned char kat20_retbits[] = {
+    0x1b, 0xbf, 0x85, 0xe0, 0x2c, 0x1f, 0xc0, 0x4b, 0xea, 0x5f, 0xc4, 0x7f,
+    0x23, 0x6a, 0x07, 0x1c, 0x13, 0xf8, 0xf5, 0x2e, 0xb1, 0x13, 0xcb, 0x83,
+    0xc4, 0x15, 0x2a, 0xc8, 0x32, 0x62, 0x7a, 0xbb, 0xa6, 0xec, 0xde, 0xc1,
+    0x7a, 0x9f, 0xf0, 0x30, 0x5b, 0x7a, 0x49, 0x81, 0x79, 0x83, 0xfa, 0x5b,
+    0x66, 0x51, 0x45, 0xe7, 0xba, 0x9a, 0x5d, 0xf5, 0x72, 0x26, 0xec, 0xcf,
+    0xc1, 0x64, 0xe3, 0xbb,
+};
+static const struct drbg_kat_no_reseed kat20_t = {
+    4, kat20_entropyin, kat20_nonce, kat20_persstr,
+    kat20_addin0, kat20_addin1, kat20_retbits
+};
+static const struct drbg_kat kat20 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat20_t
+};
+
+static const unsigned char kat21_entropyin[] = {
+    0xb6, 0x08, 0xb1, 0x49, 0xcf, 0x44, 0xfe, 0x06, 0x06, 0x13, 0xb1, 0x66,
+    0x1d, 0xa0, 0xdf, 0x63,
+};
+static const unsigned char kat21_nonce[] = {
+    0x95, 0x17, 0xc9, 0x93, 0xf1, 0x50, 0x34, 0x77,
+};
+static const unsigned char kat21_persstr[] = {0};
+static const unsigned char kat21_addin0[] = {
+    0x55, 0x9c, 0xb8, 0x12, 0xc3, 0x75, 0x8b, 0x2b, 0x31, 0x9d, 0xd9, 0xf5,
+    0x76, 0x8e, 0x8d, 0x3d,
+};
+static const unsigned char kat21_addin1[] = {
+    0xc9, 0xaf, 0x98, 0x7e, 0xfc, 0xe4, 0x70, 0x0f, 0xa9, 0xc8, 0xeb, 0xb9,
+    0xfe, 0xcf, 0x00, 0xda,
+};
+static const unsigned char kat21_retbits[] = {
+    0x5b, 0x48, 0x13, 0x4d, 0xc7, 0xe6, 0x58, 0x9f, 0x1b, 0x40, 0x2c, 0xf5,
+    0xc4, 0xf6, 0xe3, 0xa3, 0xeb, 0xfd, 0xa8, 0x26, 0x72, 0x50, 0xe8, 0xe8,
+    0x11, 0xec, 0x05, 0x98, 0x6f, 0xf2, 0x1c, 0x78, 0xa1, 0x69, 0x30, 0xa8,
+    0xe0, 0x81, 0x03, 0x07, 0x76, 0x08, 0xc0, 0x6f, 0xa5, 0xe2, 0xa0, 0x48,
+    0xe8, 0x5d, 0xd6, 0xf3, 0x95, 0xce, 0xe2, 0x01, 0xd3, 0xcd, 0xe6, 0x35,
+    0xe1, 0x7e, 0x20, 0x3e,
+};
+static const struct drbg_kat_no_reseed kat21_t = {
+    5, kat21_entropyin, kat21_nonce, kat21_persstr,
+    kat21_addin0, kat21_addin1, kat21_retbits
+};
+static const struct drbg_kat kat21 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat21_t
+};
+
+static const unsigned char kat22_entropyin[] = {
+    0xe9, 0x2f, 0xd0, 0x7a, 0x09, 0xf2, 0xbc, 0xcb, 0x43, 0x42, 0x4c, 0x57,
+    0x57, 0x73, 0xb0, 0xf0,
+};
+static const unsigned char kat22_nonce[] = {
+    0xb4, 0xe3, 0xca, 0x71, 0xae, 0x15, 0xa0, 0x36,
+};
+static const unsigned char kat22_persstr[] = {0};
+static const unsigned char kat22_addin0[] = {
+    0xe1, 0xb4, 0xb0, 0x40, 0x13, 0xdc, 0x12, 0x18, 0x8c, 0x62, 0x3d, 0x10,
+    0x11, 0xd4, 0x08, 0xf1,
+};
+static const unsigned char kat22_addin1[] = {
+    0x79, 0x56, 0xbf, 0x5b, 0x16, 0x58, 0x0b, 0x3e, 0x72, 0x0a, 0x81, 0x33,
+    0x3e, 0xae, 0x24, 0x83,
+};
+static const unsigned char kat22_retbits[] = {
+    0x21, 0xa4, 0x67, 0x22, 0x42, 0x46, 0x56, 0x37, 0x0c, 0x47, 0x5b, 0x69,
+    0xa1, 0xfb, 0xc7, 0x0c, 0x8c, 0xbf, 0x44, 0x2d, 0xc2, 0xbc, 0x28, 0xe0,
+    0xab, 0x34, 0xbb, 0x6f, 0xfe, 0xd0, 0x6d, 0x10, 0xf4, 0x90, 0xdf, 0x7e,
+    0x78, 0x7c, 0x12, 0xb6, 0x52, 0xd2, 0x19, 0xa5, 0x77, 0x30, 0x6f, 0x04,
+    0xa9, 0xc8, 0x78, 0xb6, 0xcf, 0xdf, 0xf4, 0x3e, 0x13, 0x55, 0xc4, 0xd1,
+    0x10, 0xfb, 0x0f, 0xb2,
+};
+static const struct drbg_kat_no_reseed kat22_t = {
+    6, kat22_entropyin, kat22_nonce, kat22_persstr,
+    kat22_addin0, kat22_addin1, kat22_retbits
+};
+static const struct drbg_kat kat22 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat22_t
+};
+
+static const unsigned char kat23_entropyin[] = {
+    0xde, 0x0b, 0x4e, 0xa1, 0xa4, 0x40, 0xce, 0x68, 0x0e, 0xd0, 0x04, 0xcf,
+    0x64, 0xaf, 0xbe, 0x0f,
+};
+static const unsigned char kat23_nonce[] = {
+    0xab, 0xb3, 0x1a, 0x3a, 0xb1, 0x5e, 0xd4, 0x49,
+};
+static const unsigned char kat23_persstr[] = {0};
+static const unsigned char kat23_addin0[] = {
+    0x45, 0xe7, 0x10, 0x10, 0x0c, 0xad, 0x00, 0xf3, 0xd2, 0x93, 0xdb, 0x75,
+    0x5e, 0xe1, 0x99, 0x0d,
+};
+static const unsigned char kat23_addin1[] = {
+    0xb9, 0x11, 0xc9, 0xa4, 0x38, 0x9e, 0x71, 0x67, 0x98, 0x2a, 0x51, 0x24,
+    0x8e, 0xe2, 0x93, 0x7e,
+};
+static const unsigned char kat23_retbits[] = {
+    0x01, 0xc3, 0xaf, 0x83, 0x55, 0x7c, 0x63, 0x2d, 0xd8, 0x22, 0x83, 0x3f,
+    0x18, 0xe5, 0x48, 0xfb, 0x60, 0x36, 0xe9, 0xcc, 0xac, 0xc3, 0xb4, 0x33,
+    0xc5, 0xa7, 0x00, 0x79, 0x39, 0x93, 0x30, 0x89, 0x16, 0x22, 0x0e, 0x5a,
+    0x74, 0x16, 0x39, 0x86, 0x1c, 0x2f, 0x17, 0x71, 0x9b, 0x32, 0x51, 0x22,
+    0x06, 0xe3, 0x6e, 0x94, 0x7b, 0x28, 0x60, 0x07, 0x3b, 0x11, 0x3c, 0xcd,
+    0xa3, 0xfe, 0x31, 0x68,
+};
+static const struct drbg_kat_no_reseed kat23_t = {
+    7, kat23_entropyin, kat23_nonce, kat23_persstr,
+    kat23_addin0, kat23_addin1, kat23_retbits
+};
+static const struct drbg_kat kat23 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat23_t
+};
+
+static const unsigned char kat24_entropyin[] = {
+    0x72, 0x27, 0xe1, 0x1c, 0xfc, 0x1a, 0x6b, 0x84, 0xb4, 0x0e, 0xca, 0x24,
+    0xe7, 0x7f, 0x8c, 0x64,
+};
+static const unsigned char kat24_nonce[] = {
+    0xab, 0x7e, 0x9f, 0xc4, 0x5e, 0x58, 0x63, 0xfb,
+};
+static const unsigned char kat24_persstr[] = {0};
+static const unsigned char kat24_addin0[] = {
+    0xca, 0xeb, 0xb3, 0xcd, 0x32, 0xc9, 0xd3, 0xe1, 0xf5, 0xd3, 0x8f, 0x8b,
+    0xdd, 0x89, 0x58, 0x7d,
+};
+static const unsigned char kat24_addin1[] = {
+    0x31, 0x38, 0x09, 0x26, 0xb8, 0x60, 0x80, 0x06, 0xb7, 0xc7, 0x93, 0x61,
+    0xf0, 0xf9, 0x1d, 0x5e,
+};
+static const unsigned char kat24_retbits[] = {
+    0x3a, 0xd7, 0xb9, 0x32, 0x59, 0xc6, 0xd0, 0xfd, 0xb5, 0x14, 0x27, 0x7a,
+    0xe9, 0x95, 0x01, 0x22, 0xfb, 0x97, 0x11, 0x33, 0x74, 0x2d, 0xe8, 0xe5,
+    0x17, 0xdd, 0x22, 0x69, 0xdd, 0x5a, 0x3c, 0x25, 0x7e, 0x3d, 0x10, 0x6b,
+    0x55, 0x56, 0x60, 0xcf, 0xdd, 0x6a, 0x92, 0xc2, 0xcd, 0xdf, 0x1e, 0x53,
+    0xc4, 0x94, 0x5e, 0xd7, 0x72, 0xee, 0x30, 0x38, 0x04, 0xd0, 0x56, 0xf2,
+    0x42, 0xbf, 0x53, 0x99,
+};
+static const struct drbg_kat_no_reseed kat24_t = {
+    8, kat24_entropyin, kat24_nonce, kat24_persstr,
+    kat24_addin0, kat24_addin1, kat24_retbits
+};
+static const struct drbg_kat kat24 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat24_t
+};
+
+static const unsigned char kat25_entropyin[] = {
+    0x3b, 0x9e, 0xe2, 0x0c, 0x82, 0x42, 0xb3, 0xf3, 0x58, 0xdb, 0xe8, 0xea,
+    0x58, 0x9e, 0x6e, 0x7c,
+};
+static const unsigned char kat25_nonce[] = {
+    0xb1, 0xdc, 0x3a, 0x47, 0x03, 0x68, 0x52, 0x15,
+};
+static const unsigned char kat25_persstr[] = {0};
+static const unsigned char kat25_addin0[] = {
+    0x47, 0x33, 0x34, 0x47, 0x86, 0x73, 0xe7, 0xb4, 0xa4, 0x3e, 0x9a, 0xe6,
+    0xa8, 0xac, 0x98, 0xbf,
+};
+static const unsigned char kat25_addin1[] = {
+    0x06, 0x1f, 0xe4, 0x45, 0x5a, 0x17, 0x08, 0x74, 0x98, 0xfe, 0x20, 0x9c,
+    0x2c, 0xba, 0x7a, 0x91,
+};
+static const unsigned char kat25_retbits[] = {
+    0x8e, 0x50, 0x62, 0xb1, 0xfb, 0x29, 0x05, 0xc1, 0x57, 0xc5, 0x26, 0xfa,
+    0x5f, 0x67, 0xcc, 0x99, 0xc6, 0xd7, 0x08, 0x0a, 0x3d, 0x31, 0x42, 0xfa,
+    0x37, 0xc2, 0x09, 0xcf, 0x53, 0x4a, 0xf1, 0x6a, 0x9a, 0x2f, 0x28, 0x61,
+    0xb8, 0x94, 0xea, 0x84, 0xa3, 0x73, 0xd4, 0xa8, 0x04, 0xc3, 0xdc, 0xd5,
+    0x1f, 0xcc, 0x09, 0xdd, 0x0f, 0x5b, 0x39, 0x45, 0x69, 0x7a, 0xac, 0xd0,
+    0xb8, 0xf3, 0xea, 0xfd,
+};
+static const struct drbg_kat_no_reseed kat25_t = {
+    9, kat25_entropyin, kat25_nonce, kat25_persstr,
+    kat25_addin0, kat25_addin1, kat25_retbits
+};
+static const struct drbg_kat kat25 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat25_t
+};
+
+static const unsigned char kat26_entropyin[] = {
+    0x8f, 0xf7, 0x57, 0xb2, 0x11, 0x69, 0xb3, 0xfd, 0x6e, 0x88, 0x00, 0xaa,
+    0xc0, 0xe3, 0xc4, 0x1f,
+};
+static const unsigned char kat26_nonce[] = {
+    0x49, 0x4d, 0x42, 0x51, 0xe8, 0x88, 0x15, 0xb4,
+};
+static const unsigned char kat26_persstr[] = {0};
+static const unsigned char kat26_addin0[] = {
+    0xe0, 0x19, 0x9f, 0xb9, 0xf0, 0xf0, 0xa1, 0xa8, 0xdd, 0x9d, 0x19, 0xd1,
+    0x43, 0x68, 0xfa, 0x1e,
+};
+static const unsigned char kat26_addin1[] = {
+    0x21, 0x91, 0xab, 0xe7, 0x24, 0x41, 0x28, 0x56, 0x36, 0xc1, 0x1b, 0xde,
+    0xe9, 0x83, 0xed, 0x8c,
+};
+static const unsigned char kat26_retbits[] = {
+    0x06, 0x75, 0xb2, 0x25, 0x4b, 0x71, 0x31, 0x8e, 0xb3, 0xa3, 0x60, 0x4d,
+    0x7b, 0x6d, 0x77, 0x80, 0x6c, 0xd7, 0xdf, 0x32, 0x5c, 0x7c, 0xe8, 0x9e,
+    0x16, 0xd3, 0xbd, 0x56, 0x16, 0xb0, 0xfa, 0xec, 0x33, 0x0c, 0xfe, 0x6b,
+    0x84, 0xb6, 0x87, 0x61, 0xad, 0xf7, 0x0c, 0xc1, 0x4e, 0x46, 0x25, 0x3e,
+    0x11, 0x55, 0x72, 0xc1, 0xa4, 0xac, 0xbb, 0xae, 0xee, 0x1a, 0xd6, 0x81,
+    0xb5, 0x38, 0xd6, 0xc9,
+};
+static const struct drbg_kat_no_reseed kat26_t = {
+    10, kat26_entropyin, kat26_nonce, kat26_persstr,
+    kat26_addin0, kat26_addin1, kat26_retbits
+};
+static const struct drbg_kat kat26 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat26_t
+};
+
+static const unsigned char kat27_entropyin[] = {
+    0x46, 0x0c, 0x0a, 0x1e, 0x92, 0x9b, 0x75, 0x18, 0xdb, 0xcf, 0x44, 0xe4,
+    0xe7, 0xee, 0x4d, 0x83,
+};
+static const unsigned char kat27_nonce[] = {
+    0x88, 0x65, 0xd5, 0x01, 0x53, 0x48, 0x25, 0x9e,
+};
+static const unsigned char kat27_persstr[] = {0};
+static const unsigned char kat27_addin0[] = {
+    0xf9, 0x32, 0x78, 0x91, 0x40, 0xa0, 0xa7, 0x6f, 0x07, 0xb2, 0x5b, 0x5f,
+    0x8e, 0x1d, 0x00, 0xdc,
+};
+static const unsigned char kat27_addin1[] = {
+    0xe6, 0x44, 0x6a, 0xe2, 0xc6, 0x62, 0x66, 0x73, 0xe1, 0x8e, 0x37, 0x3d,
+    0xeb, 0x12, 0xbd, 0x26,
+};
+static const unsigned char kat27_retbits[] = {
+    0xc5, 0xde, 0x2e, 0x1a, 0x2a, 0xa7, 0x0a, 0x28, 0xac, 0xe6, 0x8e, 0x62,
+    0x0c, 0x94, 0xb8, 0x88, 0xa0, 0x7b, 0x07, 0x80, 0xb3, 0x14, 0x38, 0xc5,
+    0xe1, 0x1c, 0x5d, 0x76, 0xdf, 0xd6, 0x15, 0xf4, 0x1d, 0x4b, 0xa3, 0x24,
+    0xd2, 0x2c, 0x12, 0xfe, 0xe3, 0x8f, 0x58, 0x93, 0x5d, 0xad, 0x35, 0xe0,
+    0x0f, 0xe6, 0xa6, 0xe6, 0x11, 0x86, 0xc7, 0x88, 0x1c, 0x30, 0x6e, 0x96,
+    0x31, 0xcc, 0x15, 0xec,
+};
+static const struct drbg_kat_no_reseed kat27_t = {
+    11, kat27_entropyin, kat27_nonce, kat27_persstr,
+    kat27_addin0, kat27_addin1, kat27_retbits
+};
+static const struct drbg_kat kat27 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat27_t
+};
+
+static const unsigned char kat28_entropyin[] = {
+    0xb2, 0xda, 0x44, 0xbc, 0x3b, 0xe2, 0xd1, 0x7a, 0x9a, 0xc2, 0x08, 0x80,
+    0x85, 0xe9, 0x26, 0xf8,
+};
+static const unsigned char kat28_nonce[] = {
+    0x04, 0xbe, 0x54, 0x49, 0x35, 0x26, 0xc5, 0x78,
+};
+static const unsigned char kat28_persstr[] = {0};
+static const unsigned char kat28_addin0[] = {
+    0x67, 0xbe, 0x89, 0x19, 0x59, 0x65, 0xcd, 0x7d, 0xc9, 0x84, 0x27, 0x1b,
+    0x49, 0x7d, 0x61, 0x90,
+};
+static const unsigned char kat28_addin1[] = {
+    0xc9, 0x95, 0x6b, 0x00, 0x4b, 0x0c, 0x26, 0xb3, 0xf6, 0x57, 0xc6, 0xc1,
+    0x55, 0xd3, 0x60, 0xcc,
+};
+static const unsigned char kat28_retbits[] = {
+    0xc7, 0x74, 0x56, 0x62, 0x19, 0x48, 0xf6, 0x08, 0x38, 0xe3, 0x77, 0x9a,
+    0x14, 0x60, 0x63, 0x22, 0x52, 0x96, 0xda, 0x38, 0x18, 0x0e, 0x2c, 0x4c,
+    0x58, 0x35, 0xea, 0x27, 0xb2, 0x84, 0x24, 0xa8, 0x83, 0x1c, 0xee, 0x8c,
+    0x8d, 0xf7, 0x39, 0xa2, 0xb1, 0x73, 0xb3, 0x7b, 0xe2, 0xc0, 0x2b, 0xff,
+    0x38, 0xe0, 0xb3, 0x67, 0xd4, 0x82, 0xfb, 0x76, 0x54, 0x5f, 0xb3, 0xc9,
+    0x8d, 0x82, 0xb6, 0xe7,
+};
+static const struct drbg_kat_no_reseed kat28_t = {
+    12, kat28_entropyin, kat28_nonce, kat28_persstr,
+    kat28_addin0, kat28_addin1, kat28_retbits
+};
+static const struct drbg_kat kat28 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat28_t
+};
+
+static const unsigned char kat29_entropyin[] = {
+    0xf1, 0x77, 0xbc, 0x8a, 0xf7, 0x5c, 0x49, 0xe1, 0xd3, 0x79, 0xb5, 0x72,
+    0x26, 0x92, 0xbb, 0x3f,
+};
+static const unsigned char kat29_nonce[] = {
+    0xd8, 0xb5, 0xfb, 0xdc, 0x5d, 0xa7, 0xea, 0x7b,
+};
+static const unsigned char kat29_persstr[] = {0};
+static const unsigned char kat29_addin0[] = {
+    0x37, 0x41, 0x94, 0x38, 0x35, 0x54, 0xa4, 0x21, 0x41, 0x0a, 0xf5, 0xde,
+    0x2f, 0xc2, 0xec, 0x82,
+};
+static const unsigned char kat29_addin1[] = {
+    0x00, 0x0b, 0xe9, 0xac, 0x8e, 0x4b, 0x0c, 0xd1, 0x24, 0x5d, 0x7b, 0x7d,
+    0xbf, 0x8d, 0x87, 0x4f,
+};
+static const unsigned char kat29_retbits[] = {
+    0xb4, 0xa0, 0x0c, 0xd6, 0xe5, 0xf4, 0x7e, 0xa8, 0x7b, 0x12, 0x07, 0xc3,
+    0xa2, 0x18, 0xd8, 0x98, 0x8d, 0x4c, 0xb7, 0xed, 0x52, 0xb1, 0x4b, 0x79,
+    0xbb, 0xa5, 0x6a, 0xa7, 0xe5, 0x7e, 0x63, 0x64, 0x05, 0x70, 0x25, 0xab,
+    0x8f, 0x60, 0xd9, 0x7b, 0x84, 0x71, 0x7b, 0xbf, 0x25, 0x58, 0xdd, 0x43,
+    0x1f, 0x4b, 0xc3, 0x8c, 0xf1, 0xf6, 0x1e, 0xc0, 0xe7, 0xc2, 0xb4, 0xae,
+    0xb5, 0x4b, 0x2f, 0xaa,
+};
+static const struct drbg_kat_no_reseed kat29_t = {
+    13, kat29_entropyin, kat29_nonce, kat29_persstr,
+    kat29_addin0, kat29_addin1, kat29_retbits
+};
+static const struct drbg_kat kat29 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat29_t
+};
+
+static const unsigned char kat30_entropyin[] = {
+    0x52, 0x6b, 0xc8, 0xb7, 0x97, 0xad, 0x67, 0xeb, 0x9b, 0x11, 0xbb, 0x5d,
+    0x17, 0x32, 0x00, 0x87,
+};
+static const unsigned char kat30_nonce[] = {
+    0x64, 0x7b, 0xd2, 0x32, 0xad, 0x4d, 0x13, 0x00,
+};
+static const unsigned char kat30_persstr[] = {0};
+static const unsigned char kat30_addin0[] = {
+    0x58, 0xc8, 0xbf, 0x95, 0x0f, 0xab, 0x02, 0x71, 0x19, 0xee, 0x4a, 0x59,
+    0x27, 0x27, 0xaa, 0x02,
+};
+static const unsigned char kat30_addin1[] = {
+    0x25, 0x39, 0xe1, 0x23, 0x92, 0x6b, 0x74, 0xab, 0x23, 0x41, 0x4d, 0x63,
+    0x50, 0xb8, 0x92, 0x87,
+};
+static const unsigned char kat30_retbits[] = {
+    0x35, 0x9c, 0x56, 0x08, 0x34, 0xbb, 0xeb, 0xdb, 0x41, 0x34, 0xcc, 0x3e,
+    0x66, 0xbc, 0x06, 0x95, 0xce, 0xfd, 0xb4, 0xfe, 0x56, 0x63, 0x75, 0x2b,
+    0x6e, 0xba, 0x97, 0x4c, 0x4b, 0x85, 0x92, 0x4a, 0x01, 0xdc, 0xd4, 0xea,
+    0x3e, 0xd7, 0x7f, 0x2a, 0xf3, 0x95, 0x7b, 0x87, 0x51, 0xf7, 0x37, 0x15,
+    0x74, 0xbb, 0x8b, 0x09, 0x0b, 0xc0, 0xd5, 0x12, 0xc1, 0x57, 0xc6, 0x55,
+    0x9c, 0x16, 0xd0, 0xfd,
+};
+static const struct drbg_kat_no_reseed kat30_t = {
+    14, kat30_entropyin, kat30_nonce, kat30_persstr,
+    kat30_addin0, kat30_addin1, kat30_retbits
+};
+static const struct drbg_kat kat30 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat30_t
+};
+
+static const unsigned char kat31_entropyin[] = {
+    0xe1, 0x0b, 0xc2, 0x8a, 0x0b, 0xfd, 0xdf, 0xe9, 0x3e, 0x7f, 0x51, 0x86,
+    0xe0, 0xca, 0x0b, 0x3b,
+};
+static const unsigned char kat31_nonce[] = {
+    0x9f, 0xf4, 0x77, 0xc1, 0x86, 0x73, 0x84, 0x0d,
+};
+static const unsigned char kat31_persstr[] = {
+    0xc9, 0x80, 0xde, 0xdf, 0x98, 0x82, 0xed, 0x44, 0x64, 0xa6, 0x74, 0x96,
+    0x78, 0x68, 0xf1, 0x43,
+};
+static const unsigned char kat31_addin0[] = {0};
+static const unsigned char kat31_addin1[] = {0};
+static const unsigned char kat31_retbits[] = {
+    0x35, 0xb0, 0x0d, 0xf6, 0x26, 0x9b, 0x66, 0x41, 0xfd, 0x4c, 0xcb, 0x35,
+    0x4d, 0x56, 0xd8, 0x51, 0xde, 0x7a, 0x77, 0x52, 0x7e, 0x03, 0x4d, 0x60,
+    0xc9, 0xe1, 0xa9, 0xe1, 0x52, 0x5a, 0x30, 0xed, 0x36, 0x1f, 0xde, 0xd8,
+    0x9d, 0x3d, 0xcc, 0xb9, 0x78, 0xd4, 0xe7, 0xa9, 0xe1, 0x00, 0xeb, 0xf6,
+    0x30, 0x62, 0x73, 0x5b, 0x52, 0x83, 0x1c, 0x6f, 0x0a, 0x1d, 0x3e, 0x1b,
+    0xdc, 0x5e, 0xbc, 0x72,
+};
+static const struct drbg_kat_no_reseed kat31_t = {
+    0, kat31_entropyin, kat31_nonce, kat31_persstr,
+    kat31_addin0, kat31_addin1, kat31_retbits
+};
+static const struct drbg_kat kat31 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat31_t
+};
+
+static const unsigned char kat32_entropyin[] = {
+    0xca, 0x4b, 0x1e, 0xfa, 0x75, 0xbd, 0x69, 0x36, 0x38, 0x73, 0xb8, 0xf9,
+    0xdb, 0x4d, 0x35, 0x0e,
+};
+static const unsigned char kat32_nonce[] = {
+    0x47, 0xbf, 0x6c, 0x37, 0x72, 0xfd, 0xf7, 0xa9,
+};
+static const unsigned char kat32_persstr[] = {
+    0xeb, 0xaa, 0x60, 0x2c, 0x4d, 0xbe, 0x33, 0xff, 0x1b, 0xef, 0xbf, 0x0a,
+    0x0b, 0xc6, 0x97, 0x54,
+};
+static const unsigned char kat32_addin0[] = {0};
+static const unsigned char kat32_addin1[] = {0};
+static const unsigned char kat32_retbits[] = {
+    0x59, 0xc3, 0x19, 0x79, 0x1b, 0xb1, 0xf3, 0x0e, 0xe9, 0x34, 0xae, 0x6e,
+    0x8b, 0x1f, 0xad, 0x1f, 0x74, 0xca, 0x25, 0x45, 0x68, 0xb8, 0x7f, 0x75,
+    0x12, 0xf8, 0xf2, 0xab, 0x4c, 0x23, 0x01, 0x03, 0x05, 0xe1, 0x70, 0xee,
+    0x75, 0xd8, 0xcb, 0xeb, 0x23, 0x4c, 0x7a, 0x23, 0x6e, 0x12, 0x27, 0xdb,
+    0x6f, 0x7a, 0xac, 0x3c, 0x44, 0xb7, 0x87, 0x4b, 0x65, 0x56, 0x74, 0x45,
+    0x34, 0x30, 0x0c, 0x3d,
+};
+static const struct drbg_kat_no_reseed kat32_t = {
+    1, kat32_entropyin, kat32_nonce, kat32_persstr,
+    kat32_addin0, kat32_addin1, kat32_retbits
+};
+static const struct drbg_kat kat32 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat32_t
+};
+
+static const unsigned char kat33_entropyin[] = {
+    0x35, 0x19, 0x49, 0x15, 0x74, 0x71, 0x9d, 0xdb, 0x1f, 0x51, 0xb5, 0xf5,
+    0x9e, 0x21, 0xad, 0x3d,
+};
+static const unsigned char kat33_nonce[] = {
+    0xef, 0x1d, 0xbe, 0xae, 0x79, 0xf0, 0x89, 0x8b,
+};
+static const unsigned char kat33_persstr[] = {
+    0x7f, 0xdc, 0x21, 0xe3, 0x53, 0x24, 0x9e, 0x93, 0xdf, 0x98, 0xf2, 0x91,
+    0x02, 0xb9, 0xac, 0xec,
+};
+static const unsigned char kat33_addin0[] = {0};
+static const unsigned char kat33_addin1[] = {0};
+static const unsigned char kat33_retbits[] = {
+    0x19, 0x2c, 0x71, 0x85, 0x74, 0x47, 0xaf, 0x82, 0x01, 0x37, 0x06, 0xb8,
+    0xeb, 0x00, 0x8f, 0x8e, 0x2c, 0x2e, 0xb3, 0x99, 0x4a, 0x23, 0x8c, 0xf7,
+    0x39, 0xe1, 0x74, 0x60, 0xfe, 0x84, 0xef, 0x71, 0xca, 0x43, 0x7e, 0x8a,
+    0xcb, 0xb8, 0xd9, 0xd2, 0x88, 0x07, 0xc4, 0x7a, 0x5f, 0x03, 0x44, 0x42,
+    0xaa, 0xf3, 0xc2, 0xf3, 0xe7, 0xde, 0xbe, 0x53, 0x1b, 0xc3, 0x59, 0x60,
+    0x56, 0x68, 0x58, 0x48,
+};
+static const struct drbg_kat_no_reseed kat33_t = {
+    2, kat33_entropyin, kat33_nonce, kat33_persstr,
+    kat33_addin0, kat33_addin1, kat33_retbits
+};
+static const struct drbg_kat kat33 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat33_t
+};
+
+static const unsigned char kat34_entropyin[] = {
+    0x68, 0xed, 0xc1, 0xc7, 0xf0, 0x4f, 0xa2, 0x2f, 0x75, 0x1b, 0x91, 0x8b,
+    0x01, 0x6b, 0xbf, 0xb5,
+};
+static const unsigned char kat34_nonce[] = {
+    0xa9, 0xb6, 0x7a, 0x39, 0x58, 0xf2, 0x02, 0xf0,
+};
+static const unsigned char kat34_persstr[] = {
+    0x9d, 0x6f, 0xbb, 0x02, 0x0e, 0x3d, 0x99, 0xd1, 0x95, 0xff, 0x46, 0x9f,
+    0x0a, 0xc0, 0xb8, 0xca,
+};
+static const unsigned char kat34_addin0[] = {0};
+static const unsigned char kat34_addin1[] = {0};
+static const unsigned char kat34_retbits[] = {
+    0xd9, 0x02, 0x89, 0xb1, 0xb6, 0x76, 0x3a, 0x76, 0x90, 0xfc, 0xb5, 0xd6,
+    0x7c, 0x81, 0xc2, 0x03, 0xa1, 0xcf, 0xb0, 0x88, 0x71, 0xb9, 0x4a, 0xf6,
+    0x51, 0xc4, 0xcd, 0x7e, 0xc2, 0xfa, 0x4b, 0x9d, 0x47, 0xc8, 0xe5, 0xfc,
+    0xc9, 0x9a, 0xff, 0xc2, 0x21, 0x43, 0xb6, 0x12, 0x70, 0x18, 0xe9, 0xe2,
+    0xc0, 0x91, 0x4f, 0x9d, 0x47, 0xa5, 0xa3, 0x0b, 0x26, 0xe7, 0x4d, 0xdc,
+    0x31, 0xa4, 0x48, 0x42,
+};
+static const struct drbg_kat_no_reseed kat34_t = {
+    3, kat34_entropyin, kat34_nonce, kat34_persstr,
+    kat34_addin0, kat34_addin1, kat34_retbits
+};
+static const struct drbg_kat kat34 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat34_t
+};
+
+static const unsigned char kat35_entropyin[] = {
+    0x8e, 0x6b, 0xaf, 0x81, 0xa3, 0xf9, 0xe7, 0x32, 0xef, 0xb9, 0x65, 0xaf,
+    0xa5, 0x9e, 0x71, 0xee,
+};
+static const unsigned char kat35_nonce[] = {
+    0x9a, 0x40, 0x36, 0xfe, 0x7f, 0xf2, 0x25, 0xb8,
+};
+static const unsigned char kat35_persstr[] = {
+    0xc5, 0x7e, 0x42, 0xad, 0x7a, 0xef, 0x53, 0x77, 0xfc, 0x4c, 0xd6, 0x20,
+    0xd6, 0x31, 0xb0, 0x61,
+};
+static const unsigned char kat35_addin0[] = {0};
+static const unsigned char kat35_addin1[] = {0};
+static const unsigned char kat35_retbits[] = {
+    0x71, 0x39, 0xa2, 0xd6, 0x74, 0xee, 0xfe, 0x54, 0x08, 0x7a, 0x2d, 0xd5,
+    0xf4, 0x97, 0xf5, 0xa1, 0xcb, 0x44, 0x44, 0x72, 0xe3, 0x64, 0x04, 0x5c,
+    0xb9, 0x20, 0x2b, 0xce, 0x24, 0x58, 0x1b, 0x4b, 0x1b, 0x80, 0x3f, 0xa5,
+    0xf4, 0xa9, 0xac, 0x6d, 0x66, 0x37, 0xbd, 0xd9, 0x06, 0xaf, 0x3d, 0x8f,
+    0x49, 0xb5, 0xb8, 0x0f, 0x44, 0xcd, 0x16, 0xee, 0x5b, 0x1a, 0xe3, 0xbf,
+    0x51, 0xb5, 0x98, 0xba,
+};
+static const struct drbg_kat_no_reseed kat35_t = {
+    4, kat35_entropyin, kat35_nonce, kat35_persstr,
+    kat35_addin0, kat35_addin1, kat35_retbits
+};
+static const struct drbg_kat kat35 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat35_t
+};
+
+static const unsigned char kat36_entropyin[] = {
+    0xf8, 0x99, 0x2f, 0x34, 0x0f, 0x90, 0xc8, 0xd8, 0x16, 0xb4, 0xbd, 0x8b,
+    0x43, 0x5d, 0xa0, 0x35,
+};
+static const unsigned char kat36_nonce[] = {
+    0xfc, 0xf9, 0x44, 0x00, 0x6f, 0x29, 0x27, 0x98,
+};
+static const unsigned char kat36_persstr[] = {
+    0x56, 0x32, 0x23, 0x5e, 0x85, 0x2c, 0x07, 0x40, 0x09, 0xb4, 0x97, 0xed,
+    0xa4, 0x38, 0xa1, 0x6f,
+};
+static const unsigned char kat36_addin0[] = {0};
+static const unsigned char kat36_addin1[] = {0};
+static const unsigned char kat36_retbits[] = {
+    0x9e, 0xab, 0x55, 0xfa, 0x4b, 0x2c, 0x1c, 0xfa, 0xc6, 0x3d, 0x4d, 0xe4,
+    0x7a, 0xa8, 0xf5, 0x9f, 0x78, 0x5e, 0xe4, 0x90, 0xda, 0x44, 0xce, 0xe3,
+    0x0f, 0x91, 0x61, 0xe9, 0x3a, 0xfc, 0x46, 0x1d, 0xad, 0x0e, 0x7f, 0x4a,
+    0x06, 0x4e, 0x92, 0xef, 0xd6, 0x00, 0x89, 0x16, 0xc2, 0x2f, 0x83, 0x64,
+    0xc1, 0x90, 0x46, 0x7a, 0xde, 0x12, 0xab, 0x4e, 0x18, 0xb1, 0xf3, 0x9c,
+    0xe1, 0x8b, 0x35, 0x8a,
+};
+static const struct drbg_kat_no_reseed kat36_t = {
+    5, kat36_entropyin, kat36_nonce, kat36_persstr,
+    kat36_addin0, kat36_addin1, kat36_retbits
+};
+static const struct drbg_kat kat36 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat36_t
+};
+
+static const unsigned char kat37_entropyin[] = {
+    0x07, 0x43, 0x8f, 0x83, 0x53, 0xb7, 0xb0, 0x67, 0x42, 0x18, 0x31, 0x9e,
+    0x29, 0x54, 0x0b, 0xca,
+};
+static const unsigned char kat37_nonce[] = {
+    0x41, 0x14, 0x77, 0x63, 0x6a, 0x50, 0x0c, 0x62,
+};
+static const unsigned char kat37_persstr[] = {
+    0xcf, 0x36, 0xf2, 0xaa, 0x72, 0xf2, 0xf3, 0x5e, 0x33, 0x5e, 0x65, 0xcf,
+    0xd1, 0x7e, 0x2d, 0x3d,
+};
+static const unsigned char kat37_addin0[] = {0};
+static const unsigned char kat37_addin1[] = {0};
+static const unsigned char kat37_retbits[] = {
+    0x6c, 0xfa, 0xcf, 0xe4, 0x7a, 0xcf, 0x8f, 0x61, 0xd8, 0xaf, 0x3e, 0xd4,
+    0xfb, 0xac, 0xef, 0x5c, 0xd7, 0x41, 0xac, 0x2f, 0x16, 0x5e, 0x15, 0xbd,
+    0xaa, 0xb1, 0xd0, 0x30, 0xc6, 0x85, 0x67, 0x83, 0x7e, 0xf3, 0xda, 0x1e,
+    0xc8, 0x3d, 0xa0, 0x42, 0x3c, 0xa3, 0x42, 0x4c, 0xf2, 0x93, 0xf6, 0x1f,
+    0x71, 0x75, 0xfb, 0xa8, 0xe9, 0x1e, 0x5f, 0xdc, 0x8b, 0x39, 0x55, 0x77,
+    0x73, 0x61, 0xd6, 0x90,
+};
+static const struct drbg_kat_no_reseed kat37_t = {
+    6, kat37_entropyin, kat37_nonce, kat37_persstr,
+    kat37_addin0, kat37_addin1, kat37_retbits
+};
+static const struct drbg_kat kat37 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat37_t
+};
+
+static const unsigned char kat38_entropyin[] = {
+    0x8e, 0x93, 0x73, 0x5c, 0x34, 0xae, 0x0c, 0x5e, 0xa5, 0x21, 0x3d, 0x83,
+    0xa8, 0xda, 0x80, 0x45,
+};
+static const unsigned char kat38_nonce[] = {
+    0x2a, 0x0b, 0x27, 0x9a, 0x9d, 0x67, 0x78, 0x38,
+};
+static const unsigned char kat38_persstr[] = {
+    0x14, 0xf4, 0x52, 0x66, 0x52, 0x4a, 0x81, 0x52, 0x85, 0x7a, 0x83, 0x31,
+    0x6a, 0x17, 0x75, 0x85,
+};
+static const unsigned char kat38_addin0[] = {0};
+static const unsigned char kat38_addin1[] = {0};
+static const unsigned char kat38_retbits[] = {
+    0xe0, 0x0c, 0xb8, 0x63, 0x6f, 0x96, 0x02, 0xc3, 0x30, 0x21, 0xa8, 0x2a,
+    0x7f, 0x9d, 0xc9, 0xc7, 0x4e, 0xd3, 0x43, 0x5b, 0x34, 0x89, 0x7d, 0x6e,
+    0xfd, 0x8c, 0x05, 0xf1, 0x77, 0xe8, 0x55, 0x6a, 0x44, 0x3b, 0xd1, 0x8c,
+    0x20, 0xa5, 0x57, 0xb9, 0xbd, 0xc4, 0x17, 0xe8, 0x99, 0x85, 0x06, 0x48,
+    0x50, 0x91, 0xd6, 0xbc, 0x91, 0x8e, 0x9c, 0xbf, 0xfb, 0xb8, 0x5c, 0x62,
+    0x0f, 0x74, 0xc6, 0xec,
+};
+static const struct drbg_kat_no_reseed kat38_t = {
+    7, kat38_entropyin, kat38_nonce, kat38_persstr,
+    kat38_addin0, kat38_addin1, kat38_retbits
+};
+static const struct drbg_kat kat38 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat38_t
+};
+
+static const unsigned char kat39_entropyin[] = {
+    0xec, 0x6b, 0x87, 0xe9, 0xe0, 0x3f, 0x44, 0xf9, 0x19, 0xe4, 0x0e, 0x1d,
+    0xac, 0x02, 0xf8, 0x73,
+};
+static const unsigned char kat39_nonce[] = {
+    0x5e, 0x9a, 0xc5, 0x09, 0x0a, 0x5e, 0x28, 0x97,
+};
+static const unsigned char kat39_persstr[] = {
+    0x0d, 0x9b, 0xa4, 0x62, 0xbf, 0x16, 0x6f, 0x3b, 0x36, 0x6a, 0x2a, 0xdf,
+    0x55, 0xd2, 0x76, 0x45,
+};
+static const unsigned char kat39_addin0[] = {0};
+static const unsigned char kat39_addin1[] = {0};
+static const unsigned char kat39_retbits[] = {
+    0xec, 0x37, 0xac, 0xbd, 0xdf, 0xb0, 0x41, 0xe4, 0x24, 0x9c, 0x1c, 0xb9,
+    0x83, 0x3a, 0x31, 0xfc, 0x6f, 0xbd, 0xaa, 0x66, 0x58, 0xe4, 0xb7, 0x48,
+    0xc0, 0xeb, 0xf6, 0xab, 0x54, 0xa3, 0xb9, 0xc0, 0xf6, 0x2d, 0x7c, 0x89,
+    0xdb, 0xb2, 0x1d, 0x1d, 0xe1, 0x33, 0x15, 0xcb, 0xae, 0x2f, 0xf4, 0xf5,
+    0x46, 0x24, 0x91, 0x32, 0x1f, 0xbe, 0x04, 0xb4, 0x14, 0xfb, 0xa2, 0x80,
+    0x7e, 0xd9, 0x14, 0xee,
+};
+static const struct drbg_kat_no_reseed kat39_t = {
+    8, kat39_entropyin, kat39_nonce, kat39_persstr,
+    kat39_addin0, kat39_addin1, kat39_retbits
+};
+static const struct drbg_kat kat39 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat39_t
+};
+
+static const unsigned char kat40_entropyin[] = {
+    0x9d, 0x28, 0x2f, 0x5a, 0x0c, 0x15, 0xa6, 0x53, 0x04, 0x73, 0x10, 0xb5,
+    0x62, 0x7d, 0x8f, 0xa2,
+};
+static const unsigned char kat40_nonce[] = {
+    0x55, 0x22, 0xc4, 0x2f, 0x4b, 0xb0, 0x76, 0xdc,
+};
+static const unsigned char kat40_persstr[] = {
+    0x84, 0x6b, 0x2e, 0x17, 0xb0, 0x62, 0xc4, 0xc7, 0xc5, 0x61, 0x94, 0x3b,
+    0x5d, 0x97, 0x56, 0x5d,
+};
+static const unsigned char kat40_addin0[] = {0};
+static const unsigned char kat40_addin1[] = {0};
+static const unsigned char kat40_retbits[] = {
+    0x45, 0xf6, 0x0e, 0x1b, 0xa9, 0x81, 0xaf, 0x7f, 0x52, 0xef, 0x49, 0x39,
+    0xc0, 0xbb, 0x0b, 0xdb, 0x6f, 0xe4, 0x6f, 0x37, 0x2c, 0xc6, 0x48, 0x06,
+    0x4b, 0xbd, 0x3a, 0x0a, 0x2b, 0x85, 0xc0, 0x23, 0x91, 0xb2, 0x97, 0x92,
+    0xcc, 0x88, 0x05, 0xbb, 0x5d, 0x45, 0x3e, 0xe2, 0x90, 0xcd, 0x1b, 0x9c,
+    0x9f, 0x8f, 0x20, 0xb0, 0x91, 0x16, 0xaf, 0x1f, 0xd5, 0xec, 0xea, 0xe8,
+    0x0d, 0x03, 0x58, 0xd8,
+};
+static const struct drbg_kat_no_reseed kat40_t = {
+    9, kat40_entropyin, kat40_nonce, kat40_persstr,
+    kat40_addin0, kat40_addin1, kat40_retbits
+};
+static const struct drbg_kat kat40 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat40_t
+};
+
+static const unsigned char kat41_entropyin[] = {
+    0x83, 0x82, 0x7c, 0x08, 0x52, 0x4b, 0x54, 0xe8, 0x0f, 0x60, 0xe1, 0x86,
+    0xcf, 0xce, 0x36, 0xdb,
+};
+static const unsigned char kat41_nonce[] = {
+    0x17, 0x7e, 0x5c, 0x00, 0xf7, 0x85, 0xa6, 0xf9,
+};
+static const unsigned char kat41_persstr[] = {
+    0x71, 0x75, 0xa2, 0xc2, 0x2e, 0xab, 0x4d, 0x0b, 0x1a, 0x65, 0xfd, 0xad,
+    0xed, 0x35, 0x6a, 0xeb,
+};
+static const unsigned char kat41_addin0[] = {0};
+static const unsigned char kat41_addin1[] = {0};
+static const unsigned char kat41_retbits[] = {
+    0x84, 0x24, 0xe7, 0x6c, 0x73, 0x6c, 0x03, 0x09, 0x42, 0x3c, 0xf4, 0x8d,
+    0xc1, 0x05, 0xfe, 0xef, 0x22, 0x8d, 0xd4, 0x7b, 0xfd, 0x8d, 0x33, 0x80,
+    0x19, 0x50, 0xd2, 0x10, 0x2d, 0x5d, 0xba, 0xfb, 0x51, 0xe1, 0xa8, 0x5b,
+    0x4a, 0x97, 0x1e, 0x4f, 0x0b, 0x9d, 0x52, 0x65, 0x69, 0x73, 0xdb, 0x45,
+    0x5b, 0x28, 0x6f, 0x58, 0x8c, 0xa6, 0x1d, 0x15, 0x99, 0xc4, 0xec, 0x60,
+    0xdd, 0x80, 0xbe, 0x98,
+};
+static const struct drbg_kat_no_reseed kat41_t = {
+    10, kat41_entropyin, kat41_nonce, kat41_persstr,
+    kat41_addin0, kat41_addin1, kat41_retbits
+};
+static const struct drbg_kat kat41 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat41_t
+};
+
+static const unsigned char kat42_entropyin[] = {
+    0x9f, 0x32, 0x13, 0xa2, 0xd6, 0xfe, 0x5f, 0x3d, 0xfa, 0xf0, 0xe4, 0xed,
+    0x29, 0x2e, 0x0f, 0x2a,
+};
+static const unsigned char kat42_nonce[] = {
+    0xf9, 0xc0, 0x55, 0x3b, 0x18, 0xb2, 0x1c, 0xc3,
+};
+static const unsigned char kat42_persstr[] = {
+    0x21, 0x73, 0xd3, 0x9b, 0x37, 0x55, 0x04, 0x19, 0x11, 0x98, 0x9f, 0x89,
+    0xf1, 0xe9, 0x5d, 0x3e,
+};
+static const unsigned char kat42_addin0[] = {0};
+static const unsigned char kat42_addin1[] = {0};
+static const unsigned char kat42_retbits[] = {
+    0x10, 0x45, 0xf7, 0xb5, 0x36, 0xda, 0xb4, 0xde, 0x01, 0x54, 0x48, 0xac,
+    0x47, 0x66, 0x18, 0x8a, 0x36, 0x7b, 0xb6, 0x93, 0x97, 0x91, 0x3d, 0xfd,
+    0x3d, 0x5b, 0xbf, 0x83, 0xf1, 0xbb, 0xac, 0x73, 0x23, 0x2d, 0x47, 0x64,
+    0x4e, 0x5a, 0x9c, 0x16, 0x99, 0x60, 0x58, 0x1e, 0x4a, 0xd5, 0xed, 0x26,
+    0x95, 0x36, 0x0b, 0x94, 0xf4, 0x20, 0x9c, 0x77, 0xd7, 0x69, 0x40, 0x16,
+    0xb4, 0xb3, 0x97, 0xc2,
+};
+static const struct drbg_kat_no_reseed kat42_t = {
+    11, kat42_entropyin, kat42_nonce, kat42_persstr,
+    kat42_addin0, kat42_addin1, kat42_retbits
+};
+static const struct drbg_kat kat42 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat42_t
+};
+
+static const unsigned char kat43_entropyin[] = {
+    0xfb, 0xc8, 0x19, 0x90, 0x74, 0xa7, 0x6f, 0x23, 0x68, 0x86, 0x36, 0xae,
+    0x31, 0x14, 0x28, 0x1e,
+};
+static const unsigned char kat43_nonce[] = {
+    0xeb, 0xc2, 0x2e, 0x95, 0xdd, 0xae, 0xb6, 0xfc,
+};
+static const unsigned char kat43_persstr[] = {
+    0x71, 0xfb, 0xd5, 0x9f, 0x88, 0xfc, 0x99, 0xa9, 0xb6, 0x07, 0x00, 0x27,
+    0xe7, 0x35, 0x41, 0xc2,
+};
+static const unsigned char kat43_addin0[] = {0};
+static const unsigned char kat43_addin1[] = {0};
+static const unsigned char kat43_retbits[] = {
+    0x87, 0x25, 0x66, 0xa7, 0x00, 0x47, 0x98, 0xe0, 0x06, 0x97, 0xbd, 0xb3,
+    0x3a, 0xf1, 0xee, 0x7a, 0x07, 0x6e, 0x9f, 0xd2, 0x89, 0xaf, 0x83, 0xaf,
+    0xcb, 0x10, 0xa0, 0x25, 0x2b, 0xb5, 0xc1, 0x06, 0xc8, 0xdd, 0x20, 0xd7,
+    0x7c, 0x85, 0x9f, 0x14, 0x01, 0x11, 0x8c, 0x24, 0xf5, 0xa8, 0x96, 0x8f,
+    0x11, 0xfa, 0x9f, 0x77, 0x78, 0xc2, 0x80, 0x31, 0x89, 0xc8, 0xda, 0x87,
+    0xe6, 0x49, 0x45, 0xc8,
+};
+static const struct drbg_kat_no_reseed kat43_t = {
+    12, kat43_entropyin, kat43_nonce, kat43_persstr,
+    kat43_addin0, kat43_addin1, kat43_retbits
+};
+static const struct drbg_kat kat43 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat43_t
+};
+
+static const unsigned char kat44_entropyin[] = {
+    0x43, 0xf4, 0xd0, 0x89, 0x06, 0x0c, 0x90, 0x7f, 0x38, 0x76, 0x05, 0x1f,
+    0xd5, 0xe3, 0x6f, 0x74,
+};
+static const unsigned char kat44_nonce[] = {
+    0x45, 0x71, 0xe6, 0x61, 0x5b, 0xa3, 0xbb, 0xce,
+};
+static const unsigned char kat44_persstr[] = {
+    0xfc, 0x90, 0x57, 0x74, 0x9b, 0xa4, 0x37, 0xd8, 0xfb, 0xe9, 0xf8, 0x1d,
+    0x29, 0xdf, 0x5e, 0xf1,
+};
+static const unsigned char kat44_addin0[] = {0};
+static const unsigned char kat44_addin1[] = {0};
+static const unsigned char kat44_retbits[] = {
+    0x90, 0x78, 0xf1, 0xbc, 0x92, 0x91, 0x0e, 0xbc, 0xf8, 0xe3, 0x17, 0x57,
+    0xb6, 0x24, 0xbd, 0x23, 0xdb, 0xcd, 0x74, 0xf9, 0xca, 0x70, 0xff, 0x1c,
+    0x6f, 0x2b, 0x21, 0xd8, 0x59, 0xa4, 0xe8, 0xa4, 0xe9, 0x96, 0x3e, 0xf1,
+    0x32, 0xa0, 0x25, 0xb3, 0xae, 0x28, 0x5b, 0x43, 0xa6, 0x96, 0x98, 0x90,
+    0x0d, 0x4f, 0x8a, 0x30, 0xbb, 0x5e, 0x99, 0x29, 0x0e, 0x45, 0x04, 0x16,
+    0x19, 0x97, 0xa8, 0x37,
+};
+static const struct drbg_kat_no_reseed kat44_t = {
+    13, kat44_entropyin, kat44_nonce, kat44_persstr,
+    kat44_addin0, kat44_addin1, kat44_retbits
+};
+static const struct drbg_kat kat44 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat44_t
+};
+
+static const unsigned char kat45_entropyin[] = {
+    0x0e, 0xe3, 0x8e, 0xa2, 0x9d, 0x71, 0x95, 0x00, 0x3e, 0x2b, 0x94, 0x2a,
+    0xbf, 0x13, 0x48, 0xfc,
+};
+static const unsigned char kat45_nonce[] = {
+    0x80, 0xa7, 0x5c, 0x77, 0xce, 0xff, 0x54, 0xe4,
+};
+static const unsigned char kat45_persstr[] = {
+    0x83, 0x8e, 0xae, 0xbc, 0x98, 0x2c, 0xaa, 0x15, 0x62, 0xc3, 0x06, 0x4c,
+    0xce, 0x42, 0xe5, 0x1e,
+};
+static const unsigned char kat45_addin0[] = {0};
+static const unsigned char kat45_addin1[] = {0};
+static const unsigned char kat45_retbits[] = {
+    0x66, 0x29, 0x1b, 0x86, 0x85, 0xe9, 0x7c, 0x76, 0xe2, 0x21, 0x6d, 0x70,
+    0x8b, 0x40, 0x70, 0x22, 0x68, 0x4b, 0x28, 0x29, 0x1f, 0x3d, 0xc7, 0x1b,
+    0x5d, 0x60, 0xde, 0x14, 0x3f, 0x5f, 0xdf, 0x0b, 0xb0, 0x7a, 0xe9, 0xd7,
+    0x52, 0x44, 0x56, 0xc4, 0xdf, 0xd0, 0x89, 0xea, 0x88, 0xde, 0x86, 0xdd,
+    0xfa, 0x1d, 0x48, 0xca, 0x54, 0x2f, 0x00, 0xfa, 0x58, 0x6d, 0xa7, 0xa6,
+    0x02, 0x7d, 0x83, 0x7b,
+};
+static const struct drbg_kat_no_reseed kat45_t = {
+    14, kat45_entropyin, kat45_nonce, kat45_persstr,
+    kat45_addin0, kat45_addin1, kat45_retbits
+};
+static const struct drbg_kat kat45 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat45_t
+};
+
+static const unsigned char kat46_entropyin[] = {
+    0xca, 0xe4, 0x8d, 0xd8, 0x0d, 0x29, 0x81, 0x03, 0xef, 0x1e, 0xc0, 0xbf,
+    0x1b, 0xb9, 0x62, 0x70,
+};
+static const unsigned char kat46_nonce[] = {
+    0xd8, 0x27, 0xf9, 0x16, 0x13, 0xe0, 0xb4, 0x7f,
+};
+static const unsigned char kat46_persstr[] = {
+    0xcc, 0x92, 0x8f, 0x3d, 0x2d, 0xf3, 0x1a, 0x29, 0xf4, 0xe4, 0x44, 0xf3,
+    0xdf, 0x08, 0xbe, 0x21,
+};
+static const unsigned char kat46_addin0[] = {
+    0x7e, 0xaa, 0x1b, 0xbe, 0xc7, 0x93, 0x93, 0xa7, 0xf4, 0xa8, 0x22, 0x7b,
+    0x69, 0x1e, 0xcb, 0x68,
+};
+static const unsigned char kat46_addin1[] = {
+    0x68, 0x69, 0xc6, 0xc7, 0xb9, 0xe6, 0x65, 0x3b, 0x39, 0x77, 0xf0, 0x78,
+    0x9e, 0x94, 0x47, 0x8a,
+};
+static const unsigned char kat46_retbits[] = {
+    0x92, 0x01, 0x32, 0xcd, 0x28, 0x46, 0x95, 0xb8, 0x68, 0xb5, 0xbc, 0x4b,
+    0x70, 0x3a, 0xfe, 0xa4, 0xd9, 0x96, 0x62, 0x4a, 0x8f, 0x57, 0xe9, 0xfb,
+    0xf5, 0xe7, 0x93, 0xb5, 0x09, 0xcb, 0x15, 0xb4, 0xbe, 0xaf, 0x70, 0x2d,
+    0xac, 0x28, 0x71, 0x2d, 0x24, 0x9a, 0xe7, 0x50, 0x90, 0xa9, 0x1f, 0xd3,
+    0x57, 0x75, 0x29, 0x4b, 0xf2, 0x4d, 0xde, 0xbf, 0xd2, 0x4e, 0x45, 0xd1,
+    0x3f, 0x4a, 0x17, 0x48,
+};
+static const struct drbg_kat_no_reseed kat46_t = {
+    0, kat46_entropyin, kat46_nonce, kat46_persstr,
+    kat46_addin0, kat46_addin1, kat46_retbits
+};
+static const struct drbg_kat kat46 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat46_t
+};
+
+static const unsigned char kat47_entropyin[] = {
+    0xc0, 0x70, 0x1f, 0x92, 0x50, 0x75, 0x8f, 0xcd, 0xf2, 0xbe, 0x73, 0x98,
+    0x80, 0xdb, 0x66, 0xeb,
+};
+static const unsigned char kat47_nonce[] = {
+    0x14, 0x68, 0xb4, 0xa5, 0x87, 0x9c, 0x2d, 0xa6,
+};
+static const unsigned char kat47_persstr[] = {
+    0x80, 0x08, 0xae, 0xe8, 0xe9, 0x69, 0x40, 0xc5, 0x08, 0x73, 0xc7, 0x9f,
+    0x8e, 0xcf, 0xe0, 0x02,
+};
+static const unsigned char kat47_addin0[] = {
+    0xf9, 0x01, 0xf8, 0x16, 0x7a, 0x1d, 0xff, 0xde, 0x8e, 0x3c, 0x83, 0xe2,
+    0x44, 0x85, 0xe7, 0xfe,
+};
+static const unsigned char kat47_addin1[] = {
+    0x17, 0x1c, 0x09, 0x38, 0xc2, 0x38, 0x9f, 0x97, 0x87, 0x60, 0x55, 0xb4,
+    0x82, 0x16, 0x62, 0x7f,
+};
+static const unsigned char kat47_retbits[] = {
+    0x97, 0xc0, 0xc0, 0xe5, 0xa0, 0xcc, 0xf2, 0x4f, 0x33, 0x63, 0x48, 0x8a,
+    0xdb, 0x13, 0x0a, 0x35, 0x89, 0xbf, 0x80, 0x65, 0x62, 0xee, 0x13, 0x95,
+    0x7c, 0x33, 0xd3, 0x7d, 0xf4, 0x07, 0x77, 0x7a, 0x2b, 0x65, 0x0b, 0x5f,
+    0x45, 0x5c, 0x13, 0xf1, 0x90, 0x77, 0x7f, 0xc5, 0x04, 0x3f, 0xcc, 0x1a,
+    0x38, 0xf8, 0xcd, 0x1b, 0xbb, 0xd5, 0x57, 0xd1, 0x4a, 0x4c, 0x2e, 0x8a,
+    0x2b, 0x49, 0x1e, 0x5c,
+};
+static const struct drbg_kat_no_reseed kat47_t = {
+    1, kat47_entropyin, kat47_nonce, kat47_persstr,
+    kat47_addin0, kat47_addin1, kat47_retbits
+};
+static const struct drbg_kat kat47 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat47_t
+};
+
+static const unsigned char kat48_entropyin[] = {
+    0x6b, 0x98, 0x53, 0x2d, 0x67, 0x8f, 0xd2, 0x79, 0xcf, 0x73, 0x7c, 0x58,
+    0x15, 0x0c, 0xe5, 0x89,
+};
+static const unsigned char kat48_nonce[] = {
+    0xca, 0x55, 0x45, 0x07, 0x3d, 0x54, 0x9d, 0x06,
+};
+static const unsigned char kat48_persstr[] = {
+    0x80, 0x90, 0x8a, 0xc1, 0x34, 0xe0, 0xcd, 0x23, 0xef, 0x7e, 0x31, 0x85,
+    0x48, 0xf9, 0x21, 0x91,
+};
+static const unsigned char kat48_addin0[] = {
+    0x53, 0x79, 0x0d, 0xa9, 0x09, 0xbf, 0xde, 0xed, 0xaa, 0xfd, 0x99, 0x61,
+    0x9f, 0x3f, 0x46, 0x1b,
+};
+static const unsigned char kat48_addin1[] = {
+    0xc7, 0xa5, 0x87, 0x77, 0xd1, 0xfb, 0xd1, 0x55, 0x3e, 0x95, 0x46, 0xc8,
+    0x3e, 0x40, 0x9f, 0xc2,
+};
+static const unsigned char kat48_retbits[] = {
+    0xd9, 0x84, 0xa2, 0x40, 0x58, 0x87, 0x39, 0x02, 0x27, 0x94, 0x09, 0x59,
+    0xe4, 0x9f, 0x94, 0x4e, 0x49, 0x04, 0xc4, 0xf0, 0x46, 0x7f, 0xf2, 0x4d,
+    0x87, 0x64, 0xdb, 0x91, 0x53, 0x0a, 0x1e, 0x59, 0x65, 0x68, 0x84, 0x72,
+    0xfa, 0xc1, 0x31, 0xbe, 0xa0, 0x55, 0xc7, 0x15, 0x12, 0x27, 0xe2, 0xfc,
+    0xb0, 0xda, 0xd9, 0x65, 0x5e, 0xc3, 0xac, 0x22, 0xcd, 0x7d, 0xff, 0x72,
+    0xf6, 0xc7, 0x4a, 0xa0,
+};
+static const struct drbg_kat_no_reseed kat48_t = {
+    2, kat48_entropyin, kat48_nonce, kat48_persstr,
+    kat48_addin0, kat48_addin1, kat48_retbits
+};
+static const struct drbg_kat kat48 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat48_t
+};
+
+static const unsigned char kat49_entropyin[] = {
+    0x97, 0x51, 0x6e, 0x48, 0xd9, 0x10, 0x37, 0x2a, 0x3f, 0x1f, 0xb4, 0xaa,
+    0x7a, 0xe4, 0x93, 0x0f,
+};
+static const unsigned char kat49_nonce[] = {
+    0xbb, 0xa3, 0x0b, 0x3d, 0xeb, 0x19, 0x33, 0x89,
+};
+static const unsigned char kat49_persstr[] = {
+    0x8c, 0x0e, 0x3e, 0x71, 0xc8, 0x20, 0x1a, 0x77, 0x10, 0x55, 0x19, 0xdf,
+    0xfa, 0x89, 0xc1, 0xaa,
+};
+static const unsigned char kat49_addin0[] = {
+    0x0a, 0x18, 0x78, 0x7e, 0x46, 0x50, 0xfa, 0x02, 0x49, 0xf7, 0x79, 0x62,
+    0xac, 0x15, 0x8c, 0x63,
+};
+static const unsigned char kat49_addin1[] = {
+    0x2f, 0xb1, 0x92, 0x31, 0x4c, 0x3e, 0x07, 0xf9, 0x63, 0xfb, 0xa3, 0x4d,
+    0x8d, 0xfc, 0x8c, 0x9c,
+};
+static const unsigned char kat49_retbits[] = {
+    0xd7, 0xb7, 0x3e, 0x44, 0x9a, 0xed, 0x8f, 0x0a, 0x06, 0x93, 0x84, 0x83,
+    0xe8, 0x78, 0x11, 0x04, 0x9b, 0x4a, 0xcf, 0xe5, 0x1c, 0xa5, 0x55, 0xf1,
+    0xee, 0x97, 0x86, 0xe3, 0x3f, 0xce, 0x90, 0x69, 0x7d, 0xb6, 0x8d, 0x2d,
+    0xc6, 0x36, 0x1c, 0x94, 0x2c, 0xf6, 0x7d, 0x89, 0x26, 0x19, 0x49, 0x7e,
+    0x96, 0x19, 0x43, 0x32, 0xae, 0x32, 0xa6, 0x35, 0xcf, 0x35, 0x5b, 0xbc,
+    0x3c, 0x66, 0x79, 0x55,
+};
+static const struct drbg_kat_no_reseed kat49_t = {
+    3, kat49_entropyin, kat49_nonce, kat49_persstr,
+    kat49_addin0, kat49_addin1, kat49_retbits
+};
+static const struct drbg_kat kat49 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat49_t
+};
+
+static const unsigned char kat50_entropyin[] = {
+    0x62, 0xce, 0xf3, 0x5a, 0x51, 0x8e, 0xf6, 0x52, 0x0b, 0x6e, 0xdb, 0x1a,
+    0xa9, 0xa2, 0x14, 0x96,
+};
+static const unsigned char kat50_nonce[] = {
+    0x2b, 0x98, 0xe2, 0x69, 0xf5, 0x1f, 0xb3, 0xba,
+};
+static const unsigned char kat50_persstr[] = {
+    0x89, 0xa6, 0xc9, 0x11, 0x27, 0x13, 0xd0, 0xd1, 0x96, 0xc8, 0xe0, 0x26,
+    0x60, 0xa2, 0x51, 0x31,
+};
+static const unsigned char kat50_addin0[] = {
+    0x35, 0xed, 0xb8, 0x77, 0x01, 0xcb, 0x50, 0x01, 0x43, 0x4d, 0xb1, 0x85,
+    0x7b, 0xf9, 0x8e, 0xfb,
+};
+static const unsigned char kat50_addin1[] = {
+    0xa9, 0xfa, 0x53, 0xb5, 0xd3, 0x03, 0x2e, 0x4b, 0xe6, 0x0d, 0xcd, 0xb1,
+    0xe9, 0x4b, 0x4f, 0x50,
+};
+static const unsigned char kat50_retbits[] = {
+    0xde, 0x8b, 0x77, 0x0b, 0x3e, 0xd4, 0x33, 0x15, 0xab, 0x7e, 0x83, 0x31,
+    0xe2, 0xdf, 0x12, 0xcb, 0x9a, 0xbe, 0xb3, 0xf6, 0xb1, 0x4c, 0x45, 0x7a,
+    0x30, 0x4b, 0xcd, 0x1d, 0xf7, 0x30, 0xdb, 0x52, 0xd4, 0xb4, 0x02, 0xf7,
+    0x8b, 0x80, 0x54, 0x59, 0x65, 0xfc, 0x5a, 0x83, 0xdd, 0xf9, 0x99, 0x63,
+    0xaa, 0xb5, 0xe1, 0xb3, 0x79, 0x24, 0x57, 0xdf, 0x4b, 0xf9, 0x27, 0xb6,
+    0x6a, 0x4d, 0x67, 0x45,
+};
+static const struct drbg_kat_no_reseed kat50_t = {
+    4, kat50_entropyin, kat50_nonce, kat50_persstr,
+    kat50_addin0, kat50_addin1, kat50_retbits
+};
+static const struct drbg_kat kat50 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat50_t
+};
+
+static const unsigned char kat51_entropyin[] = {
+    0xc0, 0x2a, 0xf7, 0x05, 0xf6, 0x99, 0xc3, 0xa7, 0xf5, 0xe2, 0xbb, 0x9b,
+    0x14, 0xc7, 0xce, 0xa7,
+};
+static const unsigned char kat51_nonce[] = {
+    0xeb, 0x24, 0x6b, 0x26, 0xa3, 0xa0, 0xa1, 0x0b,
+};
+static const unsigned char kat51_persstr[] = {
+    0x07, 0xdf, 0x3d, 0x3d, 0x48, 0x6b, 0xbe, 0x68, 0x19, 0x04, 0x40, 0x94,
+    0xc9, 0x15, 0x89, 0x99,
+};
+static const unsigned char kat51_addin0[] = {
+    0xf4, 0x9d, 0x27, 0x9f, 0x04, 0x81, 0x5d, 0x98, 0x30, 0x92, 0xb6, 0xb5,
+    0xfe, 0x4f, 0x10, 0xf7,
+};
+static const unsigned char kat51_addin1[] = {
+    0xd7, 0x66, 0x07, 0x00, 0x64, 0xdf, 0xe2, 0x03, 0xb2, 0xa3, 0x9d, 0x1b,
+    0x24, 0x75, 0x84, 0x10,
+};
+static const unsigned char kat51_retbits[] = {
+    0xdd, 0xbb, 0x48, 0x8c, 0x6b, 0x6f, 0x0f, 0x9c, 0xb7, 0x05, 0xa3, 0xc5,
+    0xab, 0x13, 0xc3, 0x17, 0x6f, 0x86, 0x7b, 0x12, 0x0c, 0x29, 0xdb, 0x37,
+    0xf7, 0x9c, 0x00, 0x23, 0x8a, 0x77, 0xa0, 0x41, 0x45, 0x04, 0xd3, 0x28,
+    0x93, 0xa0, 0x8c, 0x7e, 0x99, 0xc2, 0xb1, 0xa8, 0x8d, 0x50, 0x92, 0x2e,
+    0x52, 0xb0, 0xdf, 0x56, 0x0b, 0x75, 0x3a, 0xdd, 0x48, 0x60, 0x4c, 0xaa,
+    0xbb, 0xb9, 0x75, 0x2f,
+};
+static const struct drbg_kat_no_reseed kat51_t = {
+    5, kat51_entropyin, kat51_nonce, kat51_persstr,
+    kat51_addin0, kat51_addin1, kat51_retbits
+};
+static const struct drbg_kat kat51 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat51_t
+};
+
+static const unsigned char kat52_entropyin[] = {
+    0x56, 0x6f, 0xc3, 0x38, 0x98, 0x5a, 0x8f, 0xc8, 0x67, 0xda, 0xbe, 0x24,
+    0xf7, 0xf9, 0x09, 0x7d,
+};
+static const unsigned char kat52_nonce[] = {
+    0xdb, 0xf7, 0x1d, 0x79, 0x17, 0xe0, 0xb1, 0x51,
+};
+static const unsigned char kat52_persstr[] = {
+    0x66, 0x56, 0x94, 0x18, 0x17, 0xa6, 0x15, 0xe2, 0x9f, 0x62, 0xbd, 0x4f,
+    0x1d, 0x93, 0xcb, 0x11,
+};
+static const unsigned char kat52_addin0[] = {
+    0xa2, 0x74, 0xbe, 0x52, 0x97, 0x46, 0xbd, 0x0b, 0x6a, 0x58, 0x73, 0xdc,
+    0x3c, 0x1d, 0xae, 0xbc,
+};
+static const unsigned char kat52_addin1[] = {
+    0x4e, 0x23, 0xfa, 0x29, 0xd2, 0x6b, 0x1f, 0xe9, 0x2b, 0xb4, 0x2b, 0x3e,
+    0x9f, 0x2b, 0x4c, 0x08,
+};
+static const unsigned char kat52_retbits[] = {
+    0xb5, 0xda, 0x60, 0xb8, 0x70, 0x22, 0x6a, 0x48, 0xb2, 0xb9, 0xb5, 0xd9,
+    0xa9, 0x46, 0x49, 0x54, 0xa8, 0xdb, 0x0d, 0x3e, 0x5f, 0xb3, 0x06, 0x3c,
+    0x80, 0xe6, 0x75, 0x19, 0x7d, 0xc5, 0x84, 0x07, 0xb4, 0xc0, 0x40, 0x9c,
+    0xd0, 0x69, 0x75, 0xed, 0xa8, 0xaf, 0xe6, 0x66, 0x7a, 0xa0, 0xd7, 0x9e,
+    0xcf, 0x55, 0x5e, 0x23, 0x8f, 0x83, 0x42, 0x4f, 0x13, 0x08, 0x19, 0x20,
+    0x0c, 0x24, 0x4a, 0x77,
+};
+static const struct drbg_kat_no_reseed kat52_t = {
+    6, kat52_entropyin, kat52_nonce, kat52_persstr,
+    kat52_addin0, kat52_addin1, kat52_retbits
+};
+static const struct drbg_kat kat52 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat52_t
+};
+
+static const unsigned char kat53_entropyin[] = {
+    0x67, 0x43, 0xbc, 0x12, 0x2a, 0xaa, 0x13, 0x4f, 0x82, 0xac, 0x8c, 0x78,
+    0xcc, 0x0b, 0x64, 0xe7,
+};
+static const unsigned char kat53_nonce[] = {
+    0x2d, 0xc3, 0x2e, 0x4f, 0x3b, 0xba, 0x5a, 0x20,
+};
+static const unsigned char kat53_persstr[] = {
+    0xb8, 0x07, 0x7f, 0x23, 0xa9, 0x08, 0xc4, 0x25, 0x92, 0xc1, 0x3b, 0x63,
+    0x89, 0x09, 0x98, 0xd0,
+};
+static const unsigned char kat53_addin0[] = {
+    0xd6, 0x83, 0x74, 0xf5, 0x8c, 0xe2, 0x5b, 0xd8, 0xe9, 0x5f, 0xe0, 0x6d,
+    0xe8, 0xa9, 0x50, 0xa1,
+};
+static const unsigned char kat53_addin1[] = {
+    0x07, 0xb7, 0xab, 0x9c, 0x32, 0xa9, 0x78, 0x30, 0xa0, 0x0e, 0xd9, 0x89,
+    0x5e, 0x3b, 0xbe, 0x19,
+};
+static const unsigned char kat53_retbits[] = {
+    0xfe, 0x82, 0x7f, 0x53, 0x07, 0x6d, 0xf3, 0x08, 0x47, 0xd0, 0xfb, 0x0f,
+    0x55, 0xa2, 0xcd, 0x63, 0x81, 0xca, 0x0e, 0x79, 0xe6, 0x81, 0x62, 0x1f,
+    0x49, 0xf3, 0x1e, 0x48, 0x11, 0xe9, 0xa6, 0x4c, 0x57, 0xc0, 0x99, 0x4f,
+    0x18, 0x0c, 0x31, 0x1a, 0x40, 0x44, 0x40, 0xf2, 0x77, 0xfa, 0x62, 0xe0,
+    0xf9, 0x9c, 0x6f, 0x5c, 0x7b, 0x88, 0xbe, 0xe2, 0x07, 0xfc, 0xa9, 0x92,
+    0x6b, 0xfc, 0x9e, 0x46,
+};
+static const struct drbg_kat_no_reseed kat53_t = {
+    7, kat53_entropyin, kat53_nonce, kat53_persstr,
+    kat53_addin0, kat53_addin1, kat53_retbits
+};
+static const struct drbg_kat kat53 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat53_t
+};
+
+static const unsigned char kat54_entropyin[] = {
+    0xf2, 0xad, 0xdf, 0x01, 0x67, 0xa1, 0x6d, 0xa3, 0x8d, 0x2f, 0xd7, 0x92,
+    0xa7, 0x18, 0x9c, 0x06,
+};
+static const unsigned char kat54_nonce[] = {
+    0x2b, 0x50, 0xd8, 0xcc, 0x7f, 0x71, 0x40, 0x1c,
+};
+static const unsigned char kat54_persstr[] = {
+    0xb9, 0x17, 0xa5, 0x4c, 0x13, 0xd5, 0x8c, 0xb6, 0xad, 0x47, 0xc8, 0xfa,
+    0xf6, 0xf9, 0xa7, 0xf5,
+};
+static const unsigned char kat54_addin0[] = {
+    0xcf, 0x2e, 0x78, 0x5a, 0x06, 0xbc, 0x5e, 0xb7, 0x1e, 0x3b, 0x52, 0x4f,
+    0x11, 0x72, 0xc7, 0x55,
+};
+static const unsigned char kat54_addin1[] = {
+    0xc9, 0xa7, 0x53, 0xa9, 0xce, 0xdd, 0xd7, 0x5d, 0x1a, 0x62, 0x6d, 0xa7,
+    0x27, 0x95, 0xa3, 0xc6,
+};
+static const unsigned char kat54_retbits[] = {
+    0xe2, 0xaa, 0xf1, 0x1c, 0x20, 0xde, 0x2b, 0xaf, 0x89, 0x23, 0x04, 0x1d,
+    0x83, 0x8f, 0x4a, 0xcb, 0x38, 0xe2, 0x22, 0xd3, 0x06, 0xb9, 0x7c, 0x97,
+    0xbf, 0xe5, 0x46, 0x61, 0x7b, 0x3d, 0x8d, 0x92, 0xe4, 0x0c, 0xaa, 0x2e,
+    0xdc, 0xac, 0x7a, 0x2f, 0xb0, 0x64, 0x3e, 0xd5, 0x7d, 0x47, 0xa9, 0x0a,
+    0x11, 0x64, 0x10, 0x44, 0xb6, 0xc6, 0xa7, 0xdf, 0x42, 0x4d, 0xbd, 0xa2,
+    0xb4, 0x5f, 0x0d, 0xf9,
+};
+static const struct drbg_kat_no_reseed kat54_t = {
+    8, kat54_entropyin, kat54_nonce, kat54_persstr,
+    kat54_addin0, kat54_addin1, kat54_retbits
+};
+static const struct drbg_kat kat54 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat54_t
+};
+
+static const unsigned char kat55_entropyin[] = {
+    0xca, 0x23, 0x34, 0x58, 0xf6, 0x6b, 0x26, 0xf2, 0xc1, 0x35, 0x7a, 0xef,
+    0xce, 0xb6, 0x79, 0xef,
+};
+static const unsigned char kat55_nonce[] = {
+    0xfe, 0x13, 0x64, 0x04, 0xad, 0x7a, 0x49, 0xe7,
+};
+static const unsigned char kat55_persstr[] = {
+    0x26, 0x83, 0xdc, 0x31, 0x3b, 0xc0, 0xbb, 0x93, 0xeb, 0xb4, 0x6b, 0xbb,
+    0x55, 0x3f, 0x58, 0x75,
+};
+static const unsigned char kat55_addin0[] = {
+    0xf7, 0x8a, 0xb1, 0xf4, 0x52, 0x6f, 0x0f, 0xa5, 0xcb, 0x75, 0x43, 0xd1,
+    0x46, 0x43, 0xfe, 0xb5,
+};
+static const unsigned char kat55_addin1[] = {
+    0x40, 0xb9, 0x26, 0x32, 0x4c, 0xc2, 0x94, 0x3a, 0xca, 0x83, 0x7f, 0x69,
+    0x0d, 0x0b, 0xcd, 0xa4,
+};
+static const unsigned char kat55_retbits[] = {
+    0x37, 0x24, 0xd0, 0xe5, 0x80, 0xe9, 0x0d, 0x4e, 0xf3, 0x2e, 0x5f, 0x8a,
+    0x5b, 0xb5, 0x62, 0x25, 0xa9, 0x13, 0xf2, 0x10, 0xb7, 0x6d, 0x5a, 0x78,
+    0xfd, 0x8e, 0xf2, 0x5d, 0x6e, 0xec, 0x9f, 0xf1, 0x47, 0x11, 0xd6, 0xdb,
+    0x80, 0xe1, 0xe8, 0x11, 0x42, 0xa5, 0x60, 0x75, 0x34, 0xa7, 0x25, 0xd2,
+    0x78, 0x5c, 0x8e, 0x3e, 0x4a, 0x48, 0xa5, 0x94, 0xb0, 0xd9, 0x1b, 0xc9,
+    0x32, 0x82, 0x7b, 0xd7,
+};
+static const struct drbg_kat_no_reseed kat55_t = {
+    9, kat55_entropyin, kat55_nonce, kat55_persstr,
+    kat55_addin0, kat55_addin1, kat55_retbits
+};
+static const struct drbg_kat kat55 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat55_t
+};
+
+static const unsigned char kat56_entropyin[] = {
+    0x2b, 0x52, 0x1d, 0xc4, 0x03, 0x12, 0x9f, 0xd9, 0xed, 0x0b, 0xe9, 0xf5,
+    0xfd, 0xe0, 0x66, 0x17,
+};
+static const unsigned char kat56_nonce[] = {
+    0xf0, 0xdf, 0xa0, 0x1e, 0x09, 0x9b, 0x95, 0xa1,
+};
+static const unsigned char kat56_persstr[] = {
+    0xfe, 0x85, 0x8d, 0x59, 0xd7, 0x34, 0xf6, 0x0f, 0x71, 0xa3, 0x87, 0x55,
+    0x3c, 0xca, 0x46, 0xff,
+};
+static const unsigned char kat56_addin0[] = {
+    0x6f, 0xba, 0x8d, 0x06, 0xff, 0x43, 0x30, 0x07, 0xbd, 0x7d, 0x15, 0x56,
+    0x9a, 0xf3, 0xd0, 0x69,
+};
+static const unsigned char kat56_addin1[] = {
+    0x80, 0xb0, 0xc1, 0x1f, 0x18, 0xb5, 0x92, 0x3a, 0x89, 0xf0, 0xfe, 0x23,
+    0x77, 0x6d, 0x39, 0x05,
+};
+static const unsigned char kat56_retbits[] = {
+    0x41, 0x73, 0x88, 0xde, 0xe9, 0x08, 0x4f, 0x58, 0x8d, 0x0a, 0xdb, 0x5e,
+    0x5d, 0x1b, 0x54, 0x6b, 0x12, 0x55, 0xcd, 0xf5, 0x9d, 0x69, 0x95, 0x7a,
+    0xe6, 0x87, 0xc7, 0x82, 0x2b, 0x93, 0x5c, 0xe0, 0x29, 0x30, 0x6c, 0x02,
+    0x50, 0xd4, 0x69, 0x83, 0x9c, 0x7d, 0xf9, 0xd3, 0xd0, 0x8e, 0xc8, 0xc5,
+    0x0a, 0x66, 0x7a, 0xf1, 0x0d, 0x8d, 0x5b, 0x00, 0x73, 0x02, 0xa6, 0xe8,
+    0x7b, 0x4e, 0x7f, 0x2c,
+};
+static const struct drbg_kat_no_reseed kat56_t = {
+    10, kat56_entropyin, kat56_nonce, kat56_persstr,
+    kat56_addin0, kat56_addin1, kat56_retbits
+};
+static const struct drbg_kat kat56 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat56_t
+};
+
+static const unsigned char kat57_entropyin[] = {
+    0xd0, 0x50, 0x2b, 0x78, 0xf7, 0xaa, 0x6f, 0xa1, 0xd8, 0x88, 0x42, 0x1d,
+    0x70, 0x2c, 0xad, 0xd1,
+};
+static const unsigned char kat57_nonce[] = {
+    0x4b, 0x37, 0xb8, 0x96, 0x59, 0x69, 0xea, 0x8d,
+};
+static const unsigned char kat57_persstr[] = {
+    0x56, 0xbd, 0x43, 0x1f, 0x04, 0x88, 0xfe, 0x6d, 0x7b, 0xa3, 0x83, 0x6e,
+    0x5c, 0x8c, 0x7a, 0xa9,
+};
+static const unsigned char kat57_addin0[] = {
+    0x26, 0x92, 0x5d, 0xbc, 0xbe, 0xd7, 0x33, 0xbe, 0x2a, 0x5e, 0x76, 0x49,
+    0xc8, 0x76, 0xa0, 0xf8,
+};
+static const unsigned char kat57_addin1[] = {
+    0x9c, 0x70, 0x35, 0x2d, 0x4f, 0x9c, 0x88, 0x0e, 0x76, 0xd4, 0x68, 0x08,
+    0x38, 0xdd, 0x0d, 0xea,
+};
+static const unsigned char kat57_retbits[] = {
+    0x65, 0x00, 0x24, 0x2c, 0x35, 0x88, 0xb4, 0x52, 0x30, 0x7b, 0x2a, 0x06,
+    0x34, 0x90, 0x0e, 0x75, 0x6a, 0x3d, 0x26, 0x19, 0xfc, 0x2a, 0xdf, 0x10,
+    0x77, 0x69, 0x22, 0xb0, 0x06, 0x61, 0x7e, 0xe8, 0x81, 0x82, 0x83, 0x66,
+    0xac, 0x52, 0x7f, 0xad, 0xa0, 0x01, 0x86, 0xbc, 0x8b, 0xfd, 0x6b, 0xee,
+    0x66, 0xd6, 0x38, 0x03, 0x5a, 0xaf, 0xff, 0xbc, 0x83, 0x32, 0xa5, 0x4c,
+    0xa1, 0x7d, 0xf1, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat57_t = {
+    11, kat57_entropyin, kat57_nonce, kat57_persstr,
+    kat57_addin0, kat57_addin1, kat57_retbits
+};
+static const struct drbg_kat kat57 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat57_t
+};
+
+static const unsigned char kat58_entropyin[] = {
+    0xa3, 0xb9, 0x5f, 0x32, 0x01, 0xfa, 0x01, 0x01, 0x07, 0x57, 0x30, 0x74,
+    0xb1, 0x19, 0x9b, 0xc0,
+};
+static const unsigned char kat58_nonce[] = {
+    0x60, 0x30, 0xe5, 0xb6, 0x13, 0x47, 0xb0, 0xe2,
+};
+static const unsigned char kat58_persstr[] = {
+    0x9e, 0x77, 0x85, 0x46, 0xd4, 0x5f, 0x17, 0x93, 0xa1, 0x1d, 0x80, 0xa0,
+    0x2e, 0x4c, 0xa3, 0xc3,
+};
+static const unsigned char kat58_addin0[] = {
+    0xe5, 0x07, 0x33, 0x61, 0x98, 0x25, 0x31, 0x37, 0xa5, 0x55, 0xe8, 0xc1,
+    0x18, 0xa1, 0x2d, 0x2f,
+};
+static const unsigned char kat58_addin1[] = {
+    0xe5, 0xce, 0xea, 0xcb, 0xb5, 0x22, 0xf5, 0xde, 0x81, 0x78, 0x9c, 0x32,
+    0xcb, 0xcd, 0xef, 0x30,
+};
+static const unsigned char kat58_retbits[] = {
+    0x4a, 0xd1, 0x8e, 0xa0, 0x83, 0x7f, 0x06, 0x3e, 0x9f, 0xbf, 0x6c, 0x72,
+    0xd1, 0xaf, 0x6f, 0x77, 0x96, 0x41, 0xf4, 0xe1, 0x1c, 0x40, 0x0d, 0x95,
+    0xcb, 0x2b, 0xa4, 0x22, 0x99, 0xa9, 0x66, 0x48, 0xe0, 0x59, 0xe1, 0xa6,
+    0x3f, 0x7c, 0x03, 0x79, 0x25, 0x44, 0x89, 0xc7, 0xcb, 0xff, 0xfb, 0x22,
+    0x11, 0x84, 0x57, 0x18, 0xc5, 0x26, 0x00, 0xc9, 0xe8, 0x58, 0x49, 0xd6,
+    0xe0, 0x95, 0x1f, 0x7b,
+};
+static const struct drbg_kat_no_reseed kat58_t = {
+    12, kat58_entropyin, kat58_nonce, kat58_persstr,
+    kat58_addin0, kat58_addin1, kat58_retbits
+};
+static const struct drbg_kat kat58 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat58_t
+};
+
+static const unsigned char kat59_entropyin[] = {
+    0x88, 0x18, 0xbe, 0x7e, 0x8e, 0x81, 0x5b, 0xca, 0x0c, 0xb5, 0xa0, 0x14,
+    0x4d, 0x44, 0xb6, 0x72,
+};
+static const unsigned char kat59_nonce[] = {
+    0x12, 0x2b, 0x14, 0x8c, 0xa1, 0xaa, 0xba, 0x60,
+};
+static const unsigned char kat59_persstr[] = {
+    0x90, 0x6d, 0xc3, 0x0b, 0x39, 0x54, 0x27, 0x38, 0x56, 0x73, 0x26, 0x13,
+    0x66, 0xf5, 0xe9, 0xa8,
+};
+static const unsigned char kat59_addin0[] = {
+    0x56, 0xee, 0x67, 0xff, 0x14, 0x66, 0xce, 0xed, 0xd7, 0x28, 0x1d, 0x73,
+    0xf3, 0x9c, 0x6c, 0x85,
+};
+static const unsigned char kat59_addin1[] = {
+    0x82, 0xe4, 0xa6, 0xed, 0xb0, 0x78, 0x00, 0x79, 0xfa, 0xee, 0x25, 0x8e,
+    0xd1, 0x13, 0x7e, 0xcf,
+};
+static const unsigned char kat59_retbits[] = {
+    0x88, 0x55, 0xad, 0x03, 0xe3, 0x87, 0x27, 0xd0, 0x49, 0xe8, 0x55, 0x8e,
+    0xcc, 0x66, 0x3b, 0x8c, 0x89, 0xcb, 0x5b, 0xd1, 0x38, 0xac, 0x34, 0x9c,
+    0x6e, 0x5f, 0x78, 0x41, 0x70, 0xc5, 0x07, 0x69, 0xc8, 0xc9, 0x7b, 0x09,
+    0x4d, 0xfa, 0x07, 0x52, 0xd0, 0x65, 0x53, 0x1d, 0xa4, 0x00, 0x85, 0x81,
+    0x7c, 0xcb, 0x08, 0xf2, 0xb9, 0x4c, 0xbb, 0xba, 0xe7, 0x59, 0x8c, 0x96,
+    0x3e, 0x3a, 0xd6, 0xd1,
+};
+static const struct drbg_kat_no_reseed kat59_t = {
+    13, kat59_entropyin, kat59_nonce, kat59_persstr,
+    kat59_addin0, kat59_addin1, kat59_retbits
+};
+static const struct drbg_kat kat59 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat59_t
+};
+
+static const unsigned char kat60_entropyin[] = {
+    0x00, 0x90, 0xdc, 0xb9, 0x1f, 0x02, 0x70, 0xf6, 0x58, 0x20, 0x7d, 0x49,
+    0xa7, 0x47, 0x38, 0xe2,
+};
+static const unsigned char kat60_nonce[] = {
+    0x9d, 0x18, 0xae, 0xa2, 0x68, 0x4e, 0xe2, 0xb7,
+};
+static const unsigned char kat60_persstr[] = {
+    0x64, 0xa8, 0x18, 0x57, 0xce, 0x29, 0xf0, 0xd2, 0xa8, 0x51, 0x03, 0x00,
+    0xb0, 0xa3, 0xfa, 0xc0,
+};
+static const unsigned char kat60_addin0[] = {
+    0xcd, 0x7f, 0x89, 0xf8, 0xd5, 0x46, 0x8e, 0xae, 0x8b, 0xca, 0x31, 0x4f,
+    0xd9, 0xf2, 0x5b, 0x23,
+};
+static const unsigned char kat60_addin1[] = {
+    0x94, 0x9b, 0x94, 0x41, 0x7f, 0xb4, 0x2b, 0xbc, 0x7c, 0xdb, 0x3f, 0x53,
+    0xa0, 0x55, 0x80, 0x19,
+};
+static const unsigned char kat60_retbits[] = {
+    0x63, 0xd3, 0xe9, 0x19, 0x88, 0x1f, 0x87, 0xd6, 0x9c, 0xba, 0xdc, 0xb6,
+    0x78, 0x9e, 0x0b, 0x8f, 0x2e, 0x49, 0xf4, 0xc9, 0xd0, 0xe3, 0xba, 0x1e,
+    0x4a, 0x59, 0x16, 0x2a, 0xf7, 0x18, 0xbc, 0x40, 0xdd, 0x67, 0x3e, 0xae,
+    0x8f, 0x48, 0xfd, 0x27, 0x82, 0xe0, 0x6c, 0xde, 0xc5, 0x63, 0x2a, 0x4b,
+    0x2e, 0x60, 0x65, 0x5c, 0xba, 0x75, 0xaf, 0xaf, 0x4c, 0x12, 0xa6, 0x74,
+    0xee, 0xe4, 0xd3, 0xfc,
+};
+static const struct drbg_kat_no_reseed kat60_t = {
+    14, kat60_entropyin, kat60_nonce, kat60_persstr,
+    kat60_addin0, kat60_addin1, kat60_retbits
+};
+static const struct drbg_kat kat60 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat60_t
+};
+
+static const unsigned char kat61_entropyin[] = {
+    0x2d, 0x2a, 0xb5, 0x64, 0x20, 0x29, 0x18, 0xc4, 0xef, 0x5b, 0x10, 0x2d,
+    0xda, 0x38, 0x5a, 0x18,
+};
+static const unsigned char kat61_nonce[] = {
+    0x25, 0x91, 0x95, 0x26, 0x9e, 0xc1, 0x1a, 0xf6,
+};
+static const unsigned char kat61_persstr[] = {0};
+static const unsigned char kat61_addin0[] = {0};
+static const unsigned char kat61_addin1[] = {0};
+static const unsigned char kat61_retbits[] = {
+    0x2c, 0x5c, 0xd7, 0x9e, 0xd8, 0x76, 0x22, 0xa9, 0x1b, 0x86, 0x54, 0xc8,
+    0x90, 0x3d, 0x85, 0x22, 0x42, 0xcd, 0x49, 0xcb, 0x5d, 0xf2, 0xd4, 0xb4,
+    0x15, 0x05, 0x84, 0x30, 0x1c, 0x59, 0xf0, 0x1f, 0xd9, 0x5a, 0x70, 0x2a,
+    0xc1, 0x57, 0xc8, 0x4c, 0xc1, 0x5f, 0x42, 0xc8, 0x21, 0x13, 0x35, 0x67,
+    0x2d, 0x8c, 0xe1, 0x29, 0x1e, 0xf9, 0xb1, 0xde, 0xf7, 0x81, 0x49, 0xa0,
+    0x4f, 0xa2, 0x69, 0x7c,
+};
+static const struct drbg_kat_no_reseed kat61_t = {
+    0, kat61_entropyin, kat61_nonce, kat61_persstr,
+    kat61_addin0, kat61_addin1, kat61_retbits
+};
+static const struct drbg_kat kat61 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat61_t
+};
+
+static const unsigned char kat62_entropyin[] = {
+    0xa0, 0x16, 0x46, 0x3d, 0xbb, 0x49, 0x99, 0x90, 0xcb, 0xcd, 0xa4, 0x50,
+    0x46, 0xd8, 0xf3, 0x37,
+};
+static const unsigned char kat62_nonce[] = {
+    0x24, 0x9d, 0x02, 0xde, 0x2d, 0xcf, 0x3e, 0x57,
+};
+static const unsigned char kat62_persstr[] = {0};
+static const unsigned char kat62_addin0[] = {0};
+static const unsigned char kat62_addin1[] = {0};
+static const unsigned char kat62_retbits[] = {
+    0x35, 0xb8, 0x1f, 0xb9, 0x42, 0x41, 0xf4, 0xc9, 0x31, 0x9a, 0x7f, 0x16,
+    0xb4, 0x42, 0x49, 0x52, 0x52, 0xdb, 0x4c, 0x98, 0x48, 0x60, 0xd0, 0x35,
+    0xf6, 0xc4, 0x54, 0x03, 0xf9, 0x74, 0xf5, 0x34, 0xfa, 0x93, 0xb2, 0x1b,
+    0x6b, 0x89, 0x44, 0x1b, 0xe0, 0x7c, 0x5c, 0x29, 0x31, 0x7f, 0x86, 0x8d,
+    0xc9, 0xab, 0x5c, 0x18, 0x37, 0x74, 0x37, 0xfa, 0xdb, 0x4d, 0x85, 0x7e,
+    0xe0, 0x92, 0xf9, 0x23,
+};
+static const struct drbg_kat_no_reseed kat62_t = {
+    1, kat62_entropyin, kat62_nonce, kat62_persstr,
+    kat62_addin0, kat62_addin1, kat62_retbits
+};
+static const struct drbg_kat kat62 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat62_t
+};
+
+static const unsigned char kat63_entropyin[] = {
+    0x1e, 0x38, 0x20, 0xc4, 0x6e, 0x50, 0xb7, 0xcb, 0xc5, 0x8b, 0x05, 0xaa,
+    0x72, 0x24, 0x27, 0xa8,
+};
+static const unsigned char kat63_nonce[] = {
+    0xfe, 0x0f, 0x40, 0x01, 0x4e, 0xb3, 0x27, 0x9f,
+};
+static const unsigned char kat63_persstr[] = {0};
+static const unsigned char kat63_addin0[] = {0};
+static const unsigned char kat63_addin1[] = {0};
+static const unsigned char kat63_retbits[] = {
+    0x18, 0x53, 0x0b, 0x9d, 0xe8, 0x89, 0xd8, 0xad, 0x3f, 0x41, 0xd5, 0x39,
+    0x79, 0x6c, 0x2a, 0x95, 0xd6, 0x82, 0xfb, 0x02, 0x6d, 0xf7, 0xca, 0x09,
+    0x4a, 0xf4, 0xab, 0x23, 0x95, 0x29, 0x2e, 0x6f, 0xcd, 0xb1, 0x75, 0xba,
+    0x25, 0x7d, 0x61, 0x27, 0x9d, 0xa4, 0xd0, 0xfc, 0x78, 0xfd, 0xf8, 0xa4,
+    0xeb, 0x46, 0xa0, 0xe2, 0xd7, 0x54, 0xf5, 0xf8, 0xf0, 0x9e, 0xcb, 0x15,
+    0x7c, 0x8a, 0x58, 0xa1,
+};
+static const struct drbg_kat_no_reseed kat63_t = {
+    2, kat63_entropyin, kat63_nonce, kat63_persstr,
+    kat63_addin0, kat63_addin1, kat63_retbits
+};
+static const struct drbg_kat kat63 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat63_t
+};
+
+static const unsigned char kat64_entropyin[] = {
+    0x3b, 0x02, 0xc5, 0xa4, 0x74, 0x67, 0x96, 0x48, 0xe2, 0xfe, 0x09, 0x0a,
+    0x13, 0xbe, 0x04, 0x1c,
+};
+static const unsigned char kat64_nonce[] = {
+    0x71, 0xed, 0x5a, 0xa0, 0x78, 0xb8, 0x3a, 0x7b,
+};
+static const unsigned char kat64_persstr[] = {0};
+static const unsigned char kat64_addin0[] = {0};
+static const unsigned char kat64_addin1[] = {0};
+static const unsigned char kat64_retbits[] = {
+    0xe8, 0xe2, 0xe5, 0xd8, 0xbd, 0x99, 0x29, 0xe4, 0xe1, 0x67, 0x5c, 0x84,
+    0x61, 0x45, 0x7c, 0xab, 0x06, 0x33, 0xd8, 0x3f, 0x9b, 0xd2, 0x43, 0xbc,
+    0x58, 0x29, 0x37, 0xc2, 0xb9, 0x61, 0xb7, 0x1c, 0x11, 0x85, 0x6f, 0x83,
+    0x6c, 0x37, 0x32, 0x9d, 0x3f, 0xa8, 0x63, 0x76, 0xee, 0xc9, 0x71, 0x39,
+    0x10, 0x4d, 0xe5, 0x32, 0x60, 0xe1, 0x22, 0xcb, 0x2b, 0x6d, 0x82, 0x4e,
+    0x21, 0xe7, 0x5c, 0xe7,
+};
+static const struct drbg_kat_no_reseed kat64_t = {
+    3, kat64_entropyin, kat64_nonce, kat64_persstr,
+    kat64_addin0, kat64_addin1, kat64_retbits
+};
+static const struct drbg_kat kat64 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat64_t
+};
+
+static const unsigned char kat65_entropyin[] = {
+    0x05, 0x0c, 0x48, 0xab, 0x8a, 0x05, 0xff, 0x69, 0x0b, 0x62, 0xe3, 0x7d,
+    0x9b, 0x21, 0xf2, 0xfa,
+};
+static const unsigned char kat65_nonce[] = {
+    0xf7, 0x96, 0x48, 0x75, 0xbe, 0x28, 0x83, 0x53,
+};
+static const unsigned char kat65_persstr[] = {0};
+static const unsigned char kat65_addin0[] = {0};
+static const unsigned char kat65_addin1[] = {0};
+static const unsigned char kat65_retbits[] = {
+    0x24, 0xcb, 0x0e, 0xdc, 0xb8, 0x9e, 0xec, 0x61, 0x76, 0x13, 0xa2, 0x7f,
+    0xe3, 0xe4, 0x47, 0x5a, 0xff, 0xab, 0x49, 0x8d, 0x57, 0xbc, 0x3c, 0x4e,
+    0xf8, 0x44, 0xfe, 0x19, 0xb3, 0x84, 0x13, 0x47, 0x7c, 0x1d, 0xb0, 0x40,
+    0xf1, 0x67, 0x57, 0xf1, 0x85, 0x1b, 0x79, 0x9c, 0x1f, 0x26, 0x69, 0xaa,
+    0x9f, 0x9c, 0x50, 0x53, 0x2e, 0xaf, 0xbe, 0x1e, 0x29, 0x48, 0xe3, 0x38,
+    0xd1, 0xca, 0x4b, 0xd7,
+};
+static const struct drbg_kat_no_reseed kat65_t = {
+    4, kat65_entropyin, kat65_nonce, kat65_persstr,
+    kat65_addin0, kat65_addin1, kat65_retbits
+};
+static const struct drbg_kat kat65 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat65_t
+};
+
+static const unsigned char kat66_entropyin[] = {
+    0xec, 0xd9, 0x9c, 0x0b, 0x49, 0x1c, 0xf6, 0xa3, 0x23, 0xbc, 0x33, 0x36,
+    0x46, 0xe5, 0xc5, 0x6a,
+};
+static const unsigned char kat66_nonce[] = {
+    0xb1, 0x0a, 0x17, 0x84, 0x99, 0x5c, 0xb3, 0x4c,
+};
+static const unsigned char kat66_persstr[] = {0};
+static const unsigned char kat66_addin0[] = {0};
+static const unsigned char kat66_addin1[] = {0};
+static const unsigned char kat66_retbits[] = {
+    0x65, 0x35, 0xc4, 0x8d, 0x99, 0x9a, 0x30, 0x6a, 0xcb, 0x83, 0xf7, 0xb7,
+    0x20, 0xb3, 0xc3, 0x97, 0x72, 0xa4, 0x96, 0xe7, 0x5a, 0x89, 0x0f, 0x6e,
+    0x14, 0xd7, 0x0a, 0x82, 0x41, 0x42, 0xa1, 0x2d, 0x01, 0xde, 0xe5, 0x52,
+    0x71, 0xb8, 0x2c, 0x7b, 0x02, 0x7b, 0x94, 0x68, 0xc3, 0x09, 0xfa, 0x2d,
+    0x08, 0xe9, 0x1e, 0x5e, 0x37, 0x9e, 0xb9, 0x0c, 0xf8, 0x91, 0x5c, 0xf4,
+    0xcc, 0x24, 0x1b, 0x50,
+};
+static const struct drbg_kat_no_reseed kat66_t = {
+    5, kat66_entropyin, kat66_nonce, kat66_persstr,
+    kat66_addin0, kat66_addin1, kat66_retbits
+};
+static const struct drbg_kat kat66 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat66_t
+};
+
+static const unsigned char kat67_entropyin[] = {
+    0x34, 0xae, 0xe3, 0xef, 0x35, 0xb2, 0xa1, 0xe3, 0x1c, 0x42, 0x97, 0x25,
+    0xfe, 0xaa, 0x6b, 0xfd,
+};
+static const unsigned char kat67_nonce[] = {
+    0xe4, 0x36, 0x9b, 0x6a, 0xda, 0x90, 0x91, 0xed,
+};
+static const unsigned char kat67_persstr[] = {0};
+static const unsigned char kat67_addin0[] = {0};
+static const unsigned char kat67_addin1[] = {0};
+static const unsigned char kat67_retbits[] = {
+    0xaf, 0x9d, 0xb4, 0xdf, 0x46, 0xac, 0x80, 0xfe, 0xca, 0xd6, 0xc3, 0xd1,
+    0xd9, 0x75, 0xd2, 0xd0, 0xa6, 0x65, 0xf3, 0x1b, 0x4e, 0x3b, 0x07, 0xd9,
+    0x62, 0x63, 0x22, 0x96, 0xb7, 0x60, 0x39, 0xdd, 0xca, 0xb8, 0xed, 0xde,
+    0x17, 0xba, 0xd6, 0x23, 0x01, 0x31, 0x16, 0x2e, 0x59, 0xd0, 0x7d, 0xbb,
+    0xd0, 0xf0, 0xb5, 0x2e, 0x5c, 0xa9, 0x3c, 0xf3, 0x7f, 0x12, 0xc0, 0x30,
+    0x42, 0xbf, 0x0c, 0x82,
+};
+static const struct drbg_kat_no_reseed kat67_t = {
+    6, kat67_entropyin, kat67_nonce, kat67_persstr,
+    kat67_addin0, kat67_addin1, kat67_retbits
+};
+static const struct drbg_kat kat67 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat67_t
+};
+
+static const unsigned char kat68_entropyin[] = {
+    0x91, 0x15, 0x64, 0x69, 0x54, 0x0c, 0x78, 0x5d, 0xf5, 0x6a, 0x10, 0xe1,
+    0x6b, 0x66, 0x10, 0x7c,
+};
+static const unsigned char kat68_nonce[] = {
+    0x7e, 0x2b, 0x2a, 0x7f, 0x58, 0xf3, 0xef, 0x20,
+};
+static const unsigned char kat68_persstr[] = {0};
+static const unsigned char kat68_addin0[] = {0};
+static const unsigned char kat68_addin1[] = {0};
+static const unsigned char kat68_retbits[] = {
+    0x9a, 0x76, 0x3a, 0x4c, 0x05, 0x27, 0x25, 0xe7, 0xae, 0x9d, 0x21, 0x22,
+    0xa4, 0x5c, 0xd1, 0x8e, 0xa2, 0x8c, 0x58, 0x17, 0x2b, 0x87, 0xc5, 0x7e,
+    0xdb, 0x9d, 0xaa, 0x32, 0xf8, 0xa2, 0x6e, 0xb9, 0x8d, 0x6b, 0x88, 0x12,
+    0x09, 0x5a, 0x54, 0xcf, 0x62, 0x82, 0xc5, 0xe0, 0xfc, 0x18, 0xcd, 0x30,
+    0x12, 0x44, 0x15, 0xd2, 0x67, 0xc9, 0xfc, 0x2c, 0xda, 0xe9, 0xbe, 0xed,
+    0xbb, 0x86, 0x58, 0x4e,
+};
+static const struct drbg_kat_no_reseed kat68_t = {
+    7, kat68_entropyin, kat68_nonce, kat68_persstr,
+    kat68_addin0, kat68_addin1, kat68_retbits
+};
+static const struct drbg_kat kat68 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat68_t
+};
+
+static const unsigned char kat69_entropyin[] = {
+    0xcd, 0x5d, 0xbc, 0x35, 0xd1, 0xb4, 0x43, 0x5c, 0x4c, 0x94, 0x5b, 0xaf,
+    0xe4, 0xb8, 0xfc, 0x7a,
+};
+static const unsigned char kat69_nonce[] = {
+    0xaf, 0x4a, 0xcd, 0xfc, 0x81, 0x19, 0x32, 0x2c,
+};
+static const unsigned char kat69_persstr[] = {0};
+static const unsigned char kat69_addin0[] = {0};
+static const unsigned char kat69_addin1[] = {0};
+static const unsigned char kat69_retbits[] = {
+    0xfe, 0x67, 0x82, 0x99, 0xf1, 0xad, 0xe1, 0x96, 0x21, 0x88, 0x02, 0x35,
+    0xfa, 0x6f, 0xe2, 0xb5, 0x01, 0x84, 0xf8, 0x12, 0x43, 0x83, 0x3e, 0xbe,
+    0x68, 0xc6, 0x16, 0xa9, 0x03, 0x4e, 0x23, 0xe0, 0xcc, 0x87, 0x3e, 0x8a,
+    0xc4, 0xd0, 0xe3, 0x65, 0xb5, 0x24, 0xa3, 0x78, 0x32, 0xb5, 0x2d, 0x97,
+    0xa8, 0x38, 0x62, 0x93, 0x24, 0x91, 0xd2, 0x64, 0x3a, 0x73, 0xe4, 0x6a,
+    0x80, 0xb5, 0x14, 0x9c,
+};
+static const struct drbg_kat_no_reseed kat69_t = {
+    8, kat69_entropyin, kat69_nonce, kat69_persstr,
+    kat69_addin0, kat69_addin1, kat69_retbits
+};
+static const struct drbg_kat kat69 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat69_t
+};
+
+static const unsigned char kat70_entropyin[] = {
+    0xd5, 0x2d, 0x11, 0x59, 0x78, 0x7b, 0xaa, 0xb2, 0x13, 0xe8, 0x79, 0x21,
+    0xfd, 0x95, 0x91, 0x10,
+};
+static const unsigned char kat70_nonce[] = {
+    0x7a, 0xb3, 0x75, 0x38, 0xee, 0x02, 0x45, 0xc8,
+};
+static const unsigned char kat70_persstr[] = {0};
+static const unsigned char kat70_addin0[] = {0};
+static const unsigned char kat70_addin1[] = {0};
+static const unsigned char kat70_retbits[] = {
+    0xf4, 0xd9, 0xea, 0xd3, 0x59, 0x46, 0x06, 0xac, 0x51, 0x94, 0x22, 0x15,
+    0xaa, 0x0b, 0xd2, 0x9b, 0xaa, 0x7c, 0x28, 0x1e, 0x62, 0xd2, 0xbc, 0xc1,
+    0xa7, 0x7f, 0x57, 0xe3, 0x59, 0x66, 0x83, 0x19, 0x9d, 0x70, 0xc0, 0x09,
+    0xc0, 0x84, 0xeb, 0x36, 0x54, 0x22, 0x4e, 0xd7, 0xb0, 0x7a, 0x09, 0xb4,
+    0x94, 0x48, 0x0a, 0x11, 0x3b, 0x33, 0xe0, 0x36, 0x6c, 0xb2, 0x25, 0x3e,
+    0xdb, 0xb0, 0xcb, 0x5e,
+};
+static const struct drbg_kat_no_reseed kat70_t = {
+    9, kat70_entropyin, kat70_nonce, kat70_persstr,
+    kat70_addin0, kat70_addin1, kat70_retbits
+};
+static const struct drbg_kat kat70 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat70_t
+};
+
+static const unsigned char kat71_entropyin[] = {
+    0x51, 0x10, 0xdb, 0x9d, 0x5f, 0x4f, 0xbd, 0xc0, 0x37, 0x55, 0x0e, 0x83,
+    0xc2, 0xbd, 0x96, 0xfe,
+};
+static const unsigned char kat71_nonce[] = {
+    0xde, 0xe6, 0x41, 0xf9, 0x17, 0x7c, 0x9d, 0xa4,
+};
+static const unsigned char kat71_persstr[] = {0};
+static const unsigned char kat71_addin0[] = {0};
+static const unsigned char kat71_addin1[] = {0};
+static const unsigned char kat71_retbits[] = {
+    0x05, 0xf8, 0xca, 0xd2, 0xd0, 0x31, 0xce, 0x6b, 0x52, 0x7e, 0xe0, 0x43,
+    0xb5, 0x05, 0x6d, 0xb2, 0x0e, 0xe5, 0xca, 0x66, 0x0a, 0x95, 0xc2, 0x9b,
+    0x8f, 0x8b, 0x2e, 0x43, 0xef, 0xa5, 0xc7, 0xaa, 0x62, 0x35, 0x12, 0x33,
+    0xf4, 0xf1, 0x60, 0x36, 0x8c, 0x3d, 0xad, 0x4a, 0x74, 0xf4, 0x71, 0xbb,
+    0x02, 0x15, 0x3f, 0x86, 0xc8, 0x7a, 0x14, 0x0a, 0x36, 0xe0, 0xf1, 0x22,
+    0xc6, 0x8b, 0xa7, 0x7d,
+};
+static const struct drbg_kat_no_reseed kat71_t = {
+    10, kat71_entropyin, kat71_nonce, kat71_persstr,
+    kat71_addin0, kat71_addin1, kat71_retbits
+};
+static const struct drbg_kat kat71 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat71_t
+};
+
+static const unsigned char kat72_entropyin[] = {
+    0x97, 0x90, 0x65, 0xbc, 0x1a, 0x1c, 0x8c, 0x82, 0x90, 0xdd, 0xe2, 0x19,
+    0xf0, 0x12, 0x1a, 0xbe,
+};
+static const unsigned char kat72_nonce[] = {
+    0x59, 0x3a, 0x0e, 0x1f, 0xa9, 0x85, 0x64, 0xa3,
+};
+static const unsigned char kat72_persstr[] = {0};
+static const unsigned char kat72_addin0[] = {0};
+static const unsigned char kat72_addin1[] = {0};
+static const unsigned char kat72_retbits[] = {
+    0x19, 0x9e, 0x68, 0xe5, 0xb6, 0x37, 0xa2, 0x7b, 0xe7, 0x94, 0x53, 0xd9,
+    0x95, 0x3a, 0x0e, 0x52, 0x95, 0x36, 0x37, 0x4e, 0x7f, 0x63, 0xe8, 0x59,
+    0x5a, 0xfe, 0x4b, 0x5d, 0x4e, 0x3b, 0xb3, 0x79, 0xc6, 0xd4, 0x62, 0xf6,
+    0x43, 0x12, 0x44, 0xaf, 0x43, 0x36, 0xb1, 0x7f, 0x9d, 0xfd, 0xfe, 0xaf,
+    0xa6, 0xf4, 0xff, 0xf5, 0x00, 0x4a, 0xa6, 0x5f, 0x7d, 0x6b, 0xb3, 0xb8,
+    0x8a, 0xf8, 0xe9, 0xe2,
+};
+static const struct drbg_kat_no_reseed kat72_t = {
+    11, kat72_entropyin, kat72_nonce, kat72_persstr,
+    kat72_addin0, kat72_addin1, kat72_retbits
+};
+static const struct drbg_kat kat72 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat72_t
+};
+
+static const unsigned char kat73_entropyin[] = {
+    0x89, 0xa7, 0x87, 0xbe, 0x64, 0xba, 0x33, 0x58, 0x95, 0x2f, 0x9d, 0x60,
+    0x2b, 0xd8, 0xfa, 0xb4,
+};
+static const unsigned char kat73_nonce[] = {
+    0xab, 0x96, 0x1b, 0x68, 0xc6, 0x58, 0x92, 0xd3,
+};
+static const unsigned char kat73_persstr[] = {0};
+static const unsigned char kat73_addin0[] = {0};
+static const unsigned char kat73_addin1[] = {0};
+static const unsigned char kat73_retbits[] = {
+    0x6e, 0x5d, 0xd2, 0xa6, 0x51, 0xf2, 0x61, 0x4f, 0xca, 0x88, 0x1f, 0x5e,
+    0xdb, 0x05, 0xd5, 0xee, 0xc6, 0x12, 0x75, 0xdd, 0x05, 0xb3, 0x1f, 0xd8,
+    0xa3, 0x06, 0x2f, 0xac, 0x51, 0x59, 0x60, 0xde, 0xf7, 0xb0, 0xd4, 0xdb,
+    0x30, 0x4f, 0x64, 0x2b, 0x91, 0xe6, 0x40, 0x1f, 0x2a, 0x00, 0xb0, 0xfb,
+    0x69, 0x3e, 0xdd, 0x73, 0x13, 0x10, 0x2f, 0x58, 0xd7, 0x33, 0x02, 0xea,
+    0x8b, 0x5a, 0x9d, 0x7a,
+};
+static const struct drbg_kat_no_reseed kat73_t = {
+    12, kat73_entropyin, kat73_nonce, kat73_persstr,
+    kat73_addin0, kat73_addin1, kat73_retbits
+};
+static const struct drbg_kat kat73 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat73_t
+};
+
+static const unsigned char kat74_entropyin[] = {
+    0x21, 0xf0, 0x2f, 0xc7, 0x5a, 0x28, 0x2d, 0x7f, 0x87, 0xca, 0xb0, 0x57,
+    0x67, 0x55, 0x8e, 0x08,
+};
+static const unsigned char kat74_nonce[] = {
+    0x3b, 0x43, 0xd7, 0x7b, 0x0c, 0x64, 0x71, 0xe9,
+};
+static const unsigned char kat74_persstr[] = {0};
+static const unsigned char kat74_addin0[] = {0};
+static const unsigned char kat74_addin1[] = {0};
+static const unsigned char kat74_retbits[] = {
+    0x3b, 0x87, 0x09, 0xce, 0xfe, 0x27, 0x06, 0x27, 0xeb, 0x49, 0x47, 0xf3,
+    0xc7, 0x69, 0x5e, 0xed, 0x2c, 0x85, 0xcc, 0x15, 0x25, 0xbe, 0x25, 0x3f,
+    0x20, 0x0a, 0x44, 0xad, 0x55, 0xf7, 0x58, 0x3e, 0x10, 0x91, 0xb8, 0x80,
+    0xee, 0x16, 0xa8, 0x08, 0xe9, 0x0d, 0xc1, 0xdd, 0x5c, 0x0e, 0xd3, 0xb8,
+    0xd1, 0x96, 0x40, 0x76, 0x61, 0xde, 0x80, 0x61, 0xf6, 0xa2, 0xd7, 0x8c,
+    0xdc, 0x93, 0x42, 0x9d,
+};
+static const struct drbg_kat_no_reseed kat74_t = {
+    13, kat74_entropyin, kat74_nonce, kat74_persstr,
+    kat74_addin0, kat74_addin1, kat74_retbits
+};
+static const struct drbg_kat kat74 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat74_t
+};
+
+static const unsigned char kat75_entropyin[] = {
+    0xdf, 0x5b, 0x1c, 0xd5, 0x10, 0x45, 0xc8, 0x38, 0x01, 0x53, 0x24, 0x49,
+    0xd6, 0xa8, 0x7a, 0xed,
+};
+static const unsigned char kat75_nonce[] = {
+    0x8d, 0xd1, 0x72, 0xb8, 0x12, 0x86, 0xa2, 0x38,
+};
+static const unsigned char kat75_persstr[] = {0};
+static const unsigned char kat75_addin0[] = {0};
+static const unsigned char kat75_addin1[] = {0};
+static const unsigned char kat75_retbits[] = {
+    0xf0, 0x17, 0x2b, 0x3a, 0x5b, 0x42, 0xea, 0xd6, 0xe6, 0x54, 0xd3, 0xab,
+    0xc7, 0x8d, 0xda, 0x08, 0x78, 0x0e, 0xa4, 0x32, 0x23, 0x62, 0x57, 0x07,
+    0xf8, 0xab, 0x02, 0x1b, 0xef, 0x54, 0x12, 0xdb, 0x89, 0xb0, 0x89, 0xcf,
+    0x75, 0x11, 0x78, 0xeb, 0x1b, 0x97, 0xbe, 0x13, 0xf5, 0xe8, 0x3b, 0x9f,
+    0x10, 0x76, 0xd0, 0xfc, 0x88, 0xe6, 0xbb, 0xd6, 0xee, 0xf1, 0xef, 0x63,
+    0x55, 0xe3, 0x67, 0x2b,
+};
+static const struct drbg_kat_no_reseed kat75_t = {
+    14, kat75_entropyin, kat75_nonce, kat75_persstr,
+    kat75_addin0, kat75_addin1, kat75_retbits
+};
+static const struct drbg_kat kat75 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat75_t
+};
+
+static const unsigned char kat76_entropyin[] = {
+    0xad, 0xf5, 0x71, 0x1f, 0x93, 0xd8, 0xc8, 0x99, 0x73, 0x49, 0x42, 0x9c,
+    0xca, 0xed, 0xae, 0x0a,
+};
+static const unsigned char kat76_nonce[] = {
+    0xb2, 0x57, 0x16, 0x93, 0x1b, 0x6e, 0x3c, 0xc1,
+};
+static const unsigned char kat76_persstr[] = {0};
+static const unsigned char kat76_addin0[] = {
+    0xab, 0xf8, 0xcd, 0x66, 0xdd, 0x39, 0x75, 0x8b, 0x01, 0xd7, 0xdb, 0xb9,
+    0x9a, 0xb1, 0x7d, 0xc3,
+};
+static const unsigned char kat76_addin1[] = {
+    0x4b, 0xe0, 0xf6, 0xb2, 0x75, 0x53, 0x77, 0xc6, 0xe8, 0x81, 0xfb, 0xb2,
+    0x61, 0xb5, 0x6b, 0xeb,
+};
+static const unsigned char kat76_retbits[] = {
+    0xd4, 0x20, 0x60, 0x4d, 0xee, 0x64, 0x67, 0x49, 0x2d, 0xb5, 0x95, 0x7c,
+    0x86, 0x20, 0x7a, 0x70, 0x8f, 0xd2, 0x42, 0xed, 0x67, 0x94, 0x2a, 0xed,
+    0x29, 0x94, 0x25, 0x33, 0x5c, 0x83, 0xb4, 0x14, 0x37, 0x41, 0x85, 0x82,
+    0xf4, 0x1b, 0xc7, 0xfc, 0x0e, 0xf0, 0xd6, 0x92, 0x7f, 0x34, 0xd8, 0x3a,
+    0xcd, 0x67, 0xc7, 0x01, 0x33, 0x64, 0x4f, 0xd7, 0x11, 0xdd, 0x5a, 0x65,
+    0x73, 0x1f, 0x9f, 0x02,
+};
+static const struct drbg_kat_no_reseed kat76_t = {
+    0, kat76_entropyin, kat76_nonce, kat76_persstr,
+    kat76_addin0, kat76_addin1, kat76_retbits
+};
+static const struct drbg_kat kat76 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat76_t
+};
+
+static const unsigned char kat77_entropyin[] = {
+    0xe9, 0x21, 0x00, 0x02, 0x07, 0x34, 0x90, 0x9d, 0x61, 0x09, 0xd2, 0x9c,
+    0xf2, 0xc8, 0x98, 0xb0,
+};
+static const unsigned char kat77_nonce[] = {
+    0x91, 0xfb, 0xd9, 0xa3, 0xa8, 0xed, 0xc3, 0xa4,
+};
+static const unsigned char kat77_persstr[] = {0};
+static const unsigned char kat77_addin0[] = {
+    0x09, 0x80, 0xc7, 0xdb, 0xcf, 0xd0, 0xe7, 0xf7, 0x7a, 0xf8, 0x35, 0xac,
+    0xc7, 0x4a, 0x4b, 0xa3,
+};
+static const unsigned char kat77_addin1[] = {
+    0x3c, 0xbf, 0x47, 0xd4, 0x66, 0x55, 0xa0, 0xce, 0x75, 0xa5, 0xd5, 0x65,
+    0x28, 0x12, 0x7b, 0xc0,
+};
+static const unsigned char kat77_retbits[] = {
+    0xe7, 0x7c, 0xcc, 0x52, 0x63, 0x62, 0x54, 0x29, 0xce, 0x7e, 0x53, 0x56,
+    0x22, 0x48, 0x1d, 0x0b, 0xef, 0x47, 0x61, 0x41, 0xd1, 0xa0, 0xab, 0xfa,
+    0x7f, 0x69, 0x67, 0xc1, 0x1f, 0x47, 0xf7, 0xa7, 0x0f, 0xa9, 0xbc, 0x70,
+    0x59, 0x8e, 0xce, 0x3f, 0xf2, 0x83, 0xe5, 0xae, 0x04, 0xf1, 0x05, 0x35,
+    0xd3, 0x49, 0xc2, 0x31, 0x34, 0x9a, 0xf8, 0x07, 0x1a, 0x22, 0x32, 0x3a,
+    0x6e, 0x95, 0x10, 0x39,
+};
+static const struct drbg_kat_no_reseed kat77_t = {
+    1, kat77_entropyin, kat77_nonce, kat77_persstr,
+    kat77_addin0, kat77_addin1, kat77_retbits
+};
+static const struct drbg_kat kat77 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat77_t
+};
+
+static const unsigned char kat78_entropyin[] = {
+    0x09, 0x2f, 0xfe, 0x74, 0x57, 0xd6, 0x17, 0x3e, 0x67, 0x13, 0xb0, 0xaf,
+    0x76, 0x52, 0x1d, 0x82,
+};
+static const unsigned char kat78_nonce[] = {
+    0xd0, 0xb8, 0xca, 0xe6, 0xab, 0x9e, 0x29, 0xac,
+};
+static const unsigned char kat78_persstr[] = {0};
+static const unsigned char kat78_addin0[] = {
+    0xe3, 0x1a, 0xf5, 0xe1, 0x81, 0xc4, 0x34, 0x6e, 0x42, 0x3e, 0xbc, 0x1f,
+    0xf9, 0xf4, 0x6d, 0xdd,
+};
+static const unsigned char kat78_addin1[] = {
+    0x02, 0xb9, 0x49, 0xd1, 0x34, 0xfc, 0x89, 0x68, 0xba, 0x51, 0x8f, 0xda,
+    0x3b, 0x42, 0xc9, 0x7f,
+};
+static const unsigned char kat78_retbits[] = {
+    0x0b, 0x64, 0xd9, 0xc6, 0x1d, 0x1f, 0x23, 0x44, 0x0c, 0xe5, 0x7d, 0xbf,
+    0x46, 0x5f, 0x8c, 0x62, 0x9a, 0x9f, 0xfe, 0xdd, 0x16, 0x43, 0x99, 0xab,
+    0x84, 0xfc, 0x11, 0x84, 0x66, 0xa5, 0x67, 0x9b, 0xb2, 0xd9, 0xc8, 0x05,
+    0xea, 0x9d, 0x29, 0x49, 0x72, 0x61, 0xea, 0x58, 0xbd, 0x8f, 0xa4, 0x5c,
+    0xf2, 0x4e, 0x21, 0x2c, 0x07, 0x7b, 0xab, 0xa4, 0xd4, 0xe5, 0x73, 0x8b,
+    0xb8, 0x83, 0xc8, 0x83,
+};
+static const struct drbg_kat_no_reseed kat78_t = {
+    2, kat78_entropyin, kat78_nonce, kat78_persstr,
+    kat78_addin0, kat78_addin1, kat78_retbits
+};
+static const struct drbg_kat kat78 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat78_t
+};
+
+static const unsigned char kat79_entropyin[] = {
+    0xa7, 0xa4, 0x78, 0x41, 0xcf, 0x1a, 0x75, 0xee, 0x96, 0x93, 0x5f, 0x52,
+    0xa3, 0x32, 0x2d, 0x9d,
+};
+static const unsigned char kat79_nonce[] = {
+    0x5b, 0x48, 0xc3, 0xc3, 0x47, 0x39, 0x46, 0x56,
+};
+static const unsigned char kat79_persstr[] = {0};
+static const unsigned char kat79_addin0[] = {
+    0xaa, 0xc2, 0x03, 0x1f, 0x6a, 0xa4, 0x0f, 0x08, 0x75, 0x49, 0x33, 0x70,
+    0x92, 0x7c, 0x7c, 0xa8,
+};
+static const unsigned char kat79_addin1[] = {
+    0x1a, 0x67, 0x44, 0xd0, 0x3f, 0xc2, 0x15, 0x12, 0x94, 0x70, 0x7c, 0x3b,
+    0xce, 0xa8, 0x84, 0x02,
+};
+static const unsigned char kat79_retbits[] = {
+    0xb4, 0x67, 0x48, 0x67, 0xcb, 0x6c, 0xd4, 0xfa, 0xde, 0x78, 0x46, 0xf4,
+    0x92, 0xbd, 0x9e, 0xca, 0x69, 0xc1, 0x33, 0xf1, 0x17, 0x1c, 0xc6, 0x0b,
+    0x6c, 0xd7, 0x5f, 0x22, 0xe2, 0xba, 0x7e, 0x70, 0x20, 0x7c, 0xa3, 0x8b,
+    0xdc, 0xef, 0x17, 0xac, 0x15, 0xe4, 0x88, 0x49, 0xba, 0x13, 0x0d, 0x5f,
+    0xb8, 0x10, 0x84, 0x4c, 0x25, 0x39, 0xfe, 0xc5, 0x19, 0xc4, 0xfa, 0x97,
+    0x7f, 0xfa, 0x07, 0x38,
+};
+static const struct drbg_kat_no_reseed kat79_t = {
+    3, kat79_entropyin, kat79_nonce, kat79_persstr,
+    kat79_addin0, kat79_addin1, kat79_retbits
+};
+static const struct drbg_kat kat79 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat79_t
+};
+
+static const unsigned char kat80_entropyin[] = {
+    0x52, 0x89, 0xc3, 0x33, 0xce, 0x1c, 0xee, 0xf5, 0x6a, 0x19, 0xa1, 0x11,
+    0xe9, 0x20, 0x1a, 0x38,
+};
+static const unsigned char kat80_nonce[] = {
+    0xdb, 0xd6, 0xb7, 0x6b, 0x1f, 0xdf, 0x5d, 0x1b,
+};
+static const unsigned char kat80_persstr[] = {0};
+static const unsigned char kat80_addin0[] = {
+    0xf1, 0xfa, 0x6e, 0xc8, 0xca, 0xf9, 0x4f, 0x65, 0xf1, 0x2e, 0x9c, 0x0d,
+    0x8f, 0x57, 0x04, 0xf6,
+};
+static const unsigned char kat80_addin1[] = {
+    0x6e, 0xb6, 0xa5, 0x57, 0xf1, 0x70, 0x18, 0x83, 0x0b, 0x5d, 0x72, 0xb6,
+    0x7d, 0x32, 0x22, 0x63,
+};
+static const unsigned char kat80_retbits[] = {
+    0x39, 0xec, 0x96, 0xbc, 0x71, 0x6e, 0x1d, 0x21, 0x48, 0x80, 0xd1, 0xf4,
+    0xb8, 0xa9, 0x84, 0xbb, 0x83, 0x39, 0x94, 0x53, 0xec, 0x1e, 0xb9, 0xf3,
+    0x71, 0x28, 0x2d, 0x65, 0x8e, 0x32, 0xd7, 0x39, 0xb4, 0x89, 0xf4, 0xc5,
+    0xee, 0xae, 0x62, 0xa8, 0xfe, 0xe8, 0xe0, 0x84, 0xee, 0xae, 0x6d, 0x01,
+    0xcc, 0xa0, 0xad, 0x80, 0xda, 0x1c, 0x53, 0x23, 0x0f, 0x8a, 0x1f, 0xaf,
+    0x7c, 0x33, 0x5e, 0xdf,
+};
+static const struct drbg_kat_no_reseed kat80_t = {
+    4, kat80_entropyin, kat80_nonce, kat80_persstr,
+    kat80_addin0, kat80_addin1, kat80_retbits
+};
+static const struct drbg_kat kat80 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat80_t
+};
+
+static const unsigned char kat81_entropyin[] = {
+    0x4f, 0x05, 0xef, 0x26, 0xc6, 0x85, 0x44, 0x4d, 0x6e, 0x65, 0xd8, 0xf2,
+    0x6e, 0x0f, 0x2e, 0xf2,
+};
+static const unsigned char kat81_nonce[] = {
+    0xd0, 0xab, 0x06, 0x6c, 0x7a, 0x49, 0x03, 0xb7,
+};
+static const unsigned char kat81_persstr[] = {0};
+static const unsigned char kat81_addin0[] = {
+    0xd2, 0x75, 0x42, 0x60, 0x43, 0xa8, 0x2d, 0xe2, 0x0f, 0x89, 0xf1, 0xcb,
+    0x2c, 0xff, 0x5c, 0x9b,
+};
+static const unsigned char kat81_addin1[] = {
+    0x02, 0xa3, 0x27, 0x63, 0xed, 0x9a, 0xab, 0x16, 0x72, 0x82, 0xd0, 0xa0,
+    0x97, 0xf3, 0x10, 0x3e,
+};
+static const unsigned char kat81_retbits[] = {
+    0xaf, 0xa2, 0xd3, 0x7c, 0xc1, 0xc7, 0x9d, 0x20, 0xa6, 0x10, 0x4d, 0x67,
+    0x29, 0xfc, 0x75, 0x44, 0x36, 0x1b, 0x95, 0xd2, 0x36, 0x33, 0x48, 0x7e,
+    0x8b, 0xb2, 0x82, 0xb2, 0x77, 0xe2, 0x5f, 0x8a, 0xd5, 0x31, 0x36, 0x10,
+    0x9b, 0x21, 0xc3, 0x80, 0xaa, 0x05, 0xe4, 0x1d, 0xd9, 0xef, 0xd8, 0xad,
+    0xf4, 0x6b, 0x7d, 0x69, 0x5b, 0xba, 0xf5, 0xb0, 0x30, 0x72, 0x16, 0xa1,
+    0x94, 0xfd, 0x91, 0x28,
+};
+static const struct drbg_kat_no_reseed kat81_t = {
+    5, kat81_entropyin, kat81_nonce, kat81_persstr,
+    kat81_addin0, kat81_addin1, kat81_retbits
+};
+static const struct drbg_kat kat81 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat81_t
+};
+
+static const unsigned char kat82_entropyin[] = {
+    0x0c, 0x2c, 0xcf, 0xd6, 0x5c, 0x23, 0xbc, 0x06, 0x93, 0xc9, 0xd4, 0x66,
+    0x7a, 0x94, 0x2b, 0x42,
+};
+static const unsigned char kat82_nonce[] = {
+    0xc0, 0x8d, 0x55, 0x22, 0x8f, 0xe8, 0x4b, 0xd7,
+};
+static const unsigned char kat82_persstr[] = {0};
+static const unsigned char kat82_addin0[] = {
+    0xcc, 0x01, 0x7b, 0xb7, 0x96, 0x2d, 0xa6, 0xdb, 0x0f, 0x51, 0x7b, 0xe9,
+    0x18, 0x3f, 0xa6, 0xf4,
+};
+static const unsigned char kat82_addin1[] = {
+    0xc4, 0x24, 0xaa, 0x0c, 0xe8, 0x4a, 0x80, 0x7a, 0x78, 0xb7, 0xb7, 0x32,
+    0x11, 0x3c, 0x22, 0xa1,
+};
+static const unsigned char kat82_retbits[] = {
+    0xcb, 0x55, 0x6f, 0x6d, 0x22, 0x3a, 0x51, 0xa2, 0x00, 0xd7, 0x35, 0xf2,
+    0xf4, 0xba, 0x21, 0x7a, 0x67, 0x2e, 0xf6, 0xbc, 0x14, 0x51, 0x97, 0x6d,
+    0x1d, 0x05, 0xb4, 0x4a, 0x2c, 0x0d, 0x54, 0x27, 0x8a, 0xf7, 0x47, 0x83,
+    0x79, 0x22, 0xcd, 0x0b, 0x28, 0xd7, 0xaa, 0xa2, 0xa8, 0x7e, 0x23, 0x05,
+    0x5e, 0x18, 0xd6, 0x7d, 0x76, 0xfa, 0x90, 0x72, 0x82, 0x94, 0xab, 0xa4,
+    0xac, 0x36, 0x96, 0x5e,
+};
+static const struct drbg_kat_no_reseed kat82_t = {
+    6, kat82_entropyin, kat82_nonce, kat82_persstr,
+    kat82_addin0, kat82_addin1, kat82_retbits
+};
+static const struct drbg_kat kat82 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat82_t
+};
+
+static const unsigned char kat83_entropyin[] = {
+    0x3b, 0x74, 0x81, 0x3e, 0xeb, 0xf5, 0xf5, 0xf2, 0xa6, 0xa5, 0xa4, 0xf3,
+    0xf9, 0x07, 0xdc, 0xb8,
+};
+static const unsigned char kat83_nonce[] = {
+    0x35, 0xda, 0xa2, 0xef, 0xda, 0xd8, 0x8f, 0xb8,
+};
+static const unsigned char kat83_persstr[] = {0};
+static const unsigned char kat83_addin0[] = {
+    0x5e, 0x0a, 0xe3, 0x69, 0xb6, 0xe8, 0x50, 0xed, 0x30, 0xf9, 0xae, 0x64,
+    0xfe, 0x10, 0x5a, 0xf3,
+};
+static const unsigned char kat83_addin1[] = {
+    0x3e, 0x69, 0x7b, 0xb2, 0xbf, 0x25, 0x85, 0x26, 0x45, 0xf2, 0xd1, 0x6f,
+    0x67, 0x6f, 0x90, 0x78,
+};
+static const unsigned char kat83_retbits[] = {
+    0x79, 0x0b, 0x1f, 0x6c, 0xcd, 0xf3, 0x52, 0xde, 0xc0, 0xe5, 0x7f, 0xa0,
+    0xc7, 0x72, 0xc6, 0x4d, 0x77, 0x77, 0xe4, 0xbd, 0xb9, 0xff, 0x8a, 0x91,
+    0xda, 0x01, 0x89, 0x02, 0x20, 0x3d, 0xb5, 0x82, 0xf9, 0x01, 0xc2, 0x0d,
+    0xd2, 0x53, 0x61, 0xdf, 0x22, 0xe7, 0x17, 0x12, 0xa4, 0x97, 0x57, 0x8d,
+    0x22, 0xee, 0xa8, 0x52, 0x46, 0xce, 0xfd, 0x42, 0x5b, 0x08, 0xf1, 0x50,
+    0x74, 0x34, 0x1f, 0x39,
+};
+static const struct drbg_kat_no_reseed kat83_t = {
+    7, kat83_entropyin, kat83_nonce, kat83_persstr,
+    kat83_addin0, kat83_addin1, kat83_retbits
+};
+static const struct drbg_kat kat83 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat83_t
+};
+
+static const unsigned char kat84_entropyin[] = {
+    0x46, 0x26, 0x07, 0xb2, 0xb7, 0x7b, 0x90, 0x3f, 0xdb, 0xd4, 0x2b, 0xf1,
+    0xd7, 0x7b, 0xc8, 0x1a,
+};
+static const unsigned char kat84_nonce[] = {
+    0xb5, 0x4d, 0x43, 0x00, 0x6a, 0xde, 0x2a, 0x7c,
+};
+static const unsigned char kat84_persstr[] = {0};
+static const unsigned char kat84_addin0[] = {
+    0x61, 0x05, 0xc5, 0xdd, 0xed, 0xcc, 0x74, 0x46, 0x65, 0x91, 0x5e, 0xbe,
+    0x48, 0xad, 0x3b, 0x54,
+};
+static const unsigned char kat84_addin1[] = {
+    0xfd, 0xde, 0xe2, 0x35, 0xc3, 0x7e, 0xd4, 0xbc, 0x21, 0xea, 0xe0, 0x8e,
+    0x61, 0x53, 0x33, 0x1f,
+};
+static const unsigned char kat84_retbits[] = {
+    0x16, 0x33, 0x9e, 0x91, 0x0e, 0xaf, 0x9b, 0xad, 0x90, 0x4a, 0x7b, 0x3f,
+    0x9b, 0x2e, 0x02, 0x41, 0xd2, 0xb4, 0x66, 0x5d, 0x1f, 0x9c, 0x76, 0x55,
+    0xf9, 0x21, 0x7e, 0x34, 0x25, 0x3a, 0xcc, 0x33, 0x0d, 0xfc, 0x98, 0x81,
+    0x7d, 0x97, 0x81, 0x86, 0xf8, 0xad, 0x77, 0xb1, 0x0f, 0x38, 0xdd, 0x72,
+    0xf4, 0x71, 0xb4, 0x61, 0x5b, 0x28, 0xf3, 0xa3, 0x9c, 0x40, 0x66, 0x23,
+    0xea, 0x5d, 0x63, 0x77,
+};
+static const struct drbg_kat_no_reseed kat84_t = {
+    8, kat84_entropyin, kat84_nonce, kat84_persstr,
+    kat84_addin0, kat84_addin1, kat84_retbits
+};
+static const struct drbg_kat kat84 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat84_t
+};
+
+static const unsigned char kat85_entropyin[] = {
+    0xba, 0x2e, 0xa9, 0x9b, 0x79, 0x2b, 0xde, 0xe8, 0xbd, 0xba, 0xf9, 0xc0,
+    0x5a, 0xb7, 0xb6, 0x33,
+};
+static const unsigned char kat85_nonce[] = {
+    0x44, 0x53, 0x34, 0x46, 0x44, 0xd4, 0x34, 0xa5,
+};
+static const unsigned char kat85_persstr[] = {0};
+static const unsigned char kat85_addin0[] = {
+    0x81, 0x72, 0x7d, 0x30, 0xd6, 0x4a, 0xe0, 0x7f, 0xf6, 0x15, 0x69, 0xfc,
+    0x7a, 0x35, 0x0c, 0xcc,
+};
+static const unsigned char kat85_addin1[] = {
+    0x65, 0x56, 0xf6, 0x2f, 0x75, 0xd5, 0x26, 0x84, 0x93, 0xcc, 0xa5, 0x12,
+    0x01, 0x14, 0x93, 0x4c,
+};
+static const unsigned char kat85_retbits[] = {
+    0x2a, 0x3b, 0x39, 0x87, 0x02, 0xbc, 0x5f, 0xff, 0xd9, 0x14, 0xf9, 0x16,
+    0x72, 0xaa, 0x05, 0xbe, 0xb6, 0x87, 0x82, 0xe0, 0xa6, 0x22, 0xf6, 0x7b,
+    0x21, 0x82, 0x6c, 0x23, 0x32, 0x6c, 0x50, 0x78, 0xcc, 0xda, 0x6a, 0xa3,
+    0xdb, 0x01, 0x4c, 0xec, 0x56, 0xa0, 0x65, 0x63, 0x6b, 0x80, 0x57, 0xe8,
+    0x12, 0xa6, 0xf4, 0xb7, 0xc6, 0xc4, 0xde, 0x6e, 0x9f, 0x06, 0xaa, 0x53,
+    0x77, 0xb2, 0x8b, 0xe6,
+};
+static const struct drbg_kat_no_reseed kat85_t = {
+    9, kat85_entropyin, kat85_nonce, kat85_persstr,
+    kat85_addin0, kat85_addin1, kat85_retbits
+};
+static const struct drbg_kat kat85 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat85_t
+};
+
+static const unsigned char kat86_entropyin[] = {
+    0x61, 0xcf, 0x4e, 0x09, 0xd9, 0xa4, 0x6a, 0xf3, 0x18, 0xc7, 0x06, 0x42,
+    0x5c, 0xd3, 0x50, 0xfb,
+};
+static const unsigned char kat86_nonce[] = {
+    0x28, 0xec, 0x9c, 0x4a, 0xe9, 0x8f, 0x05, 0x74,
+};
+static const unsigned char kat86_persstr[] = {0};
+static const unsigned char kat86_addin0[] = {
+    0x7f, 0xc3, 0xbf, 0x8a, 0xd3, 0x3e, 0x59, 0x61, 0x74, 0x5b, 0xb2, 0xae,
+    0x7c, 0x39, 0x9b, 0xa0,
+};
+static const unsigned char kat86_addin1[] = {
+    0x31, 0x35, 0x71, 0xd3, 0x0d, 0xc5, 0x90, 0x9a, 0x03, 0x38, 0x8c, 0x69,
+    0x3f, 0x4e, 0xf9, 0x4c,
+};
+static const unsigned char kat86_retbits[] = {
+    0xd2, 0x25, 0xf0, 0xc6, 0x5e, 0x9a, 0xe8, 0xc3, 0x64, 0x93, 0xb0, 0x09,
+    0x47, 0x6f, 0x5a, 0x56, 0x36, 0xd4, 0x52, 0x54, 0x4c, 0xe1, 0x6b, 0x99,
+    0x1c, 0x73, 0xd6, 0xea, 0xe5, 0xef, 0x5e, 0xff, 0x3b, 0x74, 0xe0, 0x03,
+    0x28, 0xf8, 0x7f, 0x20, 0x30, 0xf3, 0xdf, 0x53, 0xb2, 0xfc, 0x26, 0x47,
+    0xd6, 0x3a, 0x28, 0xe5, 0xc7, 0xb5, 0x83, 0x44, 0xed, 0x99, 0xc5, 0xd0,
+    0xbc, 0x62, 0x93, 0xb4,
+};
+static const struct drbg_kat_no_reseed kat86_t = {
+    10, kat86_entropyin, kat86_nonce, kat86_persstr,
+    kat86_addin0, kat86_addin1, kat86_retbits
+};
+static const struct drbg_kat kat86 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat86_t
+};
+
+static const unsigned char kat87_entropyin[] = {
+    0xdd, 0x6c, 0x7d, 0xba, 0xc4, 0xfc, 0x4c, 0x8d, 0x9c, 0x69, 0xce, 0x4d,
+    0xcf, 0x43, 0xb6, 0x67,
+};
+static const unsigned char kat87_nonce[] = {
+    0x83, 0x26, 0x16, 0x1c, 0x2a, 0xac, 0x48, 0x06,
+};
+static const unsigned char kat87_persstr[] = {0};
+static const unsigned char kat87_addin0[] = {
+    0xcf, 0x95, 0x9f, 0x9e, 0x93, 0x89, 0x09, 0xd9, 0x5c, 0x47, 0x25, 0xdc,
+    0x39, 0xd7, 0xef, 0xd7,
+};
+static const unsigned char kat87_addin1[] = {
+    0xe4, 0x37, 0xd2, 0x26, 0xc4, 0x02, 0x68, 0xcb, 0x9f, 0x63, 0x94, 0x5c,
+    0xbc, 0xe5, 0x4b, 0x2d,
+};
+static const unsigned char kat87_retbits[] = {
+    0x90, 0xdd, 0xc5, 0x3c, 0x48, 0x04, 0x1f, 0x0c, 0x45, 0x01, 0xff, 0xee,
+    0x61, 0x7b, 0x3a, 0x35, 0x83, 0xcb, 0xf5, 0x1a, 0x4c, 0x45, 0xad, 0x7b,
+    0xa5, 0xb3, 0xdd, 0x34, 0x65, 0xff, 0x13, 0x92, 0xbd, 0x2e, 0xb4, 0x65,
+    0x1a, 0xc2, 0x2a, 0x34, 0xa0, 0xf5, 0x37, 0x72, 0x01, 0x27, 0x12, 0xf2,
+    0x39, 0x31, 0xba, 0x8f, 0x0a, 0x3b, 0x74, 0xfa, 0xe0, 0xa1, 0x6b, 0xd4,
+    0xa1, 0x88, 0x35, 0x13,
+};
+static const struct drbg_kat_no_reseed kat87_t = {
+    11, kat87_entropyin, kat87_nonce, kat87_persstr,
+    kat87_addin0, kat87_addin1, kat87_retbits
+};
+static const struct drbg_kat kat87 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat87_t
+};
+
+static const unsigned char kat88_entropyin[] = {
+    0xdf, 0x4f, 0xef, 0xc1, 0xc3, 0xd4, 0x03, 0xfb, 0x17, 0x9b, 0x9b, 0x95,
+    0x77, 0x53, 0x81, 0xe3,
+};
+static const unsigned char kat88_nonce[] = {
+    0xd6, 0x84, 0x83, 0xae, 0xe4, 0x2c, 0xfc, 0x00,
+};
+static const unsigned char kat88_persstr[] = {0};
+static const unsigned char kat88_addin0[] = {
+    0xe8, 0x77, 0xeb, 0x37, 0x51, 0xe2, 0xba, 0xfe, 0xa0, 0x33, 0xac, 0x8c,
+    0xc5, 0xba, 0x66, 0xf6,
+};
+static const unsigned char kat88_addin1[] = {
+    0x79, 0x56, 0x87, 0x40, 0x22, 0xb5, 0x0a, 0xa0, 0x32, 0xba, 0xfa, 0x29,
+    0xe7, 0x21, 0xf3, 0x56,
+};
+static const unsigned char kat88_retbits[] = {
+    0x6a, 0xda, 0x06, 0x20, 0xd4, 0x29, 0xcd, 0x38, 0x75, 0x4e, 0x55, 0x9a,
+    0x2e, 0xb8, 0x8c, 0x08, 0x26, 0x6c, 0xd9, 0xcb, 0xac, 0x24, 0x48, 0xb2,
+    0xb8, 0xa0, 0x5d, 0x92, 0x7d, 0xa1, 0x72, 0x59, 0x19, 0x9d, 0xbc, 0xc5,
+    0xeb, 0x0b, 0x7a, 0xde, 0xe6, 0x1c, 0x60, 0x74, 0xae, 0x2e, 0x7a, 0xf6,
+    0xb2, 0xc9, 0xb1, 0xfd, 0x52, 0x89, 0xfb, 0xc3, 0xd9, 0xbe, 0x30, 0x85,
+    0x84, 0xd0, 0xae, 0x4a,
+};
+static const struct drbg_kat_no_reseed kat88_t = {
+    12, kat88_entropyin, kat88_nonce, kat88_persstr,
+    kat88_addin0, kat88_addin1, kat88_retbits
+};
+static const struct drbg_kat kat88 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat88_t
+};
+
+static const unsigned char kat89_entropyin[] = {
+    0x62, 0x0e, 0xa3, 0x17, 0x34, 0x4d, 0x86, 0x85, 0x8d, 0x64, 0xf6, 0xbb,
+    0x05, 0xd4, 0x47, 0x97,
+};
+static const unsigned char kat89_nonce[] = {
+    0xf6, 0xdd, 0xc5, 0x84, 0x4f, 0xbd, 0x73, 0x9e,
+};
+static const unsigned char kat89_persstr[] = {0};
+static const unsigned char kat89_addin0[] = {
+    0x3c, 0xcf, 0xb0, 0x69, 0xef, 0x27, 0xf8, 0x64, 0xe3, 0xb7, 0x31, 0xd9,
+    0x4c, 0x3f, 0x2c, 0x6c,
+};
+static const unsigned char kat89_addin1[] = {
+    0x80, 0x85, 0x7d, 0x3f, 0x59, 0x8b, 0x1b, 0x16, 0x01, 0x4e, 0x6a, 0x35,
+    0x49, 0xa2, 0xd2, 0x2c,
+};
+static const unsigned char kat89_retbits[] = {
+    0xd7, 0xa7, 0x87, 0xbe, 0xeb, 0x7e, 0xfc, 0x9c, 0x58, 0x4f, 0x93, 0x34,
+    0x55, 0x33, 0xa5, 0x99, 0xed, 0x61, 0x5e, 0xb2, 0x13, 0x6b, 0x8f, 0xb8,
+    0x74, 0xa7, 0xf5, 0xa7, 0x1a, 0xea, 0x98, 0xf8, 0x0c, 0x56, 0x92, 0x30,
+    0x98, 0x56, 0x7a, 0xa3, 0xb4, 0xc3, 0x16, 0x96, 0x82, 0x6f, 0x08, 0x16,
+    0x76, 0xa3, 0xce, 0xed, 0x1d, 0x91, 0x4c, 0x94, 0x9d, 0x54, 0x23, 0x90,
+    0xb6, 0x99, 0xd3, 0xfe,
+};
+static const struct drbg_kat_no_reseed kat89_t = {
+    13, kat89_entropyin, kat89_nonce, kat89_persstr,
+    kat89_addin0, kat89_addin1, kat89_retbits
+};
+static const struct drbg_kat kat89 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat89_t
+};
+
+static const unsigned char kat90_entropyin[] = {
+    0xd8, 0xba, 0x9d, 0x16, 0xa0, 0x07, 0x0f, 0xbd, 0xf5, 0x10, 0x9d, 0x3c,
+    0x1e, 0xd8, 0x59, 0x16,
+};
+static const unsigned char kat90_nonce[] = {
+    0x29, 0xce, 0x07, 0xdd, 0xa6, 0x1b, 0x50, 0x14,
+};
+static const unsigned char kat90_persstr[] = {0};
+static const unsigned char kat90_addin0[] = {
+    0x16, 0x0a, 0xd7, 0x76, 0x75, 0xc6, 0x4c, 0x74, 0x87, 0xee, 0xdb, 0x34,
+    0x34, 0x37, 0x00, 0xc0,
+};
+static const unsigned char kat90_addin1[] = {
+    0x16, 0x32, 0x54, 0x60, 0x58, 0xf1, 0x9e, 0xe1, 0xb8, 0x49, 0xe5, 0xd2,
+    0x7e, 0x2d, 0x75, 0x5a,
+};
+static const unsigned char kat90_retbits[] = {
+    0xe0, 0x5c, 0x62, 0xcb, 0xef, 0xaf, 0x03, 0x80, 0x43, 0xd4, 0x9c, 0x97,
+    0x6b, 0xa8, 0x55, 0x21, 0xc2, 0x06, 0x71, 0xd9, 0xf8, 0x1c, 0xeb, 0xf5,
+    0xa8, 0x75, 0x81, 0x65, 0x9e, 0x3d, 0x18, 0x19, 0x90, 0x8e, 0x84, 0xec,
+    0x01, 0x93, 0xa5, 0x30, 0xf3, 0x10, 0xcc, 0x35, 0x44, 0xba, 0x90, 0xad,
+    0x92, 0xa6, 0xc9, 0x9d, 0x3a, 0x1a, 0xf5, 0x5b, 0x5a, 0xed, 0x72, 0x87,
+    0x1d, 0xb8, 0x90, 0x02,
+};
+static const struct drbg_kat_no_reseed kat90_t = {
+    14, kat90_entropyin, kat90_nonce, kat90_persstr,
+    kat90_addin0, kat90_addin1, kat90_retbits
+};
+static const struct drbg_kat kat90 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat90_t
+};
+
+static const unsigned char kat91_entropyin[] = {
+    0x0a, 0xf1, 0x3f, 0x64, 0x59, 0x02, 0xaf, 0x49, 0xe9, 0xa7, 0xce, 0xd6,
+    0xe3, 0x6a, 0x21, 0x0d,
+};
+static const unsigned char kat91_nonce[] = {
+    0xc3, 0xbf, 0xf2, 0x91, 0xa1, 0x1a, 0xc4, 0x97,
+};
+static const unsigned char kat91_persstr[] = {
+    0xe8, 0xf1, 0xd1, 0xb4, 0x73, 0x1c, 0x4d, 0x57, 0xd7, 0xea, 0xd9, 0xc2,
+    0xf6, 0x00, 0xfd, 0xc6,
+};
+static const unsigned char kat91_addin0[] = {0};
+static const unsigned char kat91_addin1[] = {0};
+static const unsigned char kat91_retbits[] = {
+    0xac, 0x6f, 0x94, 0x5a, 0x4b, 0x9f, 0xd3, 0xb4, 0x7c, 0x74, 0x37, 0x9e,
+    0xb1, 0xf2, 0xa7, 0xbb, 0xed, 0xf8, 0xee, 0xc6, 0x8e, 0xfd, 0x3c, 0x7a,
+    0x6c, 0xf6, 0x8c, 0x54, 0xae, 0x7a, 0x3f, 0x7b, 0xe7, 0x28, 0x0f, 0x45,
+    0x9c, 0x2e, 0x0b, 0x72, 0xaf, 0xa4, 0x5c, 0xeb, 0xbe, 0xbb, 0xa1, 0x7c,
+    0x86, 0x7e, 0x96, 0x11, 0xc8, 0x96, 0xa5, 0x7d, 0x51, 0x5b, 0xeb, 0x06,
+    0xa7, 0xb9, 0x1f, 0x4c,
+};
+static const struct drbg_kat_no_reseed kat91_t = {
+    0, kat91_entropyin, kat91_nonce, kat91_persstr,
+    kat91_addin0, kat91_addin1, kat91_retbits
+};
+static const struct drbg_kat kat91 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat91_t
+};
+
+static const unsigned char kat92_entropyin[] = {
+    0x0e, 0x11, 0x3f, 0x47, 0xf2, 0xfc, 0x76, 0xe8, 0x3e, 0x2d, 0x13, 0xd5,
+    0x72, 0x24, 0x56, 0x08,
+};
+static const unsigned char kat92_nonce[] = {
+    0x5f, 0xf8, 0x5c, 0xc6, 0xa5, 0x34, 0xf1, 0x5a,
+};
+static const unsigned char kat92_persstr[] = {
+    0x50, 0x25, 0x06, 0x68, 0xe5, 0x9d, 0xe3, 0x5f, 0xde, 0x91, 0xe0, 0x8f,
+    0xe1, 0x84, 0x84, 0xab,
+};
+static const unsigned char kat92_addin0[] = {0};
+static const unsigned char kat92_addin1[] = {0};
+static const unsigned char kat92_retbits[] = {
+    0xdc, 0xc6, 0x4a, 0x96, 0x6a, 0x52, 0xd6, 0x00, 0x8d, 0xbe, 0x07, 0xa2,
+    0x48, 0x4b, 0xca, 0xad, 0x67, 0xb2, 0x54, 0xd6, 0xf2, 0x46, 0xe4, 0x50,
+    0x1d, 0x98, 0x64, 0xb6, 0x4a, 0xd8, 0xb7, 0xed, 0xf1, 0x0f, 0xdb, 0xc6,
+    0xdd, 0xc4, 0x14, 0xa9, 0xb4, 0x31, 0xb0, 0x58, 0xa7, 0xee, 0x5c, 0xed,
+    0x23, 0xf7, 0xa6, 0xac, 0x7e, 0xea, 0x0f, 0xe6, 0x13, 0x1c, 0x9e, 0xb7,
+    0x41, 0x2e, 0x68, 0xdf,
+};
+static const struct drbg_kat_no_reseed kat92_t = {
+    1, kat92_entropyin, kat92_nonce, kat92_persstr,
+    kat92_addin0, kat92_addin1, kat92_retbits
+};
+static const struct drbg_kat kat92 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat92_t
+};
+
+static const unsigned char kat93_entropyin[] = {
+    0x16, 0xd2, 0xa2, 0x33, 0xf0, 0x49, 0x7c, 0x75, 0x1d, 0xdd, 0x85, 0xef,
+    0x7c, 0xd8, 0x62, 0xe6,
+};
+static const unsigned char kat93_nonce[] = {
+    0x7e, 0x7e, 0x1a, 0xab, 0x1b, 0x82, 0x67, 0x5d,
+};
+static const unsigned char kat93_persstr[] = {
+    0x15, 0xf8, 0x1e, 0x40, 0xa2, 0x49, 0x3b, 0x85, 0x9c, 0xce, 0xd3, 0x3c,
+    0xdf, 0x7b, 0x75, 0x90,
+};
+static const unsigned char kat93_addin0[] = {0};
+static const unsigned char kat93_addin1[] = {0};
+static const unsigned char kat93_retbits[] = {
+    0xc5, 0x20, 0x97, 0xd2, 0xd0, 0x09, 0xdc, 0xe7, 0xcb, 0xd4, 0x6d, 0x74,
+    0x0d, 0xe5, 0x4d, 0x70, 0xc0, 0x73, 0x2f, 0x96, 0xfa, 0xc0, 0xbd, 0x16,
+    0x9f, 0x38, 0x56, 0xe5, 0x0f, 0x9e, 0x46, 0x01, 0x67, 0x25, 0x38, 0xb2,
+    0x3f, 0x37, 0x1f, 0x78, 0x0e, 0x61, 0xe8, 0x2f, 0x2d, 0xb9, 0x9e, 0xf3,
+    0x83, 0x40, 0x08, 0xaa, 0xdc, 0x26, 0xc2, 0x78, 0x55, 0xa6, 0x86, 0x96,
+    0xee, 0x81, 0x2c, 0x9c,
+};
+static const struct drbg_kat_no_reseed kat93_t = {
+    2, kat93_entropyin, kat93_nonce, kat93_persstr,
+    kat93_addin0, kat93_addin1, kat93_retbits
+};
+static const struct drbg_kat kat93 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat93_t
+};
+
+static const unsigned char kat94_entropyin[] = {
+    0xea, 0x36, 0x89, 0x1e, 0x0d, 0x64, 0x26, 0x94, 0x5a, 0x6e, 0x1f, 0x33,
+    0x8c, 0x86, 0xca, 0x4b,
+};
+static const unsigned char kat94_nonce[] = {
+    0x89, 0x69, 0x66, 0x60, 0x0e, 0x85, 0xd3, 0xda,
+};
+static const unsigned char kat94_persstr[] = {
+    0xb8, 0xc7, 0x01, 0xa1, 0x1e, 0x7c, 0x00, 0x8e, 0x37, 0xc2, 0x32, 0x62,
+    0x7c, 0x24, 0xb6, 0xd1,
+};
+static const unsigned char kat94_addin0[] = {0};
+static const unsigned char kat94_addin1[] = {0};
+static const unsigned char kat94_retbits[] = {
+    0x44, 0x63, 0x60, 0xf1, 0x6b, 0x1e, 0x59, 0xa8, 0x25, 0x96, 0xe6, 0x1d,
+    0xf2, 0x3a, 0xf1, 0x8f, 0x5a, 0x95, 0xb7, 0xd8, 0xb7, 0xdd, 0x61, 0x72,
+    0xf3, 0x57, 0x5d, 0x45, 0x25, 0x13, 0x86, 0xb0, 0x4b, 0x69, 0x78, 0x5b,
+    0xa4, 0x4a, 0x75, 0xeb, 0x2a, 0x54, 0x15, 0x71, 0x3a, 0x84, 0x36, 0x5c,
+    0xac, 0x81, 0xb3, 0x0d, 0xf0, 0xb4, 0x8a, 0x61, 0x09, 0x77, 0xfe, 0x69,
+    0x61, 0xe7, 0xee, 0x8a,
+};
+static const struct drbg_kat_no_reseed kat94_t = {
+    3, kat94_entropyin, kat94_nonce, kat94_persstr,
+    kat94_addin0, kat94_addin1, kat94_retbits
+};
+static const struct drbg_kat kat94 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat94_t
+};
+
+static const unsigned char kat95_entropyin[] = {
+    0x3f, 0x41, 0x38, 0xd8, 0x4d, 0x7a, 0xbd, 0x13, 0xbb, 0xe1, 0x5e, 0x18,
+    0xb2, 0x92, 0xf1, 0x5f,
+};
+static const unsigned char kat95_nonce[] = {
+    0x34, 0x62, 0xe5, 0x2e, 0x82, 0xf2, 0x86, 0x53,
+};
+static const unsigned char kat95_persstr[] = {
+    0x24, 0xc5, 0x17, 0x70, 0x84, 0x95, 0x1c, 0xf5, 0x32, 0xf2, 0x43, 0x2a,
+    0x18, 0x82, 0x59, 0x6f,
+};
+static const unsigned char kat95_addin0[] = {0};
+static const unsigned char kat95_addin1[] = {0};
+static const unsigned char kat95_retbits[] = {
+    0xba, 0x2c, 0xa1, 0xe4, 0x43, 0xc7, 0x5d, 0x55, 0xc4, 0x20, 0x65, 0xba,
+    0x91, 0xf7, 0x7d, 0xb5, 0xb8, 0xde, 0x6c, 0x34, 0x2b, 0x65, 0xa2, 0xc1,
+    0x49, 0x44, 0x59, 0x79, 0xff, 0x26, 0x3e, 0x9d, 0x01, 0x8f, 0x56, 0x44,
+    0x30, 0xfe, 0x1e, 0xdb, 0x48, 0xb4, 0x03, 0xce, 0xf2, 0x3f, 0x86, 0x0e,
+    0xa2, 0x71, 0x46, 0xd8, 0x51, 0x18, 0x43, 0xe0, 0xa3, 0x9f, 0xf3, 0x37,
+    0xba, 0x74, 0xd2, 0x21,
+};
+static const struct drbg_kat_no_reseed kat95_t = {
+    4, kat95_entropyin, kat95_nonce, kat95_persstr,
+    kat95_addin0, kat95_addin1, kat95_retbits
+};
+static const struct drbg_kat kat95 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat95_t
+};
+
+static const unsigned char kat96_entropyin[] = {
+    0xa6, 0xae, 0xf8, 0x0f, 0xab, 0x61, 0xe2, 0x7e, 0xf6, 0x11, 0xb8, 0x6f,
+    0x92, 0x4e, 0x97, 0x6c,
+};
+static const unsigned char kat96_nonce[] = {
+    0x74, 0x27, 0x8f, 0x50, 0x23, 0xc2, 0x55, 0x2c,
+};
+static const unsigned char kat96_persstr[] = {
+    0xa3, 0x85, 0x16, 0x79, 0xe1, 0x12, 0x94, 0x82, 0x01, 0x39, 0x6d, 0x98,
+    0xd6, 0xbe, 0x5c, 0x13,
+};
+static const unsigned char kat96_addin0[] = {0};
+static const unsigned char kat96_addin1[] = {0};
+static const unsigned char kat96_retbits[] = {
+    0x68, 0x57, 0x26, 0x82, 0x7f, 0x3d, 0x38, 0x42, 0x7d, 0x07, 0xdf, 0xcf,
+    0xb6, 0x4a, 0x7f, 0x95, 0xb6, 0xf0, 0x6e, 0xf0, 0x1c, 0xed, 0x28, 0x1d,
+    0xce, 0x7f, 0x41, 0x30, 0x34, 0x12, 0x36, 0x11, 0x24, 0x36, 0x2b, 0xa5,
+    0x1c, 0xe8, 0xd2, 0x55, 0x2a, 0xf0, 0x54, 0xa2, 0x0f, 0xda, 0xc9, 0x4e,
+    0x51, 0x69, 0x16, 0x5b, 0x71, 0x52, 0x67, 0x63, 0x8c, 0x1e, 0x0b, 0x9b,
+    0x34, 0x52, 0xb5, 0xb7,
+};
+static const struct drbg_kat_no_reseed kat96_t = {
+    5, kat96_entropyin, kat96_nonce, kat96_persstr,
+    kat96_addin0, kat96_addin1, kat96_retbits
+};
+static const struct drbg_kat kat96 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat96_t
+};
+
+static const unsigned char kat97_entropyin[] = {
+    0x01, 0x64, 0xae, 0x53, 0xe5, 0x33, 0xf2, 0xf1, 0x22, 0x2d, 0x4a, 0xa2,
+    0x72, 0x76, 0x81, 0x4c,
+};
+static const unsigned char kat97_nonce[] = {
+    0x26, 0x05, 0xf5, 0x89, 0xcb, 0x1b, 0xea, 0x9c,
+};
+static const unsigned char kat97_persstr[] = {
+    0x9d, 0xe7, 0x03, 0xa5, 0xe2, 0xbb, 0xf2, 0xe5, 0x3d, 0x0f, 0xe3, 0xb5,
+    0x73, 0xf5, 0x2a, 0xcf,
+};
+static const unsigned char kat97_addin0[] = {0};
+static const unsigned char kat97_addin1[] = {0};
+static const unsigned char kat97_retbits[] = {
+    0xfd, 0x7f, 0x64, 0x62, 0x2e, 0x87, 0xde, 0x3b, 0x66, 0xe1, 0x99, 0x30,
+    0xcf, 0x4c, 0xcd, 0xc3, 0xe6, 0x72, 0xf5, 0xa4, 0xde, 0xf0, 0xda, 0xdd,
+    0xb3, 0x71, 0x07, 0x43, 0x0e, 0xc7, 0xf6, 0x91, 0xc6, 0x32, 0x15, 0x45,
+    0x10, 0x3c, 0x2a, 0x61, 0x4d, 0x7f, 0x0f, 0x33, 0x17, 0x3b, 0xde, 0xc4,
+    0x20, 0x58, 0x58, 0x22, 0xcd, 0xa8, 0xc2, 0x72, 0x20, 0x19, 0x22, 0xb6,
+    0x02, 0xf5, 0xd8, 0xa7,
+};
+static const struct drbg_kat_no_reseed kat97_t = {
+    6, kat97_entropyin, kat97_nonce, kat97_persstr,
+    kat97_addin0, kat97_addin1, kat97_retbits
+};
+static const struct drbg_kat kat97 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat97_t
+};
+
+static const unsigned char kat98_entropyin[] = {
+    0x29, 0xdc, 0x8b, 0xad, 0x50, 0x0c, 0xce, 0x29, 0x5b, 0x9e, 0x86, 0xb2,
+    0x15, 0x9c, 0x6d, 0xcd,
+};
+static const unsigned char kat98_nonce[] = {
+    0xb6, 0x9a, 0x5a, 0x77, 0x69, 0x4f, 0xc4, 0xa0,
+};
+static const unsigned char kat98_persstr[] = {
+    0xc5, 0x3b, 0x13, 0xaf, 0xbf, 0x21, 0xf1, 0x7e, 0xe9, 0xf4, 0xdd, 0x7c,
+    0x09, 0x93, 0xe0, 0xf9,
+};
+static const unsigned char kat98_addin0[] = {0};
+static const unsigned char kat98_addin1[] = {0};
+static const unsigned char kat98_retbits[] = {
+    0x08, 0xc9, 0x7d, 0x63, 0x8b, 0x5d, 0x82, 0x59, 0x93, 0x10, 0x32, 0x5d,
+    0x3b, 0x1e, 0x63, 0x27, 0x74, 0x1c, 0xd9, 0x18, 0x87, 0xd6, 0x58, 0xb5,
+    0xd8, 0x15, 0xee, 0xed, 0x7a, 0x72, 0xab, 0x86, 0xe2, 0xfa, 0x17, 0xe9,
+    0xd0, 0x13, 0xe1, 0x7a, 0x92, 0x14, 0xd6, 0x39, 0x6a, 0xc1, 0x48, 0x1f,
+    0x76, 0x88, 0x30, 0xa4, 0xd8, 0xc4, 0xfc, 0x39, 0x20, 0x12, 0xe9, 0x07,
+    0x64, 0x34, 0x93, 0x9f,
+};
+static const struct drbg_kat_no_reseed kat98_t = {
+    7, kat98_entropyin, kat98_nonce, kat98_persstr,
+    kat98_addin0, kat98_addin1, kat98_retbits
+};
+static const struct drbg_kat kat98 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat98_t
+};
+
+static const unsigned char kat99_entropyin[] = {
+    0xb3, 0xae, 0xe2, 0xcf, 0x80, 0xe3, 0xd0, 0x5a, 0xed, 0xa0, 0xe0, 0x1c,
+    0xf6, 0x5e, 0xa9, 0x65,
+};
+static const unsigned char kat99_nonce[] = {
+    0x24, 0xb5, 0x8b, 0x7c, 0x6a, 0x99, 0xeb, 0x2a,
+};
+static const unsigned char kat99_persstr[] = {
+    0x73, 0x44, 0x04, 0x3c, 0x84, 0x91, 0x5b, 0xcd, 0xd6, 0xd8, 0x1f, 0x3f,
+    0xe2, 0x3b, 0xa2, 0x73,
+};
+static const unsigned char kat99_addin0[] = {0};
+static const unsigned char kat99_addin1[] = {0};
+static const unsigned char kat99_retbits[] = {
+    0xbe, 0x35, 0x3c, 0xf8, 0x32, 0xe8, 0x46, 0x44, 0x4a, 0xf0, 0x01, 0x5e,
+    0xd0, 0x5d, 0x54, 0xb7, 0x2c, 0x9a, 0x1a, 0x02, 0x31, 0xf2, 0xa4, 0xc4,
+    0x75, 0x61, 0x17, 0x46, 0xef, 0x86, 0x10, 0x29, 0xe1, 0x88, 0x42, 0xc1,
+    0xb7, 0x61, 0x48, 0xd2, 0xa3, 0xeb, 0x01, 0x74, 0xa3, 0x0c, 0xad, 0x81,
+    0xb5, 0x58, 0xd0, 0xd1, 0xe0, 0x1a, 0x8c, 0x7d, 0xd5, 0x10, 0xf0, 0xb5,
+    0x6f, 0x1f, 0xdd, 0xc3,
+};
+static const struct drbg_kat_no_reseed kat99_t = {
+    8, kat99_entropyin, kat99_nonce, kat99_persstr,
+    kat99_addin0, kat99_addin1, kat99_retbits
+};
+static const struct drbg_kat kat99 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat99_t
+};
+
+static const unsigned char kat100_entropyin[] = {
+    0xa5, 0x25, 0xf6, 0x91, 0x65, 0xc4, 0x4f, 0x3a, 0x8a, 0xf8, 0x08, 0x57,
+    0xa5, 0xe8, 0x74, 0xb0,
+};
+static const unsigned char kat100_nonce[] = {
+    0x0c, 0x80, 0x6a, 0x40, 0xc1, 0xdc, 0xb7, 0xcc,
+};
+static const unsigned char kat100_persstr[] = {
+    0x43, 0x12, 0xc2, 0x30, 0x9a, 0x1d, 0xfe, 0x2d, 0x9a, 0x66, 0xf5, 0xc1,
+    0x8f, 0xc4, 0x0b, 0x87,
+};
+static const unsigned char kat100_addin0[] = {0};
+static const unsigned char kat100_addin1[] = {0};
+static const unsigned char kat100_retbits[] = {
+    0xd0, 0xb4, 0x6f, 0x7e, 0x18, 0x77, 0xdb, 0x24, 0x4f, 0xf4, 0xe0, 0xae,
+    0xb6, 0x4c, 0x4e, 0xfa, 0x3e, 0x8c, 0x2a, 0x86, 0x62, 0x41, 0x5c, 0xf5,
+    0xba, 0x67, 0xf2, 0xdc, 0x91, 0xe8, 0x23, 0x10, 0xa6, 0xa9, 0x33, 0xc4,
+    0xdf, 0x6a, 0x40, 0x2f, 0x8f, 0xae, 0x27, 0x0b, 0x22, 0x9b, 0xf2, 0x54,
+    0xcd, 0x35, 0x94, 0x3a, 0x13, 0x34, 0x09, 0x79, 0x37, 0x66, 0x69, 0x11,
+    0x9e, 0x0e, 0x5c, 0xf8,
+};
+static const struct drbg_kat_no_reseed kat100_t = {
+    9, kat100_entropyin, kat100_nonce, kat100_persstr,
+    kat100_addin0, kat100_addin1, kat100_retbits
+};
+static const struct drbg_kat kat100 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat100_t
+};
+
+static const unsigned char kat101_entropyin[] = {
+    0x06, 0x08, 0xdc, 0x6c, 0x8f, 0x9f, 0x19, 0x56, 0xfb, 0xe7, 0xd5, 0xa7,
+    0xc8, 0x2f, 0xd3, 0xb3,
+};
+static const unsigned char kat101_nonce[] = {
+    0x61, 0x5b, 0x62, 0xa0, 0x0d, 0x6d, 0x8d, 0x85,
+};
+static const unsigned char kat101_persstr[] = {
+    0x70, 0xdd, 0x43, 0xc1, 0x76, 0x43, 0x18, 0x17, 0x4a, 0x28, 0x57, 0xc4,
+    0x20, 0xdd, 0xf4, 0x07,
+};
+static const unsigned char kat101_addin0[] = {0};
+static const unsigned char kat101_addin1[] = {0};
+static const unsigned char kat101_retbits[] = {
+    0x71, 0xf4, 0xb5, 0xdf, 0x5b, 0xfa, 0x5f, 0xd5, 0x2c, 0xdc, 0x98, 0x51,
+    0xa6, 0x33, 0xf7, 0x7e, 0xd9, 0x04, 0x58, 0xb5, 0xa2, 0x90, 0xb0, 0x4d,
+    0x2f, 0x35, 0x13, 0x0d, 0x67, 0xa4, 0x2c, 0x16, 0x98, 0xac, 0x5f, 0x9b,
+    0x13, 0x9a, 0x9e, 0xcf, 0x35, 0x90, 0x75, 0x5a, 0x20, 0x41, 0x60, 0xa3,
+    0xa8, 0xf1, 0x7b, 0x77, 0x72, 0x66, 0x52, 0xc6, 0xdc, 0x6e, 0x9f, 0x00,
+    0x96, 0x64, 0x54, 0xfd,
+};
+static const struct drbg_kat_no_reseed kat101_t = {
+    10, kat101_entropyin, kat101_nonce, kat101_persstr,
+    kat101_addin0, kat101_addin1, kat101_retbits
+};
+static const struct drbg_kat kat101 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat101_t
+};
+
+static const unsigned char kat102_entropyin[] = {
+    0x7b, 0x39, 0x1f, 0x35, 0xdb, 0x0e, 0x53, 0xbf, 0x48, 0xee, 0x55, 0x76,
+    0xb0, 0x23, 0xff, 0x90,
+};
+static const unsigned char kat102_nonce[] = {
+    0x76, 0x21, 0xaa, 0xd5, 0x32, 0x98, 0x2b, 0x23,
+};
+static const unsigned char kat102_persstr[] = {
+    0xa6, 0xe7, 0x57, 0x78, 0xb7, 0x77, 0xd0, 0x1f, 0x00, 0x62, 0x27, 0xc4,
+    0x00, 0xd8, 0xff, 0x86,
+};
+static const unsigned char kat102_addin0[] = {0};
+static const unsigned char kat102_addin1[] = {0};
+static const unsigned char kat102_retbits[] = {
+    0xd6, 0x17, 0x80, 0xb5, 0xc7, 0x81, 0x41, 0x2b, 0xf3, 0x08, 0x5e, 0xec,
+    0xce, 0xe4, 0x9b, 0x99, 0x35, 0x8a, 0x18, 0x32, 0x23, 0x82, 0x8c, 0x1d,
+    0x80, 0x13, 0xac, 0xe6, 0x13, 0xd8, 0x9a, 0x45, 0x04, 0xd7, 0x5b, 0xa3,
+    0x09, 0xe5, 0x10, 0x58, 0x9a, 0x53, 0xb4, 0x72, 0xbd, 0x5f, 0xa1, 0xee,
+    0x2a, 0x22, 0x39, 0x2b, 0x82, 0x65, 0x70, 0x7c, 0x15, 0xe3, 0x29, 0x35,
+    0xbc, 0x8e, 0xfb, 0x4e,
+};
+static const struct drbg_kat_no_reseed kat102_t = {
+    11, kat102_entropyin, kat102_nonce, kat102_persstr,
+    kat102_addin0, kat102_addin1, kat102_retbits
+};
+static const struct drbg_kat kat102 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat102_t
+};
+
+static const unsigned char kat103_entropyin[] = {
+    0x09, 0x9f, 0x1f, 0x59, 0x17, 0x07, 0xd1, 0xf9, 0xab, 0xae, 0x7e, 0x2b,
+    0x65, 0xad, 0xab, 0xc3,
+};
+static const unsigned char kat103_nonce[] = {
+    0xf9, 0x0d, 0x35, 0x7a, 0x90, 0x1f, 0x11, 0x35,
+};
+static const unsigned char kat103_persstr[] = {
+    0x74, 0xb8, 0x26, 0x0c, 0xed, 0x4b, 0xbb, 0x80, 0x41, 0x77, 0x92, 0xf1,
+    0x93, 0xc6, 0xf9, 0xac,
+};
+static const unsigned char kat103_addin0[] = {0};
+static const unsigned char kat103_addin1[] = {0};
+static const unsigned char kat103_retbits[] = {
+    0x86, 0xf5, 0x06, 0x25, 0x6d, 0x29, 0x45, 0x0f, 0x16, 0x07, 0x31, 0x27,
+    0x39, 0xe5, 0xa0, 0x89, 0xb6, 0xb7, 0x86, 0xfd, 0xf5, 0x21, 0x45, 0x76,
+    0x9c, 0xb7, 0x0e, 0xf4, 0xee, 0xd3, 0x21, 0x09, 0xcf, 0x62, 0x36, 0x9d,
+    0x7a, 0x76, 0x59, 0x55, 0x78, 0x1e, 0xae, 0x63, 0x52, 0x02, 0x75, 0x16,
+    0x93, 0x68, 0x25, 0x7c, 0x6d, 0x34, 0x8e, 0xcc, 0x90, 0x0a, 0x38, 0x98,
+    0x77, 0x8d, 0x9a, 0x1a,
+};
+static const struct drbg_kat_no_reseed kat103_t = {
+    12, kat103_entropyin, kat103_nonce, kat103_persstr,
+    kat103_addin0, kat103_addin1, kat103_retbits
+};
+static const struct drbg_kat kat103 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat103_t
+};
+
+static const unsigned char kat104_entropyin[] = {
+    0xc9, 0x05, 0x9d, 0x7c, 0x01, 0x5c, 0x64, 0xf6, 0xe4, 0x1a, 0xa4, 0x92,
+    0x09, 0x9f, 0x4e, 0xf0,
+};
+static const unsigned char kat104_nonce[] = {
+    0x3f, 0x6e, 0x07, 0x69, 0xce, 0xe1, 0x77, 0xc6,
+};
+static const unsigned char kat104_persstr[] = {
+    0x76, 0xc6, 0xc6, 0x61, 0x32, 0x98, 0xd9, 0x25, 0xa6, 0xc5, 0x07, 0xae,
+    0x65, 0x4d, 0x6d, 0x9a,
+};
+static const unsigned char kat104_addin0[] = {0};
+static const unsigned char kat104_addin1[] = {0};
+static const unsigned char kat104_retbits[] = {
+    0x23, 0x81, 0x11, 0xc0, 0x06, 0xe5, 0x14, 0xc0, 0x5f, 0x2a, 0xe9, 0x35,
+    0xa3, 0x2d, 0xba, 0xa0, 0xb1, 0x28, 0xda, 0xa0, 0x73, 0x6e, 0x83, 0xd9,
+    0x34, 0x03, 0x77, 0x6c, 0x91, 0xe4, 0x77, 0xd0, 0xd0, 0x2c, 0x4a, 0x24,
+    0x87, 0x6a, 0x23, 0x29, 0xa0, 0xf1, 0x06, 0x03, 0x8d, 0x70, 0x1f, 0xed,
+    0xdf, 0x02, 0x47, 0xcc, 0x75, 0x84, 0x6d, 0xd3, 0x01, 0x08, 0x29, 0x9d,
+    0x84, 0x0e, 0xc4, 0xa8,
+};
+static const struct drbg_kat_no_reseed kat104_t = {
+    13, kat104_entropyin, kat104_nonce, kat104_persstr,
+    kat104_addin0, kat104_addin1, kat104_retbits
+};
+static const struct drbg_kat kat104 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat104_t
+};
+
+static const unsigned char kat105_entropyin[] = {
+    0x98, 0xd1, 0x3c, 0x30, 0xa6, 0xda, 0xe2, 0xca, 0x76, 0xd7, 0xd6, 0x67,
+    0x9f, 0x1f, 0xfb, 0xc4,
+};
+static const unsigned char kat105_nonce[] = {
+    0x49, 0x0b, 0x93, 0x9e, 0xb5, 0x56, 0xff, 0x1b,
+};
+static const unsigned char kat105_persstr[] = {
+    0x6c, 0x10, 0xa7, 0xc3, 0x0f, 0xb5, 0x34, 0xb5, 0x93, 0x4b, 0x1c, 0x29,
+    0x80, 0x84, 0x94, 0xb9,
+};
+static const unsigned char kat105_addin0[] = {0};
+static const unsigned char kat105_addin1[] = {0};
+static const unsigned char kat105_retbits[] = {
+    0xcb, 0x7d, 0xee, 0xea, 0x97, 0xbd, 0xb0, 0x3f, 0x72, 0xa0, 0x3b, 0x2d,
+    0x9b, 0x5f, 0x1b, 0x33, 0x03, 0x44, 0x48, 0x6e, 0x53, 0xe0, 0x49, 0x27,
+    0xc5, 0x8f, 0xb6, 0x3c, 0x97, 0x1a, 0xc9, 0x87, 0x33, 0xb0, 0x24, 0x9a,
+    0x1e, 0xfa, 0x85, 0xf8, 0x8b, 0xec, 0x48, 0x18, 0xe1, 0x31, 0x10, 0x22,
+    0x07, 0x76, 0xe4, 0xfd, 0xe4, 0x29, 0xe6, 0x39, 0x0a, 0xf4, 0x66, 0x71,
+    0x29, 0x01, 0x18, 0x9b,
+};
+static const struct drbg_kat_no_reseed kat105_t = {
+    14, kat105_entropyin, kat105_nonce, kat105_persstr,
+    kat105_addin0, kat105_addin1, kat105_retbits
+};
+static const struct drbg_kat kat105 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat105_t
+};
+
+static const unsigned char kat106_entropyin[] = {
+    0x25, 0xad, 0x6e, 0x73, 0x05, 0x5e, 0xcb, 0xc9, 0x49, 0xf2, 0x91, 0xf0,
+    0xf7, 0x97, 0xf1, 0x7a,
+};
+static const unsigned char kat106_nonce[] = {
+    0x1f, 0x85, 0xa9, 0x2a, 0x46, 0x0a, 0x2e, 0xea,
+};
+static const unsigned char kat106_persstr[] = {
+    0x83, 0xd0, 0x4b, 0x4b, 0x15, 0x91, 0xc7, 0xba, 0xc9, 0xbc, 0xa9, 0x07,
+    0xbb, 0xe9, 0xdd, 0xd4,
+};
+static const unsigned char kat106_addin0[] = {
+    0x52, 0x3c, 0x6c, 0xb0, 0xbc, 0x27, 0xd1, 0x9f, 0x8d, 0x2e, 0xbe, 0xf5,
+    0x79, 0x26, 0xdd, 0xe4,
+};
+static const unsigned char kat106_addin1[] = {
+    0xd3, 0x3c, 0xd1, 0x4b, 0x5b, 0x79, 0x37, 0x38, 0x8e, 0x89, 0xec, 0xc0,
+    0x80, 0x63, 0x03, 0xf0,
+};
+static const unsigned char kat106_retbits[] = {
+    0x23, 0xd9, 0x19, 0x5e, 0x40, 0x26, 0xed, 0xf0, 0x70, 0x88, 0xb8, 0x37,
+    0x62, 0x75, 0x47, 0xa0, 0xea, 0x91, 0x37, 0xed, 0x03, 0x36, 0xd7, 0x69,
+    0x60, 0x15, 0xdd, 0x6f, 0x29, 0x84, 0xde, 0xdb, 0x2a, 0x20, 0x7f, 0x2e,
+    0xb8, 0xa2, 0x56, 0x60, 0xa5, 0xee, 0x78, 0x11, 0x78, 0x57, 0x9a, 0x0f,
+    0x23, 0x3f, 0xb6, 0xf7, 0x26, 0x03, 0x58, 0xdb, 0xfd, 0x53, 0x25, 0xc3,
+    0xf8, 0xc8, 0xfe, 0x33,
+};
+static const struct drbg_kat_no_reseed kat106_t = {
+    0, kat106_entropyin, kat106_nonce, kat106_persstr,
+    kat106_addin0, kat106_addin1, kat106_retbits
+};
+static const struct drbg_kat kat106 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat106_t
+};
+
+static const unsigned char kat107_entropyin[] = {
+    0xae, 0x33, 0x2f, 0x73, 0x39, 0x0e, 0x27, 0x75, 0x6b, 0xc9, 0x3d, 0x2b,
+    0x95, 0x1b, 0x8b, 0x44,
+};
+static const unsigned char kat107_nonce[] = {
+    0xe6, 0x9f, 0xc8, 0xa1, 0x64, 0x50, 0xfb, 0x6d,
+};
+static const unsigned char kat107_persstr[] = {
+    0x5f, 0x76, 0x86, 0x3d, 0x3a, 0x20, 0x87, 0xe9, 0xcb, 0x90, 0xe1, 0x12,
+    0xc1, 0x68, 0x06, 0xe2,
+};
+static const unsigned char kat107_addin0[] = {
+    0xbf, 0x6a, 0x8e, 0x05, 0x6e, 0x6c, 0x3c, 0xc1, 0xa6, 0xcb, 0xdb, 0x6b,
+    0x59, 0xeb, 0xea, 0xe2,
+};
+static const unsigned char kat107_addin1[] = {
+    0xd8, 0x7a, 0xb9, 0x22, 0x4a, 0xa9, 0xcd, 0x9b, 0x5b, 0x84, 0x78, 0x35,
+    0xcb, 0x0d, 0xaa, 0xc4,
+};
+static const unsigned char kat107_retbits[] = {
+    0xe0, 0xa2, 0xdd, 0x56, 0x06, 0xa0, 0xa2, 0x61, 0x57, 0xf9, 0x21, 0x05,
+    0x11, 0xbb, 0xde, 0x50, 0xc9, 0x2f, 0x34, 0xad, 0x92, 0x36, 0x3c, 0xb9,
+    0x2a, 0x05, 0x20, 0x8b, 0x60, 0xb3, 0x3d, 0x21, 0xc3, 0xd6, 0xc0, 0xc6,
+    0xef, 0x05, 0x4e, 0xc4, 0x09, 0xb4, 0x63, 0x0d, 0xea, 0xc4, 0xc6, 0xd1,
+    0xad, 0x1b, 0x6b, 0xe7, 0x5f, 0xff, 0x27, 0xaa, 0x74, 0x94, 0x13, 0xc8,
+    0xb6, 0x4c, 0xf3, 0xe1,
+};
+static const struct drbg_kat_no_reseed kat107_t = {
+    1, kat107_entropyin, kat107_nonce, kat107_persstr,
+    kat107_addin0, kat107_addin1, kat107_retbits
+};
+static const struct drbg_kat kat107 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat107_t
+};
+
+static const unsigned char kat108_entropyin[] = {
+    0xe1, 0xa5, 0x89, 0xaf, 0xab, 0x83, 0x91, 0x69, 0x2d, 0xba, 0x52, 0x31,
+    0x8a, 0xa8, 0xdc, 0x0d,
+};
+static const unsigned char kat108_nonce[] = {
+    0x22, 0xeb, 0xcf, 0x2e, 0x24, 0xa9, 0x55, 0x28,
+};
+static const unsigned char kat108_persstr[] = {
+    0x82, 0xe8, 0xc3, 0x55, 0xdb, 0xc9, 0xcd, 0x4c, 0x8d, 0x52, 0xfa, 0x45,
+    0x21, 0x18, 0xf9, 0xf8,
+};
+static const unsigned char kat108_addin0[] = {
+    0xf7, 0x74, 0x57, 0xec, 0x32, 0xde, 0x66, 0x6f, 0x37, 0x0d, 0xa9, 0xe6,
+    0xc2, 0x20, 0xc5, 0x80,
+};
+static const unsigned char kat108_addin1[] = {
+    0xba, 0x25, 0xaa, 0x3a, 0xb3, 0xd5, 0x0a, 0x72, 0xb6, 0xc1, 0xb4, 0x3f,
+    0x30, 0xdb, 0x44, 0x55,
+};
+static const unsigned char kat108_retbits[] = {
+    0x88, 0x59, 0x55, 0xd1, 0x27, 0xfa, 0xf4, 0xc9, 0x21, 0xc4, 0xed, 0x3f,
+    0x38, 0xbc, 0x15, 0x42, 0xb9, 0x5a, 0x87, 0x83, 0x4d, 0x4d, 0x73, 0xd1,
+    0x56, 0x24, 0x00, 0xa6, 0xd3, 0xaa, 0x8e, 0x6c, 0x69, 0x7b, 0x71, 0x1d,
+    0x91, 0x0e, 0xec, 0xeb, 0xc9, 0xca, 0x4e, 0xc2, 0xdc, 0x17, 0xe7, 0x98,
+    0x93, 0xe7, 0xf7, 0x34, 0xc4, 0x56, 0x75, 0xde, 0x47, 0x7f, 0x55, 0x45,
+    0xbd, 0x94, 0xcd, 0xee,
+};
+static const struct drbg_kat_no_reseed kat108_t = {
+    2, kat108_entropyin, kat108_nonce, kat108_persstr,
+    kat108_addin0, kat108_addin1, kat108_retbits
+};
+static const struct drbg_kat kat108 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat108_t
+};
+
+static const unsigned char kat109_entropyin[] = {
+    0x6f, 0xb7, 0x6f, 0xcd, 0x3d, 0x76, 0x2f, 0xa4, 0xc5, 0x0d, 0xe1, 0xf2,
+    0x2e, 0x92, 0x76, 0x83,
+};
+static const unsigned char kat109_nonce[] = {
+    0xa5, 0xee, 0xf1, 0x2f, 0x3b, 0x3c, 0x25, 0xa3,
+};
+static const unsigned char kat109_persstr[] = {
+    0x54, 0x86, 0x7d, 0x7d, 0xc8, 0xce, 0xf5, 0x23, 0x42, 0xbb, 0xc0, 0x09,
+    0x95, 0x4e, 0xfb, 0xf8,
+};
+static const unsigned char kat109_addin0[] = {
+    0xfa, 0xc5, 0x52, 0xaa, 0x87, 0x96, 0xe8, 0x85, 0x8d, 0x55, 0xae, 0x37,
+    0x1a, 0x0f, 0x54, 0x8f,
+};
+static const unsigned char kat109_addin1[] = {
+    0xfe, 0xfb, 0xe9, 0xc8, 0x3c, 0x15, 0x9f, 0xcf, 0xa9, 0x2e, 0xe8, 0x18,
+    0x76, 0x1d, 0x49, 0xdc,
+};
+static const unsigned char kat109_retbits[] = {
+    0x09, 0x4f, 0x86, 0x3b, 0x88, 0xe2, 0xb5, 0x5e, 0xf4, 0x15, 0xd2, 0x68,
+    0x82, 0x94, 0xc7, 0xd8, 0xd2, 0xd7, 0x76, 0xc1, 0x69, 0x16, 0x73, 0x91,
+    0xdf, 0x36, 0xf8, 0x0a, 0xd8, 0xe9, 0x83, 0x3e, 0x97, 0x61, 0x6e, 0xf6,
+    0xe0, 0xa4, 0x5f, 0x94, 0x0d, 0x66, 0x38, 0x30, 0x18, 0xae, 0xe8, 0x6a,
+    0x48, 0x0a, 0x26, 0x51, 0xd6, 0xe2, 0xef, 0xad, 0x61, 0x5a, 0x05, 0x1f,
+    0x0d, 0xca, 0x64, 0xae,
+};
+static const struct drbg_kat_no_reseed kat109_t = {
+    3, kat109_entropyin, kat109_nonce, kat109_persstr,
+    kat109_addin0, kat109_addin1, kat109_retbits
+};
+static const struct drbg_kat kat109 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat109_t
+};
+
+static const unsigned char kat110_entropyin[] = {
+    0x5b, 0x32, 0xa3, 0x92, 0xdc, 0x66, 0x5a, 0xb5, 0x8f, 0x25, 0x98, 0xea,
+    0xb0, 0x7d, 0x8e, 0x53,
+};
+static const unsigned char kat110_nonce[] = {
+    0xc6, 0xf6, 0x13, 0x10, 0x73, 0x88, 0x60, 0xf5,
+};
+static const unsigned char kat110_persstr[] = {
+    0x9f, 0x30, 0x9a, 0x68, 0x53, 0x29, 0x82, 0x16, 0x92, 0xa9, 0x73, 0x00,
+    0x62, 0x0c, 0x01, 0x56,
+};
+static const unsigned char kat110_addin0[] = {
+    0x87, 0x5a, 0x4a, 0x43, 0xbd, 0xdf, 0x1a, 0x73, 0x05, 0x52, 0x6a, 0x48,
+    0x8a, 0x1e, 0x0e, 0xb4,
+};
+static const unsigned char kat110_addin1[] = {
+    0x21, 0x14, 0xa7, 0xcb, 0x15, 0x49, 0x0c, 0x06, 0x3b, 0xb4, 0x66, 0x8f,
+    0x36, 0x9a, 0x3d, 0x8e,
+};
+static const unsigned char kat110_retbits[] = {
+    0x91, 0xc1, 0xf1, 0x99, 0xf6, 0x71, 0xff, 0x56, 0x8e, 0x0e, 0xce, 0x46,
+    0x08, 0x87, 0x65, 0x16, 0x23, 0x22, 0xa8, 0x21, 0x60, 0x66, 0xf9, 0xa4,
+    0x15, 0xd7, 0xcc, 0xd9, 0xdf, 0xe7, 0x23, 0xc5, 0x21, 0xf5, 0x7d, 0xbd,
+    0x84, 0x69, 0xe3, 0x9b, 0xac, 0xda, 0xc3, 0x1e, 0x74, 0x2a, 0x2d, 0x2f,
+    0xf2, 0xa3, 0x1d, 0x5a, 0x15, 0xa0, 0x1b, 0xfd, 0x32, 0xbe, 0x50, 0x28,
+    0x6c, 0x73, 0x0e, 0xad,
+};
+static const struct drbg_kat_no_reseed kat110_t = {
+    4, kat110_entropyin, kat110_nonce, kat110_persstr,
+    kat110_addin0, kat110_addin1, kat110_retbits
+};
+static const struct drbg_kat kat110 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat110_t
+};
+
+static const unsigned char kat111_entropyin[] = {
+    0x79, 0x95, 0x7c, 0x33, 0xe4, 0x5b, 0xba, 0x1c, 0x8a, 0xe6, 0x90, 0x29,
+    0x07, 0x7a, 0xe3, 0x6b,
+};
+static const unsigned char kat111_nonce[] = {
+    0x5b, 0x49, 0xd8, 0xe7, 0xc1, 0x80, 0xbc, 0xb6,
+};
+static const unsigned char kat111_persstr[] = {
+    0x2a, 0xa8, 0xe7, 0x7b, 0x94, 0xfe, 0x0d, 0xdf, 0x0e, 0x57, 0x30, 0x2c,
+    0x8e, 0xbd, 0xc2, 0x2a,
+};
+static const unsigned char kat111_addin0[] = {
+    0x14, 0x84, 0x4d, 0x85, 0xe5, 0x0c, 0xb1, 0xfc, 0xb4, 0xe6, 0x88, 0x7b,
+    0x3f, 0xc6, 0x7f, 0x54,
+};
+static const unsigned char kat111_addin1[] = {
+    0x4c, 0x7c, 0xb0, 0x69, 0x29, 0x7c, 0x18, 0x65, 0x33, 0x94, 0xb8, 0x2b,
+    0xe6, 0xa9, 0x30, 0x99,
+};
+static const unsigned char kat111_retbits[] = {
+    0x06, 0x61, 0xe2, 0x41, 0x6e, 0x71, 0xfe, 0x49, 0x11, 0x9f, 0x96, 0x76,
+    0x42, 0xfd, 0x37, 0xdd, 0xb5, 0x82, 0xa1, 0x89, 0xa8, 0x88, 0xe7, 0xd4,
+    0xa2, 0xaa, 0x56, 0x27, 0x51, 0x94, 0xc8, 0xca, 0x69, 0x8f, 0xb2, 0xd6,
+    0x96, 0x83, 0x4b, 0x88, 0xb5, 0x72, 0xf0, 0xfd, 0xf5, 0xba, 0xdb, 0x6b,
+    0xf5, 0x8d, 0x16, 0x12, 0xd2, 0x5f, 0x5e, 0xe3, 0xf6, 0x2d, 0x33, 0xdb,
+    0x9a, 0x86, 0xb0, 0x87,
+};
+static const struct drbg_kat_no_reseed kat111_t = {
+    5, kat111_entropyin, kat111_nonce, kat111_persstr,
+    kat111_addin0, kat111_addin1, kat111_retbits
+};
+static const struct drbg_kat kat111 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat111_t
+};
+
+static const unsigned char kat112_entropyin[] = {
+    0x70, 0x50, 0x89, 0x80, 0x36, 0x2e, 0x96, 0x2a, 0xe7, 0x78, 0x45, 0x80,
+    0x81, 0xcf, 0xbb, 0xe6,
+};
+static const unsigned char kat112_nonce[] = {
+    0x29, 0xcc, 0xf6, 0xed, 0xba, 0x46, 0x2d, 0xc2,
+};
+static const unsigned char kat112_persstr[] = {
+    0x48, 0xa3, 0xd8, 0xdb, 0xdc, 0x85, 0x18, 0x8a, 0xbb, 0x35, 0xb5, 0x6c,
+    0x19, 0x4d, 0x60, 0x20,
+};
+static const unsigned char kat112_addin0[] = {
+    0xa8, 0x14, 0x72, 0x42, 0xe2, 0x47, 0x37, 0xfc, 0xf3, 0xb0, 0x07, 0xd2,
+    0x84, 0xd6, 0x61, 0xc4,
+};
+static const unsigned char kat112_addin1[] = {
+    0x96, 0x4a, 0x9d, 0x06, 0x86, 0xd9, 0x61, 0x93, 0xfb, 0x2e, 0x4a, 0x35,
+    0x14, 0x5e, 0xdc, 0xc8,
+};
+static const unsigned char kat112_retbits[] = {
+    0xd8, 0x1b, 0xd5, 0xda, 0x60, 0xd9, 0x9d, 0x6d, 0xaa, 0xec, 0xeb, 0xc0,
+    0x60, 0x65, 0x26, 0x33, 0xec, 0x14, 0xdc, 0x3b, 0x84, 0x69, 0x3b, 0xdf,
+    0xf7, 0x67, 0x77, 0x1f, 0x03, 0x2b, 0xfa, 0x2e, 0x4d, 0xfa, 0xd5, 0x3e,
+    0xf6, 0xd1, 0x99, 0x10, 0xbd, 0x92, 0x5d, 0xf1, 0x20, 0x9f, 0x33, 0xea,
+    0x11, 0xe3, 0xf1, 0xe8, 0x37, 0xb0, 0x3e, 0x7a, 0x70, 0x03, 0x25, 0x7f,
+    0xf4, 0x20, 0xa6, 0x92,
+};
+static const struct drbg_kat_no_reseed kat112_t = {
+    6, kat112_entropyin, kat112_nonce, kat112_persstr,
+    kat112_addin0, kat112_addin1, kat112_retbits
+};
+static const struct drbg_kat kat112 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat112_t
+};
+
+static const unsigned char kat113_entropyin[] = {
+    0xb7, 0x83, 0x71, 0xba, 0xf5, 0x86, 0xc0, 0xdd, 0x05, 0x4b, 0xfd, 0x29,
+    0x3f, 0xc7, 0xe8, 0xdc,
+};
+static const unsigned char kat113_nonce[] = {
+    0x11, 0x9b, 0x23, 0x2c, 0xe4, 0xca, 0xda, 0x97,
+};
+static const unsigned char kat113_persstr[] = {
+    0x3a, 0x58, 0x75, 0xb4, 0x43, 0x07, 0x3c, 0x9b, 0xf6, 0x4a, 0x0a, 0xaa,
+    0xf2, 0x6b, 0xa4, 0x4f,
+};
+static const unsigned char kat113_addin0[] = {
+    0x4d, 0x2d, 0x4f, 0x16, 0xb7, 0xb7, 0xd2, 0xd2, 0xbb, 0x4d, 0x83, 0xa4,
+    0x92, 0x99, 0x96, 0xb2,
+};
+static const unsigned char kat113_addin1[] = {
+    0x7d, 0x31, 0x73, 0xe0, 0x8a, 0xea, 0x4c, 0x8b, 0x6e, 0xf9, 0xe3, 0xcd,
+    0x69, 0x8f, 0x9b, 0x09,
+};
+static const unsigned char kat113_retbits[] = {
+    0xbb, 0x04, 0x86, 0x41, 0xf0, 0x36, 0xdc, 0x11, 0xb8, 0xdf, 0x8a, 0xd3,
+    0xe4, 0xd5, 0xbd, 0xfc, 0x30, 0x9b, 0x2c, 0x3f, 0x22, 0xb3, 0xd2, 0xb8,
+    0xac, 0xf1, 0x96, 0xd5, 0x0c, 0xd5, 0x42, 0xde, 0x13, 0xcd, 0x99, 0x97,
+    0x8a, 0x92, 0x0a, 0xcb, 0xa6, 0x1d, 0xc0, 0x7c, 0x64, 0x6b, 0x48, 0x09,
+    0x44, 0x79, 0xbb, 0x44, 0x17, 0xd8, 0x40, 0x9a, 0xba, 0xe3, 0xd6, 0x9e,
+    0xd5, 0x2a, 0x2a, 0x3e,
+};
+static const struct drbg_kat_no_reseed kat113_t = {
+    7, kat113_entropyin, kat113_nonce, kat113_persstr,
+    kat113_addin0, kat113_addin1, kat113_retbits
+};
+static const struct drbg_kat kat113 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat113_t
+};
+
+static const unsigned char kat114_entropyin[] = {
+    0x96, 0xbf, 0xc3, 0x47, 0xb3, 0x06, 0x80, 0x5a, 0xf8, 0x8d, 0xa0, 0x07,
+    0x67, 0x5d, 0xb4, 0x7c,
+};
+static const unsigned char kat114_nonce[] = {
+    0x12, 0x95, 0x37, 0x06, 0xa0, 0x6e, 0xb5, 0x30,
+};
+static const unsigned char kat114_persstr[] = {
+    0x46, 0x73, 0x3d, 0xdd, 0xaf, 0x70, 0xe3, 0xf2, 0x07, 0x5c, 0xb8, 0x70,
+    0xf4, 0x7e, 0x72, 0xdf,
+};
+static const unsigned char kat114_addin0[] = {
+    0x64, 0xf7, 0x9a, 0xd1, 0xdf, 0xa3, 0x93, 0xd3, 0x6b, 0xf5, 0xbe, 0x83,
+    0x32, 0x90, 0xb6, 0x94,
+};
+static const unsigned char kat114_addin1[] = {
+    0x5d, 0x21, 0x0f, 0x12, 0x85, 0xf0, 0xfb, 0x03, 0x8a, 0x75, 0x34, 0x76,
+    0xef, 0x24, 0x91, 0x79,
+};
+static const unsigned char kat114_retbits[] = {
+    0x67, 0xb6, 0x9b, 0xa4, 0x34, 0x90, 0x3e, 0x2b, 0xbf, 0x46, 0xd3, 0xf5,
+    0xe3, 0x00, 0xb9, 0xe5, 0xcf, 0x33, 0x01, 0xbe, 0xaa, 0xb7, 0xd3, 0x0b,
+    0x46, 0x52, 0xed, 0x3b, 0xf6, 0x62, 0x65, 0x79, 0x50, 0x3a, 0x54, 0x4e,
+    0x58, 0x23, 0x7c, 0x5e, 0x55, 0x1a, 0xd5, 0xee, 0x17, 0xb7, 0x36, 0x12,
+    0x0c, 0x37, 0xa3, 0x02, 0x9b, 0xd7, 0xa1, 0x03, 0x4d, 0x4c, 0x49, 0xf6,
+    0x1e, 0x04, 0x0a, 0xca,
+};
+static const struct drbg_kat_no_reseed kat114_t = {
+    8, kat114_entropyin, kat114_nonce, kat114_persstr,
+    kat114_addin0, kat114_addin1, kat114_retbits
+};
+static const struct drbg_kat kat114 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat114_t
+};
+
+static const unsigned char kat115_entropyin[] = {
+    0x9a, 0x4c, 0x8b, 0x46, 0xa9, 0x74, 0xfb, 0xc8, 0x5e, 0x25, 0x6d, 0x1f,
+    0x07, 0xcc, 0x59, 0xaa,
+};
+static const unsigned char kat115_nonce[] = {
+    0xeb, 0x8d, 0x66, 0x21, 0x02, 0x09, 0x01, 0x14,
+};
+static const unsigned char kat115_persstr[] = {
+    0xb9, 0x4b, 0x8d, 0x2a, 0x64, 0x92, 0x66, 0x64, 0x5a, 0x71, 0x5a, 0xfc,
+    0xa0, 0x99, 0x5d, 0x9d,
+};
+static const unsigned char kat115_addin0[] = {
+    0xf3, 0x36, 0xe1, 0xd6, 0x2a, 0xc5, 0x68, 0xed, 0x13, 0x2e, 0xa0, 0x18,
+    0x15, 0xda, 0xd5, 0x08,
+};
+static const unsigned char kat115_addin1[] = {
+    0x66, 0x76, 0x26, 0xa2, 0x3d, 0x23, 0xb7, 0x16, 0x5a, 0x6a, 0x88, 0x5d,
+    0x41, 0xfa, 0x90, 0x1c,
+};
+static const unsigned char kat115_retbits[] = {
+    0x2d, 0xf3, 0x3f, 0x7a, 0xd2, 0xc2, 0xd8, 0x6e, 0x61, 0x63, 0x3c, 0x25,
+    0xa8, 0xac, 0x57, 0xb5, 0xde, 0xad, 0x88, 0x02, 0x1c, 0x93, 0xad, 0x69,
+    0xba, 0x6c, 0x52, 0x27, 0x99, 0xc4, 0xbe, 0xbf, 0xda, 0x78, 0x27, 0x72,
+    0xc8, 0x1e, 0x7e, 0x02, 0xd8, 0xb8, 0x82, 0x54, 0x6b, 0x24, 0x2b, 0xb2,
+    0x2f, 0x31, 0x05, 0x65, 0xba, 0xc3, 0x16, 0x26, 0x9f, 0xfc, 0x80, 0x04,
+    0xd5, 0x44, 0x06, 0x31,
+};
+static const struct drbg_kat_no_reseed kat115_t = {
+    9, kat115_entropyin, kat115_nonce, kat115_persstr,
+    kat115_addin0, kat115_addin1, kat115_retbits
+};
+static const struct drbg_kat kat115 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat115_t
+};
+
+static const unsigned char kat116_entropyin[] = {
+    0xc7, 0xd6, 0x55, 0x75, 0x65, 0xa1, 0xfd, 0xe4, 0x80, 0x84, 0x1f, 0x1f,
+    0x1a, 0x10, 0xf6, 0x7d,
+};
+static const unsigned char kat116_nonce[] = {
+    0x02, 0xf8, 0x47, 0x98, 0x66, 0x26, 0xbb, 0x4b,
+};
+static const unsigned char kat116_persstr[] = {
+    0x61, 0x8c, 0xac, 0x99, 0x53, 0x17, 0x91, 0x67, 0x36, 0x03, 0xa1, 0x6b,
+    0x99, 0xab, 0x0e, 0x80,
+};
+static const unsigned char kat116_addin0[] = {
+    0x81, 0x0c, 0x8b, 0xe4, 0xb1, 0x80, 0x1f, 0xec, 0x75, 0x40, 0x63, 0xc2,
+    0x61, 0x15, 0x66, 0x60,
+};
+static const unsigned char kat116_addin1[] = {
+    0xe2, 0x59, 0x4d, 0x34, 0xce, 0x1a, 0xd6, 0x53, 0x51, 0x28, 0x60, 0x69,
+    0xeb, 0x1a, 0x63, 0x08,
+};
+static const unsigned char kat116_retbits[] = {
+    0xa3, 0xc4, 0xd0, 0x2d, 0xa0, 0x16, 0x6f, 0xef, 0x32, 0xce, 0x69, 0x97,
+    0x5d, 0xb9, 0x4d, 0x19, 0x60, 0x44, 0xe8, 0x1f, 0x59, 0x04, 0x4d, 0x22,
+    0xdf, 0x84, 0x05, 0xb4, 0x68, 0xeb, 0xd5, 0xa9, 0x29, 0x97, 0xfe, 0xeb,
+    0xa8, 0x2d, 0x7a, 0xdf, 0x97, 0xcc, 0xbb, 0x1a, 0x59, 0x35, 0x56, 0x26,
+    0xae, 0xfa, 0xe0, 0xd4, 0x35, 0xb4, 0x03, 0xb7, 0xde, 0xb9, 0x00, 0x5b,
+    0x8f, 0x5e, 0xa9, 0xa5,
+};
+static const struct drbg_kat_no_reseed kat116_t = {
+    10, kat116_entropyin, kat116_nonce, kat116_persstr,
+    kat116_addin0, kat116_addin1, kat116_retbits
+};
+static const struct drbg_kat kat116 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat116_t
+};
+
+static const unsigned char kat117_entropyin[] = {
+    0x14, 0x0d, 0xbf, 0xf6, 0x3e, 0x70, 0x83, 0xc3, 0x08, 0x41, 0x9f, 0x86,
+    0x4c, 0x09, 0x3e, 0x99,
+};
+static const unsigned char kat117_nonce[] = {
+    0xeb, 0x1c, 0x66, 0x92, 0xdb, 0x94, 0x9d, 0x5a,
+};
+static const unsigned char kat117_persstr[] = {
+    0x23, 0xd3, 0x27, 0x21, 0xf1, 0xc0, 0x3a, 0x90, 0xf3, 0x9e, 0xf0, 0x21,
+    0xac, 0x88, 0x84, 0xc7,
+};
+static const unsigned char kat117_addin0[] = {
+    0xc6, 0xe3, 0x80, 0x8d, 0xb9, 0xf9, 0xda, 0x14, 0x23, 0x9a, 0xd7, 0xd7,
+    0x18, 0x28, 0x6a, 0x96,
+};
+static const unsigned char kat117_addin1[] = {
+    0xa8, 0x4a, 0xaa, 0xdb, 0x7d, 0x57, 0x2a, 0x9a, 0xfc, 0xa3, 0xf7, 0x6c,
+    0xed, 0xf0, 0xa4, 0xb9,
+};
+static const unsigned char kat117_retbits[] = {
+    0x74, 0x3d, 0xf9, 0x7c, 0x2e, 0x99, 0xd9, 0x74, 0x07, 0x77, 0x72, 0xa6,
+    0xfe, 0xa4, 0x03, 0x12, 0x8f, 0x41, 0xff, 0x32, 0xa9, 0x5f, 0xb4, 0xf8,
+    0xb0, 0xec, 0xca, 0xa0, 0x57, 0x1c, 0xd2, 0x57, 0x8e, 0x48, 0x2c, 0xe7,
+    0x09, 0x84, 0x99, 0xc4, 0xd3, 0x01, 0x5f, 0x91, 0x92, 0x35, 0x52, 0x38,
+    0xc7, 0x0f, 0x8b, 0x76, 0xa5, 0x04, 0x27, 0x2a, 0x87, 0x09, 0xcd, 0x0e,
+    0x2d, 0xc8, 0x2c, 0x9c,
+};
+static const struct drbg_kat_no_reseed kat117_t = {
+    11, kat117_entropyin, kat117_nonce, kat117_persstr,
+    kat117_addin0, kat117_addin1, kat117_retbits
+};
+static const struct drbg_kat kat117 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat117_t
+};
+
+static const unsigned char kat118_entropyin[] = {
+    0x6a, 0xf3, 0x96, 0x2f, 0xd6, 0xae, 0x84, 0xde, 0xc3, 0xf8, 0x94, 0xbf,
+    0x39, 0xc6, 0x46, 0x42,
+};
+static const unsigned char kat118_nonce[] = {
+    0xc0, 0x20, 0x49, 0x64, 0x61, 0xa3, 0x91, 0x61,
+};
+static const unsigned char kat118_persstr[] = {
+    0x75, 0xca, 0xef, 0xe7, 0x75, 0x20, 0x45, 0xfc, 0xb1, 0xe5, 0xfc, 0x22,
+    0x7f, 0xfb, 0x94, 0x0d,
+};
+static const unsigned char kat118_addin0[] = {
+    0x16, 0x64, 0xf7, 0xcc, 0x88, 0xd0, 0x1d, 0x7f, 0x27, 0x86, 0x15, 0xc5,
+    0x63, 0x09, 0x2f, 0xd6,
+};
+static const unsigned char kat118_addin1[] = {
+    0x60, 0xb7, 0xa8, 0x6b, 0xc0, 0xc8, 0xdd, 0x2b, 0xd0, 0x7a, 0xda, 0xa4,
+    0xd5, 0xc2, 0x4d, 0x68,
+};
+static const unsigned char kat118_retbits[] = {
+    0xb4, 0xed, 0xc9, 0x65, 0x0d, 0x81, 0x47, 0x17, 0x0c, 0x81, 0x52, 0x9f,
+    0x2f, 0xd7, 0x33, 0x11, 0x53, 0xa6, 0x1d, 0x0d, 0x58, 0xb7, 0x6b, 0x50,
+    0xbb, 0x52, 0xda, 0x0a, 0x79, 0x51, 0x64, 0xbe, 0xeb, 0xc6, 0x09, 0x32,
+    0x05, 0x20, 0x32, 0x8f, 0x3d, 0x4e, 0x83, 0xcd, 0x80, 0xd0, 0xb1, 0xcb,
+    0xbb, 0xfd, 0x0a, 0x84, 0xa9, 0x65, 0x10, 0x88, 0x11, 0x01, 0xfb, 0xc7,
+    0x40, 0xb2, 0x81, 0x7f,
+};
+static const struct drbg_kat_no_reseed kat118_t = {
+    12, kat118_entropyin, kat118_nonce, kat118_persstr,
+    kat118_addin0, kat118_addin1, kat118_retbits
+};
+static const struct drbg_kat kat118 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat118_t
+};
+
+static const unsigned char kat119_entropyin[] = {
+    0x36, 0xe2, 0x7a, 0xa6, 0xb3, 0x66, 0x99, 0xe9, 0x46, 0x45, 0x95, 0xa9,
+    0x32, 0xcc, 0x92, 0x8e,
+};
+static const unsigned char kat119_nonce[] = {
+    0x65, 0x16, 0xbb, 0x91, 0x85, 0x66, 0xbf, 0x89,
+};
+static const unsigned char kat119_persstr[] = {
+    0x9b, 0xc6, 0x83, 0xa1, 0xf4, 0x65, 0xba, 0x0f, 0x2c, 0xe1, 0x8c, 0x8b,
+    0x9c, 0x61, 0x42, 0x44,
+};
+static const unsigned char kat119_addin0[] = {
+    0x0d, 0x17, 0x5b, 0x34, 0xd8, 0xb9, 0xe2, 0x70, 0x74, 0x5a, 0x71, 0xf3,
+    0x5d, 0x41, 0x6f, 0x10,
+};
+static const unsigned char kat119_addin1[] = {
+    0xa7, 0x90, 0xc8, 0x6f, 0xdf, 0x0c, 0xa8, 0x0e, 0xb3, 0xd6, 0xf7, 0x02,
+    0x91, 0x6e, 0xa9, 0x9f,
+};
+static const unsigned char kat119_retbits[] = {
+    0x34, 0xea, 0x96, 0x29, 0x62, 0x7f, 0x66, 0x84, 0xb9, 0xab, 0x85, 0xf8,
+    0x16, 0x46, 0x86, 0x4d, 0xd8, 0xef, 0x3a, 0x15, 0xed, 0xc8, 0x01, 0xdc,
+    0x39, 0xa7, 0x31, 0xdc, 0x9e, 0x80, 0xe6, 0x26, 0xfc, 0x8c, 0xe2, 0x1e,
+    0x9b, 0x62, 0xe9, 0x48, 0x88, 0x64, 0x89, 0xd5, 0xe4, 0x43, 0x6e, 0x65,
+    0x9f, 0x26, 0xbf, 0xb3, 0x43, 0x51, 0x04, 0xad, 0x9b, 0xfa, 0x0a, 0xaf,
+    0xc5, 0x50, 0x69, 0x17,
+};
+static const struct drbg_kat_no_reseed kat119_t = {
+    13, kat119_entropyin, kat119_nonce, kat119_persstr,
+    kat119_addin0, kat119_addin1, kat119_retbits
+};
+static const struct drbg_kat kat119 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat119_t
+};
+
+static const unsigned char kat120_entropyin[] = {
+    0xac, 0xa3, 0x59, 0xf1, 0x07, 0xc3, 0x24, 0x64, 0x8a, 0xd4, 0x45, 0x56,
+    0x4b, 0xfa, 0xe5, 0x6d,
+};
+static const unsigned char kat120_nonce[] = {
+    0xf9, 0x5d, 0x1c, 0x8f, 0xd2, 0x66, 0xdf, 0x64,
+};
+static const unsigned char kat120_persstr[] = {
+    0xa5, 0xcf, 0xdc, 0x76, 0xc4, 0xe8, 0x49, 0xe4, 0x5d, 0x8b, 0xcc, 0x68,
+    0xee, 0xb0, 0x12, 0x84,
+};
+static const unsigned char kat120_addin0[] = {
+    0x57, 0x80, 0x2c, 0xc0, 0x6e, 0xf0, 0x34, 0x4b, 0xd1, 0x4a, 0x48, 0x57,
+    0xc6, 0x9f, 0x68, 0xd4,
+};
+static const unsigned char kat120_addin1[] = {
+    0x53, 0x14, 0xfc, 0xcb, 0xe4, 0x52, 0x01, 0x8f, 0xc1, 0x6e, 0x5f, 0xfb,
+    0x5d, 0x90, 0xe8, 0x88,
+};
+static const unsigned char kat120_retbits[] = {
+    0x21, 0x1d, 0x90, 0xec, 0xd7, 0xd3, 0xdd, 0xd0, 0x3f, 0x91, 0xe8, 0xa6,
+    0x74, 0x40, 0x0f, 0xb1, 0x8d, 0x3f, 0xb3, 0x98, 0x86, 0xa2, 0x26, 0x2f,
+    0x0e, 0x09, 0xff, 0x07, 0x5f, 0x99, 0x8d, 0x21, 0x74, 0x19, 0xf2, 0xe9,
+    0x35, 0x3d, 0x45, 0xb9, 0xdf, 0x10, 0x72, 0x3e, 0xba, 0xeb, 0xcf, 0xf1,
+    0xaa, 0x80, 0x24, 0xd9, 0xb0, 0x96, 0x06, 0x4d, 0x6f, 0x31, 0x83, 0x5b,
+    0x75, 0xf8, 0xea, 0xa6,
+};
+static const struct drbg_kat_no_reseed kat120_t = {
+    14, kat120_entropyin, kat120_nonce, kat120_persstr,
+    kat120_addin0, kat120_addin1, kat120_retbits
+};
+static const struct drbg_kat kat120 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat120_t
+};
+
+static const unsigned char kat121_entropyin[] = {
+    0x2e, 0x17, 0x24, 0xdb, 0x48, 0x22, 0x32, 0xa3, 0xe6, 0x1f, 0x92, 0xc1,
+    0xc2, 0x66, 0xfa, 0xf8,
+};
+static const unsigned char kat121_nonce[] = {
+    0x38, 0xaa, 0x55, 0x90, 0xf6, 0xbf, 0xaa, 0x4b,
+};
+static const unsigned char kat121_persstr[] = {0};
+static const unsigned char kat121_addin0[] = {0};
+static const unsigned char kat121_addin1[] = {0};
+static const unsigned char kat121_retbits[] = {
+    0x44, 0x38, 0xb4, 0x8a, 0x45, 0xfb, 0x01, 0x41, 0xe3, 0x1f, 0x0a, 0x96,
+    0x24, 0xdf, 0xe6, 0xfc, 0xc2, 0xf9, 0xed, 0xc0, 0x75, 0xc0, 0xa5, 0x2b,
+    0xc5, 0xfc, 0x46, 0xd8, 0x5a, 0x96, 0x6c, 0x85, 0x3f, 0xee, 0xe6, 0xaf,
+    0x91, 0x32, 0x34, 0xb3, 0xf9, 0xa6, 0x79, 0xf6, 0x67, 0x89, 0x8d, 0xc1,
+    0x5a, 0x24, 0xaa, 0xed, 0x89, 0xf0, 0x35, 0xbf, 0xa5, 0xda, 0x51, 0x6e,
+    0x43, 0x5b, 0xba, 0xd1,
+};
+static const struct drbg_kat_no_reseed kat121_t = {
+    0, kat121_entropyin, kat121_nonce, kat121_persstr,
+    kat121_addin0, kat121_addin1, kat121_retbits
+};
+static const struct drbg_kat kat121 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat121_t
+};
+
+static const unsigned char kat122_entropyin[] = {
+    0x22, 0x56, 0x4f, 0x77, 0xc4, 0x5b, 0x05, 0x3c, 0xdf, 0x61, 0x43, 0x3e,
+    0xb9, 0x6b, 0x1d, 0x7c,
+};
+static const unsigned char kat122_nonce[] = {
+    0xcf, 0x73, 0xe6, 0x20, 0xf8, 0x51, 0x52, 0x03,
+};
+static const unsigned char kat122_persstr[] = {0};
+static const unsigned char kat122_addin0[] = {0};
+static const unsigned char kat122_addin1[] = {0};
+static const unsigned char kat122_retbits[] = {
+    0xc7, 0x90, 0x8e, 0x71, 0x2c, 0x71, 0x6d, 0x1f, 0x5e, 0xd5, 0x33, 0xe1,
+    0x42, 0xe7, 0x21, 0x87, 0xea, 0x77, 0xfb, 0x4f, 0x51, 0x6d, 0xc3, 0x1a,
+    0xa1, 0x0a, 0x1e, 0x54, 0x9d, 0x85, 0xea, 0xdb, 0x7a, 0x46, 0x46, 0x17,
+    0x04, 0x64, 0xc1, 0xf7, 0xa7, 0x52, 0xc0, 0x1a, 0x94, 0x06, 0xbe, 0x66,
+    0x43, 0xee, 0x96, 0x7d, 0x04, 0x64, 0xb8, 0x4b, 0x6a, 0x08, 0xb2, 0xed,
+    0x0a, 0x7a, 0xcb, 0x07,
+};
+static const struct drbg_kat_no_reseed kat122_t = {
+    1, kat122_entropyin, kat122_nonce, kat122_persstr,
+    kat122_addin0, kat122_addin1, kat122_retbits
+};
+static const struct drbg_kat kat122 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat122_t
+};
+
+static const unsigned char kat123_entropyin[] = {
+    0x2a, 0x5b, 0x01, 0x2b, 0x09, 0x79, 0x26, 0xe8, 0xf8, 0x57, 0x0f, 0xf8,
+    0x69, 0x2c, 0xc5, 0xd1,
+};
+static const unsigned char kat123_nonce[] = {
+    0xde, 0x8e, 0x07, 0x2d, 0x15, 0x81, 0xaf, 0xe6,
+};
+static const unsigned char kat123_persstr[] = {0};
+static const unsigned char kat123_addin0[] = {0};
+static const unsigned char kat123_addin1[] = {0};
+static const unsigned char kat123_retbits[] = {
+    0x81, 0xf2, 0xe2, 0xc8, 0x58, 0x5e, 0x8d, 0xc4, 0x65, 0xd7, 0x8e, 0x7b,
+    0x75, 0xb9, 0xf6, 0xc2, 0xbb, 0xdc, 0xde, 0x94, 0x75, 0xd4, 0x25, 0x0f,
+    0xb4, 0x9e, 0x04, 0xc5, 0x6e, 0x30, 0x48, 0x9e, 0x24, 0xdf, 0x48, 0x58,
+    0xf7, 0x4e, 0xd0, 0x85, 0xcb, 0xa9, 0xf9, 0x92, 0xeb, 0x7d, 0x13, 0xe4,
+    0xe0, 0x64, 0xa7, 0x45, 0xf4, 0x51, 0xcb, 0x6e, 0xdf, 0xc3, 0x7c, 0x57,
+    0xf3, 0x5e, 0x8d, 0x57,
+};
+static const struct drbg_kat_no_reseed kat123_t = {
+    2, kat123_entropyin, kat123_nonce, kat123_persstr,
+    kat123_addin0, kat123_addin1, kat123_retbits
+};
+static const struct drbg_kat kat123 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat123_t
+};
+
+static const unsigned char kat124_entropyin[] = {
+    0x2c, 0x6b, 0x05, 0xd1, 0xc8, 0x6a, 0xae, 0x86, 0xa8, 0x9e, 0x81, 0x64,
+    0x82, 0x98, 0x32, 0x36,
+};
+static const unsigned char kat124_nonce[] = {
+    0x33, 0x85, 0xd9, 0x29, 0xad, 0xe9, 0x96, 0xe8,
+};
+static const unsigned char kat124_persstr[] = {0};
+static const unsigned char kat124_addin0[] = {0};
+static const unsigned char kat124_addin1[] = {0};
+static const unsigned char kat124_retbits[] = {
+    0x52, 0x56, 0xa6, 0x44, 0x29, 0xa5, 0x56, 0xd1, 0xa9, 0x1d, 0x58, 0x99,
+    0x9c, 0x75, 0xb3, 0x6d, 0xe7, 0xcc, 0x01, 0xf7, 0x46, 0x3c, 0x4e, 0x24,
+    0xaf, 0xd1, 0x5d, 0xe0, 0xa3, 0x5d, 0xcb, 0x5a, 0xda, 0x26, 0x79, 0x13,
+    0x4f, 0x15, 0xf4, 0xc5, 0x1d, 0xc0, 0x6b, 0x34, 0x45, 0x4d, 0x6d, 0xca,
+    0xa1, 0xd2, 0x51, 0x1c, 0x1d, 0x22, 0x6f, 0x23, 0x2f, 0x44, 0x52, 0x76,
+    0x25, 0x57, 0x51, 0xe6,
+};
+static const struct drbg_kat_no_reseed kat124_t = {
+    3, kat124_entropyin, kat124_nonce, kat124_persstr,
+    kat124_addin0, kat124_addin1, kat124_retbits
+};
+static const struct drbg_kat kat124 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat124_t
+};
+
+static const unsigned char kat125_entropyin[] = {
+    0x48, 0xba, 0xb2, 0xf8, 0x2d, 0x80, 0x59, 0x7f, 0x93, 0xad, 0xdb, 0x7e,
+    0x1f, 0x0f, 0x2e, 0x72,
+};
+static const unsigned char kat125_nonce[] = {
+    0xf5, 0xf4, 0x90, 0x18, 0xe8, 0x55, 0x9b, 0x0a,
+};
+static const unsigned char kat125_persstr[] = {0};
+static const unsigned char kat125_addin0[] = {0};
+static const unsigned char kat125_addin1[] = {0};
+static const unsigned char kat125_retbits[] = {
+    0xfa, 0x32, 0x3d, 0x2d, 0xae, 0x96, 0x74, 0xd8, 0x0b, 0xd2, 0xf1, 0x42,
+    0x7c, 0x1c, 0x79, 0x53, 0x2b, 0x23, 0x74, 0xed, 0x1f, 0xb3, 0xa1, 0x3c,
+    0x62, 0x06, 0x05, 0x04, 0x8a, 0xc5, 0x78, 0xb3, 0x07, 0x0c, 0x67, 0x48,
+    0x31, 0x4e, 0x5e, 0xd1, 0xdb, 0xd3, 0xea, 0xaa, 0x64, 0x1e, 0x50, 0x5c,
+    0x3d, 0x3f, 0x59, 0xfa, 0xc2, 0x5d, 0x89, 0x7b, 0xf3, 0x94, 0xdc, 0xad,
+    0xb6, 0x3b, 0x7f, 0xf9,
+};
+static const struct drbg_kat_no_reseed kat125_t = {
+    4, kat125_entropyin, kat125_nonce, kat125_persstr,
+    kat125_addin0, kat125_addin1, kat125_retbits
+};
+static const struct drbg_kat kat125 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat125_t
+};
+
+static const unsigned char kat126_entropyin[] = {
+    0xad, 0x7a, 0xff, 0x42, 0x24, 0xe9, 0x3f, 0x32, 0x35, 0x45, 0x41, 0x6a,
+    0x1e, 0x56, 0x97, 0xce,
+};
+static const unsigned char kat126_nonce[] = {
+    0x9c, 0xc1, 0x2c, 0xe2, 0xed, 0x5e, 0x8d, 0x1c,
+};
+static const unsigned char kat126_persstr[] = {0};
+static const unsigned char kat126_addin0[] = {0};
+static const unsigned char kat126_addin1[] = {0};
+static const unsigned char kat126_retbits[] = {
+    0x36, 0xc7, 0x22, 0x23, 0xb9, 0x24, 0x4c, 0xdb, 0x2c, 0x2c, 0x0d, 0xd5,
+    0xa5, 0x97, 0x06, 0x55, 0x8e, 0x2e, 0x5a, 0x11, 0x84, 0x5c, 0xab, 0xf9,
+    0x54, 0x5c, 0xd4, 0xad, 0x08, 0x15, 0x4a, 0x46, 0x70, 0x3a, 0xe7, 0x50,
+    0xb7, 0xf0, 0xc4, 0xf5, 0xbb, 0x33, 0xac, 0xd3, 0xc3, 0x81, 0xe5, 0xee,
+    0x4c, 0xe0, 0x99, 0x16, 0x43, 0x11, 0x44, 0xe8, 0x51, 0x5f, 0xed, 0x91,
+    0x4d, 0x5c, 0x5b, 0x5e,
+};
+static const struct drbg_kat_no_reseed kat126_t = {
+    5, kat126_entropyin, kat126_nonce, kat126_persstr,
+    kat126_addin0, kat126_addin1, kat126_retbits
+};
+static const struct drbg_kat kat126 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat126_t
+};
+
+static const unsigned char kat127_entropyin[] = {
+    0x29, 0x9c, 0x01, 0xd3, 0xa2, 0xf1, 0x32, 0x3d, 0xf7, 0x53, 0xcf, 0x14,
+    0x84, 0x5e, 0x0d, 0xe5,
+};
+static const unsigned char kat127_nonce[] = {
+    0x51, 0x1e, 0x36, 0x23, 0x2a, 0x11, 0x29, 0x1d,
+};
+static const unsigned char kat127_persstr[] = {0};
+static const unsigned char kat127_addin0[] = {0};
+static const unsigned char kat127_addin1[] = {0};
+static const unsigned char kat127_retbits[] = {
+    0x77, 0x09, 0xfd, 0xc6, 0x27, 0x8d, 0xb4, 0x4b, 0x21, 0xd3, 0x9a, 0x19,
+    0x4b, 0x80, 0x6e, 0x48, 0xe7, 0xfe, 0x3e, 0x9a, 0xe1, 0x16, 0xe2, 0x38,
+    0xc2, 0x05, 0xc2, 0xc3, 0x45, 0x98, 0x1c, 0xe8, 0x1f, 0x25, 0x57, 0x13,
+    0x59, 0x7c, 0xec, 0x2b, 0x3a, 0xd3, 0x91, 0x0f, 0x2b, 0x67, 0x42, 0xae,
+    0xa6, 0x64, 0x04, 0x71, 0x2d, 0xf8, 0x32, 0x8d, 0x2f, 0x2d, 0x19, 0x48,
+    0x41, 0x30, 0x97, 0xdb,
+};
+static const struct drbg_kat_no_reseed kat127_t = {
+    6, kat127_entropyin, kat127_nonce, kat127_persstr,
+    kat127_addin0, kat127_addin1, kat127_retbits
+};
+static const struct drbg_kat kat127 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat127_t
+};
+
+static const unsigned char kat128_entropyin[] = {
+    0xb6, 0xee, 0x77, 0x79, 0x99, 0x4b, 0xa8, 0xcd, 0x49, 0x0a, 0x03, 0xcf,
+    0x68, 0x99, 0xb1, 0x35,
+};
+static const unsigned char kat128_nonce[] = {
+    0x66, 0xed, 0xa9, 0xb5, 0xa5, 0x4d, 0x7d, 0xed,
+};
+static const unsigned char kat128_persstr[] = {0};
+static const unsigned char kat128_addin0[] = {0};
+static const unsigned char kat128_addin1[] = {0};
+static const unsigned char kat128_retbits[] = {
+    0x4e, 0x21, 0xb4, 0x8f, 0xde, 0x08, 0x22, 0x63, 0xd7, 0x6a, 0x10, 0x34,
+    0xe8, 0x7a, 0x56, 0x6e, 0x1a, 0x1c, 0x9d, 0x2e, 0x1b, 0xd5, 0xc7, 0x48,
+    0xe3, 0x0e, 0x1d, 0x87, 0x50, 0xf2, 0xff, 0x03, 0x93, 0x1c, 0x4b, 0xfe,
+    0x19, 0x4d, 0x2d, 0xa4, 0xed, 0x1c, 0xf1, 0x53, 0x03, 0x01, 0xe5, 0xb1,
+    0xab, 0xc4, 0xbd, 0x2b, 0xda, 0x7b, 0xe8, 0x92, 0x84, 0xf8, 0xc2, 0x19,
+    0x36, 0x88, 0xc9, 0x82,
+};
+static const struct drbg_kat_no_reseed kat128_t = {
+    7, kat128_entropyin, kat128_nonce, kat128_persstr,
+    kat128_addin0, kat128_addin1, kat128_retbits
+};
+static const struct drbg_kat kat128 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat128_t
+};
+
+static const unsigned char kat129_entropyin[] = {
+    0xe3, 0xcc, 0xb9, 0x91, 0xc3, 0xe1, 0xb3, 0xed, 0xa0, 0xb4, 0x0b, 0x51,
+    0x42, 0xac, 0x84, 0xd3,
+};
+static const unsigned char kat129_nonce[] = {
+    0x99, 0x87, 0x57, 0xe0, 0x0d, 0xa2, 0xb9, 0xef,
+};
+static const unsigned char kat129_persstr[] = {0};
+static const unsigned char kat129_addin0[] = {0};
+static const unsigned char kat129_addin1[] = {0};
+static const unsigned char kat129_retbits[] = {
+    0xd3, 0x2b, 0xc1, 0x90, 0x99, 0x8f, 0x18, 0xe9, 0xd5, 0x50, 0x9f, 0x46,
+    0x02, 0x29, 0x05, 0xd0, 0x11, 0xbb, 0xec, 0x77, 0x4f, 0x05, 0x83, 0x69,
+    0x1d, 0x48, 0x12, 0x43, 0x79, 0xe8, 0x1d, 0x99, 0xf0, 0xcd, 0xd4, 0x61,
+    0x38, 0xbc, 0xcc, 0x47, 0xeb, 0x77, 0x3f, 0x25, 0x7a, 0x66, 0x2b, 0x79,
+    0x8f, 0xab, 0x27, 0x58, 0x86, 0x94, 0x89, 0x36, 0xbc, 0xe7, 0x2d, 0xbd,
+    0x2c, 0x61, 0x88, 0xac,
+};
+static const struct drbg_kat_no_reseed kat129_t = {
+    8, kat129_entropyin, kat129_nonce, kat129_persstr,
+    kat129_addin0, kat129_addin1, kat129_retbits
+};
+static const struct drbg_kat kat129 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat129_t
+};
+
+static const unsigned char kat130_entropyin[] = {
+    0xc3, 0x4e, 0x39, 0x80, 0x41, 0xcc, 0xee, 0x23, 0x89, 0x7f, 0x7c, 0xa3,
+    0x43, 0xf3, 0x56, 0x40,
+};
+static const unsigned char kat130_nonce[] = {
+    0xa2, 0x4f, 0x8e, 0xa0, 0x88, 0x6b, 0xf6, 0xbf,
+};
+static const unsigned char kat130_persstr[] = {0};
+static const unsigned char kat130_addin0[] = {0};
+static const unsigned char kat130_addin1[] = {0};
+static const unsigned char kat130_retbits[] = {
+    0x5f, 0xf0, 0xda, 0xef, 0x30, 0x04, 0xc5, 0x03, 0xb8, 0x09, 0x8e, 0x3b,
+    0x96, 0x8a, 0x8e, 0x32, 0x33, 0x19, 0xbe, 0x78, 0x6c, 0x7b, 0x74, 0x2a,
+    0xac, 0xee, 0x35, 0x5f, 0x1a, 0x3c, 0x9d, 0xe7, 0x50, 0x61, 0x10, 0x8e,
+    0x79, 0x18, 0x13, 0x61, 0xf2, 0xe3, 0x30, 0x6a, 0xf0, 0x7b, 0xcd, 0xed,
+    0x10, 0xe3, 0x2d, 0xef, 0x1b, 0x7b, 0xb3, 0xe4, 0xeb, 0xc1, 0x70, 0x96,
+    0xc6, 0x93, 0x30, 0x58,
+};
+static const struct drbg_kat_no_reseed kat130_t = {
+    9, kat130_entropyin, kat130_nonce, kat130_persstr,
+    kat130_addin0, kat130_addin1, kat130_retbits
+};
+static const struct drbg_kat kat130 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat130_t
+};
+
+static const unsigned char kat131_entropyin[] = {
+    0xfc, 0x1f, 0xd2, 0x5c, 0xed, 0x5b, 0xd3, 0x0a, 0x62, 0x1c, 0xd4, 0xae,
+    0x77, 0x96, 0x80, 0xad,
+};
+static const unsigned char kat131_nonce[] = {
+    0xaf, 0x17, 0xa9, 0xc9, 0x74, 0xb3, 0x6e, 0x6c,
+};
+static const unsigned char kat131_persstr[] = {0};
+static const unsigned char kat131_addin0[] = {0};
+static const unsigned char kat131_addin1[] = {0};
+static const unsigned char kat131_retbits[] = {
+    0x59, 0xf9, 0x9d, 0x08, 0x57, 0x49, 0x36, 0x74, 0x78, 0x68, 0x4a, 0x5d,
+    0xdc, 0x8f, 0xe1, 0x81, 0xb9, 0x7a, 0x4e, 0x67, 0xfd, 0xe5, 0xc1, 0x51,
+    0xc4, 0x69, 0x6d, 0x52, 0x3d, 0x7c, 0x14, 0xb7, 0x26, 0x89, 0xa9, 0x5a,
+    0x5b, 0x60, 0x92, 0xe9, 0x49, 0xdd, 0x16, 0x3b, 0xd8, 0xf9, 0xe4, 0x57,
+    0x27, 0xd2, 0xb8, 0xa3, 0x1e, 0xd2, 0x88, 0xc8, 0xc6, 0x22, 0x9e, 0x8b,
+    0xe6, 0x80, 0x8e, 0xc8,
+};
+static const struct drbg_kat_no_reseed kat131_t = {
+    10, kat131_entropyin, kat131_nonce, kat131_persstr,
+    kat131_addin0, kat131_addin1, kat131_retbits
+};
+static const struct drbg_kat kat131 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat131_t
+};
+
+static const unsigned char kat132_entropyin[] = {
+    0x72, 0xc0, 0xe2, 0x3d, 0x92, 0x07, 0x0a, 0x8b, 0xab, 0x70, 0x7f, 0x65,
+    0xd5, 0x95, 0x18, 0x6d,
+};
+static const unsigned char kat132_nonce[] = {
+    0x1a, 0x63, 0xdc, 0xfc, 0x52, 0xe5, 0x5c, 0x58,
+};
+static const unsigned char kat132_persstr[] = {0};
+static const unsigned char kat132_addin0[] = {0};
+static const unsigned char kat132_addin1[] = {0};
+static const unsigned char kat132_retbits[] = {
+    0x49, 0xfe, 0xc2, 0x67, 0x58, 0x85, 0xd5, 0x4a, 0x4c, 0x6b, 0x10, 0x1f,
+    0x29, 0x19, 0x45, 0xc7, 0x35, 0xad, 0x9c, 0x2d, 0xb5, 0x1a, 0x63, 0xb9,
+    0x41, 0xbc, 0x18, 0x2e, 0xe5, 0x1f, 0xd8, 0xfd, 0x84, 0xb8, 0xc6, 0x33,
+    0x7b, 0x0f, 0x77, 0xf3, 0x10, 0xca, 0x50, 0x69, 0x3b, 0x91, 0xb5, 0x90,
+    0xe3, 0xef, 0x65, 0x5b, 0xe7, 0xad, 0x76, 0x21, 0xed, 0x21, 0xff, 0x39,
+    0xd3, 0x29, 0x2e, 0xfd,
+};
+static const struct drbg_kat_no_reseed kat132_t = {
+    11, kat132_entropyin, kat132_nonce, kat132_persstr,
+    kat132_addin0, kat132_addin1, kat132_retbits
+};
+static const struct drbg_kat kat132 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat132_t
+};
+
+static const unsigned char kat133_entropyin[] = {
+    0xa0, 0x90, 0x91, 0xca, 0x32, 0x80, 0xf7, 0xf5, 0x83, 0x76, 0xbf, 0x68,
+    0x0d, 0xe1, 0x11, 0x92,
+};
+static const unsigned char kat133_nonce[] = {
+    0x1d, 0x08, 0xdc, 0x0d, 0x06, 0x00, 0x95, 0xb3,
+};
+static const unsigned char kat133_persstr[] = {0};
+static const unsigned char kat133_addin0[] = {0};
+static const unsigned char kat133_addin1[] = {0};
+static const unsigned char kat133_retbits[] = {
+    0x0d, 0x59, 0xac, 0xa0, 0x23, 0x64, 0x7f, 0x0b, 0xf2, 0x68, 0x81, 0xd9,
+    0x12, 0x6b, 0xab, 0x8c, 0x7f, 0xea, 0x92, 0x2d, 0x2b, 0x4c, 0x24, 0xf1,
+    0xdc, 0xc0, 0xbf, 0xf8, 0x7a, 0x3d, 0x0d, 0x1b, 0x1d, 0xa0, 0xe8, 0x75,
+    0x62, 0x6a, 0x56, 0x42, 0x61, 0x86, 0xef, 0xd0, 0x07, 0x1f, 0x5a, 0x78,
+    0x9f, 0xbf, 0x35, 0xfa, 0x8b, 0xfc, 0x85, 0xaf, 0xaf, 0xd3, 0xaf, 0x6c,
+    0x9c, 0x7c, 0xd0, 0x7a,
+};
+static const struct drbg_kat_no_reseed kat133_t = {
+    12, kat133_entropyin, kat133_nonce, kat133_persstr,
+    kat133_addin0, kat133_addin1, kat133_retbits
+};
+static const struct drbg_kat kat133 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat133_t
+};
+
+static const unsigned char kat134_entropyin[] = {
+    0x8b, 0x41, 0x75, 0xd0, 0xa1, 0x95, 0x39, 0xef, 0x3d, 0x5d, 0x40, 0x84,
+    0x6c, 0xb4, 0x0a, 0xb3,
+};
+static const unsigned char kat134_nonce[] = {
+    0x8c, 0x31, 0x0d, 0x43, 0x1c, 0xf0, 0x0b, 0x3e,
+};
+static const unsigned char kat134_persstr[] = {0};
+static const unsigned char kat134_addin0[] = {0};
+static const unsigned char kat134_addin1[] = {0};
+static const unsigned char kat134_retbits[] = {
+    0x92, 0xb3, 0xb0, 0xe5, 0x7a, 0xe4, 0xce, 0xfc, 0x40, 0xd6, 0xe5, 0xfa,
+    0x0d, 0x9f, 0xa8, 0x5c, 0x97, 0x0c, 0x2d, 0xd0, 0xcd, 0x4e, 0x04, 0xd7,
+    0x27, 0x27, 0x56, 0x63, 0x4b, 0x84, 0xcc, 0x20, 0xc5, 0x36, 0x8f, 0x3a,
+    0x7b, 0x3e, 0x12, 0x11, 0xc5, 0xfa, 0x2e, 0x63, 0x35, 0x43, 0x6b, 0x88,
+    0x58, 0x2d, 0x04, 0x8b, 0xc7, 0x6a, 0x7c, 0x19, 0xbb, 0xfe, 0xc1, 0x35,
+    0xa1, 0x05, 0x5c, 0xbd,
+};
+static const struct drbg_kat_no_reseed kat134_t = {
+    13, kat134_entropyin, kat134_nonce, kat134_persstr,
+    kat134_addin0, kat134_addin1, kat134_retbits
+};
+static const struct drbg_kat kat134 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat134_t
+};
+
+static const unsigned char kat135_entropyin[] = {
+    0x68, 0xc8, 0x53, 0xb9, 0x12, 0x9c, 0xb2, 0x0a, 0x3d, 0xdf, 0x11, 0xe7,
+    0x8a, 0x58, 0x75, 0xba,
+};
+static const unsigned char kat135_nonce[] = {
+    0xf5, 0xab, 0x54, 0x86, 0x05, 0xa5, 0x11, 0x03,
+};
+static const unsigned char kat135_persstr[] = {0};
+static const unsigned char kat135_addin0[] = {0};
+static const unsigned char kat135_addin1[] = {0};
+static const unsigned char kat135_retbits[] = {
+    0x43, 0xcf, 0xb0, 0x3a, 0x51, 0xd7, 0xda, 0x40, 0xb3, 0x94, 0x68, 0x36,
+    0x1c, 0x2e, 0xe0, 0x78, 0x81, 0x90, 0x75, 0x87, 0x2f, 0x4f, 0x7c, 0x5d,
+    0x2b, 0x09, 0xef, 0x39, 0x91, 0x46, 0x02, 0xa7, 0x2a, 0x62, 0xc6, 0x3e,
+    0x29, 0x38, 0x3f, 0xbb, 0x9e, 0x45, 0x0f, 0xb2, 0xae, 0xf3, 0x2e, 0xb9,
+    0xf3, 0x70, 0xcb, 0xbc, 0x1a, 0xb4, 0x70, 0x8a, 0x5d, 0x28, 0x98, 0xdf,
+    0x8a, 0xe4, 0xf6, 0x26,
+};
+static const struct drbg_kat_no_reseed kat135_t = {
+    14, kat135_entropyin, kat135_nonce, kat135_persstr,
+    kat135_addin0, kat135_addin1, kat135_retbits
+};
+static const struct drbg_kat kat135 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat135_t
+};
+
+static const unsigned char kat136_entropyin[] = {
+    0x9b, 0xfa, 0xef, 0xb6, 0x98, 0xb1, 0xb5, 0xfc, 0xc6, 0x2d, 0xb2, 0xc1,
+    0x64, 0x98, 0xc3, 0x3a,
+};
+static const unsigned char kat136_nonce[] = {
+    0x11, 0x1d, 0x86, 0x12, 0xa0, 0xf0, 0x4e, 0x2a,
+};
+static const unsigned char kat136_persstr[] = {0};
+static const unsigned char kat136_addin0[] = {
+    0xae, 0xdb, 0xe0, 0x28, 0x47, 0xb1, 0xb0, 0x8b, 0x6a, 0x67, 0x3b, 0xdf,
+    0x25, 0xb0, 0x22, 0x4c,
+};
+static const unsigned char kat136_addin1[] = {
+    0x99, 0x01, 0xea, 0xd6, 0x2c, 0xe5, 0x65, 0x73, 0xb0, 0xf7, 0x1c, 0xd0,
+    0x20, 0xfe, 0x34, 0x69,
+};
+static const unsigned char kat136_retbits[] = {
+    0xdf, 0xf8, 0xbf, 0x2a, 0xec, 0x53, 0x1f, 0x85, 0x32, 0x60, 0x7e, 0x73,
+    0x8b, 0xd7, 0x9f, 0x91, 0xd6, 0x08, 0x5c, 0xb1, 0x95, 0x68, 0xb7, 0xb0,
+    0x24, 0x0c, 0xe6, 0xa6, 0xb3, 0x71, 0xa2, 0x82, 0xba, 0xfc, 0xdb, 0xa0,
+    0x21, 0x37, 0xdf, 0x99, 0x05, 0x35, 0xd9, 0xeb, 0xf0, 0xba, 0x77, 0x11,
+    0x77, 0x51, 0x62, 0x6b, 0x26, 0x78, 0xac, 0xa7, 0xbe, 0x4d, 0xec, 0xfd,
+    0x6b, 0x9d, 0x4b, 0x38,
+};
+static const struct drbg_kat_no_reseed kat136_t = {
+    0, kat136_entropyin, kat136_nonce, kat136_persstr,
+    kat136_addin0, kat136_addin1, kat136_retbits
+};
+static const struct drbg_kat kat136 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat136_t
+};
+
+static const unsigned char kat137_entropyin[] = {
+    0xdf, 0x99, 0x3f, 0xed, 0xd5, 0x96, 0x74, 0xa8, 0x7a, 0x15, 0x14, 0x7b,
+    0x80, 0xbe, 0x37, 0xae,
+};
+static const unsigned char kat137_nonce[] = {
+    0x22, 0xb3, 0x31, 0x5a, 0xcc, 0xf1, 0xad, 0x13,
+};
+static const unsigned char kat137_persstr[] = {0};
+static const unsigned char kat137_addin0[] = {
+    0x9f, 0x9b, 0x94, 0x09, 0x04, 0x8a, 0x71, 0x17, 0x45, 0xc7, 0xef, 0x7a,
+    0x6d, 0xdd, 0xc1, 0x7d,
+};
+static const unsigned char kat137_addin1[] = {
+    0xc5, 0x60, 0x68, 0x5b, 0xd4, 0x9c, 0x05, 0x9f, 0x04, 0x38, 0xe9, 0xdf,
+    0xf6, 0x2d, 0x82, 0xd7,
+};
+static const unsigned char kat137_retbits[] = {
+    0x04, 0xd7, 0x4f, 0xa1, 0xb6, 0x9d, 0xe6, 0x89, 0x3a, 0x47, 0xbf, 0xb0,
+    0xb6, 0xae, 0x58, 0xa7, 0x98, 0x4b, 0xbb, 0x08, 0x8f, 0xce, 0x62, 0x0b,
+    0x9d, 0x8e, 0xbc, 0x0b, 0x54, 0xcd, 0xdb, 0xca, 0x00, 0x45, 0xd7, 0x5d,
+    0x5b, 0x04, 0x6f, 0xcd, 0x88, 0x95, 0xc1, 0x6b, 0x05, 0x13, 0xaa, 0x52,
+    0x1b, 0x8d, 0x4a, 0xf2, 0x76, 0x78, 0x3d, 0x9d, 0x25, 0x77, 0xac, 0xb3,
+    0x2c, 0xea, 0xdb, 0x89,
+};
+static const struct drbg_kat_no_reseed kat137_t = {
+    1, kat137_entropyin, kat137_nonce, kat137_persstr,
+    kat137_addin0, kat137_addin1, kat137_retbits
+};
+static const struct drbg_kat kat137 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat137_t
+};
+
+static const unsigned char kat138_entropyin[] = {
+    0xdb, 0x4f, 0xae, 0x0c, 0x43, 0x02, 0xeb, 0xe8, 0x4f, 0x2a, 0x28, 0xad,
+    0x98, 0x4d, 0xae, 0xc1,
+};
+static const unsigned char kat138_nonce[] = {
+    0x07, 0x9e, 0xbf, 0x0f, 0x00, 0x93, 0xcd, 0xb2,
+};
+static const unsigned char kat138_persstr[] = {0};
+static const unsigned char kat138_addin0[] = {
+    0x2f, 0xfb, 0x64, 0x85, 0xac, 0xe2, 0xad, 0x77, 0xd5, 0xf8, 0xad, 0xbd,
+    0x09, 0xb3, 0xf3, 0x72,
+};
+static const unsigned char kat138_addin1[] = {
+    0xf4, 0xb8, 0x44, 0x74, 0x3d, 0x00, 0x65, 0xa0, 0x38, 0x98, 0x80, 0x49,
+    0xf6, 0xaa, 0x53, 0xb5,
+};
+static const unsigned char kat138_retbits[] = {
+    0xcb, 0x8e, 0x71, 0x44, 0x8f, 0xf7, 0x91, 0x1e, 0x5c, 0xae, 0xa7, 0xd5,
+    0x4a, 0x12, 0x94, 0x5e, 0xd3, 0x4b, 0xea, 0x42, 0xdb, 0xb6, 0x57, 0x3b,
+    0xf8, 0x42, 0x0d, 0xbb, 0x6b, 0xae, 0x6a, 0x11, 0xe0, 0x24, 0x82, 0x92,
+    0xc9, 0xd9, 0x3d, 0xa3, 0x09, 0x68, 0x56, 0xe0, 0xf2, 0x94, 0x18, 0xf1,
+    0xc8, 0x0d, 0x13, 0x8b, 0x34, 0x15, 0x66, 0x7b, 0xfb, 0x45, 0x6b, 0x08,
+    0x9f, 0x26, 0x62, 0x1a,
+};
+static const struct drbg_kat_no_reseed kat138_t = {
+    2, kat138_entropyin, kat138_nonce, kat138_persstr,
+    kat138_addin0, kat138_addin1, kat138_retbits
+};
+static const struct drbg_kat kat138 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat138_t
+};
+
+static const unsigned char kat139_entropyin[] = {
+    0xa4, 0x23, 0x48, 0xf1, 0xbe, 0xc0, 0x6f, 0x58, 0x36, 0xfc, 0xa0, 0x60,
+    0x66, 0x14, 0x34, 0xc0,
+};
+static const unsigned char kat139_nonce[] = {
+    0x2f, 0x70, 0xf6, 0xa2, 0xe7, 0xd0, 0xb4, 0x36,
+};
+static const unsigned char kat139_persstr[] = {0};
+static const unsigned char kat139_addin0[] = {
+    0x54, 0x70, 0x91, 0xef, 0x85, 0xb0, 0x13, 0xf3, 0xf5, 0xdc, 0x82, 0x2a,
+    0x5b, 0x3f, 0x27, 0xf9,
+};
+static const unsigned char kat139_addin1[] = {
+    0x2c, 0xa9, 0x9e, 0xe7, 0x97, 0xf4, 0xa9, 0xb1, 0x67, 0x88, 0xd2, 0x98,
+    0xbb, 0xa2, 0xd1, 0x83,
+};
+static const unsigned char kat139_retbits[] = {
+    0x4b, 0x41, 0xed, 0x62, 0x81, 0xa8, 0x1d, 0x44, 0x2a, 0x8c, 0xb0, 0x3a,
+    0x81, 0x45, 0xfe, 0x78, 0x86, 0x3d, 0x25, 0xd7, 0xee, 0x70, 0xe7, 0x2d,
+    0x4d, 0x3a, 0xfd, 0x51, 0x68, 0x16, 0x48, 0x76, 0xa6, 0x6b, 0x5a, 0xca,
+    0x31, 0x8c, 0x9c, 0x91, 0x17, 0x23, 0x05, 0xe3, 0x88, 0xe1, 0xda, 0xc3,
+    0x86, 0xcb, 0xab, 0x6d, 0x15, 0x0a, 0x39, 0x12, 0x36, 0x9c, 0x93, 0x90,
+    0x08, 0x6b, 0xd7, 0x44,
+};
+static const struct drbg_kat_no_reseed kat139_t = {
+    3, kat139_entropyin, kat139_nonce, kat139_persstr,
+    kat139_addin0, kat139_addin1, kat139_retbits
+};
+static const struct drbg_kat kat139 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat139_t
+};
+
+static const unsigned char kat140_entropyin[] = {
+    0x14, 0x83, 0xb9, 0x8e, 0x08, 0xc0, 0x40, 0x12, 0xb0, 0x3f, 0x1f, 0x61,
+    0x02, 0xa2, 0x83, 0x06,
+};
+static const unsigned char kat140_nonce[] = {
+    0x89, 0xe6, 0x7c, 0xa1, 0xda, 0x05, 0xdd, 0x4f,
+};
+static const unsigned char kat140_persstr[] = {0};
+static const unsigned char kat140_addin0[] = {
+    0x30, 0x85, 0x9e, 0xcc, 0x30, 0x25, 0x04, 0x79, 0x30, 0xb3, 0x85, 0x3a,
+    0xe6, 0x8a, 0xbd, 0xa2,
+};
+static const unsigned char kat140_addin1[] = {
+    0xf5, 0x05, 0x57, 0xf0, 0x40, 0x29, 0x28, 0x6c, 0xaf, 0xb2, 0xfc, 0xbf,
+    0x14, 0x64, 0xe4, 0xe5,
+};
+static const unsigned char kat140_retbits[] = {
+    0x45, 0xac, 0xf5, 0x2f, 0xf5, 0x69, 0xcc, 0x48, 0x15, 0x95, 0x88, 0x01,
+    0x62, 0x89, 0x3b, 0x57, 0x9b, 0xe4, 0x05, 0x43, 0xc5, 0x6a, 0x94, 0xb7,
+    0x18, 0x4b, 0xc9, 0x92, 0xd1, 0xdf, 0x37, 0x85, 0x18, 0xf9, 0x3f, 0xb4,
+    0xd9, 0x75, 0x5d, 0x86, 0x58, 0xe9, 0x72, 0x2b, 0x34, 0x79, 0x53, 0x6b,
+    0xa4, 0x83, 0x9a, 0x8e, 0xee, 0x7a, 0x65, 0x5f, 0xed, 0x88, 0x4a, 0xaf,
+    0x5a, 0x55, 0x6e, 0xb7,
+};
+static const struct drbg_kat_no_reseed kat140_t = {
+    4, kat140_entropyin, kat140_nonce, kat140_persstr,
+    kat140_addin0, kat140_addin1, kat140_retbits
+};
+static const struct drbg_kat kat140 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat140_t
+};
+
+static const unsigned char kat141_entropyin[] = {
+    0xbe, 0x9f, 0xcd, 0xd7, 0x11, 0xce, 0x1b, 0x0a, 0x3c, 0x97, 0xb1, 0xac,
+    0x19, 0x79, 0x20, 0x7d,
+};
+static const unsigned char kat141_nonce[] = {
+    0xa8, 0x02, 0x94, 0xb5, 0xd6, 0x59, 0xff, 0xb4,
+};
+static const unsigned char kat141_persstr[] = {0};
+static const unsigned char kat141_addin0[] = {
+    0xb2, 0x0c, 0x04, 0x54, 0x6a, 0x0c, 0x6a, 0x5e, 0x6b, 0x95, 0x63, 0x7c,
+    0x96, 0x0b, 0xca, 0x63,
+};
+static const unsigned char kat141_addin1[] = {
+    0x67, 0x07, 0xcc, 0x21, 0x7f, 0xb1, 0x98, 0xaf, 0x85, 0x2e, 0x06, 0xdb,
+    0x14, 0x61, 0x58, 0x05,
+};
+static const unsigned char kat141_retbits[] = {
+    0x6b, 0x62, 0x0c, 0x76, 0xf0, 0xb1, 0xa4, 0xa3, 0xd7, 0xf0, 0xf6, 0x0a,
+    0x76, 0x45, 0x81, 0x1b, 0xb7, 0x9b, 0xf1, 0x84, 0x77, 0xf8, 0x5b, 0x94,
+    0xf0, 0xee, 0x09, 0xe0, 0xc6, 0x8b, 0x0f, 0xdb, 0x3e, 0x11, 0xd8, 0xe5,
+    0x8a, 0x34, 0xd2, 0x4f, 0xe3, 0x6e, 0x8b, 0x7e, 0xa7, 0x2a, 0x26, 0xb6,
+    0xcb, 0x92, 0xd9, 0x87, 0xc5, 0x81, 0xab, 0x48, 0xe5, 0xfb, 0x8f, 0xb7,
+    0x0f, 0x76, 0x5f, 0x5f,
+};
+static const struct drbg_kat_no_reseed kat141_t = {
+    5, kat141_entropyin, kat141_nonce, kat141_persstr,
+    kat141_addin0, kat141_addin1, kat141_retbits
+};
+static const struct drbg_kat kat141 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat141_t
+};
+
+static const unsigned char kat142_entropyin[] = {
+    0xa5, 0x8e, 0xb5, 0x4d, 0x10, 0x9b, 0x51, 0x4d, 0xb3, 0x38, 0xfc, 0xce,
+    0xa2, 0x8e, 0xf2, 0xea,
+};
+static const unsigned char kat142_nonce[] = {
+    0x91, 0x2d, 0x24, 0xa1, 0xd8, 0x1d, 0xe7, 0xdc,
+};
+static const unsigned char kat142_persstr[] = {0};
+static const unsigned char kat142_addin0[] = {
+    0x59, 0xd4, 0x59, 0xb0, 0x73, 0x52, 0x60, 0x21, 0xec, 0x45, 0x51, 0x12,
+    0x56, 0xcf, 0xb3, 0x58,
+};
+static const unsigned char kat142_addin1[] = {
+    0xf7, 0x9f, 0x7e, 0x5a, 0x2a, 0x79, 0x1a, 0x39, 0xbb, 0x32, 0xb6, 0xb1,
+    0x5f, 0xe0, 0x14, 0x61,
+};
+static const unsigned char kat142_retbits[] = {
+    0xc1, 0x26, 0xd4, 0x09, 0xc2, 0x0d, 0x5d, 0x3d, 0x4c, 0x79, 0x46, 0x12,
+    0x56, 0xf5, 0x40, 0x3d, 0x1c, 0xc5, 0x9b, 0xcf, 0x11, 0xa4, 0xa6, 0x16,
+    0xab, 0xf0, 0x65, 0x30, 0x32, 0xe0, 0x45, 0x0a, 0x11, 0xf3, 0x2f, 0x38,
+    0x16, 0xc3, 0x51, 0x91, 0x2f, 0xe8, 0xe3, 0x00, 0x84, 0xed, 0x34, 0xdb,
+    0xcd, 0x0a, 0x9c, 0x95, 0xe1, 0xc0, 0x13, 0x62, 0xef, 0x61, 0x6d, 0xd2,
+    0x2a, 0x13, 0x7f, 0x72,
+};
+static const struct drbg_kat_no_reseed kat142_t = {
+    6, kat142_entropyin, kat142_nonce, kat142_persstr,
+    kat142_addin0, kat142_addin1, kat142_retbits
+};
+static const struct drbg_kat kat142 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat142_t
+};
+
+static const unsigned char kat143_entropyin[] = {
+    0xe0, 0xa5, 0xd9, 0x4d, 0x0c, 0xa9, 0x5a, 0x7b, 0x38, 0x0b, 0x99, 0x9c,
+    0x69, 0xd9, 0x01, 0x1c,
+};
+static const unsigned char kat143_nonce[] = {
+    0x47, 0xcd, 0xc5, 0x5a, 0x19, 0x56, 0xaf, 0x8d,
+};
+static const unsigned char kat143_persstr[] = {0};
+static const unsigned char kat143_addin0[] = {
+    0xa9, 0x16, 0x84, 0xd0, 0x12, 0xdc, 0x48, 0x83, 0x0b, 0xe4, 0xcf, 0xae,
+    0xe2, 0xfc, 0x88, 0x54,
+};
+static const unsigned char kat143_addin1[] = {
+    0xa0, 0x61, 0xc2, 0xb1, 0x3b, 0xf1, 0x00, 0x6d, 0x3b, 0xa2, 0xf2, 0x29,
+    0x7f, 0x95, 0x4f, 0xb5,
+};
+static const unsigned char kat143_retbits[] = {
+    0xe1, 0x36, 0xea, 0x57, 0x3d, 0x1d, 0x81, 0xec, 0xb7, 0x84, 0x2e, 0xc4,
+    0x3a, 0xf0, 0xb4, 0xb9, 0x78, 0x3f, 0x3f, 0xe4, 0xb1, 0xab, 0x90, 0x24,
+    0xc6, 0x2e, 0xae, 0xf0, 0x86, 0x0e, 0x81, 0x3d, 0x5a, 0x24, 0xf1, 0xa5,
+    0xfa, 0xb7, 0x4b, 0x8f, 0x1f, 0x66, 0x1b, 0x50, 0x39, 0x29, 0x02, 0x56,
+    0xd0, 0xe5, 0xaa, 0xa9, 0xe0, 0xfd, 0xab, 0x3a, 0x18, 0x9b, 0x2d, 0x66,
+    0x95, 0x89, 0x39, 0x99,
+};
+static const struct drbg_kat_no_reseed kat143_t = {
+    7, kat143_entropyin, kat143_nonce, kat143_persstr,
+    kat143_addin0, kat143_addin1, kat143_retbits
+};
+static const struct drbg_kat kat143 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat143_t
+};
+
+static const unsigned char kat144_entropyin[] = {
+    0x91, 0x8b, 0xda, 0x9e, 0x89, 0x72, 0x7b, 0xbd, 0x97, 0x04, 0x25, 0xc7,
+    0x48, 0x3e, 0xf1, 0xaf,
+};
+static const unsigned char kat144_nonce[] = {
+    0xfc, 0x3b, 0xee, 0xec, 0x38, 0x0b, 0x02, 0xc2,
+};
+static const unsigned char kat144_persstr[] = {0};
+static const unsigned char kat144_addin0[] = {
+    0x6f, 0x48, 0x36, 0x73, 0xaf, 0x64, 0xbc, 0xd7, 0x4c, 0xfe, 0xff, 0x3f,
+    0x98, 0xb6, 0xcd, 0x5a,
+};
+static const unsigned char kat144_addin1[] = {
+    0x15, 0xbd, 0x5e, 0xab, 0xba, 0x23, 0x2d, 0xf5, 0xa1, 0xb6, 0x03, 0xa2,
+    0xfc, 0x16, 0x39, 0xc0,
+};
+static const unsigned char kat144_retbits[] = {
+    0x43, 0x85, 0x55, 0x1a, 0x3a, 0x7d, 0xd9, 0x0d, 0x77, 0xa7, 0x65, 0xf7,
+    0xcb, 0x85, 0x9d, 0x80, 0xab, 0x6a, 0xc4, 0x84, 0x8e, 0x3b, 0xd9, 0x11,
+    0x01, 0xb4, 0x52, 0x32, 0x34, 0xca, 0x0f, 0x16, 0xc0, 0x6a, 0x45, 0x79,
+    0xa9, 0x7e, 0xa5, 0x1d, 0xb0, 0x37, 0xfd, 0x8b, 0x8c, 0x40, 0x83, 0xcd,
+    0xb6, 0xf4, 0xed, 0x97, 0x56, 0xf5, 0xa4, 0x48, 0x8b, 0xb5, 0xdf, 0xcf,
+    0x7a, 0x8f, 0x8a, 0x9a,
+};
+static const struct drbg_kat_no_reseed kat144_t = {
+    8, kat144_entropyin, kat144_nonce, kat144_persstr,
+    kat144_addin0, kat144_addin1, kat144_retbits
+};
+static const struct drbg_kat kat144 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat144_t
+};
+
+static const unsigned char kat145_entropyin[] = {
+    0xd8, 0xad, 0xd3, 0x82, 0xd4, 0xdc, 0x7a, 0x1d, 0x10, 0xd4, 0x63, 0x03,
+    0x17, 0x39, 0x18, 0x01,
+};
+static const unsigned char kat145_nonce[] = {
+    0x6f, 0xc0, 0xb1, 0xa3, 0xaa, 0x2b, 0x3a, 0xdb,
+};
+static const unsigned char kat145_persstr[] = {0};
+static const unsigned char kat145_addin0[] = {
+    0x10, 0x1f, 0xcf, 0xd6, 0x60, 0x80, 0x75, 0xdc, 0xbb, 0xf2, 0xeb, 0xe8,
+    0x32, 0xd9, 0x6b, 0x13,
+};
+static const unsigned char kat145_addin1[] = {
+    0x63, 0x2f, 0x7a, 0x11, 0xfb, 0xa9, 0x79, 0xd2, 0x97, 0x9e, 0x41, 0x7e,
+    0x2d, 0xed, 0x1d, 0x30,
+};
+static const unsigned char kat145_retbits[] = {
+    0xa6, 0xa1, 0x55, 0x95, 0xbb, 0xd8, 0x57, 0xbb, 0x62, 0x15, 0x04, 0xc8,
+    0x5f, 0x03, 0x03, 0x3c, 0xe4, 0x7b, 0x5d, 0xf8, 0x62, 0x96, 0xb8, 0x0d,
+    0x40, 0xd0, 0x09, 0xfe, 0x6c, 0x5e, 0x1f, 0xff, 0xf0, 0x84, 0x04, 0x56,
+    0x99, 0x0a, 0x14, 0xf3, 0xa1, 0xc4, 0x9c, 0x36, 0x73, 0x7b, 0x70, 0xb6,
+    0x2f, 0x40, 0x6f, 0xa3, 0xc5, 0x32, 0x95, 0x2f, 0xb2, 0x2e, 0xfc, 0x76,
+    0x00, 0x9a, 0x1b, 0x1a,
+};
+static const struct drbg_kat_no_reseed kat145_t = {
+    9, kat145_entropyin, kat145_nonce, kat145_persstr,
+    kat145_addin0, kat145_addin1, kat145_retbits
+};
+static const struct drbg_kat kat145 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat145_t
+};
+
+static const unsigned char kat146_entropyin[] = {
+    0xd1, 0x9f, 0xa3, 0x38, 0xc7, 0xbd, 0x52, 0x40, 0x74, 0x7b, 0xac, 0xab,
+    0x70, 0x32, 0x8f, 0xb3,
+};
+static const unsigned char kat146_nonce[] = {
+    0x5b, 0x42, 0x82, 0x35, 0x41, 0x42, 0x83, 0xb4,
+};
+static const unsigned char kat146_persstr[] = {0};
+static const unsigned char kat146_addin0[] = {
+    0xf3, 0x7c, 0x9f, 0xeb, 0x90, 0xc9, 0x6a, 0x26, 0x3f, 0x41, 0xb1, 0xc4,
+    0x98, 0xd5, 0xe0, 0x75,
+};
+static const unsigned char kat146_addin1[] = {
+    0xa3, 0xd8, 0x86, 0x96, 0xfc, 0x1a, 0x44, 0x70, 0x28, 0x42, 0x31, 0x71,
+    0xba, 0xd4, 0x65, 0x24,
+};
+static const unsigned char kat146_retbits[] = {
+    0x11, 0xee, 0x72, 0xb4, 0x81, 0xd5, 0x54, 0xf0, 0xfe, 0x49, 0xdc, 0x27,
+    0x37, 0x46, 0x6d, 0x5f, 0x5a, 0x64, 0x76, 0xa2, 0xb5, 0xb2, 0xf9, 0x3c,
+    0xd6, 0x0e, 0xe8, 0xab, 0x1b, 0xf7, 0x56, 0x3d, 0x3e, 0xbc, 0x60, 0x5e,
+    0x44, 0xc3, 0x65, 0xe7, 0x86, 0x5b, 0xff, 0x31, 0xc0, 0x77, 0xd1, 0x76,
+    0xd3, 0x61, 0xa4, 0x24, 0x06, 0x27, 0xde, 0xb2, 0x8a, 0xd5, 0x68, 0x50,
+    0x46, 0x91, 0xf9, 0x47,
+};
+static const struct drbg_kat_no_reseed kat146_t = {
+    10, kat146_entropyin, kat146_nonce, kat146_persstr,
+    kat146_addin0, kat146_addin1, kat146_retbits
+};
+static const struct drbg_kat kat146 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat146_t
+};
+
+static const unsigned char kat147_entropyin[] = {
+    0xc3, 0xd8, 0x2c, 0x63, 0x01, 0x41, 0x77, 0xe6, 0x2b, 0xda, 0x82, 0xdd,
+    0xe9, 0x11, 0x54, 0x50,
+};
+static const unsigned char kat147_nonce[] = {
+    0x5e, 0x6f, 0x3b, 0x1c, 0x75, 0x70, 0x6f, 0x5f,
+};
+static const unsigned char kat147_persstr[] = {0};
+static const unsigned char kat147_addin0[] = {
+    0x72, 0xa7, 0x17, 0xc6, 0x6f, 0xb2, 0x69, 0x06, 0xd6, 0x99, 0x5d, 0x3e,
+    0xec, 0xc5, 0x79, 0xd9,
+};
+static const unsigned char kat147_addin1[] = {
+    0xb1, 0xb7, 0xa9, 0xad, 0x3c, 0x64, 0x35, 0x5d, 0x5d, 0x70, 0xf0, 0x3c,
+    0x7b, 0x83, 0x29, 0xb0,
+};
+static const unsigned char kat147_retbits[] = {
+    0x34, 0xc3, 0x09, 0xf2, 0x35, 0x27, 0x09, 0xa9, 0x1f, 0x1f, 0x1a, 0x6a,
+    0xfb, 0x60, 0x14, 0x66, 0xf8, 0x6d, 0xc8, 0x02, 0x2b, 0xcb, 0xfd, 0xee,
+    0x09, 0x51, 0x90, 0xa8, 0x5f, 0xe1, 0xf0, 0x33, 0x2b, 0x8b, 0xab, 0x32,
+    0xf4, 0x42, 0x49, 0x43, 0x00, 0x41, 0xcb, 0x0c, 0xf2, 0xc4, 0x0d, 0x9c,
+    0xdd, 0x0c, 0x0d, 0xf4, 0x23, 0xe3, 0x4f, 0x2d, 0xa8, 0xd7, 0xf7, 0xb8,
+    0x32, 0x94, 0x56, 0x19,
+};
+static const struct drbg_kat_no_reseed kat147_t = {
+    11, kat147_entropyin, kat147_nonce, kat147_persstr,
+    kat147_addin0, kat147_addin1, kat147_retbits
+};
+static const struct drbg_kat kat147 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat147_t
+};
+
+static const unsigned char kat148_entropyin[] = {
+    0x1c, 0x34, 0x80, 0x46, 0x79, 0x40, 0x8c, 0x0d, 0xd1, 0xc0, 0xb0, 0xb2,
+    0xcb, 0x4c, 0x0c, 0x8d,
+};
+static const unsigned char kat148_nonce[] = {
+    0x23, 0xe6, 0xd5, 0xa1, 0x31, 0x74, 0x0e, 0xc9,
+};
+static const unsigned char kat148_persstr[] = {0};
+static const unsigned char kat148_addin0[] = {
+    0x8b, 0x99, 0xe4, 0x48, 0x55, 0x10, 0xe7, 0xc4, 0xef, 0x31, 0x86, 0xc7,
+    0x5d, 0x0f, 0x42, 0x1d,
+};
+static const unsigned char kat148_addin1[] = {
+    0xcc, 0x1e, 0xcf, 0x02, 0x3c, 0x9b, 0xea, 0xfb, 0x63, 0x48, 0x69, 0x57,
+    0x32, 0x7c, 0x2b, 0xde,
+};
+static const unsigned char kat148_retbits[] = {
+    0x7f, 0xbf, 0x33, 0xf0, 0x51, 0x08, 0x78, 0x6f, 0xe0, 0x19, 0x97, 0x14,
+    0x6a, 0x27, 0xe5, 0x94, 0x68, 0x76, 0x49, 0x9a, 0x8b, 0xa5, 0x2a, 0x71,
+    0x47, 0x16, 0xd9, 0x82, 0xce, 0xa2, 0x3f, 0x39, 0x2d, 0x40, 0x23, 0x4d,
+    0x3e, 0x00, 0x33, 0x8d, 0x1a, 0xc8, 0x80, 0x9d, 0x43, 0xc7, 0x79, 0x42,
+    0x40, 0x30, 0x19, 0x3b, 0xc6, 0x12, 0x3b, 0x70, 0x67, 0xb6, 0xa8, 0xc2,
+    0xed, 0x17, 0x9a, 0x25,
+};
+static const struct drbg_kat_no_reseed kat148_t = {
+    12, kat148_entropyin, kat148_nonce, kat148_persstr,
+    kat148_addin0, kat148_addin1, kat148_retbits
+};
+static const struct drbg_kat kat148 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat148_t
+};
+
+static const unsigned char kat149_entropyin[] = {
+    0xaa, 0x70, 0xaa, 0x9d, 0x3c, 0x0a, 0x77, 0xf8, 0x68, 0x38, 0x80, 0x5e,
+    0xef, 0x34, 0x82, 0xba,
+};
+static const unsigned char kat149_nonce[] = {
+    0xcf, 0x7a, 0x0f, 0x57, 0xc7, 0xde, 0xdf, 0x50,
+};
+static const unsigned char kat149_persstr[] = {0};
+static const unsigned char kat149_addin0[] = {
+    0xf6, 0xd4, 0x76, 0xea, 0xe4, 0x2f, 0x02, 0xc9, 0xec, 0x21, 0x98, 0x12,
+    0x29, 0xd0, 0xf9, 0x76,
+};
+static const unsigned char kat149_addin1[] = {
+    0x1a, 0xa4, 0x1e, 0xfd, 0xf1, 0x06, 0xe5, 0xa3, 0xe5, 0xd9, 0x76, 0x77,
+    0x8b, 0x8f, 0x0c, 0x32,
+};
+static const unsigned char kat149_retbits[] = {
+    0x84, 0xc1, 0xc0, 0x61, 0x9f, 0x69, 0x79, 0xe2, 0xf4, 0xd2, 0xab, 0xc6,
+    0x33, 0x35, 0x42, 0xbf, 0x42, 0xfd, 0x32, 0x79, 0x14, 0x2f, 0x07, 0x1d,
+    0xad, 0xb2, 0x64, 0x45, 0xfb, 0x2d, 0xe5, 0x1c, 0x4f, 0xad, 0x68, 0x1d,
+    0xce, 0x89, 0x18, 0xaf, 0x3a, 0xe1, 0x64, 0x19, 0xfa, 0xfa, 0x3c, 0x55,
+    0x26, 0xd8, 0xc4, 0x78, 0x59, 0x9e, 0x85, 0xee, 0x61, 0xa2, 0x73, 0x18,
+    0x36, 0x05, 0x45, 0x0e,
+};
+static const struct drbg_kat_no_reseed kat149_t = {
+    13, kat149_entropyin, kat149_nonce, kat149_persstr,
+    kat149_addin0, kat149_addin1, kat149_retbits
+};
+static const struct drbg_kat kat149 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat149_t
+};
+
+static const unsigned char kat150_entropyin[] = {
+    0x94, 0xc6, 0x97, 0x57, 0xc9, 0x75, 0xe5, 0x3c, 0xa9, 0x44, 0xcb, 0xe8,
+    0xf7, 0x68, 0x6f, 0x85,
+};
+static const unsigned char kat150_nonce[] = {
+    0x6e, 0x14, 0x5c, 0xc7, 0xd7, 0x2d, 0xec, 0x57,
+};
+static const unsigned char kat150_persstr[] = {0};
+static const unsigned char kat150_addin0[] = {
+    0xce, 0x08, 0x94, 0x6b, 0x04, 0xfd, 0x83, 0x13, 0xdc, 0xda, 0x8c, 0xde,
+    0x3b, 0x0f, 0xf9, 0xdf,
+};
+static const unsigned char kat150_addin1[] = {
+    0x9f, 0xfc, 0x93, 0x9d, 0x30, 0x5a, 0xe5, 0x86, 0xd8, 0x6a, 0x1a, 0x14,
+    0x70, 0x32, 0x68, 0x0b,
+};
+static const unsigned char kat150_retbits[] = {
+    0xb1, 0xd7, 0xb3, 0x87, 0xa9, 0xf6, 0x7b, 0x91, 0x50, 0x55, 0xe6, 0x82,
+    0x98, 0xe0, 0x37, 0x73, 0xa0, 0x19, 0x75, 0x56, 0xf8, 0xd4, 0xb7, 0xe0,
+    0x29, 0x52, 0x03, 0x35, 0xef, 0xdc, 0xe2, 0xac, 0xb0, 0xd4, 0xd4, 0xcd,
+    0xae, 0x8a, 0xf8, 0xc0, 0x9f, 0xb5, 0x7a, 0x21, 0x5f, 0x20, 0x87, 0xab,
+    0xb8, 0x4e, 0xc8, 0x5b, 0x12, 0xdc, 0x3a, 0x85, 0x3d, 0x73, 0xa4, 0xdd,
+    0x11, 0x43, 0x00, 0xc5,
+};
+static const struct drbg_kat_no_reseed kat150_t = {
+    14, kat150_entropyin, kat150_nonce, kat150_persstr,
+    kat150_addin0, kat150_addin1, kat150_retbits
+};
+static const struct drbg_kat kat150 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat150_t
+};
+
+static const unsigned char kat151_entropyin[] = {
+    0xab, 0xa3, 0x6f, 0xf7, 0xa5, 0x35, 0x37, 0x45, 0x4b, 0x5c, 0xb2, 0x68,
+    0x39, 0x17, 0x15, 0x40,
+};
+static const unsigned char kat151_nonce[] = {
+    0x68, 0x71, 0xc0, 0xf5, 0x26, 0xfb, 0xcd, 0xc7,
+};
+static const unsigned char kat151_persstr[] = {
+    0xdb, 0xc4, 0x4a, 0xf4, 0x98, 0x16, 0x1f, 0x1f, 0x2a, 0xf6, 0xfc, 0xe6,
+    0x6c, 0xcc, 0x30, 0xa8,
+};
+static const unsigned char kat151_addin0[] = {0};
+static const unsigned char kat151_addin1[] = {0};
+static const unsigned char kat151_retbits[] = {
+    0xaf, 0x68, 0x6e, 0x9a, 0xaf, 0x10, 0xaa, 0xbc, 0xbb, 0x44, 0xb3, 0x74,
+    0x89, 0x53, 0xad, 0x18, 0x5d, 0xbf, 0x12, 0x89, 0x8e, 0x52, 0x4d, 0x04,
+    0x08, 0x61, 0x02, 0xe4, 0x5f, 0x38, 0x41, 0xc6, 0x50, 0xf6, 0x23, 0xf4,
+    0x8f, 0x54, 0x2c, 0xaa, 0x14, 0x79, 0x3e, 0x4f, 0xcb, 0xbc, 0xf2, 0xe4,
+    0x61, 0xbe, 0x1c, 0x01, 0xed, 0x8f, 0x1f, 0x48, 0xb9, 0x70, 0x4d, 0x79,
+    0xa8, 0xeb, 0xf7, 0x9d,
+};
+static const struct drbg_kat_no_reseed kat151_t = {
+    0, kat151_entropyin, kat151_nonce, kat151_persstr,
+    kat151_addin0, kat151_addin1, kat151_retbits
+};
+static const struct drbg_kat kat151 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat151_t
+};
+
+static const unsigned char kat152_entropyin[] = {
+    0x47, 0xaf, 0xb8, 0x3e, 0x3a, 0xda, 0x22, 0x0f, 0x7d, 0x7e, 0x63, 0x82,
+    0xa8, 0xb3, 0x8c, 0xbb,
+};
+static const unsigned char kat152_nonce[] = {
+    0x7a, 0xb8, 0xae, 0x9b, 0xac, 0x8b, 0x15, 0xa5,
+};
+static const unsigned char kat152_persstr[] = {
+    0x8b, 0xec, 0x1c, 0xb2, 0xd1, 0x80, 0xb3, 0x67, 0x7c, 0xd1, 0xa8, 0x60,
+    0x4b, 0x61, 0x4d, 0xbe,
+};
+static const unsigned char kat152_addin0[] = {0};
+static const unsigned char kat152_addin1[] = {0};
+static const unsigned char kat152_retbits[] = {
+    0x90, 0xcf, 0x1d, 0x9e, 0x65, 0xd9, 0x76, 0xca, 0xce, 0x2f, 0x20, 0xe7,
+    0x81, 0x47, 0xd5, 0x04, 0x0d, 0x02, 0x23, 0x7e, 0x04, 0x17, 0x3f, 0x1f,
+    0x37, 0x10, 0xe5, 0x22, 0x7d, 0xcb, 0x85, 0x64, 0x68, 0x4f, 0x2e, 0xba,
+    0x38, 0xe1, 0xde, 0xf7, 0x2b, 0x93, 0xbe, 0xdb, 0x44, 0x85, 0xf2, 0xb8,
+    0x17, 0xee, 0x66, 0xc1, 0x89, 0x02, 0x4b, 0x2a, 0x12, 0x73, 0x65, 0xbc,
+    0x83, 0x50, 0x08, 0x71,
+};
+static const struct drbg_kat_no_reseed kat152_t = {
+    1, kat152_entropyin, kat152_nonce, kat152_persstr,
+    kat152_addin0, kat152_addin1, kat152_retbits
+};
+static const struct drbg_kat kat152 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat152_t
+};
+
+static const unsigned char kat153_entropyin[] = {
+    0xbb, 0x69, 0x93, 0xaf, 0xf4, 0x80, 0x4a, 0x87, 0xdd, 0x42, 0x59, 0x73,
+    0xfd, 0xe3, 0x53, 0x11,
+};
+static const unsigned char kat153_nonce[] = {
+    0xfb, 0x14, 0x70, 0x0b, 0x33, 0x5a, 0x01, 0x46,
+};
+static const unsigned char kat153_persstr[] = {
+    0x1e, 0xb0, 0x65, 0x44, 0xca, 0xa8, 0x6e, 0x2a, 0xc4, 0x58, 0x8a, 0xa8,
+    0x51, 0xe8, 0xfc, 0x0e,
+};
+static const unsigned char kat153_addin0[] = {0};
+static const unsigned char kat153_addin1[] = {0};
+static const unsigned char kat153_retbits[] = {
+    0x4e, 0xe7, 0x27, 0x07, 0x3a, 0xba, 0xa3, 0xd7, 0x41, 0x8d, 0x6b, 0x3e,
+    0x3b, 0xd4, 0x67, 0xc9, 0x28, 0x48, 0x54, 0x42, 0x3b, 0xa6, 0xd4, 0xef,
+    0x02, 0xb2, 0xda, 0xbf, 0x14, 0xb9, 0xb8, 0x24, 0xb2, 0x7a, 0xda, 0x2b,
+    0x4a, 0x42, 0xf7, 0xdd, 0x1c, 0xd3, 0x9d, 0xc4, 0x42, 0x0e, 0xe6, 0xe8,
+    0x43, 0xfa, 0x7f, 0x2e, 0xee, 0x06, 0xbb, 0x05, 0xc6, 0x47, 0xdc, 0xc0,
+    0xd6, 0x97, 0xc0, 0x09,
+};
+static const struct drbg_kat_no_reseed kat153_t = {
+    2, kat153_entropyin, kat153_nonce, kat153_persstr,
+    kat153_addin0, kat153_addin1, kat153_retbits
+};
+static const struct drbg_kat kat153 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat153_t
+};
+
+static const unsigned char kat154_entropyin[] = {
+    0xa0, 0x5d, 0x9d, 0x84, 0xa5, 0x0d, 0xe7, 0x97, 0x01, 0xc7, 0x59, 0x59,
+    0xaf, 0x26, 0xa8, 0xfa,
+};
+static const unsigned char kat154_nonce[] = {
+    0x7e, 0xde, 0x7f, 0x16, 0x30, 0xdc, 0x01, 0xf7,
+};
+static const unsigned char kat154_persstr[] = {
+    0x54, 0xf5, 0xd6, 0xe5, 0xd9, 0xb1, 0xfe, 0xb0, 0xa1, 0xc3, 0xd9, 0xa7,
+    0xec, 0x81, 0xdd, 0x98,
+};
+static const unsigned char kat154_addin0[] = {0};
+static const unsigned char kat154_addin1[] = {0};
+static const unsigned char kat154_retbits[] = {
+    0xf4, 0x7a, 0xab, 0x57, 0xdf, 0xff, 0x93, 0x1d, 0x4b, 0xfc, 0x75, 0xa0,
+    0x13, 0x11, 0x86, 0xf0, 0xf5, 0xc1, 0x50, 0x5e, 0x9c, 0x6c, 0x7e, 0xb9,
+    0x35, 0xe3, 0x1b, 0x49, 0xf1, 0x34, 0xef, 0xc0, 0x0e, 0x45, 0xfc, 0x96,
+    0x73, 0x58, 0xee, 0xc4, 0xa9, 0x21, 0xfd, 0xa0, 0xd0, 0x53, 0x7d, 0x9e,
+    0x4f, 0xb3, 0x3b, 0x26, 0x3d, 0xb8, 0xe0, 0x8e, 0x73, 0xf2, 0x1f, 0xe1,
+    0x75, 0x05, 0x19, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat154_t = {
+    3, kat154_entropyin, kat154_nonce, kat154_persstr,
+    kat154_addin0, kat154_addin1, kat154_retbits
+};
+static const struct drbg_kat kat154 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat154_t
+};
+
+static const unsigned char kat155_entropyin[] = {
+    0x80, 0x7d, 0x1b, 0x10, 0x96, 0xe3, 0xd7, 0xf7, 0x89, 0x03, 0x6d, 0x64,
+    0x4d, 0xfb, 0x9e, 0x8b,
+};
+static const unsigned char kat155_nonce[] = {
+    0x8c, 0xd7, 0x7f, 0x71, 0xcc, 0xd8, 0xa3, 0x22,
+};
+static const unsigned char kat155_persstr[] = {
+    0x4f, 0x72, 0x74, 0x5e, 0x2f, 0x2a, 0xa5, 0x43, 0x61, 0x89, 0xdb, 0x92,
+    0x27, 0x82, 0x0e, 0x46,
+};
+static const unsigned char kat155_addin0[] = {0};
+static const unsigned char kat155_addin1[] = {0};
+static const unsigned char kat155_retbits[] = {
+    0xff, 0x4a, 0xe0, 0x06, 0x4c, 0x25, 0xfc, 0xef, 0x07, 0x4a, 0xb3, 0x65,
+    0x0e, 0xb6, 0xd3, 0x04, 0x4f, 0x86, 0x68, 0x7e, 0x6d, 0xb2, 0x26, 0x29,
+    0x99, 0x2b, 0x08, 0xed, 0x07, 0x8c, 0x65, 0xd0, 0x3d, 0xaf, 0x62, 0x41,
+    0xa3, 0x10, 0xe5, 0x76, 0x3c, 0x29, 0x86, 0x63, 0x84, 0x8e, 0x32, 0xd0,
+    0x61, 0x4e, 0x98, 0x98, 0x9a, 0x16, 0xd3, 0x7d, 0xc1, 0x72, 0x91, 0x35,
+    0xfc, 0xa5, 0xe6, 0x2e,
+};
+static const struct drbg_kat_no_reseed kat155_t = {
+    4, kat155_entropyin, kat155_nonce, kat155_persstr,
+    kat155_addin0, kat155_addin1, kat155_retbits
+};
+static const struct drbg_kat kat155 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat155_t
+};
+
+static const unsigned char kat156_entropyin[] = {
+    0x1a, 0xbc, 0xe2, 0x1f, 0x12, 0x33, 0x68, 0xb2, 0x6c, 0x66, 0x56, 0xb0,
+    0xce, 0xbc, 0x03, 0xe8,
+};
+static const unsigned char kat156_nonce[] = {
+    0x1f, 0x7a, 0x6d, 0x5b, 0xc2, 0xcb, 0x97, 0x59,
+};
+static const unsigned char kat156_persstr[] = {
+    0x00, 0xcd, 0x25, 0x9b, 0xb8, 0x7e, 0x4e, 0x6e, 0x21, 0x3e, 0xd4, 0x4e,
+    0xec, 0x19, 0xd9, 0x9d,
+};
+static const unsigned char kat156_addin0[] = {0};
+static const unsigned char kat156_addin1[] = {0};
+static const unsigned char kat156_retbits[] = {
+    0x86, 0xc0, 0x0d, 0x31, 0x81, 0xc1, 0xb6, 0x06, 0xc5, 0x1f, 0x90, 0x98,
+    0x93, 0x83, 0xb4, 0xb8, 0x92, 0x2e, 0x4a, 0x19, 0x0b, 0x94, 0x01, 0x65,
+    0x8f, 0x8d, 0x45, 0x13, 0x69, 0x7c, 0xa7, 0xd5, 0x84, 0xf5, 0xfc, 0xce,
+    0xb3, 0x32, 0x4f, 0x62, 0x4c, 0x47, 0x81, 0xdf, 0xe5, 0x5c, 0x0d, 0xba,
+    0x2d, 0x66, 0xbd, 0x85, 0x8f, 0xb6, 0x43, 0xf2, 0x3c, 0xe5, 0xd6, 0x7e,
+    0x57, 0x25, 0x00, 0x07,
+};
+static const struct drbg_kat_no_reseed kat156_t = {
+    5, kat156_entropyin, kat156_nonce, kat156_persstr,
+    kat156_addin0, kat156_addin1, kat156_retbits
+};
+static const struct drbg_kat kat156 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat156_t
+};
+
+static const unsigned char kat157_entropyin[] = {
+    0x06, 0xd5, 0xfb, 0x81, 0x4c, 0xa4, 0xb2, 0xba, 0xc9, 0xe1, 0xcf, 0xba,
+    0x0f, 0x13, 0x69, 0x9d,
+};
+static const unsigned char kat157_nonce[] = {
+    0x0e, 0xa8, 0x7b, 0x9f, 0x3b, 0xb1, 0xe6, 0x29,
+};
+static const unsigned char kat157_persstr[] = {
+    0xf6, 0x36, 0x79, 0xdf, 0xa3, 0x53, 0x70, 0x3f, 0x12, 0xe7, 0x23, 0x61,
+    0x73, 0xc7, 0xd3, 0x20,
+};
+static const unsigned char kat157_addin0[] = {0};
+static const unsigned char kat157_addin1[] = {0};
+static const unsigned char kat157_retbits[] = {
+    0xe0, 0xc8, 0xff, 0x1f, 0x1d, 0x2c, 0x69, 0xaf, 0xca, 0xe0, 0xb7, 0x3b,
+    0xe8, 0xb3, 0xc4, 0xc7, 0x41, 0x3f, 0x7f, 0xbc, 0xbe, 0xfc, 0x3b, 0xcf,
+    0x1e, 0x68, 0x8d, 0x2a, 0x7d, 0x08, 0x49, 0xfd, 0xee, 0x60, 0xbd, 0xe9,
+    0x1a, 0x0f, 0xb1, 0xa5, 0xef, 0x4b, 0xf3, 0xdf, 0xb3, 0x36, 0xb7, 0x3e,
+    0xd0, 0x47, 0xdf, 0xa7, 0x74, 0x77, 0xa5, 0x1c, 0x6d, 0xee, 0x81, 0x72,
+    0x63, 0xa2, 0x0c, 0x37,
+};
+static const struct drbg_kat_no_reseed kat157_t = {
+    6, kat157_entropyin, kat157_nonce, kat157_persstr,
+    kat157_addin0, kat157_addin1, kat157_retbits
+};
+static const struct drbg_kat kat157 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat157_t
+};
+
+static const unsigned char kat158_entropyin[] = {
+    0xdd, 0x3b, 0x7c, 0xfc, 0x51, 0x8c, 0x18, 0x0c, 0xf2, 0x89, 0xf1, 0x45,
+    0x25, 0x15, 0x0c, 0xa5,
+};
+static const unsigned char kat158_nonce[] = {
+    0x36, 0x94, 0x04, 0x3c, 0x71, 0xc2, 0xdd, 0xc5,
+};
+static const unsigned char kat158_persstr[] = {
+    0x3b, 0x1c, 0x08, 0xfa, 0xb6, 0x36, 0x18, 0x51, 0xd7, 0xa5, 0x18, 0xae,
+    0x35, 0x5b, 0x8c, 0x9b,
+};
+static const unsigned char kat158_addin0[] = {0};
+static const unsigned char kat158_addin1[] = {0};
+static const unsigned char kat158_retbits[] = {
+    0x59, 0x16, 0x4b, 0xac, 0x7a, 0x71, 0x4f, 0xcd, 0x5a, 0x45, 0x80, 0xfb,
+    0x54, 0xed, 0x4d, 0xdf, 0x99, 0xc3, 0x9c, 0xf5, 0x9c, 0x23, 0xf8, 0x5f,
+    0x6c, 0x52, 0x16, 0xf4, 0xe8, 0x9c, 0xf2, 0x8d, 0xa1, 0x59, 0x9f, 0x82,
+    0x57, 0xa6, 0xaf, 0xc3, 0x02, 0xed, 0x3a, 0x1d, 0xec, 0x00, 0x3f, 0xf4,
+    0x50, 0x91, 0x2c, 0x2b, 0xcd, 0x68, 0x2c, 0xd3, 0x40, 0x79, 0xcf, 0xb3,
+    0xcc, 0xf2, 0x59, 0x3a,
+};
+static const struct drbg_kat_no_reseed kat158_t = {
+    7, kat158_entropyin, kat158_nonce, kat158_persstr,
+    kat158_addin0, kat158_addin1, kat158_retbits
+};
+static const struct drbg_kat kat158 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat158_t
+};
+
+static const unsigned char kat159_entropyin[] = {
+    0xb7, 0x31, 0x4b, 0xac, 0xd0, 0xb3, 0xe9, 0xe2, 0x21, 0x4e, 0x11, 0xa4,
+    0x9c, 0x4f, 0xab, 0x54,
+};
+static const unsigned char kat159_nonce[] = {
+    0x8c, 0xd5, 0x9a, 0x9c, 0x39, 0x50, 0x1c, 0x0b,
+};
+static const unsigned char kat159_persstr[] = {
+    0xb6, 0xe3, 0xa4, 0x64, 0x4f, 0xb9, 0x13, 0xa5, 0x4c, 0x89, 0x21, 0xcb,
+    0xc1, 0x73, 0x72, 0x38,
+};
+static const unsigned char kat159_addin0[] = {0};
+static const unsigned char kat159_addin1[] = {0};
+static const unsigned char kat159_retbits[] = {
+    0xe9, 0x2c, 0x97, 0xcc, 0xbb, 0xd6, 0x01, 0x31, 0x78, 0xee, 0x06, 0xd0,
+    0x1a, 0xd2, 0xc9, 0xeb, 0x54, 0x64, 0xa7, 0xe3, 0x04, 0x32, 0xb9, 0x43,
+    0xe0, 0xb3, 0x71, 0xf1, 0x36, 0xa9, 0x94, 0xb9, 0xf5, 0x44, 0xf3, 0x7b,
+    0x60, 0x56, 0x1e, 0x10, 0x25, 0xb1, 0x2b, 0x5a, 0x15, 0xcb, 0x66, 0x1b,
+    0x30, 0x1b, 0x5d, 0xd4, 0x38, 0x4b, 0x8b, 0xc0, 0x0d, 0x1d, 0x72, 0xb3,
+    0xc6, 0x18, 0xf8, 0x75,
+};
+static const struct drbg_kat_no_reseed kat159_t = {
+    8, kat159_entropyin, kat159_nonce, kat159_persstr,
+    kat159_addin0, kat159_addin1, kat159_retbits
+};
+static const struct drbg_kat kat159 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat159_t
+};
+
+static const unsigned char kat160_entropyin[] = {
+    0xd6, 0x2b, 0x1f, 0xc2, 0xb0, 0x45, 0x71, 0x8a, 0x3f, 0xe5, 0x9d, 0xfa,
+    0xc4, 0xa1, 0xc0, 0x3b,
+};
+static const unsigned char kat160_nonce[] = {
+    0x41, 0x99, 0x17, 0xd5, 0x8a, 0x67, 0x56, 0xa5,
+};
+static const unsigned char kat160_persstr[] = {
+    0xf4, 0x79, 0x4b, 0xdc, 0x10, 0x9f, 0x13, 0x00, 0x4b, 0x89, 0x3b, 0x32,
+    0x83, 0xc0, 0x97, 0x7e,
+};
+static const unsigned char kat160_addin0[] = {0};
+static const unsigned char kat160_addin1[] = {0};
+static const unsigned char kat160_retbits[] = {
+    0x05, 0x42, 0xdf, 0xda, 0xb8, 0x8e, 0x34, 0x91, 0x63, 0xed, 0x9b, 0xa6,
+    0x34, 0xee, 0x76, 0x25, 0x7d, 0xc9, 0x27, 0x66, 0x61, 0xcd, 0x5d, 0xd2,
+    0xfa, 0xa9, 0x31, 0xbc, 0x3a, 0x2e, 0x9c, 0x2d, 0x17, 0xe5, 0x70, 0xff,
+    0xa1, 0xa5, 0xf1, 0x44, 0x96, 0xf0, 0xea, 0xc3, 0x33, 0x9e, 0xfd, 0xe4,
+    0x6a, 0xa4, 0x0e, 0x87, 0xf2, 0x1a, 0x98, 0x54, 0x95, 0xfd, 0xa3, 0x94,
+    0xf2, 0x06, 0x6e, 0xbb,
+};
+static const struct drbg_kat_no_reseed kat160_t = {
+    9, kat160_entropyin, kat160_nonce, kat160_persstr,
+    kat160_addin0, kat160_addin1, kat160_retbits
+};
+static const struct drbg_kat kat160 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat160_t
+};
+
+static const unsigned char kat161_entropyin[] = {
+    0x91, 0xb4, 0xaa, 0x7d, 0x56, 0x58, 0x32, 0xe9, 0x6a, 0x21, 0xd6, 0x80,
+    0xa0, 0xec, 0xdb, 0x4c,
+};
+static const unsigned char kat161_nonce[] = {
+    0x06, 0x09, 0x09, 0xe2, 0xce, 0x8b, 0x2d, 0xc8,
+};
+static const unsigned char kat161_persstr[] = {
+    0x5c, 0xba, 0xce, 0xb8, 0x9c, 0x15, 0x0d, 0x22, 0x9b, 0x51, 0x6c, 0x34,
+    0x93, 0x60, 0xf2, 0x7f,
+};
+static const unsigned char kat161_addin0[] = {0};
+static const unsigned char kat161_addin1[] = {0};
+static const unsigned char kat161_retbits[] = {
+    0xc0, 0x79, 0xc2, 0x91, 0x7e, 0x8f, 0x6b, 0x84, 0xc5, 0x8e, 0x02, 0x26,
+    0xad, 0x0b, 0x8a, 0x60, 0xa8, 0x7b, 0x88, 0x22, 0xa9, 0x90, 0x45, 0x9d,
+    0xe2, 0x4c, 0xc6, 0x55, 0x4c, 0x7f, 0x24, 0x1a, 0xff, 0x30, 0xcd, 0xea,
+    0x61, 0xa7, 0x48, 0x47, 0x0a, 0x58, 0xc9, 0x4a, 0x15, 0x0e, 0xbd, 0xdc,
+    0x35, 0x5c, 0x64, 0x4d, 0xd4, 0x78, 0x6e, 0x36, 0xf1, 0x7e, 0xcf, 0xce,
+    0xa7, 0x33, 0x9d, 0x42,
+};
+static const struct drbg_kat_no_reseed kat161_t = {
+    10, kat161_entropyin, kat161_nonce, kat161_persstr,
+    kat161_addin0, kat161_addin1, kat161_retbits
+};
+static const struct drbg_kat kat161 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat161_t
+};
+
+static const unsigned char kat162_entropyin[] = {
+    0x32, 0xe1, 0x66, 0xc0, 0x93, 0x8d, 0x6d, 0xa7, 0x21, 0xcf, 0xce, 0x23,
+    0x5a, 0x66, 0xa1, 0x80,
+};
+static const unsigned char kat162_nonce[] = {
+    0xeb, 0x68, 0x79, 0x96, 0xa8, 0xff, 0x63, 0x94,
+};
+static const unsigned char kat162_persstr[] = {
+    0x05, 0xb9, 0x9f, 0x8d, 0x9f, 0x10, 0x2c, 0x5f, 0xf6, 0xd0, 0xd4, 0x5c,
+    0x4d, 0x68, 0x5f, 0xf8,
+};
+static const unsigned char kat162_addin0[] = {0};
+static const unsigned char kat162_addin1[] = {0};
+static const unsigned char kat162_retbits[] = {
+    0xec, 0x5a, 0xe3, 0x97, 0x25, 0x72, 0x20, 0x45, 0x2e, 0x61, 0x05, 0xa5,
+    0xa2, 0x9f, 0x56, 0xd9, 0x33, 0x21, 0x32, 0xf5, 0x33, 0x8d, 0x19, 0xe8,
+    0x1a, 0xf6, 0xd3, 0x10, 0x22, 0xbb, 0x91, 0xf8, 0x7f, 0x04, 0xe4, 0x52,
+    0x0d, 0x50, 0x76, 0x61, 0x43, 0xd3, 0x53, 0x3e, 0x7b, 0x9d, 0x57, 0x0a,
+    0x80, 0x68, 0x84, 0xa3, 0xdf, 0xe2, 0x81, 0xe0, 0x00, 0xf7, 0x7e, 0x7b,
+    0x85, 0x59, 0x44, 0x34,
+};
+static const struct drbg_kat_no_reseed kat162_t = {
+    11, kat162_entropyin, kat162_nonce, kat162_persstr,
+    kat162_addin0, kat162_addin1, kat162_retbits
+};
+static const struct drbg_kat kat162 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat162_t
+};
+
+static const unsigned char kat163_entropyin[] = {
+    0x3a, 0x3d, 0x6a, 0xa9, 0xdb, 0x0f, 0x54, 0x0a, 0x37, 0xeb, 0x81, 0x50,
+    0x9d, 0xdb, 0x65, 0x5d,
+};
+static const unsigned char kat163_nonce[] = {
+    0x1f, 0xe8, 0xc2, 0x5b, 0x27, 0xee, 0x3a, 0xbe,
+};
+static const unsigned char kat163_persstr[] = {
+    0x8e, 0x15, 0xa5, 0xad, 0x7a, 0x5f, 0x29, 0x38, 0xeb, 0xdb, 0x5c, 0x08,
+    0x8b, 0xdc, 0xf3, 0x07,
+};
+static const unsigned char kat163_addin0[] = {0};
+static const unsigned char kat163_addin1[] = {0};
+static const unsigned char kat163_retbits[] = {
+    0x8d, 0x7e, 0xae, 0xe5, 0x0e, 0x87, 0xf0, 0xbc, 0x34, 0xa4, 0x9b, 0xe9,
+    0x4e, 0x7a, 0x4a, 0x64, 0xfd, 0x1e, 0xc9, 0x86, 0x1e, 0xf3, 0x34, 0x22,
+    0x2f, 0xfb, 0x15, 0xaf, 0x89, 0x29, 0xf9, 0xed, 0x42, 0xfb, 0x3f, 0xa6,
+    0x29, 0xd6, 0xba, 0x39, 0x70, 0x6b, 0x91, 0x93, 0xe1, 0x2b, 0xa2, 0x40,
+    0x44, 0x76, 0x17, 0x7c, 0x4f, 0x69, 0xbf, 0xd1, 0x8c, 0xfe, 0x59, 0x55,
+    0x5d, 0xca, 0x7c, 0x04,
+};
+static const struct drbg_kat_no_reseed kat163_t = {
+    12, kat163_entropyin, kat163_nonce, kat163_persstr,
+    kat163_addin0, kat163_addin1, kat163_retbits
+};
+static const struct drbg_kat kat163 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat163_t
+};
+
+static const unsigned char kat164_entropyin[] = {
+    0xc0, 0x84, 0x69, 0xf8, 0x36, 0xfc, 0x12, 0x48, 0xde, 0xd4, 0xed, 0xd8,
+    0xaf, 0x4d, 0x9d, 0xe8,
+};
+static const unsigned char kat164_nonce[] = {
+    0x74, 0x6e, 0xa2, 0xd7, 0x4c, 0xcc, 0xc4, 0xcd,
+};
+static const unsigned char kat164_persstr[] = {
+    0xa5, 0x18, 0x18, 0xae, 0x54, 0x37, 0x56, 0x25, 0x52, 0x65, 0x11, 0x80,
+    0xf3, 0xde, 0x5d, 0xae,
+};
+static const unsigned char kat164_addin0[] = {0};
+static const unsigned char kat164_addin1[] = {0};
+static const unsigned char kat164_retbits[] = {
+    0xa0, 0x8a, 0xee, 0xde, 0x46, 0x3f, 0xc9, 0xac, 0x48, 0x90, 0x7a, 0xb4,
+    0xb0, 0xb3, 0x9d, 0x6f, 0x86, 0xa8, 0x79, 0xf4, 0x21, 0x81, 0x61, 0x41,
+    0xa0, 0x52, 0xeb, 0x48, 0xd8, 0x7f, 0xf5, 0xd9, 0xb5, 0xb6, 0xcb, 0xfe,
+    0xef, 0xdd, 0x8c, 0xfc, 0x17, 0x72, 0xeb, 0x62, 0x67, 0x12, 0x45, 0x3f,
+    0x88, 0xec, 0x74, 0x7f, 0x6a, 0x05, 0xaf, 0x91, 0x7c, 0x9f, 0xa1, 0x61,
+    0xed, 0xe1, 0x1d, 0x7f,
+};
+static const struct drbg_kat_no_reseed kat164_t = {
+    13, kat164_entropyin, kat164_nonce, kat164_persstr,
+    kat164_addin0, kat164_addin1, kat164_retbits
+};
+static const struct drbg_kat kat164 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat164_t
+};
+
+static const unsigned char kat165_entropyin[] = {
+    0x0c, 0xe4, 0xc1, 0x82, 0x8f, 0x9c, 0x9f, 0x0a, 0xea, 0xb4, 0x95, 0x36,
+    0x72, 0x23, 0x59, 0x23,
+};
+static const unsigned char kat165_nonce[] = {
+    0x46, 0x4b, 0x42, 0xc9, 0xfc, 0x5b, 0x38, 0x31,
+};
+static const unsigned char kat165_persstr[] = {
+    0x48, 0xde, 0x34, 0xd8, 0x48, 0x29, 0x8d, 0xcf, 0x3f, 0x58, 0xc5, 0x2d,
+    0x96, 0xc7, 0x7b, 0xf5,
+};
+static const unsigned char kat165_addin0[] = {0};
+static const unsigned char kat165_addin1[] = {0};
+static const unsigned char kat165_retbits[] = {
+    0xa7, 0xd3, 0x79, 0x02, 0x26, 0xf5, 0xab, 0x5b, 0x38, 0x33, 0xdc, 0xc7,
+    0x63, 0xc2, 0xe9, 0xe7, 0xc5, 0xb7, 0x7d, 0x57, 0xc2, 0xfa, 0x26, 0x15,
+    0x47, 0xae, 0x0e, 0x39, 0xe9, 0x78, 0x4d, 0xf2, 0x69, 0xd0, 0x8b, 0xbd,
+    0x40, 0x36, 0x46, 0x2f, 0x3a, 0xcc, 0xc7, 0x1b, 0x37, 0x8b, 0x09, 0x41,
+    0xe9, 0x9c, 0x32, 0x7c, 0x4a, 0x50, 0x34, 0x39, 0xa9, 0x3b, 0x4e, 0xc7,
+    0xa0, 0x39, 0xa2, 0xa8,
+};
+static const struct drbg_kat_no_reseed kat165_t = {
+    14, kat165_entropyin, kat165_nonce, kat165_persstr,
+    kat165_addin0, kat165_addin1, kat165_retbits
+};
+static const struct drbg_kat kat165 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat165_t
+};
+
+static const unsigned char kat166_entropyin[] = {
+    0x70, 0x7a, 0x43, 0x07, 0x2e, 0xac, 0xb8, 0xce, 0xa9, 0x5f, 0xb8, 0x52,
+    0x1a, 0xe5, 0x16, 0x0b,
+};
+static const unsigned char kat166_nonce[] = {
+    0xfd, 0x62, 0x12, 0x13, 0x26, 0x16, 0x30, 0xad,
+};
+static const unsigned char kat166_persstr[] = {
+    0x6b, 0xf9, 0xa7, 0x2e, 0xaf, 0xe3, 0x5d, 0x58, 0x3c, 0x91, 0x5c, 0x95,
+    0x25, 0x74, 0x7b, 0xa0,
+};
+static const unsigned char kat166_addin0[] = {
+    0xe3, 0xdf, 0xd6, 0x92, 0x7c, 0x4a, 0xe1, 0x03, 0x43, 0x2e, 0xb6, 0x19,
+    0x63, 0x67, 0xec, 0xee,
+};
+static const unsigned char kat166_addin1[] = {
+    0xe1, 0x8c, 0xd5, 0x04, 0xe9, 0x40, 0x27, 0x53, 0x3c, 0xf3, 0x30, 0x71,
+    0xca, 0x93, 0x1b, 0x60,
+};
+static const unsigned char kat166_retbits[] = {
+    0xee, 0x46, 0x3c, 0xdc, 0x78, 0xdd, 0x25, 0x3c, 0x44, 0x66, 0xdd, 0xc2,
+    0xe3, 0x5c, 0xc4, 0xa9, 0x1a, 0xf2, 0x0a, 0xd3, 0xb3, 0x39, 0x66, 0x69,
+    0xce, 0xf5, 0x22, 0x1b, 0x0a, 0x9c, 0xcc, 0x5d, 0xfc, 0x72, 0x3b, 0x2f,
+    0xe1, 0xe5, 0x7f, 0xa2, 0x6d, 0xd0, 0x30, 0xad, 0x0b, 0x6e, 0xa1, 0x4e,
+    0xcb, 0x89, 0xf9, 0x1c, 0x4b, 0xc6, 0x93, 0x82, 0xa0, 0x1d, 0x8d, 0xfa,
+    0x6f, 0x1d, 0xff, 0x8a,
+};
+static const struct drbg_kat_no_reseed kat166_t = {
+    0, kat166_entropyin, kat166_nonce, kat166_persstr,
+    kat166_addin0, kat166_addin1, kat166_retbits
+};
+static const struct drbg_kat kat166 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat166_t
+};
+
+static const unsigned char kat167_entropyin[] = {
+    0x35, 0x67, 0xac, 0x54, 0xb9, 0x03, 0xfd, 0x5d, 0xdc, 0x57, 0x23, 0x4c,
+    0x31, 0x9b, 0x14, 0x15,
+};
+static const unsigned char kat167_nonce[] = {
+    0x8f, 0x75, 0xc5, 0x6a, 0x85, 0x77, 0x21, 0x92,
+};
+static const unsigned char kat167_persstr[] = {
+    0xd1, 0xe3, 0xff, 0xed, 0x85, 0x21, 0x1c, 0x40, 0x8e, 0x31, 0xdb, 0x12,
+    0xe8, 0x5b, 0x75, 0xdb,
+};
+static const unsigned char kat167_addin0[] = {
+    0xcc, 0x38, 0x84, 0x33, 0x5e, 0x19, 0x42, 0x7c, 0xaf, 0x09, 0xf0, 0x1c,
+    0x63, 0x4b, 0x30, 0x8a,
+};
+static const unsigned char kat167_addin1[] = {
+    0xf7, 0x73, 0x3d, 0x02, 0x51, 0xff, 0x02, 0xaf, 0xc0, 0xe9, 0x61, 0xc1,
+    0x12, 0x28, 0x84, 0xfc,
+};
+static const unsigned char kat167_retbits[] = {
+    0x28, 0xc6, 0x9b, 0xb4, 0x98, 0x76, 0x42, 0xe5, 0xa4, 0x67, 0x93, 0x8f,
+    0x52, 0xa7, 0x37, 0x14, 0xd3, 0x9a, 0xd0, 0x89, 0xee, 0x09, 0xda, 0xbe,
+    0x70, 0xd6, 0x90, 0x36, 0x17, 0x8f, 0x59, 0x98, 0x18, 0x6c, 0xc6, 0x45,
+    0x10, 0x0b, 0x56, 0xf9, 0x8e, 0xf4, 0x5c, 0xe3, 0x5b, 0x06, 0xf0, 0x9c,
+    0x26, 0x20, 0xba, 0x68, 0x0a, 0x5a, 0x03, 0xd3, 0xd9, 0x59, 0x43, 0xed,
+    0x17, 0x16, 0x0f, 0xe4,
+};
+static const struct drbg_kat_no_reseed kat167_t = {
+    1, kat167_entropyin, kat167_nonce, kat167_persstr,
+    kat167_addin0, kat167_addin1, kat167_retbits
+};
+static const struct drbg_kat kat167 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat167_t
+};
+
+static const unsigned char kat168_entropyin[] = {
+    0x41, 0x76, 0x72, 0x58, 0xe0, 0x6e, 0x50, 0x11, 0x24, 0xf3, 0xdb, 0x8b,
+    0xe4, 0x58, 0xd3, 0xbf,
+};
+static const unsigned char kat168_nonce[] = {
+    0xde, 0x8f, 0xa0, 0xa7, 0x9f, 0x1a, 0x7f, 0x0c,
+};
+static const unsigned char kat168_persstr[] = {
+    0x9d, 0xab, 0x2f, 0x46, 0xd2, 0x2d, 0x37, 0x86, 0x08, 0xe2, 0x1f, 0xc2,
+    0x37, 0xe9, 0x98, 0x71,
+};
+static const unsigned char kat168_addin0[] = {
+    0xea, 0x41, 0xd1, 0x33, 0xb4, 0xf8, 0x6a, 0x35, 0x22, 0x7b, 0x76, 0x16,
+    0x7f, 0x51, 0xbb, 0x5f,
+};
+static const unsigned char kat168_addin1[] = {
+    0x71, 0x61, 0xe1, 0x2c, 0x6f, 0x65, 0xc1, 0x42, 0xba, 0xf9, 0x4f, 0x1a,
+    0x09, 0xe9, 0x4e, 0x22,
+};
+static const unsigned char kat168_retbits[] = {
+    0xb3, 0x90, 0xc9, 0x52, 0x0e, 0xad, 0x28, 0x82, 0x69, 0x2a, 0x29, 0x59,
+    0x3d, 0x16, 0x5c, 0x58, 0xbc, 0x66, 0x14, 0x62, 0x11, 0x2a, 0xf6, 0xd2,
+    0x5a, 0x57, 0x14, 0x73, 0xe6, 0x1f, 0x1c, 0xbc, 0xd0, 0x75, 0xe3, 0xad,
+    0x1c, 0xae, 0xeb, 0x51, 0xcb, 0x99, 0x28, 0x40, 0x51, 0xce, 0xa4, 0x5a,
+    0x17, 0x06, 0xe9, 0x84, 0xe2, 0x7c, 0x32, 0x84, 0xfc, 0x1e, 0x87, 0xab,
+    0x68, 0xa6, 0xf1, 0x46,
+};
+static const struct drbg_kat_no_reseed kat168_t = {
+    2, kat168_entropyin, kat168_nonce, kat168_persstr,
+    kat168_addin0, kat168_addin1, kat168_retbits
+};
+static const struct drbg_kat kat168 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat168_t
+};
+
+static const unsigned char kat169_entropyin[] = {
+    0x19, 0xdb, 0x2d, 0xcd, 0xc5, 0x7d, 0xf2, 0x1e, 0x55, 0xb6, 0x56, 0x4e,
+    0xae, 0x47, 0x41, 0x0b,
+};
+static const unsigned char kat169_nonce[] = {
+    0xeb, 0xec, 0x8e, 0xce, 0x62, 0xd3, 0x29, 0xb6,
+};
+static const unsigned char kat169_persstr[] = {
+    0x80, 0xba, 0xec, 0xa8, 0x2b, 0x3b, 0xa2, 0x07, 0xb9, 0xf3, 0x75, 0x08,
+    0x38, 0xbd, 0xe4, 0x98,
+};
+static const unsigned char kat169_addin0[] = {
+    0x5d, 0x74, 0xcd, 0xd7, 0xbc, 0xbe, 0x7b, 0xc9, 0x48, 0xb8, 0xf1, 0x3e,
+    0xfa, 0x83, 0x5a, 0xd4,
+};
+static const unsigned char kat169_addin1[] = {
+    0x17, 0xbb, 0x7c, 0xb9, 0x1b, 0x48, 0x11, 0xa5, 0xe7, 0xdb, 0x26, 0x78,
+    0x4c, 0xbb, 0xc2, 0xe5,
+};
+static const unsigned char kat169_retbits[] = {
+    0x26, 0x54, 0xd9, 0x86, 0x67, 0xf7, 0x56, 0x15, 0xfb, 0x6c, 0x74, 0xd5,
+    0xb9, 0x0b, 0x62, 0x3c, 0xcc, 0xb9, 0x62, 0x49, 0xe1, 0x4e, 0x08, 0xe8,
+    0x8d, 0x1c, 0xb5, 0xe0, 0x90, 0x93, 0x26, 0xb6, 0x77, 0x67, 0xa5, 0x73,
+    0xe0, 0xa4, 0xd1, 0xdf, 0x05, 0x7f, 0x2d, 0xe7, 0xa4, 0x95, 0xde, 0xae,
+    0xcb, 0xeb, 0x7e, 0x25, 0xe3, 0xaa, 0x82, 0xde, 0x55, 0x59, 0x08, 0xbf,
+    0xe3, 0xcc, 0x6a, 0x85,
+};
+static const struct drbg_kat_no_reseed kat169_t = {
+    3, kat169_entropyin, kat169_nonce, kat169_persstr,
+    kat169_addin0, kat169_addin1, kat169_retbits
+};
+static const struct drbg_kat kat169 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat169_t
+};
+
+static const unsigned char kat170_entropyin[] = {
+    0x64, 0xd7, 0xb4, 0x2c, 0x52, 0x64, 0x33, 0x76, 0xd8, 0xa1, 0x1b, 0x0d,
+    0xa5, 0xcc, 0xa5, 0xe6,
+};
+static const unsigned char kat170_nonce[] = {
+    0x6f, 0xeb, 0x03, 0x5f, 0x39, 0x14, 0x25, 0x14,
+};
+static const unsigned char kat170_persstr[] = {
+    0x3f, 0x12, 0xa6, 0xf2, 0x40, 0x01, 0xb9, 0x8c, 0x1f, 0x24, 0xab, 0xcf,
+    0xab, 0x68, 0x95, 0x08,
+};
+static const unsigned char kat170_addin0[] = {
+    0xfe, 0xe4, 0x82, 0xb1, 0xfe, 0xa0, 0x53, 0x65, 0xab, 0xa0, 0x7b, 0xc7,
+    0xc3, 0x35, 0x1c, 0x6d,
+};
+static const unsigned char kat170_addin1[] = {
+    0xaf, 0x13, 0x59, 0x83, 0xab, 0x81, 0x13, 0x91, 0x45, 0x35, 0x13, 0x49,
+    0x18, 0x78, 0xb5, 0xb5,
+};
+static const unsigned char kat170_retbits[] = {
+    0x0c, 0x21, 0xf6, 0x97, 0xf1, 0xb0, 0x0d, 0x22, 0x83, 0xae, 0xe4, 0xe7,
+    0xb7, 0xe1, 0x01, 0x33, 0x38, 0x6a, 0xb0, 0xab, 0xfa, 0xdb, 0x5e, 0x14,
+    0xbf, 0xe5, 0xb4, 0x52, 0xa6, 0xd9, 0x17, 0x46, 0x2a, 0x7b, 0xd0, 0xed,
+    0xa0, 0x6f, 0xa1, 0x41, 0xb1, 0xbc, 0x3e, 0xab, 0x4f, 0x47, 0x73, 0xa2,
+    0x40, 0xbe, 0x73, 0x51, 0xe3, 0x2a, 0x1d, 0xab, 0xdd, 0xc5, 0x7b, 0xae,
+    0x02, 0xd2, 0x6c, 0xd2,
+};
+static const struct drbg_kat_no_reseed kat170_t = {
+    4, kat170_entropyin, kat170_nonce, kat170_persstr,
+    kat170_addin0, kat170_addin1, kat170_retbits
+};
+static const struct drbg_kat kat170 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat170_t
+};
+
+static const unsigned char kat171_entropyin[] = {
+    0xa5, 0x5a, 0x5a, 0x07, 0x29, 0xc3, 0x9e, 0xfb, 0xc8, 0x6c, 0xe6, 0x4d,
+    0x91, 0x51, 0x03, 0x4e,
+};
+static const unsigned char kat171_nonce[] = {
+    0x10, 0xf1, 0x15, 0x57, 0x73, 0xfb, 0xcd, 0x3b,
+};
+static const unsigned char kat171_persstr[] = {
+    0x6c, 0x6f, 0x3f, 0x77, 0x80, 0x15, 0xb2, 0xd3, 0x34, 0x92, 0x2e, 0x7a,
+    0x13, 0xea, 0xd6, 0xe6,
+};
+static const unsigned char kat171_addin0[] = {
+    0x84, 0x10, 0x15, 0x5a, 0x9f, 0x4d, 0x40, 0xa3, 0x29, 0x8d, 0x5b, 0x0f,
+    0x42, 0xc0, 0xef, 0x46,
+};
+static const unsigned char kat171_addin1[] = {
+    0xfd, 0x91, 0x1c, 0x8b, 0xb6, 0xff, 0x14, 0xe7, 0xd7, 0x6a, 0x61, 0x1a,
+    0xdd, 0xda, 0x72, 0x11,
+};
+static const unsigned char kat171_retbits[] = {
+    0x16, 0x5f, 0x07, 0xd1, 0x4b, 0xb1, 0xb3, 0x7b, 0xd9, 0xe0, 0x94, 0x9e,
+    0x7b, 0x0c, 0x0d, 0xfa, 0xdd, 0x06, 0x7a, 0xdf, 0x15, 0xb6, 0x6c, 0xb3,
+    0x96, 0xe6, 0x44, 0x4b, 0xcd, 0xf1, 0x1b, 0xc2, 0x34, 0xb0, 0xd5, 0x9b,
+    0x23, 0x17, 0x21, 0x4a, 0x9c, 0xde, 0x72, 0xe5, 0x32, 0xf3, 0x00, 0xc9,
+    0xd0, 0x90, 0x7f, 0xf5, 0x9e, 0x62, 0x12, 0x82, 0x6a, 0x92, 0x0f, 0xd9,
+    0x2b, 0x53, 0xad, 0xf7,
+};
+static const struct drbg_kat_no_reseed kat171_t = {
+    5, kat171_entropyin, kat171_nonce, kat171_persstr,
+    kat171_addin0, kat171_addin1, kat171_retbits
+};
+static const struct drbg_kat kat171 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat171_t
+};
+
+static const unsigned char kat172_entropyin[] = {
+    0x53, 0xea, 0x1b, 0xef, 0x71, 0x12, 0xfd, 0xcb, 0x15, 0x51, 0x36, 0x16,
+    0xae, 0x7e, 0x07, 0x03,
+};
+static const unsigned char kat172_nonce[] = {
+    0xca, 0xac, 0x5b, 0x2f, 0xbf, 0x5b, 0xd1, 0xb8,
+};
+static const unsigned char kat172_persstr[] = {
+    0x79, 0x04, 0x26, 0x8d, 0x84, 0x6f, 0x81, 0x41, 0xcd, 0x78, 0x3e, 0xcb,
+    0xa6, 0xef, 0xc9, 0x01,
+};
+static const unsigned char kat172_addin0[] = {
+    0x03, 0x64, 0xae, 0xea, 0xf7, 0x42, 0x4c, 0x92, 0xc2, 0x61, 0x1f, 0x33,
+    0x86, 0xfb, 0xe3, 0x8a,
+};
+static const unsigned char kat172_addin1[] = {
+    0x9c, 0x77, 0xd6, 0x80, 0xc5, 0xf2, 0x70, 0xae, 0xfa, 0x8a, 0x45, 0xb3,
+    0xe9, 0x35, 0x53, 0x30,
+};
+static const unsigned char kat172_retbits[] = {
+    0xe5, 0x6f, 0xa9, 0x81, 0x29, 0x23, 0x89, 0x0b, 0x94, 0x81, 0xee, 0x07,
+    0x80, 0xea, 0x23, 0xb2, 0x05, 0x94, 0x7e, 0x80, 0xf3, 0xe3, 0x8f, 0x55,
+    0xc2, 0x2d, 0xef, 0xce, 0x6c, 0xae, 0xa8, 0x4f, 0xd9, 0x85, 0x0f, 0x2c,
+    0x50, 0x9c, 0x51, 0x48, 0xe0, 0x1c, 0xd9, 0x77, 0x34, 0x8c, 0xc8, 0xb3,
+    0xcc, 0xab, 0xd3, 0xd7, 0x51, 0x5c, 0xc2, 0xca, 0x95, 0xd0, 0xbc, 0x13,
+    0x48, 0xba, 0xc5, 0xc2,
+};
+static const struct drbg_kat_no_reseed kat172_t = {
+    6, kat172_entropyin, kat172_nonce, kat172_persstr,
+    kat172_addin0, kat172_addin1, kat172_retbits
+};
+static const struct drbg_kat kat172 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat172_t
+};
+
+static const unsigned char kat173_entropyin[] = {
+    0x1f, 0xae, 0xf5, 0x93, 0x5c, 0xb8, 0x2d, 0x27, 0x08, 0x13, 0x25, 0x2c,
+    0x77, 0xef, 0x3d, 0x6c,
+};
+static const unsigned char kat173_nonce[] = {
+    0x75, 0xf6, 0x8a, 0x1b, 0x65, 0x8c, 0x72, 0x77,
+};
+static const unsigned char kat173_persstr[] = {
+    0x08, 0x15, 0xfa, 0x38, 0x8d, 0xb0, 0x3a, 0x89, 0x2d, 0xf4, 0x47, 0x4f,
+    0x19, 0xde, 0x31, 0xbc,
+};
+static const unsigned char kat173_addin0[] = {
+    0x9f, 0x92, 0x23, 0xae, 0x37, 0x86, 0xd3, 0x8c, 0x43, 0xe0, 0xe9, 0x2a,
+    0xa1, 0xbf, 0x5e, 0x3f,
+};
+static const unsigned char kat173_addin1[] = {
+    0x4d, 0x9c, 0x28, 0xcd, 0x69, 0x4e, 0x01, 0x6f, 0xaf, 0xbd, 0xe3, 0xcb,
+    0x30, 0x85, 0xb8, 0xd9,
+};
+static const unsigned char kat173_retbits[] = {
+    0xcd, 0x69, 0x3a, 0xab, 0x02, 0xec, 0x80, 0xa0, 0x4b, 0xeb, 0xcf, 0xef,
+    0x66, 0x04, 0x38, 0x4f, 0x48, 0xc8, 0xeb, 0x7d, 0x44, 0xd6, 0x91, 0xac,
+    0x35, 0xfb, 0x11, 0xe1, 0x81, 0x83, 0x88, 0x4b, 0x9e, 0x35, 0xd5, 0x8e,
+    0x62, 0xfc, 0x56, 0x7b, 0x9a, 0x3d, 0xa4, 0x0e, 0x3a, 0xee, 0xa7, 0x83,
+    0x11, 0x5e, 0x80, 0x19, 0x22, 0x09, 0x03, 0xab, 0x55, 0x9b, 0xe9, 0x83,
+    0x4c, 0x37, 0x77, 0x58,
+};
+static const struct drbg_kat_no_reseed kat173_t = {
+    7, kat173_entropyin, kat173_nonce, kat173_persstr,
+    kat173_addin0, kat173_addin1, kat173_retbits
+};
+static const struct drbg_kat kat173 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat173_t
+};
+
+static const unsigned char kat174_entropyin[] = {
+    0x0b, 0x8c, 0x52, 0x08, 0xd9, 0x11, 0x3c, 0xbe, 0x8a, 0x31, 0xcf, 0x3d,
+    0xe1, 0x43, 0x38, 0x1a,
+};
+static const unsigned char kat174_nonce[] = {
+    0x44, 0x9e, 0xbf, 0x57, 0xb8, 0x2a, 0xa5, 0xcb,
+};
+static const unsigned char kat174_persstr[] = {
+    0x7f, 0x60, 0x01, 0xd6, 0x0c, 0x31, 0xcf, 0x8a, 0x90, 0x4c, 0xb3, 0x18,
+    0xcb, 0x70, 0x04, 0x7b,
+};
+static const unsigned char kat174_addin0[] = {
+    0x4f, 0xe0, 0x45, 0xed, 0xbb, 0x98, 0x16, 0x0a, 0x42, 0x63, 0x5b, 0x77,
+    0x79, 0x6e, 0x8a, 0x97,
+};
+static const unsigned char kat174_addin1[] = {
+    0xd8, 0x96, 0x4e, 0x5f, 0xa8, 0x16, 0xea, 0x83, 0xd1, 0xa5, 0xab, 0xbd,
+    0x15, 0x68, 0xad, 0xaa,
+};
+static const unsigned char kat174_retbits[] = {
+    0xab, 0x1f, 0xba, 0xf1, 0x54, 0xa9, 0x07, 0x2b, 0x62, 0xc3, 0xd6, 0xbb,
+    0x9d, 0x01, 0x48, 0xac, 0xe4, 0xb4, 0xcd, 0xe0, 0x8d, 0x9a, 0x71, 0x2a,
+    0xa2, 0x94, 0x10, 0xab, 0x51, 0x4d, 0x03, 0xe3, 0x5d, 0xb3, 0xf4, 0x91,
+    0x80, 0x66, 0x73, 0x04, 0x18, 0x33, 0xa2, 0xeb, 0xeb, 0xe8, 0x70, 0x55,
+    0xf1, 0xf5, 0xfb, 0x64, 0xdd, 0x8e, 0x40, 0x8e, 0x3b, 0x99, 0x57, 0xd2,
+    0x1e, 0x66, 0xca, 0xa2,
+};
+static const struct drbg_kat_no_reseed kat174_t = {
+    8, kat174_entropyin, kat174_nonce, kat174_persstr,
+    kat174_addin0, kat174_addin1, kat174_retbits
+};
+static const struct drbg_kat kat174 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat174_t
+};
+
+static const unsigned char kat175_entropyin[] = {
+    0xae, 0x90, 0x6d, 0x89, 0x04, 0x15, 0x45, 0xc7, 0xef, 0x70, 0x71, 0xf5,
+    0x3e, 0xce, 0xea, 0x52,
+};
+static const unsigned char kat175_nonce[] = {
+    0x1f, 0x4b, 0x28, 0x4c, 0x36, 0xaa, 0xe3, 0xba,
+};
+static const unsigned char kat175_persstr[] = {
+    0xb9, 0x19, 0x98, 0xc3, 0x21, 0x83, 0x00, 0x6f, 0x7d, 0xf1, 0xc5, 0xd7,
+    0x1f, 0xba, 0xc5, 0x7b,
+};
+static const unsigned char kat175_addin0[] = {
+    0x86, 0x47, 0x5c, 0xa2, 0xb4, 0x84, 0xb8, 0xc6, 0xf3, 0x3b, 0x11, 0x22,
+    0x8b, 0xc6, 0x65, 0x05,
+};
+static const unsigned char kat175_addin1[] = {
+    0x0c, 0x34, 0xe0, 0xea, 0xe8, 0xfa, 0x94, 0xc2, 0x6c, 0xb5, 0x11, 0xc7,
+    0x9a, 0x49, 0x83, 0x3e,
+};
+static const unsigned char kat175_retbits[] = {
+    0x89, 0xeb, 0xf1, 0x81, 0x5e, 0x2c, 0x33, 0x32, 0x59, 0xd6, 0xaa, 0xa0,
+    0x07, 0xd1, 0x9c, 0xa5, 0xe0, 0x1e, 0x59, 0x87, 0x76, 0xac, 0x2a, 0xf5,
+    0x5a, 0xbf, 0x78, 0xc1, 0x1b, 0x4e, 0xd7, 0x44, 0xb6, 0xde, 0x87, 0x5a,
+    0x36, 0xf4, 0x52, 0xc2, 0x7a, 0xc4, 0xa0, 0xe6, 0x77, 0x93, 0x8b, 0x16,
+    0x1b, 0x2c, 0x00, 0xeb, 0x06, 0x59, 0xbd, 0xf2, 0xdc, 0x42, 0x5a, 0x89,
+    0xa2, 0x4a, 0xff, 0xd0,
+};
+static const struct drbg_kat_no_reseed kat175_t = {
+    9, kat175_entropyin, kat175_nonce, kat175_persstr,
+    kat175_addin0, kat175_addin1, kat175_retbits
+};
+static const struct drbg_kat kat175 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat175_t
+};
+
+static const unsigned char kat176_entropyin[] = {
+    0x1d, 0x0e, 0x60, 0xe6, 0x80, 0x17, 0x40, 0x42, 0x1d, 0x29, 0xf6, 0x5a,
+    0x60, 0x60, 0x6c, 0x1b,
+};
+static const unsigned char kat176_nonce[] = {
+    0x37, 0x03, 0x36, 0xdb, 0x08, 0x35, 0xe9, 0x1a,
+};
+static const unsigned char kat176_persstr[] = {
+    0x7a, 0x27, 0x3b, 0x4d, 0x99, 0x75, 0x35, 0x11, 0xfc, 0xf3, 0x4f, 0x3b,
+    0x1b, 0xb2, 0x9e, 0x16,
+};
+static const unsigned char kat176_addin0[] = {
+    0xd6, 0x44, 0xcb, 0x46, 0xe0, 0x1c, 0x07, 0x12, 0xef, 0x9d, 0xa4, 0xed,
+    0xe5, 0xca, 0x40, 0x7c,
+};
+static const unsigned char kat176_addin1[] = {
+    0x5c, 0x99, 0x05, 0x45, 0xee, 0xaf, 0x59, 0xde, 0x4d, 0x34, 0x9a, 0xe6,
+    0x66, 0x1f, 0x70, 0x41,
+};
+static const unsigned char kat176_retbits[] = {
+    0xda, 0xd5, 0x03, 0xe7, 0x20, 0x96, 0x02, 0xa8, 0x6f, 0x18, 0xd0, 0x1a,
+    0x2b, 0x05, 0x15, 0xb4, 0xb3, 0xd4, 0xa4, 0xc0, 0x37, 0xaf, 0x71, 0x86,
+    0xec, 0xba, 0x25, 0xdc, 0xb7, 0x81, 0xd9, 0x73, 0x11, 0x81, 0x0f, 0x98,
+    0xc1, 0x7c, 0x34, 0x17, 0x30, 0x61, 0xab, 0x78, 0xec, 0xcb, 0xd4, 0x91,
+    0x85, 0xcf, 0x5d, 0x4f, 0xb9, 0x1d, 0xff, 0xf4, 0xb0, 0xb6, 0x53, 0xdc,
+    0x15, 0x89, 0x92, 0x29,
+};
+static const struct drbg_kat_no_reseed kat176_t = {
+    10, kat176_entropyin, kat176_nonce, kat176_persstr,
+    kat176_addin0, kat176_addin1, kat176_retbits
+};
+static const struct drbg_kat kat176 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat176_t
+};
+
+static const unsigned char kat177_entropyin[] = {
+    0x67, 0x58, 0x85, 0x38, 0x3c, 0x6b, 0x3b, 0x00, 0x8e, 0x88, 0x49, 0x37,
+    0xed, 0xa7, 0x7b, 0xe8,
+};
+static const unsigned char kat177_nonce[] = {
+    0xb9, 0x1c, 0x7c, 0x06, 0x87, 0x85, 0x32, 0xf2,
+};
+static const unsigned char kat177_persstr[] = {
+    0x12, 0xce, 0x97, 0xb4, 0x0a, 0x1b, 0xcd, 0xe5, 0x03, 0x90, 0xe3, 0x15,
+    0xcd, 0x91, 0x1d, 0x53,
+};
+static const unsigned char kat177_addin0[] = {
+    0x10, 0x58, 0x43, 0x4c, 0xf9, 0xb3, 0x8f, 0xd7, 0x2a, 0x14, 0x0c, 0xf0,
+    0x94, 0x24, 0x36, 0xe3,
+};
+static const unsigned char kat177_addin1[] = {
+    0x59, 0x8b, 0xf8, 0x01, 0x43, 0x39, 0x82, 0x09, 0x66, 0xd9, 0x4b, 0xe1,
+    0xe2, 0xe9, 0xc8, 0x55,
+};
+static const unsigned char kat177_retbits[] = {
+    0x45, 0x48, 0x8c, 0xa0, 0xe2, 0xf2, 0x83, 0xf1, 0x74, 0x1b, 0xcb, 0xf4,
+    0x9a, 0x79, 0x36, 0x54, 0x59, 0x07, 0x52, 0x49, 0xe1, 0xc4, 0x17, 0x77,
+    0xf3, 0xe0, 0x08, 0xd8, 0x02, 0x0e, 0xe1, 0xf5, 0x98, 0xac, 0xa0, 0xad,
+    0x26, 0xed, 0xcd, 0x92, 0x0c, 0x85, 0x59, 0xd0, 0xea, 0xf7, 0xcc, 0x5d,
+    0x5a, 0x71, 0x44, 0x37, 0xc0, 0x45, 0x81, 0xa6, 0x4c, 0x74, 0x99, 0xe5,
+    0xf0, 0xbe, 0x08, 0x9c,
+};
+static const struct drbg_kat_no_reseed kat177_t = {
+    11, kat177_entropyin, kat177_nonce, kat177_persstr,
+    kat177_addin0, kat177_addin1, kat177_retbits
+};
+static const struct drbg_kat kat177 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat177_t
+};
+
+static const unsigned char kat178_entropyin[] = {
+    0x71, 0x23, 0x93, 0xa9, 0xf4, 0xa1, 0xb0, 0xbb, 0xab, 0xf4, 0xf4, 0x96,
+    0xe8, 0x17, 0x0a, 0xdc,
+};
+static const unsigned char kat178_nonce[] = {
+    0x0f, 0x59, 0x0c, 0x32, 0x39, 0xc6, 0xcf, 0x47,
+};
+static const unsigned char kat178_persstr[] = {
+    0xb7, 0x2b, 0x40, 0x97, 0xa9, 0xfb, 0x3d, 0x45, 0xbb, 0x06, 0x24, 0x15,
+    0xb6, 0xf2, 0xdf, 0xb1,
+};
+static const unsigned char kat178_addin0[] = {
+    0xe2, 0x7a, 0xde, 0x7c, 0x11, 0x86, 0x56, 0x55, 0x3f, 0x06, 0xec, 0x20,
+    0x19, 0x9b, 0x53, 0x70,
+};
+static const unsigned char kat178_addin1[] = {
+    0x4e, 0xb4, 0xfd, 0xa3, 0xff, 0xda, 0xd4, 0xf9, 0xdd, 0xaf, 0xd0, 0xd0,
+    0xbf, 0xec, 0xd4, 0x44,
+};
+static const unsigned char kat178_retbits[] = {
+    0x04, 0x49, 0xa8, 0x2a, 0x31, 0x7e, 0x22, 0xe5, 0xa7, 0xa6, 0x68, 0x4d,
+    0x08, 0xb8, 0xf6, 0x3e, 0x02, 0xd8, 0xb9, 0x08, 0x5d, 0x61, 0x9a, 0xb5,
+    0x6c, 0xde, 0x52, 0x2c, 0x86, 0x67, 0xd5, 0xf8, 0x8b, 0x2e, 0xa8, 0x83,
+    0x03, 0x29, 0x49, 0x1a, 0x5e, 0xa8, 0x28, 0xe0, 0xa3, 0x66, 0xae, 0x7e,
+    0x84, 0xf2, 0xcd, 0xee, 0x69, 0x8a, 0x92, 0x41, 0x18, 0x88, 0x83, 0xbe,
+    0x00, 0xc5, 0x33, 0xe8,
+};
+static const struct drbg_kat_no_reseed kat178_t = {
+    12, kat178_entropyin, kat178_nonce, kat178_persstr,
+    kat178_addin0, kat178_addin1, kat178_retbits
+};
+static const struct drbg_kat kat178 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat178_t
+};
+
+static const unsigned char kat179_entropyin[] = {
+    0x57, 0x66, 0x40, 0xf9, 0x76, 0xa6, 0x28, 0xb0, 0x9e, 0x98, 0xaf, 0x48,
+    0x3b, 0x64, 0x5e, 0x56,
+};
+static const unsigned char kat179_nonce[] = {
+    0x82, 0x2e, 0x8a, 0x10, 0xdf, 0x06, 0xd0, 0xfe,
+};
+static const unsigned char kat179_persstr[] = {
+    0x6d, 0x6a, 0x6f, 0x68, 0xbb, 0x38, 0x1c, 0x29, 0x1f, 0x3f, 0xa6, 0x21,
+    0xd6, 0xab, 0x64, 0xb2,
+};
+static const unsigned char kat179_addin0[] = {
+    0xb0, 0x5f, 0x14, 0xe4, 0x1f, 0x54, 0x33, 0x8c, 0x44, 0x15, 0xa5, 0xb5,
+    0xc8, 0xc5, 0x61, 0x99,
+};
+static const unsigned char kat179_addin1[] = {
+    0xc6, 0x84, 0x7c, 0x9e, 0xd7, 0x4c, 0x86, 0x9a, 0xc4, 0xa5, 0x6f, 0xf2,
+    0xd0, 0x95, 0x6d, 0x6b,
+};
+static const unsigned char kat179_retbits[] = {
+    0x5c, 0x6a, 0x7e, 0x58, 0xea, 0xcf, 0xa5, 0x8d, 0xca, 0x93, 0x99, 0xa3,
+    0xf9, 0xb6, 0xcb, 0x41, 0xd2, 0xbc, 0x24, 0xf6, 0x72, 0x58, 0x7d, 0xb2,
+    0x29, 0xbf, 0x22, 0x20, 0xc2, 0x85, 0x13, 0x47, 0xd4, 0x7d, 0xa1, 0xca,
+    0x0a, 0x6a, 0x13, 0x77, 0x96, 0x05, 0xdb, 0x90, 0xd9, 0x1a, 0x61, 0x48,
+    0x88, 0x18, 0xd3, 0x3b, 0x2a, 0x4a, 0xd6, 0x74, 0x09, 0x00, 0x68, 0x5f,
+    0x8e, 0xc6, 0x13, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat179_t = {
+    13, kat179_entropyin, kat179_nonce, kat179_persstr,
+    kat179_addin0, kat179_addin1, kat179_retbits
+};
+static const struct drbg_kat kat179 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat179_t
+};
+
+static const unsigned char kat180_entropyin[] = {
+    0x69, 0x65, 0x03, 0xc8, 0x48, 0x60, 0x51, 0x87, 0x84, 0xdd, 0x4c, 0x6c,
+    0x31, 0x71, 0x0f, 0x43,
+};
+static const unsigned char kat180_nonce[] = {
+    0xee, 0x52, 0xc0, 0xa4, 0xcd, 0x90, 0xdf, 0x1e,
+};
+static const unsigned char kat180_persstr[] = {
+    0x9a, 0x08, 0xd6, 0xb4, 0x80, 0xef, 0x3a, 0xc2, 0x00, 0xa1, 0x30, 0x87,
+    0x8d, 0x80, 0xd0, 0x79,
+};
+static const unsigned char kat180_addin0[] = {
+    0x5c, 0x51, 0x31, 0x59, 0x7b, 0xd3, 0xab, 0x02, 0x5c, 0xa0, 0x05, 0x79,
+    0xc8, 0x6f, 0xfd, 0xed,
+};
+static const unsigned char kat180_addin1[] = {
+    0xa8, 0xcc, 0x33, 0xc8, 0x51, 0xee, 0x11, 0xe4, 0x70, 0x1a, 0x32, 0x19,
+    0x7b, 0x61, 0x76, 0x23,
+};
+static const unsigned char kat180_retbits[] = {
+    0x9a, 0xfd, 0xc4, 0x54, 0xf5, 0xc2, 0xce, 0x29, 0x95, 0xfc, 0x7c, 0xcf,
+    0xb4, 0xe8, 0x67, 0x1a, 0x4b, 0x27, 0xdf, 0xcb, 0x1c, 0x02, 0xfe, 0xc6,
+    0x07, 0xaa, 0xfc, 0x64, 0x22, 0x65, 0x70, 0x96, 0xce, 0x18, 0x14, 0x10,
+    0x1b, 0x8a, 0x74, 0x3e, 0x2d, 0x4a, 0x2c, 0x4e, 0x2e, 0x8d, 0xa2, 0x57,
+    0x57, 0x8d, 0xe7, 0x10, 0x54, 0x12, 0xf3, 0x52, 0xa4, 0xcd, 0x14, 0xaf,
+    0x7d, 0xb0, 0xeb, 0x03,
+};
+static const struct drbg_kat_no_reseed kat180_t = {
+    14, kat180_entropyin, kat180_nonce, kat180_persstr,
+    kat180_addin0, kat180_addin1, kat180_retbits
+};
+static const struct drbg_kat kat180 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat180_t
+};
+
+static const unsigned char kat181_entropyin[] = {
+    0x6b, 0xdf, 0x53, 0x32, 0xbd, 0xce, 0x46, 0x55, 0xd4, 0x5c, 0x2c, 0xfe,
+    0xa8, 0x97, 0xb0, 0x00,
+};
+static const unsigned char kat181_nonce[] = {
+    0xe7, 0x8c, 0x55, 0x71, 0xc5, 0xf9, 0x26, 0xf9,
+};
+static const unsigned char kat181_persstr[] = {0};
+static const unsigned char kat181_addin0[] = {0};
+static const unsigned char kat181_addin1[] = {0};
+static const unsigned char kat181_retbits[] = {
+    0xe0, 0x71, 0x56, 0x88, 0x76, 0x5a, 0x32, 0x85, 0xe7, 0xb7, 0xdb, 0x55,
+    0x5f, 0x27, 0x79, 0x24, 0xe7, 0x17, 0x1f, 0x75, 0x41, 0xbf, 0x26, 0x12,
+    0x2b, 0x13, 0xdb, 0xaa, 0xa3, 0x9f, 0x9e, 0x2b, 0x03, 0x45, 0xc6, 0x59,
+    0x58, 0x3f, 0xf8, 0xc9, 0xcf, 0xd8, 0x88, 0xf1, 0xab, 0xd2, 0xf3, 0xb3,
+    0x6a, 0x7c, 0x9d, 0x47, 0xc6, 0x87, 0xb0, 0x1c, 0x81, 0x9a, 0x9f, 0x98,
+    0x88, 0x54, 0x2e, 0x0f,
+};
+static const struct drbg_kat_no_reseed kat181_t = {
+    0, kat181_entropyin, kat181_nonce, kat181_persstr,
+    kat181_addin0, kat181_addin1, kat181_retbits
+};
+static const struct drbg_kat kat181 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat181_t
+};
+
+static const unsigned char kat182_entropyin[] = {
+    0xa4, 0x73, 0x7d, 0x48, 0xa8, 0x93, 0x25, 0x07, 0x85, 0x79, 0xe6, 0x49,
+    0xe2, 0xfa, 0x65, 0xeb,
+};
+static const unsigned char kat182_nonce[] = {
+    0x6a, 0x79, 0x9a, 0x7a, 0x2f, 0x13, 0xe8, 0x13,
+};
+static const unsigned char kat182_persstr[] = {0};
+static const unsigned char kat182_addin0[] = {0};
+static const unsigned char kat182_addin1[] = {0};
+static const unsigned char kat182_retbits[] = {
+    0x75, 0x2a, 0x91, 0x6d, 0x98, 0x05, 0x18, 0xd9, 0xe7, 0xe4, 0x75, 0x99,
+    0x06, 0x6b, 0x45, 0x71, 0x46, 0x61, 0xf3, 0x41, 0x59, 0xf0, 0xc8, 0xce,
+    0xa8, 0xda, 0xbd, 0x59, 0x6a, 0x06, 0x6a, 0xff, 0x7a, 0xe6, 0xc2, 0x1e,
+    0x69, 0xa3, 0x56, 0xdd, 0x2e, 0xe0, 0xda, 0x55, 0x42, 0x9c, 0x67, 0x5a,
+    0xa6, 0xfa, 0x09, 0x00, 0x17, 0x3f, 0x54, 0x77, 0xcd, 0x7f, 0xd6, 0x49,
+    0xea, 0xe0, 0xc9, 0x9a,
+};
+static const struct drbg_kat_no_reseed kat182_t = {
+    1, kat182_entropyin, kat182_nonce, kat182_persstr,
+    kat182_addin0, kat182_addin1, kat182_retbits
+};
+static const struct drbg_kat kat182 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat182_t
+};
+
+static const unsigned char kat183_entropyin[] = {
+    0x99, 0xb4, 0xe9, 0xe5, 0xba, 0xaa, 0x99, 0xbf, 0x8b, 0x8a, 0x0c, 0x2c,
+    0xfd, 0x9a, 0x89, 0xce,
+};
+static const unsigned char kat183_nonce[] = {
+    0xf4, 0x8b, 0x31, 0x29, 0x41, 0xd3, 0x55, 0x4d,
+};
+static const unsigned char kat183_persstr[] = {0};
+static const unsigned char kat183_addin0[] = {0};
+static const unsigned char kat183_addin1[] = {0};
+static const unsigned char kat183_retbits[] = {
+    0x85, 0xcf, 0x14, 0x8c, 0x65, 0xec, 0xe7, 0x52, 0x5d, 0xea, 0x96, 0x34,
+    0x4d, 0xa6, 0x45, 0x11, 0x99, 0x49, 0x21, 0x85, 0xc8, 0xb8, 0xdf, 0xff,
+    0x50, 0x0d, 0xdd, 0x68, 0xca, 0xab, 0x50, 0xbd, 0x74, 0x18, 0x66, 0x93,
+    0x7a, 0x50, 0x1a, 0xf8, 0x76, 0xae, 0x84, 0x9b, 0x5b, 0x1b, 0x53, 0x30,
+    0xde, 0x65, 0xeb, 0xf3, 0x8e, 0x9d, 0x55, 0x96, 0x93, 0xfa, 0xe8, 0x05,
+    0xcc, 0xc9, 0xaa, 0xed,
+};
+static const struct drbg_kat_no_reseed kat183_t = {
+    2, kat183_entropyin, kat183_nonce, kat183_persstr,
+    kat183_addin0, kat183_addin1, kat183_retbits
+};
+static const struct drbg_kat kat183 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat183_t
+};
+
+static const unsigned char kat184_entropyin[] = {
+    0x7c, 0x1e, 0xf8, 0x46, 0xe7, 0xf3, 0xa7, 0xcf, 0xe5, 0xc7, 0xbb, 0x47,
+    0xe4, 0x6a, 0xa0, 0xe8,
+};
+static const unsigned char kat184_nonce[] = {
+    0x78, 0xeb, 0x00, 0x29, 0x55, 0xd2, 0x70, 0xd3,
+};
+static const unsigned char kat184_persstr[] = {0};
+static const unsigned char kat184_addin0[] = {0};
+static const unsigned char kat184_addin1[] = {0};
+static const unsigned char kat184_retbits[] = {
+    0xb7, 0x39, 0xf9, 0x53, 0x39, 0xe8, 0x3f, 0xe8, 0xa3, 0x39, 0x16, 0x2f,
+    0x1e, 0x96, 0xcc, 0x82, 0xb6, 0x7a, 0xf4, 0x17, 0x59, 0xf4, 0x83, 0x06,
+    0x4e, 0x61, 0xa0, 0x39, 0x13, 0x7a, 0xf0, 0x7d, 0x93, 0x4a, 0x0e, 0xb7,
+    0xca, 0x72, 0x84, 0xc1, 0x46, 0x86, 0xca, 0x04, 0x88, 0x95, 0x3e, 0xe4,
+    0x40, 0xf6, 0xcd, 0x11, 0x45, 0xd0, 0x76, 0x6f, 0x4f, 0xf1, 0xc7, 0x7b,
+    0x0d, 0x81, 0xd3, 0x61,
+};
+static const struct drbg_kat_no_reseed kat184_t = {
+    3, kat184_entropyin, kat184_nonce, kat184_persstr,
+    kat184_addin0, kat184_addin1, kat184_retbits
+};
+static const struct drbg_kat kat184 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat184_t
+};
+
+static const unsigned char kat185_entropyin[] = {
+    0x6f, 0x75, 0x0f, 0xb7, 0x3f, 0xbc, 0xb6, 0xdb, 0x57, 0x50, 0x6c, 0xf2,
+    0xde, 0xfa, 0xf6, 0xd4,
+};
+static const unsigned char kat185_nonce[] = {
+    0xa5, 0x2c, 0x92, 0x97, 0xe0, 0x2f, 0x42, 0x55,
+};
+static const unsigned char kat185_persstr[] = {0};
+static const unsigned char kat185_addin0[] = {0};
+static const unsigned char kat185_addin1[] = {0};
+static const unsigned char kat185_retbits[] = {
+    0x0c, 0xa7, 0x48, 0xfc, 0xb3, 0xba, 0x23, 0xbd, 0x04, 0x3f, 0x48, 0x50,
+    0x75, 0x85, 0x42, 0x52, 0x34, 0xec, 0x4a, 0x0f, 0x35, 0x0e, 0xfd, 0xcc,
+    0x87, 0xf9, 0x06, 0x2c, 0x8a, 0xe0, 0xcf, 0x1e, 0x03, 0x3b, 0x7d, 0xf8,
+    0x35, 0x7f, 0x5b, 0x0e, 0x4f, 0x7c, 0x21, 0xd4, 0xfb, 0xdc, 0xf8, 0x9c,
+    0xe0, 0x19, 0x9c, 0x25, 0x79, 0x02, 0x70, 0xfe, 0x67, 0xff, 0xee, 0xc2,
+    0x6c, 0xfc, 0x4d, 0x18,
+};
+static const struct drbg_kat_no_reseed kat185_t = {
+    4, kat185_entropyin, kat185_nonce, kat185_persstr,
+    kat185_addin0, kat185_addin1, kat185_retbits
+};
+static const struct drbg_kat kat185 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat185_t
+};
+
+static const unsigned char kat186_entropyin[] = {
+    0x44, 0xb6, 0xc3, 0x9a, 0x3a, 0xf6, 0xa4, 0x73, 0x14, 0x8e, 0x32, 0xd9,
+    0x79, 0x2b, 0x9e, 0xee,
+};
+static const unsigned char kat186_nonce[] = {
+    0xde, 0x44, 0xdd, 0x36, 0x00, 0x3e, 0x48, 0x22,
+};
+static const unsigned char kat186_persstr[] = {0};
+static const unsigned char kat186_addin0[] = {0};
+static const unsigned char kat186_addin1[] = {0};
+static const unsigned char kat186_retbits[] = {
+    0x10, 0x12, 0x20, 0x08, 0x7c, 0xa7, 0x70, 0xe4, 0x57, 0x4f, 0xd0, 0x5b,
+    0x2e, 0x88, 0x85, 0x1b, 0x48, 0x09, 0xcf, 0x21, 0xe6, 0x5e, 0xb0, 0xe3,
+    0xd1, 0xec, 0xda, 0x29, 0xaa, 0xcf, 0x2d, 0x93, 0xe7, 0x5d, 0x79, 0x3b,
+    0x99, 0x24, 0xae, 0xdd, 0x9b, 0x9a, 0x38, 0x84, 0x4d, 0xb4, 0x30, 0x47,
+    0x0d, 0x01, 0x5d, 0xa6, 0x04, 0x18, 0x75, 0x3f, 0x2e, 0x3c, 0x6a, 0x15,
+    0xf5, 0x58, 0xf4, 0xa9,
+};
+static const struct drbg_kat_no_reseed kat186_t = {
+    5, kat186_entropyin, kat186_nonce, kat186_persstr,
+    kat186_addin0, kat186_addin1, kat186_retbits
+};
+static const struct drbg_kat kat186 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat186_t
+};
+
+static const unsigned char kat187_entropyin[] = {
+    0xe4, 0xd1, 0xff, 0x1c, 0x3c, 0xd2, 0x78, 0x49, 0xa2, 0x97, 0xe5, 0xa9,
+    0x8e, 0xde, 0x08, 0x6a,
+};
+static const unsigned char kat187_nonce[] = {
+    0xf8, 0x9d, 0x58, 0xb0, 0x61, 0x7e, 0x5d, 0x10,
+};
+static const unsigned char kat187_persstr[] = {0};
+static const unsigned char kat187_addin0[] = {0};
+static const unsigned char kat187_addin1[] = {0};
+static const unsigned char kat187_retbits[] = {
+    0x54, 0xc4, 0x67, 0x97, 0xa3, 0x8e, 0x11, 0xc5, 0x43, 0x47, 0x78, 0x09,
+    0xd9, 0xd6, 0xed, 0x0a, 0xe4, 0x02, 0x02, 0x85, 0xed, 0xf9, 0x9e, 0x7e,
+    0xc9, 0x45, 0xcf, 0xcf, 0x21, 0xdd, 0xaa, 0x6d, 0x9a, 0x71, 0x85, 0x6b,
+    0xdb, 0xd6, 0x61, 0x3b, 0xf8, 0xe9, 0x7e, 0x0a, 0xf8, 0xd3, 0xc4, 0xce,
+    0xdd, 0x0d, 0xfc, 0xfb, 0x47, 0x42, 0xa2, 0xef, 0x0a, 0x44, 0x3e, 0xf8,
+    0x78, 0x96, 0x0e, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat187_t = {
+    6, kat187_entropyin, kat187_nonce, kat187_persstr,
+    kat187_addin0, kat187_addin1, kat187_retbits
+};
+static const struct drbg_kat kat187 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat187_t
+};
+
+static const unsigned char kat188_entropyin[] = {
+    0x15, 0x14, 0xbe, 0x70, 0x6e, 0x4c, 0x16, 0x72, 0x90, 0x55, 0x06, 0xb0,
+    0xc5, 0x53, 0x47, 0xf2,
+};
+static const unsigned char kat188_nonce[] = {
+    0xad, 0x8d, 0x88, 0x9f, 0x2b, 0x91, 0xa6, 0xdd,
+};
+static const unsigned char kat188_persstr[] = {0};
+static const unsigned char kat188_addin0[] = {0};
+static const unsigned char kat188_addin1[] = {0};
+static const unsigned char kat188_retbits[] = {
+    0xb3, 0x64, 0x4a, 0x6d, 0x16, 0x34, 0x0e, 0xf8, 0xb2, 0x8a, 0xd0, 0x6f,
+    0x4c, 0xbf, 0xd5, 0xe7, 0x99, 0xf0, 0x80, 0xd4, 0xb2, 0xf8, 0x31, 0xfd,
+    0x90, 0xb3, 0x13, 0xc8, 0x62, 0xd5, 0x76, 0x3d, 0x22, 0xb1, 0x21, 0x7f,
+    0xe3, 0xd4, 0xf0, 0x7c, 0x00, 0x6a, 0x39, 0x89, 0x5d, 0x46, 0xd5, 0x24,
+    0x70, 0xb3, 0xf8, 0xb7, 0x75, 0x21, 0xe1, 0x41, 0xf6, 0x8b, 0x06, 0xb5,
+    0x4c, 0x38, 0x66, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat188_t = {
+    7, kat188_entropyin, kat188_nonce, kat188_persstr,
+    kat188_addin0, kat188_addin1, kat188_retbits
+};
+static const struct drbg_kat kat188 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat188_t
+};
+
+static const unsigned char kat189_entropyin[] = {
+    0x83, 0x35, 0xa4, 0x33, 0xa8, 0x0d, 0x5a, 0x3e, 0x8a, 0xb1, 0xf7, 0x38,
+    0x55, 0xf9, 0x7a, 0x9b,
+};
+static const unsigned char kat189_nonce[] = {
+    0x02, 0x62, 0xb4, 0x7c, 0x2a, 0xb5, 0xfc, 0xba,
+};
+static const unsigned char kat189_persstr[] = {0};
+static const unsigned char kat189_addin0[] = {0};
+static const unsigned char kat189_addin1[] = {0};
+static const unsigned char kat189_retbits[] = {
+    0x66, 0xa0, 0x3a, 0x0b, 0x3b, 0x2e, 0xf8, 0xd0, 0x4e, 0x01, 0xda, 0x6e,
+    0x31, 0xbc, 0x90, 0x02, 0xeb, 0xac, 0xa9, 0x8d, 0x63, 0xfd, 0xde, 0xb0,
+    0x7f, 0xa3, 0xe0, 0x65, 0x0a, 0x32, 0xe1, 0x42, 0xfc, 0xab, 0x99, 0x63,
+    0xf0, 0x6b, 0xa8, 0x8c, 0xd5, 0x8b, 0xe7, 0x5a, 0x99, 0xdf, 0xa1, 0x3b,
+    0x4f, 0x8f, 0xea, 0xe6, 0xf8, 0x4c, 0xe2, 0xde, 0x4d, 0x20, 0x19, 0x92,
+    0x23, 0x1f, 0xf3, 0xb8,
+};
+static const struct drbg_kat_no_reseed kat189_t = {
+    8, kat189_entropyin, kat189_nonce, kat189_persstr,
+    kat189_addin0, kat189_addin1, kat189_retbits
+};
+static const struct drbg_kat kat189 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat189_t
+};
+
+static const unsigned char kat190_entropyin[] = {
+    0x37, 0xfa, 0xeb, 0x0b, 0x3f, 0x85, 0x37, 0x2c, 0xcb, 0x44, 0x22, 0xe3,
+    0x66, 0x90, 0xe9, 0x6c,
+};
+static const unsigned char kat190_nonce[] = {
+    0xda, 0x16, 0x5c, 0x92, 0xd5, 0xfa, 0xaa, 0x3a,
+};
+static const unsigned char kat190_persstr[] = {0};
+static const unsigned char kat190_addin0[] = {0};
+static const unsigned char kat190_addin1[] = {0};
+static const unsigned char kat190_retbits[] = {
+    0x47, 0x75, 0x15, 0x90, 0x25, 0xd5, 0xb8, 0x82, 0xf3, 0x7c, 0x7e, 0xdb,
+    0x8d, 0x89, 0xb3, 0x8a, 0xcb, 0x14, 0xa0, 0x28, 0x39, 0x80, 0x2c, 0x37,
+    0x7a, 0xc4, 0x82, 0xf8, 0xc6, 0xb5, 0x9a, 0xd6, 0x9c, 0x7d, 0x67, 0x55,
+    0x6b, 0xc4, 0x1c, 0xc3, 0x22, 0xd9, 0xcd, 0x75, 0x03, 0x2a, 0xf5, 0x27,
+    0x15, 0xb3, 0x60, 0x2f, 0x24, 0xc2, 0xb0, 0x99, 0x84, 0x0e, 0xab, 0x00,
+    0xb7, 0x42, 0x93, 0xad,
+};
+static const struct drbg_kat_no_reseed kat190_t = {
+    9, kat190_entropyin, kat190_nonce, kat190_persstr,
+    kat190_addin0, kat190_addin1, kat190_retbits
+};
+static const struct drbg_kat kat190 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat190_t
+};
+
+static const unsigned char kat191_entropyin[] = {
+    0xb6, 0x83, 0x0f, 0x64, 0xe4, 0x73, 0x88, 0xa9, 0xc3, 0xc6, 0x4a, 0xa0,
+    0xbe, 0x70, 0x84, 0x51,
+};
+static const unsigned char kat191_nonce[] = {
+    0x5c, 0xd4, 0x30, 0x34, 0xc9, 0x89, 0xda, 0x56,
+};
+static const unsigned char kat191_persstr[] = {0};
+static const unsigned char kat191_addin0[] = {0};
+static const unsigned char kat191_addin1[] = {0};
+static const unsigned char kat191_retbits[] = {
+    0xe1, 0x2f, 0x1e, 0x9f, 0xd9, 0x0e, 0x4f, 0x16, 0x6a, 0x13, 0xa4, 0xd3,
+    0x5f, 0x90, 0x91, 0xa9, 0x74, 0x44, 0x32, 0x91, 0xff, 0xae, 0x44, 0x02,
+    0xcb, 0xcd, 0x9a, 0x24, 0x89, 0x3b, 0x77, 0x09, 0x6b, 0x0a, 0x00, 0xdb,
+    0x20, 0xe4, 0x32, 0x88, 0x62, 0x61, 0x39, 0xf7, 0xc1, 0x76, 0x7f, 0x6e,
+    0x7f, 0xfe, 0xe9, 0x02, 0x2d, 0xde, 0x41, 0xb4, 0x78, 0x48, 0x5e, 0xe9,
+    0x12, 0x5f, 0x3e, 0xb8,
+};
+static const struct drbg_kat_no_reseed kat191_t = {
+    10, kat191_entropyin, kat191_nonce, kat191_persstr,
+    kat191_addin0, kat191_addin1, kat191_retbits
+};
+static const struct drbg_kat kat191 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat191_t
+};
+
+static const unsigned char kat192_entropyin[] = {
+    0xf7, 0x1a, 0x01, 0xef, 0x00, 0xb3, 0xd6, 0x13, 0x46, 0x07, 0xdf, 0xc5,
+    0x73, 0x25, 0xf6, 0x87,
+};
+static const unsigned char kat192_nonce[] = {
+    0x49, 0x76, 0x0a, 0xeb, 0xbc, 0x89, 0x61, 0xfe,
+};
+static const unsigned char kat192_persstr[] = {0};
+static const unsigned char kat192_addin0[] = {0};
+static const unsigned char kat192_addin1[] = {0};
+static const unsigned char kat192_retbits[] = {
+    0x0f, 0x00, 0x8e, 0x60, 0xab, 0x48, 0x14, 0xcc, 0xd8, 0xd2, 0x89, 0x77,
+    0x53, 0xf5, 0x8c, 0xa3, 0x58, 0xba, 0xcd, 0x3f, 0x2e, 0xfc, 0x22, 0xc0,
+    0xec, 0x89, 0xa6, 0x5b, 0x0a, 0x91, 0x82, 0xf5, 0x55, 0xcc, 0x49, 0x7a,
+    0xa5, 0x9a, 0xf9, 0x14, 0xbc, 0x9c, 0x65, 0xbe, 0x7c, 0x09, 0x21, 0x46,
+    0xcb, 0x78, 0xfc, 0xe2, 0x40, 0xfc, 0x8f, 0xe1, 0x36, 0x72, 0x9e, 0xa7,
+    0x77, 0x16, 0x44, 0x7f,
+};
+static const struct drbg_kat_no_reseed kat192_t = {
+    11, kat192_entropyin, kat192_nonce, kat192_persstr,
+    kat192_addin0, kat192_addin1, kat192_retbits
+};
+static const struct drbg_kat kat192 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat192_t
+};
+
+static const unsigned char kat193_entropyin[] = {
+    0x79, 0x0e, 0xf8, 0xf0, 0xee, 0x6d, 0xf4, 0x80, 0xb2, 0xd4, 0x4d, 0xac,
+    0x1c, 0x37, 0x61, 0x4c,
+};
+static const unsigned char kat193_nonce[] = {
+    0xd5, 0x52, 0x44, 0x4d, 0x7d, 0xc3, 0x5e, 0x5c,
+};
+static const unsigned char kat193_persstr[] = {0};
+static const unsigned char kat193_addin0[] = {0};
+static const unsigned char kat193_addin1[] = {0};
+static const unsigned char kat193_retbits[] = {
+    0x2a, 0xf8, 0xe3, 0x09, 0x77, 0x55, 0x6f, 0xae, 0x7c, 0x18, 0xae, 0x12,
+    0xba, 0x22, 0x01, 0xb4, 0x0d, 0xe8, 0xc0, 0x21, 0x66, 0xed, 0x94, 0xc1,
+    0x41, 0x27, 0x20, 0x50, 0xdb, 0xea, 0x72, 0xf3, 0xb8, 0xf9, 0x91, 0x54,
+    0x7f, 0xc0, 0xf5, 0x58, 0x36, 0x17, 0x12, 0x67, 0xd4, 0x2a, 0x53, 0xdc,
+    0xfb, 0x37, 0xc1, 0x5a, 0x22, 0x76, 0x76, 0xbf, 0x21, 0x8a, 0x49, 0xd0,
+    0xb7, 0x23, 0x68, 0x9c,
+};
+static const struct drbg_kat_no_reseed kat193_t = {
+    12, kat193_entropyin, kat193_nonce, kat193_persstr,
+    kat193_addin0, kat193_addin1, kat193_retbits
+};
+static const struct drbg_kat kat193 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat193_t
+};
+
+static const unsigned char kat194_entropyin[] = {
+    0xbe, 0x19, 0x6c, 0x9c, 0xe3, 0x83, 0xc8, 0xb1, 0x01, 0xcd, 0x27, 0xa1,
+    0x12, 0x91, 0x9f, 0xbc,
+};
+static const unsigned char kat194_nonce[] = {
+    0x33, 0x2e, 0xbe, 0x3d, 0x47, 0x3a, 0x3a, 0x35,
+};
+static const unsigned char kat194_persstr[] = {0};
+static const unsigned char kat194_addin0[] = {0};
+static const unsigned char kat194_addin1[] = {0};
+static const unsigned char kat194_retbits[] = {
+    0x01, 0x6b, 0x05, 0xd5, 0x57, 0x77, 0x7b, 0x36, 0xa1, 0x92, 0x04, 0x0c,
+    0x58, 0x0a, 0x5c, 0x51, 0x6d, 0xda, 0x11, 0x55, 0x93, 0x4a, 0xfb, 0xd9,
+    0x6c, 0xc8, 0x5b, 0x6e, 0x8b, 0x00, 0x83, 0xbb, 0xda, 0x27, 0x3e, 0xa6,
+    0xdb, 0x52, 0xa0, 0x58, 0x9d, 0x9d, 0xe2, 0xe5, 0x56, 0x8f, 0xfe, 0xf9,
+    0xdb, 0x39, 0x50, 0x09, 0x3c, 0x4d, 0xb2, 0xe8, 0xce, 0x9c, 0x25, 0x13,
+    0x08, 0x46, 0x93, 0xe4,
+};
+static const struct drbg_kat_no_reseed kat194_t = {
+    13, kat194_entropyin, kat194_nonce, kat194_persstr,
+    kat194_addin0, kat194_addin1, kat194_retbits
+};
+static const struct drbg_kat kat194 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat194_t
+};
+
+static const unsigned char kat195_entropyin[] = {
+    0x76, 0x39, 0x61, 0x6e, 0xe5, 0xcb, 0x26, 0x9b, 0x5f, 0x54, 0x0d, 0xe1,
+    0x50, 0xb4, 0x65, 0x0e,
+};
+static const unsigned char kat195_nonce[] = {
+    0x3c, 0x93, 0x3a, 0xbe, 0xd3, 0x07, 0xf6, 0xe2,
+};
+static const unsigned char kat195_persstr[] = {0};
+static const unsigned char kat195_addin0[] = {0};
+static const unsigned char kat195_addin1[] = {0};
+static const unsigned char kat195_retbits[] = {
+    0x06, 0x33, 0xc9, 0xaf, 0x4d, 0x40, 0xf3, 0xc2, 0x1a, 0xd4, 0xe0, 0x78,
+    0xa0, 0xc8, 0x4e, 0xe0, 0x3a, 0xd7, 0xad, 0x41, 0x0a, 0x0f, 0x7c, 0xf3,
+    0xdf, 0xdf, 0xf5, 0x92, 0x0d, 0xcd, 0x39, 0x87, 0xfc, 0xec, 0xed, 0x11,
+    0xa2, 0xb3, 0x8b, 0x15, 0x53, 0x5e, 0x44, 0xb5, 0x53, 0x77, 0xa8, 0xf2,
+    0x0f, 0x4f, 0xe0, 0x51, 0x87, 0xf9, 0x76, 0xa2, 0x76, 0xe6, 0x4b, 0x81,
+    0x3e, 0x55, 0xa8, 0xb9,
+};
+static const struct drbg_kat_no_reseed kat195_t = {
+    14, kat195_entropyin, kat195_nonce, kat195_persstr,
+    kat195_addin0, kat195_addin1, kat195_retbits
+};
+static const struct drbg_kat kat195 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 0, 64, &kat195_t
+};
+
+static const unsigned char kat196_entropyin[] = {
+    0x8b, 0x80, 0x93, 0x6e, 0x69, 0xc6, 0x7e, 0xdb, 0x77, 0x1c, 0x28, 0xf9,
+    0xb9, 0x45, 0x21, 0x24,
+};
+static const unsigned char kat196_nonce[] = {
+    0x7e, 0xe2, 0x61, 0x4e, 0xad, 0x3c, 0x12, 0x8e,
+};
+static const unsigned char kat196_persstr[] = {0};
+static const unsigned char kat196_addin0[] = {
+    0xfc, 0x35, 0xcb, 0xa9, 0x7a, 0x1e, 0x21, 0x1b, 0xc4, 0x20, 0xe8, 0xaf,
+    0x53, 0xf8, 0xe1, 0x3c,
+};
+static const unsigned char kat196_addin1[] = {
+    0xfb, 0xa4, 0x38, 0xaa, 0xa7, 0x5a, 0x3c, 0xd4, 0xcd, 0x0c, 0xce, 0x39,
+    0x9b, 0xfe, 0xc7, 0x4a,
+};
+static const unsigned char kat196_retbits[] = {
+    0x67, 0x21, 0xcc, 0x1a, 0xda, 0x5e, 0xbc, 0x17, 0x13, 0xf7, 0x4c, 0x75,
+    0x90, 0x00, 0x76, 0x56, 0x52, 0xee, 0xb5, 0xf3, 0xf9, 0xc2, 0x4f, 0xb9,
+    0x34, 0x1b, 0x36, 0xa3, 0x69, 0xce, 0xc1, 0xd2, 0x7e, 0xa8, 0x0d, 0x6b,
+    0x73, 0xb5, 0x60, 0x47, 0xaf, 0x07, 0x13, 0x8c, 0x5a, 0x43, 0xc9, 0x9a,
+    0x87, 0x75, 0x31, 0x15, 0xc4, 0x71, 0xb8, 0x58, 0x7e, 0xa6, 0x5f, 0xa2,
+    0x06, 0x5e, 0x3c, 0xe0,
+};
+static const struct drbg_kat_no_reseed kat196_t = {
+    0, kat196_entropyin, kat196_nonce, kat196_persstr,
+    kat196_addin0, kat196_addin1, kat196_retbits
+};
+static const struct drbg_kat kat196 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat196_t
+};
+
+static const unsigned char kat197_entropyin[] = {
+    0x89, 0xce, 0x6c, 0x76, 0xbc, 0x41, 0xaa, 0x32, 0xa9, 0xc8, 0xe3, 0xe3,
+    0x7d, 0x62, 0x02, 0xef,
+};
+static const unsigned char kat197_nonce[] = {
+    0xa3, 0x47, 0xf6, 0xcb, 0x64, 0xed, 0x19, 0xdd,
+};
+static const unsigned char kat197_persstr[] = {0};
+static const unsigned char kat197_addin0[] = {
+    0xc5, 0x03, 0xb1, 0x22, 0x95, 0x7d, 0xce, 0xc8, 0xd9, 0xeb, 0x9c, 0xc9,
+    0x94, 0xb8, 0xd1, 0x22,
+};
+static const unsigned char kat197_addin1[] = {
+    0x3b, 0xb2, 0xf1, 0x19, 0x7a, 0x99, 0x58, 0x8d, 0xf3, 0x57, 0xc0, 0xd1,
+    0x98, 0x6a, 0xc6, 0xed,
+};
+static const unsigned char kat197_retbits[] = {
+    0xf0, 0xf4, 0x25, 0xb1, 0x9e, 0xb7, 0x5a, 0xea, 0x68, 0x99, 0xfa, 0xb7,
+    0x61, 0x2c, 0x98, 0xa0, 0xb5, 0xc5, 0xc5, 0xa3, 0xc8, 0x61, 0x07, 0xa8,
+    0xc2, 0x01, 0x62, 0x3f, 0x75, 0x99, 0x31, 0x90, 0x9a, 0xfd, 0x63, 0x41,
+    0x9d, 0x1c, 0xce, 0xb8, 0x6b, 0xd4, 0xf1, 0x6e, 0x94, 0x8a, 0xef, 0x08,
+    0x47, 0x61, 0x70, 0x75, 0x7b, 0xca, 0xf7, 0x98, 0x84, 0xf9, 0xc3, 0x6b,
+    0xc7, 0x7e, 0x9f, 0xf9,
+};
+static const struct drbg_kat_no_reseed kat197_t = {
+    1, kat197_entropyin, kat197_nonce, kat197_persstr,
+    kat197_addin0, kat197_addin1, kat197_retbits
+};
+static const struct drbg_kat kat197 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat197_t
+};
+
+static const unsigned char kat198_entropyin[] = {
+    0xbc, 0x51, 0x67, 0x8d, 0x1f, 0x31, 0x28, 0x65, 0x7b, 0x38, 0x84, 0x9a,
+    0xe9, 0xc4, 0xbb, 0x1e,
+};
+static const unsigned char kat198_nonce[] = {
+    0xdd, 0x29, 0xd9, 0xd8, 0x3f, 0xdb, 0x5e, 0x09,
+};
+static const unsigned char kat198_persstr[] = {0};
+static const unsigned char kat198_addin0[] = {
+    0xd4, 0xcd, 0x00, 0x67, 0x5c, 0xfe, 0x22, 0x7d, 0xe0, 0xcb, 0xab, 0x65,
+    0x11, 0x35, 0x22, 0x89,
+};
+static const unsigned char kat198_addin1[] = {
+    0x55, 0xbb, 0x93, 0x62, 0x80, 0xae, 0x46, 0xb2, 0x6d, 0x66, 0xb2, 0xf3,
+    0xfe, 0xb2, 0x68, 0xd8,
+};
+static const unsigned char kat198_retbits[] = {
+    0xe5, 0x81, 0x38, 0xb6, 0xb0, 0x23, 0x2e, 0x4d, 0x6d, 0x9e, 0xa8, 0xb6,
+    0x5b, 0xd7, 0x69, 0x65, 0xcd, 0xbc, 0x58, 0x4c, 0xca, 0x2e, 0x83, 0xd4,
+    0xea, 0xd9, 0x36, 0xbf, 0xb9, 0xc7, 0x9d, 0x77, 0xde, 0xc9, 0x42, 0x4f,
+    0x2c, 0xf8, 0x95, 0x01, 0x1e, 0xf1, 0x03, 0x3c, 0x61, 0x9e, 0x28, 0xd1,
+    0xdb, 0xa5, 0xdd, 0x3c, 0xed, 0x04, 0x42, 0x9c, 0x1b, 0xd3, 0xc0, 0x3e,
+    0x5d, 0x13, 0xe2, 0xb8,
+};
+static const struct drbg_kat_no_reseed kat198_t = {
+    2, kat198_entropyin, kat198_nonce, kat198_persstr,
+    kat198_addin0, kat198_addin1, kat198_retbits
+};
+static const struct drbg_kat kat198 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat198_t
+};
+
+static const unsigned char kat199_entropyin[] = {
+    0x06, 0x5a, 0x5d, 0x4f, 0xdb, 0x34, 0xb0, 0x8f, 0xd8, 0xef, 0xc8, 0x1f,
+    0x99, 0x62, 0x69, 0xab,
+};
+static const unsigned char kat199_nonce[] = {
+    0xd5, 0xa6, 0x74, 0x7c, 0x7f, 0x8e, 0xef, 0x46,
+};
+static const unsigned char kat199_persstr[] = {0};
+static const unsigned char kat199_addin0[] = {
+    0x72, 0xeb, 0xd3, 0x51, 0xed, 0xc0, 0x00, 0xd8, 0x36, 0x32, 0x58, 0xa6,
+    0x9f, 0x2b, 0x98, 0xcc,
+};
+static const unsigned char kat199_addin1[] = {
+    0xe5, 0xc8, 0x61, 0x21, 0x32, 0x96, 0xea, 0x2a, 0xd5, 0x09, 0x8f, 0x9b,
+    0x4c, 0x50, 0x64, 0x7d,
+};
+static const unsigned char kat199_retbits[] = {
+    0xa8, 0xea, 0x47, 0x0f, 0x17, 0xbe, 0xe5, 0x02, 0x1d, 0x49, 0xc8, 0x4b,
+    0x72, 0x1e, 0x0b, 0x67, 0x47, 0x0d, 0x3b, 0xc4, 0xf9, 0x8f, 0xac, 0x68,
+    0xc6, 0x74, 0x42, 0x97, 0x9d, 0x4f, 0xbc, 0xcb, 0xbc, 0xd0, 0x47, 0x7c,
+    0x1e, 0x74, 0x93, 0x12, 0x6c, 0xbe, 0x16, 0x9b, 0x84, 0x44, 0x6f, 0x5f,
+    0xcf, 0x66, 0x67, 0x86, 0x77, 0x5d, 0x19, 0xf3, 0x5c, 0x61, 0x52, 0x52,
+    0x9a, 0x41, 0xde, 0x6d,
+};
+static const struct drbg_kat_no_reseed kat199_t = {
+    3, kat199_entropyin, kat199_nonce, kat199_persstr,
+    kat199_addin0, kat199_addin1, kat199_retbits
+};
+static const struct drbg_kat kat199 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat199_t
+};
+
+static const unsigned char kat200_entropyin[] = {
+    0x12, 0x48, 0xed, 0x4b, 0xf6, 0x06, 0xcc, 0x65, 0x8b, 0x64, 0x1b, 0x79,
+    0x58, 0x59, 0x7f, 0x5a,
+};
+static const unsigned char kat200_nonce[] = {
+    0x16, 0xc8, 0x8d, 0xea, 0x4e, 0x75, 0x3d, 0x50,
+};
+static const unsigned char kat200_persstr[] = {0};
+static const unsigned char kat200_addin0[] = {
+    0xfc, 0x67, 0xe7, 0x63, 0x41, 0x32, 0x02, 0xe0, 0x4c, 0x55, 0x69, 0x7e,
+    0xb7, 0x54, 0x8c, 0x56,
+};
+static const unsigned char kat200_addin1[] = {
+    0x21, 0xe0, 0xe3, 0x86, 0x65, 0xec, 0xf6, 0x0f, 0xa9, 0x73, 0x0b, 0xdf,
+    0x7e, 0x22, 0xcc, 0x7f,
+};
+static const unsigned char kat200_retbits[] = {
+    0x63, 0xd9, 0xb5, 0x0d, 0xd6, 0x9e, 0xa9, 0xda, 0xc7, 0x5f, 0x48, 0xae,
+    0x01, 0x2f, 0xce, 0xc2, 0x7c, 0x2e, 0x1d, 0xcf, 0xc2, 0xac, 0x2e, 0x59,
+    0x24, 0x4a, 0xf4, 0xa6, 0xce, 0x9a, 0x73, 0xc4, 0xd8, 0xbd, 0xe6, 0x57,
+    0x0d, 0x85, 0xee, 0x15, 0xb0, 0x8a, 0x48, 0xef, 0x47, 0x3d, 0x12, 0xdb,
+    0x87, 0x1f, 0x6d, 0xf1, 0xd8, 0x14, 0x41, 0x61, 0x3d, 0xcc, 0x1e, 0xfb,
+    0x20, 0x18, 0xf0, 0xc3,
+};
+static const struct drbg_kat_no_reseed kat200_t = {
+    4, kat200_entropyin, kat200_nonce, kat200_persstr,
+    kat200_addin0, kat200_addin1, kat200_retbits
+};
+static const struct drbg_kat kat200 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat200_t
+};
+
+static const unsigned char kat201_entropyin[] = {
+    0x6f, 0xa6, 0x29, 0xd0, 0x3c, 0xb4, 0xeb, 0x53, 0x4e, 0xfa, 0x03, 0x33,
+    0x4d, 0x3b, 0x1d, 0x02,
+};
+static const unsigned char kat201_nonce[] = {
+    0xd9, 0x52, 0x15, 0x3e, 0x79, 0xdf, 0x53, 0x8f,
+};
+static const unsigned char kat201_persstr[] = {0};
+static const unsigned char kat201_addin0[] = {
+    0x2e, 0x5c, 0x55, 0x45, 0x78, 0xa0, 0x69, 0xf5, 0xe4, 0x95, 0x9d, 0xcb,
+    0x35, 0x1a, 0x29, 0x4d,
+};
+static const unsigned char kat201_addin1[] = {
+    0x2d, 0x26, 0xae, 0xaa, 0xd9, 0xcb, 0xf2, 0x53, 0xad, 0xd8, 0x68, 0x4d,
+    0x29, 0xb1, 0xa6, 0x33,
+};
+static const unsigned char kat201_retbits[] = {
+    0xf5, 0x82, 0x46, 0x31, 0x32, 0x84, 0x99, 0x02, 0x98, 0x86, 0x4a, 0x89,
+    0xbf, 0xe7, 0xbe, 0x19, 0x70, 0xc0, 0x33, 0xdc, 0x16, 0x64, 0xad, 0x7f,
+    0x5c, 0xd9, 0xb8, 0x12, 0xf5, 0xb7, 0xe9, 0x0f, 0x69, 0xa4, 0x9c, 0xdf,
+    0xbe, 0xe0, 0xe2, 0x79, 0xf7, 0xdf, 0x1a, 0x8e, 0xd7, 0x9e, 0xca, 0x6e,
+    0x68, 0x0d, 0x74, 0x0c, 0x0f, 0x2a, 0xe1, 0x2f, 0x87, 0x79, 0x8a, 0xcc,
+    0x6d, 0x73, 0xd4, 0x2f,
+};
+static const struct drbg_kat_no_reseed kat201_t = {
+    5, kat201_entropyin, kat201_nonce, kat201_persstr,
+    kat201_addin0, kat201_addin1, kat201_retbits
+};
+static const struct drbg_kat kat201 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat201_t
+};
+
+static const unsigned char kat202_entropyin[] = {
+    0xc5, 0x8e, 0xeb, 0x2e, 0x57, 0xf2, 0x95, 0xd7, 0xaf, 0x1a, 0x37, 0x67,
+    0x93, 0x5b, 0x85, 0xeb,
+};
+static const unsigned char kat202_nonce[] = {
+    0x98, 0x61, 0x2b, 0x6c, 0xa0, 0x2f, 0x60, 0xe4,
+};
+static const unsigned char kat202_persstr[] = {0};
+static const unsigned char kat202_addin0[] = {
+    0x10, 0xe8, 0x9c, 0x27, 0x1e, 0x2b, 0x28, 0x3d, 0x69, 0xb0, 0x4a, 0xbf,
+    0x6c, 0x54, 0xb1, 0xe1,
+};
+static const unsigned char kat202_addin1[] = {
+    0x20, 0x79, 0x50, 0xc2, 0x8b, 0x26, 0xec, 0x16, 0xc4, 0xf2, 0x81, 0x21,
+    0x60, 0x7f, 0x4a, 0x5a,
+};
+static const unsigned char kat202_retbits[] = {
+    0x28, 0xef, 0xf6, 0x03, 0xff, 0x0d, 0xc8, 0x39, 0xf8, 0x8f, 0x84, 0x47,
+    0x33, 0xb2, 0x75, 0xbc, 0x6f, 0xda, 0x6d, 0x45, 0x46, 0xee, 0x26, 0x03,
+    0x4f, 0x51, 0xf8, 0x4c, 0xe4, 0x30, 0xb0, 0x73, 0xc3, 0xda, 0x8a, 0xbf,
+    0xe8, 0x2b, 0x53, 0x13, 0xba, 0x2e, 0x0f, 0x60, 0x04, 0x5b, 0x80, 0x96,
+    0xb9, 0xcf, 0x31, 0x42, 0x48, 0x63, 0xe0, 0x6f, 0x72, 0xef, 0xf1, 0xba,
+    0xa4, 0xb2, 0x52, 0x70,
+};
+static const struct drbg_kat_no_reseed kat202_t = {
+    6, kat202_entropyin, kat202_nonce, kat202_persstr,
+    kat202_addin0, kat202_addin1, kat202_retbits
+};
+static const struct drbg_kat kat202 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat202_t
+};
+
+static const unsigned char kat203_entropyin[] = {
+    0x8a, 0x34, 0x5b, 0x5a, 0x5e, 0xb7, 0xd7, 0xaa, 0x70, 0x0b, 0xff, 0x26,
+    0x61, 0x25, 0xed, 0xe1,
+};
+static const unsigned char kat203_nonce[] = {
+    0x00, 0xb2, 0x96, 0x37, 0x27, 0x8d, 0xa4, 0x57,
+};
+static const unsigned char kat203_persstr[] = {0};
+static const unsigned char kat203_addin0[] = {
+    0x44, 0x53, 0x4b, 0x92, 0xaf, 0x03, 0x81, 0x71, 0xb6, 0x7b, 0x70, 0xf4,
+    0xe1, 0xd5, 0xe7, 0xf5,
+};
+static const unsigned char kat203_addin1[] = {
+    0x53, 0x14, 0x76, 0x60, 0xc0, 0xfd, 0xe5, 0xf9, 0x89, 0x34, 0x74, 0xf0,
+    0x38, 0x84, 0xab, 0x14,
+};
+static const unsigned char kat203_retbits[] = {
+    0xa6, 0xa7, 0xa5, 0x6f, 0xc3, 0x2c, 0x3d, 0x3c, 0x33, 0x06, 0xdd, 0x65,
+    0x10, 0x9f, 0xf8, 0xd6, 0x80, 0x31, 0x19, 0x3b, 0xbf, 0x5b, 0x38, 0x38,
+    0x0e, 0x38, 0x25, 0xdb, 0x7b, 0xef, 0x72, 0x94, 0x05, 0x14, 0x16, 0x26,
+    0x37, 0x95, 0xf3, 0x34, 0xd1, 0xf8, 0x70, 0x54, 0xe9, 0x7d, 0xbb, 0x52,
+    0xdd, 0x24, 0x4d, 0x52, 0x7a, 0x6f, 0xfc, 0xe0, 0x86, 0xd1, 0xad, 0x17,
+    0x7b, 0xa8, 0xfb, 0x81,
+};
+static const struct drbg_kat_no_reseed kat203_t = {
+    7, kat203_entropyin, kat203_nonce, kat203_persstr,
+    kat203_addin0, kat203_addin1, kat203_retbits
+};
+static const struct drbg_kat kat203 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat203_t
+};
+
+static const unsigned char kat204_entropyin[] = {
+    0xfe, 0x50, 0x4e, 0x06, 0x89, 0x5d, 0x34, 0x08, 0x90, 0x50, 0x9f, 0x39,
+    0x8f, 0xe7, 0x08, 0x32,
+};
+static const unsigned char kat204_nonce[] = {
+    0x3b, 0x3d, 0x94, 0xb6, 0x94, 0x8f, 0x74, 0x01,
+};
+static const unsigned char kat204_persstr[] = {0};
+static const unsigned char kat204_addin0[] = {
+    0x64, 0x20, 0x03, 0x18, 0x1f, 0x79, 0x1c, 0xb5, 0xba, 0xce, 0xf7, 0x23,
+    0xc9, 0x6c, 0xe2, 0x62,
+};
+static const unsigned char kat204_addin1[] = {
+    0x34, 0x5e, 0x8d, 0x29, 0xd5, 0xef, 0xdd, 0xc8, 0xab, 0x37, 0x83, 0x8b,
+    0x18, 0x91, 0xbc, 0xd0,
+};
+static const unsigned char kat204_retbits[] = {
+    0x45, 0x30, 0x40, 0x99, 0x14, 0x5b, 0x8e, 0x3d, 0xa8, 0x00, 0xa9, 0x2e,
+    0x0f, 0x59, 0x15, 0xc8, 0x98, 0x1f, 0xb7, 0x70, 0x6a, 0x1d, 0xf0, 0xa6,
+    0xc0, 0xb2, 0xad, 0x54, 0x35, 0xda, 0x19, 0xce, 0xd3, 0xac, 0xdf, 0xd5,
+    0x83, 0x27, 0x95, 0x01, 0x3a, 0xfa, 0x5f, 0xf2, 0x1f, 0xf3, 0x32, 0x6a,
+    0xda, 0x7d, 0x57, 0x78, 0x17, 0xf6, 0xb9, 0x4e, 0xb3, 0x5f, 0x33, 0x62,
+    0x3d, 0xb4, 0x71, 0x76,
+};
+static const struct drbg_kat_no_reseed kat204_t = {
+    8, kat204_entropyin, kat204_nonce, kat204_persstr,
+    kat204_addin0, kat204_addin1, kat204_retbits
+};
+static const struct drbg_kat kat204 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat204_t
+};
+
+static const unsigned char kat205_entropyin[] = {
+    0xe0, 0x22, 0x7d, 0xe1, 0x4d, 0x5b, 0xc6, 0xad, 0xe2, 0xa0, 0x14, 0xee,
+    0x43, 0x01, 0x51, 0xb4,
+};
+static const unsigned char kat205_nonce[] = {
+    0x15, 0x37, 0xf8, 0x56, 0x16, 0x75, 0x87, 0x53,
+};
+static const unsigned char kat205_persstr[] = {0};
+static const unsigned char kat205_addin0[] = {
+    0x87, 0xee, 0xfe, 0xf0, 0xe0, 0xcf, 0xd9, 0x0d, 0xd2, 0x6d, 0x48, 0x33,
+    0x79, 0x78, 0x7c, 0x7f,
+};
+static const unsigned char kat205_addin1[] = {
+    0x74, 0xd2, 0xff, 0xf6, 0xf2, 0x9f, 0x89, 0x2e, 0x66, 0xa9, 0xf8, 0x0b,
+    0x2a, 0x5d, 0x9d, 0x20,
+};
+static const unsigned char kat205_retbits[] = {
+    0xdd, 0xe0, 0x86, 0xce, 0xc0, 0xad, 0xd3, 0x1f, 0xb9, 0x55, 0x3d, 0x56,
+    0xcc, 0x2c, 0x6b, 0x7c, 0x02, 0x2d, 0x8c, 0x87, 0xff, 0x54, 0x99, 0xfa,
+    0x78, 0xa6, 0x8e, 0xeb, 0x05, 0x1c, 0xdb, 0xf8, 0x99, 0x67, 0x3b, 0x4e,
+    0xd7, 0x6f, 0xe8, 0x67, 0xb7, 0x9e, 0xcf, 0x6f, 0xc1, 0xd7, 0xc6, 0xf8,
+    0xf5, 0x97, 0x01, 0x31, 0x39, 0xd5, 0x28, 0xd3, 0x48, 0xca, 0x3b, 0xee,
+    0x96, 0x05, 0xdd, 0x80,
+};
+static const struct drbg_kat_no_reseed kat205_t = {
+    9, kat205_entropyin, kat205_nonce, kat205_persstr,
+    kat205_addin0, kat205_addin1, kat205_retbits
+};
+static const struct drbg_kat kat205 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat205_t
+};
+
+static const unsigned char kat206_entropyin[] = {
+    0x44, 0xb7, 0x28, 0x2f, 0x95, 0x1c, 0x59, 0x1a, 0x7a, 0x3d, 0x9f, 0xf6,
+    0x96, 0x0f, 0x20, 0xb9,
+};
+static const unsigned char kat206_nonce[] = {
+    0xb7, 0x7e, 0xbe, 0x26, 0x99, 0x0c, 0xbe, 0x8c,
+};
+static const unsigned char kat206_persstr[] = {0};
+static const unsigned char kat206_addin0[] = {
+    0x90, 0x00, 0x58, 0x7b, 0xb1, 0x8d, 0x20, 0x1e, 0xcf, 0xd5, 0x6f, 0x30,
+    0xdb, 0xa4, 0x83, 0xd2,
+};
+static const unsigned char kat206_addin1[] = {
+    0x24, 0x55, 0x23, 0x06, 0x0b, 0x0a, 0xf3, 0xe5, 0x75, 0xb1, 0x48, 0x0a,
+    0xa6, 0xd8, 0xa3, 0x3b,
+};
+static const unsigned char kat206_retbits[] = {
+    0x9f, 0x25, 0x67, 0x4a, 0xc0, 0x85, 0xa7, 0xa4, 0x87, 0xe7, 0xd7, 0x20,
+    0x84, 0xd5, 0xd3, 0xc0, 0xfb, 0xd7, 0xd4, 0x18, 0x70, 0xf0, 0xf7, 0x66,
+    0xd6, 0x13, 0x01, 0x59, 0x96, 0x05, 0x2e, 0xbf, 0xc6, 0xf6, 0x2e, 0x4c,
+    0xf3, 0x89, 0xaf, 0x85, 0xcf, 0x12, 0x5d, 0x9d, 0x99, 0xc6, 0x49, 0xd4,
+    0xe8, 0x75, 0x50, 0x79, 0xa6, 0x81, 0x7a, 0x9e, 0x81, 0x44, 0x5d, 0x1b,
+    0x99, 0x4d, 0x29, 0x61,
+};
+static const struct drbg_kat_no_reseed kat206_t = {
+    10, kat206_entropyin, kat206_nonce, kat206_persstr,
+    kat206_addin0, kat206_addin1, kat206_retbits
+};
+static const struct drbg_kat kat206 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat206_t
+};
+
+static const unsigned char kat207_entropyin[] = {
+    0x74, 0x5c, 0xa1, 0x6e, 0xbc, 0x9e, 0x1a, 0x58, 0xda, 0x81, 0x02, 0x78,
+    0x88, 0x5d, 0xff, 0x33,
+};
+static const unsigned char kat207_nonce[] = {
+    0x7e, 0x11, 0xf9, 0x49, 0x86, 0x2c, 0xbc, 0xc9,
+};
+static const unsigned char kat207_persstr[] = {0};
+static const unsigned char kat207_addin0[] = {
+    0x4b, 0x89, 0x8e, 0xbd, 0xd3, 0x21, 0x42, 0x62, 0x78, 0x15, 0xbe, 0x10,
+    0x35, 0x43, 0x56, 0x96,
+};
+static const unsigned char kat207_addin1[] = {
+    0x33, 0x0b, 0x0c, 0xe2, 0x87, 0x84, 0x2d, 0x3d, 0x71, 0x9a, 0x0c, 0xe4,
+    0x15, 0x36, 0x3b, 0x77,
+};
+static const unsigned char kat207_retbits[] = {
+    0x9c, 0x6d, 0xd7, 0x63, 0x88, 0x80, 0x65, 0x54, 0x1b, 0x1a, 0x38, 0x0c,
+    0xf4, 0xf4, 0x59, 0x83, 0x9f, 0xb4, 0xf1, 0xef, 0x4f, 0x78, 0x17, 0x28,
+    0x6b, 0xe4, 0x50, 0x33, 0x95, 0x7f, 0x79, 0xd1, 0x42, 0x9c, 0xfe, 0xfe,
+    0xd1, 0xab, 0xd6, 0x22, 0x8b, 0x26, 0x74, 0x7e, 0x69, 0xec, 0x9b, 0x1a,
+    0x02, 0x7b, 0x3a, 0x0b, 0x9a, 0x28, 0x48, 0x7e, 0x95, 0x4d, 0xda, 0x06,
+    0xb7, 0xee, 0xb4, 0x54,
+};
+static const struct drbg_kat_no_reseed kat207_t = {
+    11, kat207_entropyin, kat207_nonce, kat207_persstr,
+    kat207_addin0, kat207_addin1, kat207_retbits
+};
+static const struct drbg_kat kat207 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat207_t
+};
+
+static const unsigned char kat208_entropyin[] = {
+    0x1e, 0x54, 0x6f, 0xee, 0xba, 0xf0, 0xfe, 0xba, 0x3a, 0x07, 0xc6, 0x35,
+    0xe6, 0x23, 0x5b, 0xfb,
+};
+static const unsigned char kat208_nonce[] = {
+    0x17, 0x88, 0xd9, 0xee, 0xa4, 0x44, 0xad, 0x7b,
+};
+static const unsigned char kat208_persstr[] = {0};
+static const unsigned char kat208_addin0[] = {
+    0x51, 0x99, 0xd4, 0xaa, 0x59, 0x30, 0x22, 0x0c, 0x27, 0x34, 0x2e, 0x1c,
+    0x0b, 0x99, 0x46, 0x4f,
+};
+static const unsigned char kat208_addin1[] = {
+    0x16, 0xdd, 0x52, 0x0f, 0x00, 0x93, 0x29, 0xed, 0x7b, 0xe1, 0x4d, 0x25,
+    0xe5, 0xc7, 0x91, 0x12,
+};
+static const unsigned char kat208_retbits[] = {
+    0x34, 0xfa, 0x78, 0x30, 0x6c, 0x9e, 0xfb, 0x91, 0x2e, 0xe7, 0x8f, 0xb9,
+    0x8a, 0x03, 0x54, 0x6d, 0x16, 0xc1, 0xcc, 0x9b, 0xc3, 0xb6, 0x7a, 0x04,
+    0xf2, 0xa8, 0xe6, 0xfb, 0x26, 0x24, 0x14, 0xbc, 0xf3, 0xcc, 0x51, 0xd3,
+    0xcf, 0x3a, 0x1a, 0x30, 0x48, 0x09, 0xf1, 0x86, 0xbd, 0x74, 0xf2, 0x09,
+    0xb2, 0x42, 0x86, 0xf7, 0x71, 0x76, 0x67, 0xcc, 0x56, 0x60, 0xd3, 0xec,
+    0x73, 0x2f, 0xb0, 0xd3,
+};
+static const struct drbg_kat_no_reseed kat208_t = {
+    12, kat208_entropyin, kat208_nonce, kat208_persstr,
+    kat208_addin0, kat208_addin1, kat208_retbits
+};
+static const struct drbg_kat kat208 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat208_t
+};
+
+static const unsigned char kat209_entropyin[] = {
+    0xde, 0x1f, 0xca, 0xee, 0x63, 0x29, 0xe9, 0xac, 0x06, 0xa6, 0xdc, 0x18,
+    0xa1, 0x8d, 0x14, 0x7d,
+};
+static const unsigned char kat209_nonce[] = {
+    0xe1, 0x0e, 0xa5, 0x48, 0xcc, 0x37, 0x73, 0xab,
+};
+static const unsigned char kat209_persstr[] = {0};
+static const unsigned char kat209_addin0[] = {
+    0x5c, 0xdd, 0xd4, 0xfd, 0x07, 0xb6, 0xac, 0x3e, 0x96, 0xb1, 0x33, 0x39,
+    0xa7, 0x5f, 0x56, 0xf9,
+};
+static const unsigned char kat209_addin1[] = {
+    0x45, 0x47, 0x14, 0xbe, 0xbf, 0x96, 0x03, 0xe1, 0xcf, 0xef, 0x7b, 0x80,
+    0x38, 0x37, 0x48, 0x99,
+};
+static const unsigned char kat209_retbits[] = {
+    0x5e, 0x34, 0x83, 0x12, 0x58, 0x35, 0x24, 0x30, 0x48, 0xa5, 0x10, 0x18,
+    0x4f, 0x08, 0x64, 0x87, 0xe9, 0xb0, 0x2f, 0xc0, 0xca, 0x60, 0xfb, 0x46,
+    0x41, 0x6f, 0xb0, 0xcc, 0xc1, 0x3e, 0x45, 0x08, 0x1d, 0xa5, 0x96, 0x91,
+    0xe3, 0x26, 0x78, 0xfc, 0xb6, 0xaa, 0xbe, 0xf5, 0x85, 0xfb, 0x49, 0x2b,
+    0x19, 0x4e, 0x06, 0x17, 0x1a, 0x8d, 0x17, 0xaf, 0x85, 0x56, 0xa3, 0x6b,
+    0xf4, 0x93, 0x1f, 0xf5,
+};
+static const struct drbg_kat_no_reseed kat209_t = {
+    13, kat209_entropyin, kat209_nonce, kat209_persstr,
+    kat209_addin0, kat209_addin1, kat209_retbits
+};
+static const struct drbg_kat kat209 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat209_t
+};
+
+static const unsigned char kat210_entropyin[] = {
+    0x8b, 0x52, 0x95, 0x07, 0xbc, 0x2e, 0x8f, 0x71, 0x19, 0x34, 0xad, 0xc8,
+    0x8c, 0x65, 0x30, 0xa3,
+};
+static const unsigned char kat210_nonce[] = {
+    0x72, 0x15, 0x95, 0x6b, 0x7c, 0x57, 0x4e, 0x71,
+};
+static const unsigned char kat210_persstr[] = {0};
+static const unsigned char kat210_addin0[] = {
+    0x1a, 0xdb, 0x1e, 0xf6, 0x33, 0x47, 0xb2, 0x1e, 0x33, 0x51, 0x8b, 0x96,
+    0x2f, 0x6d, 0xb8, 0x98,
+};
+static const unsigned char kat210_addin1[] = {
+    0xd5, 0xc6, 0x9f, 0x42, 0xf3, 0x6e, 0xa2, 0x24, 0x98, 0x42, 0xb6, 0xfc,
+    0x26, 0xac, 0x54, 0xfe,
+};
+static const unsigned char kat210_retbits[] = {
+    0xc3, 0x74, 0xbd, 0xd6, 0x2c, 0xb1, 0xe4, 0x2e, 0x64, 0x84, 0x03, 0x84,
+    0x3b, 0x8c, 0x06, 0xc0, 0xb3, 0x05, 0xf9, 0x45, 0x68, 0x5f, 0x72, 0xd1,
+    0xbc, 0x2e, 0x42, 0x8c, 0x19, 0xdf, 0x45, 0x20, 0x18, 0xdd, 0xea, 0x81,
+    0xeb, 0xe5, 0xb1, 0x5f, 0xad, 0x3b, 0xe4, 0xeb, 0x17, 0xfa, 0x2d, 0x2c,
+    0xf5, 0x78, 0x36, 0xdd, 0x08, 0x09, 0x70, 0xf7, 0x16, 0xc0, 0xb2, 0x2f,
+    0x72, 0x63, 0x41, 0x4a,
+};
+static const struct drbg_kat_no_reseed kat210_t = {
+    14, kat210_entropyin, kat210_nonce, kat210_persstr,
+    kat210_addin0, kat210_addin1, kat210_retbits
+};
+static const struct drbg_kat kat210 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 0, 16, 64, &kat210_t
+};
+
+static const unsigned char kat211_entropyin[] = {
+    0xf4, 0x1f, 0x46, 0x6b, 0x32, 0x19, 0xbe, 0x21, 0x59, 0x77, 0x63, 0xfa,
+    0x7b, 0x76, 0xfb, 0x40,
+};
+static const unsigned char kat211_nonce[] = {
+    0xcd, 0x93, 0xfe, 0xb9, 0x96, 0x2e, 0x81, 0xac,
+};
+static const unsigned char kat211_persstr[] = {
+    0xb5, 0x8f, 0x86, 0x9a, 0xd0, 0xaa, 0x98, 0x08, 0xf6, 0x64, 0x61, 0x37,
+    0x43, 0x1d, 0x43, 0x0c,
+};
+static const unsigned char kat211_addin0[] = {0};
+static const unsigned char kat211_addin1[] = {0};
+static const unsigned char kat211_retbits[] = {
+    0x2f, 0xb6, 0xd7, 0xec, 0xa3, 0x92, 0x67, 0x4f, 0xc7, 0x22, 0xa6, 0x19,
+    0x20, 0x2e, 0x81, 0x9d, 0x0d, 0xa9, 0xd1, 0x1b, 0xc6, 0x7d, 0xb1, 0x0b,
+    0xe4, 0xc1, 0x3c, 0xb9, 0x64, 0xe3, 0x0a, 0xda, 0x96, 0xdc, 0xcf, 0x0c,
+    0x92, 0x2b, 0x71, 0x0a, 0xc0, 0x0d, 0xed, 0x54, 0x57, 0xfa, 0x97, 0x1b,
+    0xb1, 0xc6, 0x61, 0xa0, 0x9a, 0xfa, 0x72, 0x0a, 0x58, 0x64, 0x34, 0x4b,
+    0xf7, 0x7a, 0x36, 0xae,
+};
+static const struct drbg_kat_no_reseed kat211_t = {
+    0, kat211_entropyin, kat211_nonce, kat211_persstr,
+    kat211_addin0, kat211_addin1, kat211_retbits
+};
+static const struct drbg_kat kat211 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat211_t
+};
+
+static const unsigned char kat212_entropyin[] = {
+    0x9d, 0x1b, 0x88, 0x34, 0x83, 0x2f, 0xfa, 0x13, 0x83, 0x2e, 0xb0, 0x86,
+    0x04, 0x7b, 0xf3, 0xb1,
+};
+static const unsigned char kat212_nonce[] = {
+    0xd0, 0xf1, 0x5e, 0xfe, 0x86, 0x47, 0x7f, 0x75,
+};
+static const unsigned char kat212_persstr[] = {
+    0x73, 0xc9, 0x37, 0x34, 0xf6, 0xea, 0x39, 0xae, 0x04, 0xe6, 0xa4, 0xb4,
+    0x97, 0x66, 0xb8, 0x20,
+};
+static const unsigned char kat212_addin0[] = {0};
+static const unsigned char kat212_addin1[] = {0};
+static const unsigned char kat212_retbits[] = {
+    0x9f, 0xb6, 0x7d, 0x35, 0x37, 0x89, 0x40, 0xa5, 0xd7, 0x6b, 0x96, 0x3a,
+    0xce, 0x4f, 0x81, 0x58, 0xe9, 0x3f, 0xe0, 0xca, 0x06, 0x4f, 0x96, 0x56,
+    0xd4, 0x6d, 0xf1, 0xc1, 0x0d, 0x02, 0x5f, 0x48, 0xb3, 0x35, 0x69, 0xda,
+    0x07, 0xc7, 0x7e, 0xc5, 0x12, 0x23, 0x6d, 0x08, 0xd2, 0x69, 0x97, 0xd6,
+    0xb9, 0xbb, 0x69, 0x15, 0xdf, 0x63, 0x9e, 0xa8, 0x9d, 0xa9, 0x57, 0xe6,
+    0x6f, 0xc2, 0x90, 0x03,
+};
+static const struct drbg_kat_no_reseed kat212_t = {
+    1, kat212_entropyin, kat212_nonce, kat212_persstr,
+    kat212_addin0, kat212_addin1, kat212_retbits
+};
+static const struct drbg_kat kat212 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat212_t
+};
+
+static const unsigned char kat213_entropyin[] = {
+    0x29, 0x89, 0x86, 0x2a, 0x79, 0xe2, 0x55, 0x19, 0x5a, 0x24, 0x82, 0x8f,
+    0xd3, 0x00, 0xeb, 0x34,
+};
+static const unsigned char kat213_nonce[] = {
+    0x30, 0xff, 0xda, 0xcb, 0x3a, 0xc7, 0xb2, 0x7b,
+};
+static const unsigned char kat213_persstr[] = {
+    0x71, 0x9b, 0x89, 0x9c, 0x9e, 0x4a, 0x5d, 0xb9, 0xe7, 0x1d, 0xfd, 0xa4,
+    0x8f, 0xa6, 0x58, 0xcd,
+};
+static const unsigned char kat213_addin0[] = {0};
+static const unsigned char kat213_addin1[] = {0};
+static const unsigned char kat213_retbits[] = {
+    0xb4, 0xf2, 0x00, 0x60, 0xea, 0x30, 0x01, 0xef, 0xdb, 0xd5, 0xcc, 0x89,
+    0x83, 0x8e, 0x0a, 0x08, 0xc0, 0x9f, 0x7a, 0x6f, 0xe5, 0xbc, 0x02, 0x3c,
+    0x33, 0xd1, 0x15, 0xfe, 0xdd, 0x6a, 0xe1, 0x51, 0x30, 0x74, 0x22, 0xf9,
+    0x97, 0xd3, 0x2b, 0x3c, 0xea, 0xb8, 0x79, 0x95, 0x86, 0x23, 0x68, 0xc4,
+    0xc3, 0xaf, 0x7a, 0xc4, 0x81, 0x58, 0x74, 0xc0, 0x08, 0x4e, 0xa1, 0xdc,
+    0xec, 0x50, 0x58, 0xba,
+};
+static const struct drbg_kat_no_reseed kat213_t = {
+    2, kat213_entropyin, kat213_nonce, kat213_persstr,
+    kat213_addin0, kat213_addin1, kat213_retbits
+};
+static const struct drbg_kat kat213 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat213_t
+};
+
+static const unsigned char kat214_entropyin[] = {
+    0x74, 0x82, 0xb2, 0xb0, 0x2a, 0x74, 0x46, 0xde, 0x58, 0x9d, 0x7e, 0x60,
+    0xcf, 0x01, 0x29, 0x69,
+};
+static const unsigned char kat214_nonce[] = {
+    0x1c, 0x4b, 0xda, 0x6a, 0x57, 0xf4, 0x1f, 0xfb,
+};
+static const unsigned char kat214_persstr[] = {
+    0x52, 0x9e, 0x4e, 0x80, 0xf5, 0x01, 0xe7, 0x3e, 0xc8, 0x6e, 0xaa, 0x25,
+    0x96, 0x28, 0xa1, 0x97,
+};
+static const unsigned char kat214_addin0[] = {0};
+static const unsigned char kat214_addin1[] = {0};
+static const unsigned char kat214_retbits[] = {
+    0x74, 0x98, 0xf9, 0x17, 0x2a, 0xf7, 0xf5, 0xf2, 0x6d, 0x84, 0x77, 0x97,
+    0x76, 0x8e, 0x45, 0x91, 0x70, 0xdd, 0x9e, 0xc7, 0xf4, 0x2a, 0x1f, 0xe9,
+    0x79, 0xa2, 0xe4, 0xfa, 0x32, 0xa5, 0xe1, 0x24, 0xc5, 0xcb, 0x1a, 0xd4,
+    0xc3, 0x94, 0xa2, 0xc2, 0x09, 0x9e, 0x8f, 0x94, 0x2e, 0xfb, 0xe5, 0x9a,
+    0xf0, 0x97, 0x5b, 0x56, 0xa9, 0xaf, 0xa7, 0x74, 0x33, 0x16, 0x12, 0xad,
+    0x88, 0x7b, 0x3f, 0x55,
+};
+static const struct drbg_kat_no_reseed kat214_t = {
+    3, kat214_entropyin, kat214_nonce, kat214_persstr,
+    kat214_addin0, kat214_addin1, kat214_retbits
+};
+static const struct drbg_kat kat214 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat214_t
+};
+
+static const unsigned char kat215_entropyin[] = {
+    0x0a, 0x84, 0x05, 0x99, 0x1a, 0xeb, 0x64, 0xf3, 0xa8, 0x2d, 0x8b, 0xef,
+    0x2b, 0x6c, 0x94, 0x22,
+};
+static const unsigned char kat215_nonce[] = {
+    0xa7, 0xa5, 0x8d, 0xa9, 0xb2, 0x16, 0xf7, 0xfb,
+};
+static const unsigned char kat215_persstr[] = {
+    0x68, 0xdf, 0x62, 0xfc, 0x01, 0xd3, 0xdb, 0xb0, 0x18, 0xc1, 0x63, 0xbe,
+    0x34, 0x29, 0xf2, 0xaa,
+};
+static const unsigned char kat215_addin0[] = {0};
+static const unsigned char kat215_addin1[] = {0};
+static const unsigned char kat215_retbits[] = {
+    0x7a, 0x9b, 0xa1, 0xe8, 0x25, 0x13, 0x3f, 0xf4, 0xc1, 0xd6, 0x46, 0xce,
+    0x55, 0x77, 0xf3, 0x5a, 0x17, 0x84, 0xee, 0xc2, 0xc1, 0x97, 0x70, 0x90,
+    0xb4, 0x8e, 0x30, 0xbd, 0x3b, 0x75, 0x06, 0xf4, 0x47, 0xee, 0x62, 0xd0,
+    0x21, 0xca, 0xe1, 0x2a, 0xd2, 0x87, 0xb4, 0x17, 0xed, 0xdb, 0x9e, 0xc6,
+    0x46, 0x0e, 0x3e, 0x28, 0x4a, 0xfa, 0x73, 0xb7, 0x39, 0x56, 0x4e, 0x40,
+    0x73, 0xd0, 0x0e, 0x3c,
+};
+static const struct drbg_kat_no_reseed kat215_t = {
+    4, kat215_entropyin, kat215_nonce, kat215_persstr,
+    kat215_addin0, kat215_addin1, kat215_retbits
+};
+static const struct drbg_kat kat215 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat215_t
+};
+
+static const unsigned char kat216_entropyin[] = {
+    0xc7, 0xe9, 0xf6, 0x88, 0x33, 0xb1, 0x8e, 0x03, 0x6a, 0xa1, 0xda, 0x02,
+    0x5a, 0x35, 0x9e, 0xd7,
+};
+static const unsigned char kat216_nonce[] = {
+    0x99, 0xf0, 0xe4, 0x9c, 0xe8, 0x11, 0xee, 0x7e,
+};
+static const unsigned char kat216_persstr[] = {
+    0x8d, 0xe7, 0xc8, 0x6b, 0x8e, 0xc6, 0x1d, 0x6a, 0xbb, 0x52, 0xa7, 0x91,
+    0x66, 0x71, 0xad, 0xb9,
+};
+static const unsigned char kat216_addin0[] = {0};
+static const unsigned char kat216_addin1[] = {0};
+static const unsigned char kat216_retbits[] = {
+    0x14, 0x07, 0xb6, 0x81, 0x51, 0xfc, 0xb0, 0xf0, 0x8e, 0xba, 0xbc, 0x21,
+    0xc6, 0xc1, 0x81, 0xac, 0x1d, 0xbf, 0x9c, 0x6f, 0xb1, 0xb2, 0xc1, 0x6e,
+    0xaf, 0x1f, 0x8c, 0x49, 0x0d, 0x6f, 0x7d, 0x52, 0xd0, 0xf4, 0x21, 0x11,
+    0x6a, 0x59, 0x98, 0x33, 0x0d, 0x81, 0x05, 0xf5, 0x02, 0x76, 0x17, 0xdc,
+    0x94, 0xb1, 0x4c, 0x08, 0x3f, 0x49, 0xd1, 0x1c, 0x34, 0xf4, 0xf2, 0x63,
+    0x02, 0x31, 0x66, 0x24,
+};
+static const struct drbg_kat_no_reseed kat216_t = {
+    5, kat216_entropyin, kat216_nonce, kat216_persstr,
+    kat216_addin0, kat216_addin1, kat216_retbits
+};
+static const struct drbg_kat kat216 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat216_t
+};
+
+static const unsigned char kat217_entropyin[] = {
+    0xd6, 0x7e, 0xeb, 0x00, 0xa4, 0x29, 0x1a, 0x18, 0x47, 0x11, 0x84, 0xb4,
+    0x31, 0x59, 0xd2, 0xbd,
+};
+static const unsigned char kat217_nonce[] = {
+    0xe4, 0xa3, 0x61, 0x49, 0x7e, 0xe1, 0x43, 0x8a,
+};
+static const unsigned char kat217_persstr[] = {
+    0xf0, 0x54, 0xad, 0xf2, 0xad, 0x38, 0x49, 0xda, 0x72, 0x72, 0xb3, 0xb3,
+    0x2a, 0xe0, 0xfc, 0xab,
+};
+static const unsigned char kat217_addin0[] = {0};
+static const unsigned char kat217_addin1[] = {0};
+static const unsigned char kat217_retbits[] = {
+    0x52, 0x45, 0xc3, 0x0a, 0x65, 0x1d, 0x98, 0x61, 0xb6, 0x36, 0xc8, 0xe8,
+    0xcc, 0x8b, 0x84, 0x52, 0x46, 0xda, 0x10, 0xc1, 0x04, 0xd7, 0x81, 0x34,
+    0xa8, 0x4e, 0x41, 0xfe, 0xa8, 0x0e, 0x0e, 0x73, 0x69, 0x2f, 0x84, 0x81,
+    0xcd, 0x4d, 0x75, 0x0c, 0x79, 0xe3, 0x87, 0x6b, 0x9a, 0xbf, 0xa9, 0xd6,
+    0x14, 0xd8, 0x68, 0x24, 0x96, 0x05, 0x61, 0x9d, 0xef, 0xef, 0x29, 0x68,
+    0xfd, 0x33, 0x14, 0x1e,
+};
+static const struct drbg_kat_no_reseed kat217_t = {
+    6, kat217_entropyin, kat217_nonce, kat217_persstr,
+    kat217_addin0, kat217_addin1, kat217_retbits
+};
+static const struct drbg_kat kat217 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat217_t
+};
+
+static const unsigned char kat218_entropyin[] = {
+    0xce, 0x08, 0xf0, 0x2b, 0xcd, 0xe4, 0x7f, 0x60, 0x30, 0x82, 0x02, 0x43,
+    0xe1, 0x01, 0x38, 0x87,
+};
+static const unsigned char kat218_nonce[] = {
+    0xd1, 0xb1, 0x51, 0x30, 0xcd, 0x03, 0x8d, 0x6d,
+};
+static const unsigned char kat218_persstr[] = {
+    0xad, 0x0b, 0xcb, 0x82, 0x01, 0x16, 0x0d, 0x82, 0xf1, 0x79, 0x66, 0xd4,
+    0xc7, 0xb6, 0xa4, 0xec,
+};
+static const unsigned char kat218_addin0[] = {0};
+static const unsigned char kat218_addin1[] = {0};
+static const unsigned char kat218_retbits[] = {
+    0xf4, 0x8e, 0xd0, 0x3b, 0xdb, 0xa9, 0x31, 0x0d, 0x7f, 0xe0, 0xa5, 0xdd,
+    0xdf, 0x9d, 0xf4, 0x9c, 0x0d, 0xbe, 0x07, 0xb9, 0x5b, 0xde, 0x25, 0xa0,
+    0xb6, 0x6e, 0xd0, 0x1a, 0x9f, 0x7a, 0x07, 0x82, 0x0f, 0x2d, 0x7e, 0xaa,
+    0x98, 0x63, 0x70, 0xa0, 0xce, 0x00, 0x01, 0x3b, 0x43, 0x31, 0xe4, 0x4b,
+    0xeb, 0x30, 0x10, 0x57, 0x5a, 0xf7, 0xd6, 0x25, 0xbe, 0xd5, 0x5a, 0x59,
+    0x2d, 0x97, 0x38, 0x28,
+};
+static const struct drbg_kat_no_reseed kat218_t = {
+    7, kat218_entropyin, kat218_nonce, kat218_persstr,
+    kat218_addin0, kat218_addin1, kat218_retbits
+};
+static const struct drbg_kat kat218 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat218_t
+};
+
+static const unsigned char kat219_entropyin[] = {
+    0x8d, 0xbc, 0xda, 0xa7, 0x8a, 0xdd, 0xb2, 0x85, 0xdf, 0xdb, 0x5e, 0x41,
+    0xee, 0xf6, 0x7e, 0x6f,
+};
+static const unsigned char kat219_nonce[] = {
+    0x49, 0x06, 0x2c, 0x09, 0x8b, 0x64, 0xe7, 0xf8,
+};
+static const unsigned char kat219_persstr[] = {
+    0x7d, 0xc1, 0x4e, 0x73, 0x96, 0xf6, 0x24, 0x50, 0xbe, 0xbd, 0xf2, 0xeb,
+    0xf0, 0x17, 0xaa, 0xd5,
+};
+static const unsigned char kat219_addin0[] = {0};
+static const unsigned char kat219_addin1[] = {0};
+static const unsigned char kat219_retbits[] = {
+    0x49, 0xd0, 0x3f, 0xe3, 0xb7, 0x2d, 0x44, 0xa8, 0xa1, 0xe4, 0x69, 0xd2,
+    0x5a, 0x14, 0x5b, 0xa6, 0x4d, 0x61, 0x69, 0xdd, 0x94, 0x7f, 0x87, 0x93,
+    0xd5, 0xef, 0x43, 0xde, 0x7b, 0x23, 0x94, 0x13, 0x70, 0x83, 0xe6, 0xe7,
+    0x69, 0xbb, 0xfd, 0xe9, 0x60, 0x0c, 0x36, 0xb0, 0x32, 0xb7, 0x78, 0x65,
+    0x22, 0x07, 0x0b, 0x5a, 0x65, 0xc7, 0x93, 0x92, 0x68, 0x92, 0xb9, 0xfb,
+    0x0d, 0x1c, 0x1d, 0x54,
+};
+static const struct drbg_kat_no_reseed kat219_t = {
+    8, kat219_entropyin, kat219_nonce, kat219_persstr,
+    kat219_addin0, kat219_addin1, kat219_retbits
+};
+static const struct drbg_kat kat219 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat219_t
+};
+
+static const unsigned char kat220_entropyin[] = {
+    0x0d, 0x98, 0x37, 0x0c, 0xff, 0xa0, 0xa8, 0x79, 0xfe, 0x85, 0xb5, 0xde,
+    0x4e, 0x69, 0xcf, 0x7d,
+};
+static const unsigned char kat220_nonce[] = {
+    0x93, 0x50, 0xa8, 0x6b, 0x7a, 0x1b, 0xc6, 0x8a,
+};
+static const unsigned char kat220_persstr[] = {
+    0x01, 0x61, 0xb2, 0x4d, 0x1c, 0x3c, 0xa5, 0x90, 0x11, 0x7e, 0xc2, 0x9a,
+    0xcc, 0x39, 0x44, 0x6f,
+};
+static const unsigned char kat220_addin0[] = {0};
+static const unsigned char kat220_addin1[] = {0};
+static const unsigned char kat220_retbits[] = {
+    0x7c, 0xd6, 0x46, 0x84, 0x28, 0x9b, 0x43, 0xb1, 0xe5, 0x93, 0xd9, 0x4a,
+    0xe9, 0x79, 0xf7, 0xfa, 0x5d, 0xe8, 0x95, 0x77, 0xf3, 0x7c, 0x7a, 0xea,
+    0x0b, 0x58, 0x4d, 0x18, 0x60, 0x2c, 0x25, 0x1b, 0x1e, 0xc2, 0x5f, 0xf6,
+    0x12, 0xd9, 0x7f, 0xda, 0x37, 0x84, 0xe9, 0x65, 0x59, 0x73, 0xe3, 0x1f,
+    0xd4, 0xb5, 0xd1, 0xea, 0xde, 0xc6, 0x68, 0x61, 0xae, 0x2e, 0x97, 0x19,
+    0xad, 0x34, 0x47, 0x30,
+};
+static const struct drbg_kat_no_reseed kat220_t = {
+    9, kat220_entropyin, kat220_nonce, kat220_persstr,
+    kat220_addin0, kat220_addin1, kat220_retbits
+};
+static const struct drbg_kat kat220 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat220_t
+};
+
+static const unsigned char kat221_entropyin[] = {
+    0xd9, 0xb6, 0xfb, 0x62, 0xda, 0x0a, 0x02, 0x32, 0x35, 0xe7, 0xcd, 0x78,
+    0x16, 0x37, 0x7c, 0xf5,
+};
+static const unsigned char kat221_nonce[] = {
+    0x1c, 0xa8, 0xc5, 0xfa, 0x5b, 0x9f, 0x8c, 0x90,
+};
+static const unsigned char kat221_persstr[] = {
+    0x17, 0xbe, 0x48, 0x85, 0xb5, 0xf9, 0x64, 0x1b, 0xf5, 0xf6, 0x89, 0xbc,
+    0x97, 0x97, 0x88, 0x58,
+};
+static const unsigned char kat221_addin0[] = {0};
+static const unsigned char kat221_addin1[] = {0};
+static const unsigned char kat221_retbits[] = {
+    0xe1, 0x1e, 0x3c, 0xa6, 0xc8, 0x32, 0xf4, 0x6f, 0xf1, 0xf9, 0x71, 0xc0,
+    0x7e, 0x7b, 0x66, 0xc7, 0xd5, 0xb1, 0xb2, 0xe6, 0xec, 0x8c, 0x5f, 0xfc,
+    0x77, 0x10, 0x3f, 0x0a, 0xd3, 0x08, 0x80, 0x0b, 0xb9, 0x89, 0xb9, 0xab,
+    0x70, 0x10, 0x68, 0x33, 0x78, 0xa3, 0xf7, 0x81, 0x9a, 0x29, 0x7a, 0x37,
+    0x65, 0x25, 0x6a, 0xc4, 0x0f, 0xb0, 0xa9, 0xcb, 0x22, 0x46, 0xae, 0xb8,
+    0x5d, 0x73, 0x60, 0x1b,
+};
+static const struct drbg_kat_no_reseed kat221_t = {
+    10, kat221_entropyin, kat221_nonce, kat221_persstr,
+    kat221_addin0, kat221_addin1, kat221_retbits
+};
+static const struct drbg_kat kat221 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat221_t
+};
+
+static const unsigned char kat222_entropyin[] = {
+    0xa7, 0x11, 0x39, 0x44, 0xfc, 0x4d, 0x4b, 0x15, 0xa9, 0x49, 0x67, 0xc8,
+    0xf5, 0x65, 0x2a, 0x36,
+};
+static const unsigned char kat222_nonce[] = {
+    0xa5, 0x06, 0xb7, 0x9a, 0xfe, 0x6a, 0xf8, 0x22,
+};
+static const unsigned char kat222_persstr[] = {
+    0x91, 0x8f, 0xe4, 0xf3, 0x65, 0x25, 0x9c, 0x18, 0xeb, 0x68, 0x50, 0xfb,
+    0xee, 0x40, 0x3f, 0x5e,
+};
+static const unsigned char kat222_addin0[] = {0};
+static const unsigned char kat222_addin1[] = {0};
+static const unsigned char kat222_retbits[] = {
+    0x60, 0x76, 0xb2, 0xc0, 0xf7, 0xde, 0x1d, 0xd3, 0xe4, 0x6a, 0xdb, 0x11,
+    0x61, 0xb7, 0x2a, 0x7f, 0x83, 0xb8, 0x77, 0x3f, 0xab, 0x0d, 0xcb, 0x1c,
+    0x1f, 0xde, 0x25, 0xdb, 0x0d, 0x09, 0x86, 0x2a, 0xcd, 0xd3, 0x8f, 0x8d,
+    0x21, 0x64, 0x90, 0x3a, 0x8e, 0x88, 0x58, 0xf8, 0xa9, 0xb6, 0x1b, 0xd7,
+    0xda, 0xe3, 0xf6, 0x06, 0x68, 0xe6, 0xee, 0x26, 0x4b, 0x9f, 0xfa, 0xf5,
+    0x78, 0xb5, 0x56, 0x46,
+};
+static const struct drbg_kat_no_reseed kat222_t = {
+    11, kat222_entropyin, kat222_nonce, kat222_persstr,
+    kat222_addin0, kat222_addin1, kat222_retbits
+};
+static const struct drbg_kat kat222 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat222_t
+};
+
+static const unsigned char kat223_entropyin[] = {
+    0xac, 0xf7, 0x62, 0x38, 0x39, 0xb9, 0x4b, 0xd7, 0xa8, 0x93, 0xc2, 0x87,
+    0x61, 0x6c, 0xdb, 0x6a,
+};
+static const unsigned char kat223_nonce[] = {
+    0xa1, 0xf6, 0x03, 0x9f, 0x91, 0xc1, 0x76, 0x23,
+};
+static const unsigned char kat223_persstr[] = {
+    0x5f, 0x9c, 0x69, 0xde, 0x2c, 0x32, 0x87, 0x3f, 0x67, 0x9d, 0x17, 0x68,
+    0xef, 0x3c, 0x70, 0xfb,
+};
+static const unsigned char kat223_addin0[] = {0};
+static const unsigned char kat223_addin1[] = {0};
+static const unsigned char kat223_retbits[] = {
+    0xf6, 0xab, 0xbf, 0xfd, 0x79, 0x65, 0x64, 0x94, 0x36, 0xb4, 0x8b, 0x09,
+    0x20, 0x86, 0xcd, 0xf0, 0x50, 0x2f, 0x52, 0xc8, 0x7c, 0x8f, 0xdc, 0x8f,
+    0x6d, 0x49, 0xf0, 0x84, 0x33, 0xa2, 0x02, 0xd8, 0xbe, 0x44, 0xf6, 0x56,
+    0x2a, 0xce, 0x58, 0x0e, 0x80, 0x75, 0xf0, 0xbc, 0x67, 0x0b, 0x2e, 0x9d,
+    0x95, 0x1f, 0x15, 0xf8, 0x4d, 0x82, 0xaf, 0xe6, 0xb8, 0x32, 0x76, 0x5e,
+    0xca, 0xb0, 0x37, 0xee,
+};
+static const struct drbg_kat_no_reseed kat223_t = {
+    12, kat223_entropyin, kat223_nonce, kat223_persstr,
+    kat223_addin0, kat223_addin1, kat223_retbits
+};
+static const struct drbg_kat kat223 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat223_t
+};
+
+static const unsigned char kat224_entropyin[] = {
+    0xd9, 0x0d, 0x78, 0x6e, 0x9d, 0x19, 0x62, 0x84, 0x3b, 0x02, 0x7a, 0xa0,
+    0xe8, 0x59, 0x8f, 0xd4,
+};
+static const unsigned char kat224_nonce[] = {
+    0x04, 0x17, 0xf1, 0x4f, 0x96, 0xf2, 0x02, 0x9c,
+};
+static const unsigned char kat224_persstr[] = {
+    0xec, 0x5c, 0x55, 0x14, 0x5a, 0x4f, 0x95, 0x52, 0xf2, 0x51, 0xf7, 0xdf,
+    0xb0, 0x17, 0xc1, 0xd4,
+};
+static const unsigned char kat224_addin0[] = {0};
+static const unsigned char kat224_addin1[] = {0};
+static const unsigned char kat224_retbits[] = {
+    0xfe, 0x2c, 0xa4, 0x44, 0x55, 0xa5, 0xe7, 0xde, 0x70, 0x8a, 0x71, 0x0a,
+    0xb6, 0x46, 0xcf, 0xcf, 0xbc, 0x87, 0xd6, 0x78, 0xb3, 0xe9, 0x41, 0x06,
+    0x3f, 0xa7, 0x01, 0xda, 0xc7, 0xcb, 0x4f, 0x09, 0x53, 0xaf, 0x8f, 0xce,
+    0x45, 0x8c, 0xee, 0x54, 0x9f, 0x53, 0x7f, 0xa7, 0x71, 0xb8, 0x9b, 0x04,
+    0x94, 0xc0, 0xbb, 0x5c, 0xfd, 0x35, 0xbf, 0x67, 0xf4, 0xb2, 0x70, 0xd6,
+    0x20, 0x5f, 0x47, 0x03,
+};
+static const struct drbg_kat_no_reseed kat224_t = {
+    13, kat224_entropyin, kat224_nonce, kat224_persstr,
+    kat224_addin0, kat224_addin1, kat224_retbits
+};
+static const struct drbg_kat kat224 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat224_t
+};
+
+static const unsigned char kat225_entropyin[] = {
+    0x1c, 0xdb, 0x74, 0x45, 0x59, 0xa8, 0x2c, 0x62, 0xfb, 0x3b, 0x15, 0xa2,
+    0xa3, 0xaa, 0xd1, 0x89,
+};
+static const unsigned char kat225_nonce[] = {
+    0x43, 0x43, 0x2c, 0xe3, 0x0a, 0xe7, 0xf9, 0x6b,
+};
+static const unsigned char kat225_persstr[] = {
+    0xf5, 0x9a, 0xd9, 0x93, 0x9f, 0xcd, 0x6c, 0x0f, 0x47, 0x8c, 0xc5, 0x08,
+    0x39, 0xf8, 0xff, 0xce,
+};
+static const unsigned char kat225_addin0[] = {0};
+static const unsigned char kat225_addin1[] = {0};
+static const unsigned char kat225_retbits[] = {
+    0x91, 0xb9, 0xeb, 0xeb, 0x92, 0x9d, 0xc6, 0x99, 0x94, 0x91, 0x22, 0x97,
+    0x0b, 0x21, 0x77, 0xd5, 0xd5, 0xb7, 0x05, 0x04, 0x2d, 0x3a, 0x0d, 0x60,
+    0xd7, 0xd3, 0xbb, 0x21, 0x8b, 0x7a, 0x69, 0xe1, 0xcd, 0x68, 0x64, 0xb8,
+    0xa2, 0x68, 0xca, 0x78, 0xc8, 0x34, 0x23, 0x2d, 0x0c, 0xb8, 0x8f, 0x93,
+    0x77, 0x30, 0x08, 0x4b, 0x1e, 0xc7, 0xd2, 0x86, 0x7f, 0xbc, 0x85, 0x0e,
+    0x04, 0x05, 0x03, 0x24,
+};
+static const struct drbg_kat_no_reseed kat225_t = {
+    14, kat225_entropyin, kat225_nonce, kat225_persstr,
+    kat225_addin0, kat225_addin1, kat225_retbits
+};
+static const struct drbg_kat kat225 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 0, 64, &kat225_t
+};
+
+static const unsigned char kat226_entropyin[] = {
+    0x71, 0xba, 0x02, 0x9a, 0x7a, 0x92, 0x39, 0x1b, 0x3f, 0x29, 0x4f, 0x2f,
+    0xbf, 0x57, 0x27, 0xab,
+};
+static const unsigned char kat226_nonce[] = {
+    0xf0, 0xe9, 0x12, 0x78, 0x8f, 0x98, 0x27, 0xff,
+};
+static const unsigned char kat226_persstr[] = {
+    0x23, 0xf3, 0x69, 0x80, 0xda, 0x40, 0x16, 0x64, 0x2c, 0x81, 0x0d, 0xa2,
+    0x99, 0x0a, 0xa2, 0x5e,
+};
+static const unsigned char kat226_addin0[] = {
+    0x59, 0xab, 0x41, 0xb2, 0x4e, 0xe8, 0xe2, 0x71, 0xe2, 0x53, 0xc6, 0xcc,
+    0x40, 0x48, 0x7c, 0xb5,
+};
+static const unsigned char kat226_addin1[] = {
+    0x91, 0x64, 0xf0, 0x28, 0x60, 0x77, 0x3e, 0x3b, 0x96, 0xd8, 0x5b, 0x37,
+    0x38, 0x38, 0x50, 0x66,
+};
+static const unsigned char kat226_retbits[] = {
+    0xde, 0x1b, 0x8a, 0x25, 0x95, 0x89, 0x23, 0x54, 0xda, 0x47, 0xb4, 0xea,
+    0xaf, 0x9d, 0xdc, 0xec, 0x64, 0xa9, 0x61, 0x01, 0x17, 0xb0, 0x5e, 0x40,
+    0xd0, 0x76, 0x60, 0xa8, 0x0b, 0xcf, 0x82, 0x5e, 0xef, 0xdb, 0xd2, 0x8e,
+    0x07, 0xd5, 0x96, 0x81, 0xf9, 0xe0, 0x03, 0x7b, 0xdb, 0x72, 0x5f, 0xe6,
+    0xce, 0x84, 0x6d, 0x82, 0x4b, 0x3b, 0x34, 0xc2, 0xc2, 0x1a, 0x48, 0xf8,
+    0x89, 0x5f, 0x9f, 0x5e,
+};
+static const struct drbg_kat_no_reseed kat226_t = {
+    0, kat226_entropyin, kat226_nonce, kat226_persstr,
+    kat226_addin0, kat226_addin1, kat226_retbits
+};
+static const struct drbg_kat kat226 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat226_t
+};
+
+static const unsigned char kat227_entropyin[] = {
+    0x67, 0x73, 0x94, 0xf0, 0x3e, 0xac, 0xb5, 0xa1, 0x37, 0x51, 0x5f, 0xcd,
+    0x3e, 0xa2, 0xbb, 0xc7,
+};
+static const unsigned char kat227_nonce[] = {
+    0x9a, 0x5c, 0x1c, 0xea, 0x26, 0xef, 0xbf, 0x76,
+};
+static const unsigned char kat227_persstr[] = {
+    0xdd, 0x73, 0xb1, 0x8e, 0xee, 0x62, 0x94, 0x34, 0x9a, 0xa6, 0x45, 0x6d,
+    0xaa, 0x77, 0xd2, 0x4f,
+};
+static const unsigned char kat227_addin0[] = {
+    0xeb, 0x70, 0x19, 0x82, 0x6d, 0xb3, 0x27, 0x17, 0xa5, 0x73, 0x5e, 0xb4,
+    0x07, 0x73, 0xea, 0x56,
+};
+static const unsigned char kat227_addin1[] = {
+    0xb6, 0x2d, 0xe2, 0xb4, 0xaa, 0x8d, 0x97, 0xf5, 0x26, 0xdd, 0xba, 0x44,
+    0x09, 0xf5, 0xaa, 0x26,
+};
+static const unsigned char kat227_retbits[] = {
+    0x22, 0x22, 0xa6, 0xbb, 0x0f, 0xfe, 0x14, 0xd2, 0xf7, 0x89, 0xe6, 0x4d,
+    0xcd, 0xf4, 0x78, 0x51, 0xa6, 0xc3, 0xa6, 0xe1, 0xd0, 0x83, 0x7d, 0x8b,
+    0x51, 0x1a, 0xa2, 0xf5, 0x6a, 0x6d, 0x08, 0x53, 0x4c, 0x97, 0xf4, 0xb1,
+    0x2a, 0x77, 0x44, 0x7d, 0xb2, 0x04, 0x09, 0xd3, 0x27, 0xfc, 0x08, 0x81,
+    0x62, 0xc0, 0xf2, 0xc5, 0x9f, 0xe4, 0x7e, 0x8c, 0x92, 0xae, 0x5d, 0xcd,
+    0xd7, 0x38, 0xc7, 0x68,
+};
+static const struct drbg_kat_no_reseed kat227_t = {
+    1, kat227_entropyin, kat227_nonce, kat227_persstr,
+    kat227_addin0, kat227_addin1, kat227_retbits
+};
+static const struct drbg_kat kat227 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat227_t
+};
+
+static const unsigned char kat228_entropyin[] = {
+    0x3f, 0x51, 0xf6, 0xcc, 0xf2, 0x24, 0x79, 0xed, 0x89, 0x1b, 0x89, 0x1f,
+    0xc4, 0xc6, 0xb5, 0x51,
+};
+static const unsigned char kat228_nonce[] = {
+    0x19, 0xe0, 0x75, 0x4f, 0x7b, 0xfa, 0x0c, 0xef,
+};
+static const unsigned char kat228_persstr[] = {
+    0x40, 0x2a, 0x1d, 0xab, 0x45, 0x0e, 0xa9, 0x04, 0x97, 0x38, 0x78, 0x2a,
+    0x93, 0x34, 0x7a, 0xff,
+};
+static const unsigned char kat228_addin0[] = {
+    0x52, 0xc9, 0x0f, 0x57, 0x1c, 0x8c, 0x63, 0xf0, 0xdc, 0xdb, 0xd4, 0xe6,
+    0xc9, 0x65, 0x34, 0x78,
+};
+static const unsigned char kat228_addin1[] = {
+    0x8b, 0xe6, 0x3b, 0x5e, 0xf2, 0x12, 0x69, 0x4e, 0xdb, 0xc2, 0xc8, 0xde,
+    0xc9, 0xa0, 0x58, 0x7b,
+};
+static const unsigned char kat228_retbits[] = {
+    0x1a, 0xbf, 0xe2, 0xd7, 0x21, 0x93, 0xb6, 0xe3, 0xd9, 0xbe, 0x85, 0x10,
+    0x7e, 0xce, 0x8f, 0xea, 0x5d, 0x22, 0x95, 0x68, 0x56, 0x8c, 0x93, 0xeb,
+    0x5e, 0xae, 0xd4, 0x63, 0xbf, 0x2b, 0x79, 0xcf, 0xdb, 0xd0, 0x47, 0x40,
+    0x2f, 0xf4, 0xe4, 0x22, 0x34, 0xc4, 0xe3, 0xe1, 0x50, 0xc1, 0xf0, 0xe8,
+    0x24, 0x00, 0xf6, 0xa5, 0x9e, 0xeb, 0xd0, 0x92, 0xee, 0x73, 0xad, 0xf1,
+    0xff, 0xca, 0x64, 0x94,
+};
+static const struct drbg_kat_no_reseed kat228_t = {
+    2, kat228_entropyin, kat228_nonce, kat228_persstr,
+    kat228_addin0, kat228_addin1, kat228_retbits
+};
+static const struct drbg_kat kat228 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat228_t
+};
+
+static const unsigned char kat229_entropyin[] = {
+    0x5a, 0x01, 0xb6, 0x38, 0x31, 0x1a, 0x29, 0x6b, 0xfe, 0x1f, 0x6e, 0x18,
+    0x0f, 0x24, 0x3d, 0x5b,
+};
+static const unsigned char kat229_nonce[] = {
+    0x16, 0xbb, 0x4e, 0x36, 0xfd, 0x04, 0xb0, 0x5b,
+};
+static const unsigned char kat229_persstr[] = {
+    0xd5, 0x44, 0x0a, 0x6f, 0xa4, 0xd3, 0x45, 0xcb, 0x84, 0xd5, 0x6d, 0xec,
+    0xaa, 0x3d, 0xbd, 0x18,
+};
+static const unsigned char kat229_addin0[] = {
+    0xbd, 0x3e, 0x11, 0xdb, 0xb9, 0xf4, 0x0a, 0x13, 0x51, 0xc8, 0xbf, 0x7b,
+    0xd8, 0x94, 0xad, 0x20,
+};
+static const unsigned char kat229_addin1[] = {
+    0xe0, 0x4a, 0x83, 0xa5, 0x18, 0x75, 0x15, 0x10, 0x4a, 0xa1, 0xe7, 0xf4,
+    0x34, 0xff, 0x43, 0x36,
+};
+static const unsigned char kat229_retbits[] = {
+    0x27, 0x28, 0xfc, 0xc1, 0xfe, 0xa7, 0xfe, 0x63, 0x5d, 0xdf, 0xed, 0x8b,
+    0xb3, 0xf7, 0xca, 0x29, 0xe1, 0xcb, 0xd8, 0x51, 0x6a, 0x2b, 0x5e, 0xab,
+    0xb7, 0xd0, 0x91, 0xe6, 0xe7, 0xf2, 0x04, 0x6a, 0x80, 0x77, 0xef, 0x6d,
+    0x1a, 0x90, 0x16, 0x5f, 0x18, 0x9d, 0x07, 0xa8, 0x97, 0xcd, 0xfc, 0x06,
+    0x88, 0x2a, 0xdb, 0x78, 0x1b, 0xe5, 0x89, 0xe0, 0xe5, 0xeb, 0x2d, 0xc9,
+    0x7b, 0xe6, 0x54, 0x6b,
+};
+static const struct drbg_kat_no_reseed kat229_t = {
+    3, kat229_entropyin, kat229_nonce, kat229_persstr,
+    kat229_addin0, kat229_addin1, kat229_retbits
+};
+static const struct drbg_kat kat229 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat229_t
+};
+
+static const unsigned char kat230_entropyin[] = {
+    0x97, 0xe4, 0x15, 0xb3, 0xca, 0x11, 0x0a, 0x80, 0x9e, 0xa6, 0x00, 0xa1,
+    0x3e, 0x47, 0xaa, 0x04,
+};
+static const unsigned char kat230_nonce[] = {
+    0x12, 0x6e, 0x16, 0xdc, 0x57, 0x22, 0xa4, 0x49,
+};
+static const unsigned char kat230_persstr[] = {
+    0xa9, 0xbe, 0x38, 0xe3, 0x01, 0x19, 0x86, 0xb9, 0x04, 0x71, 0x71, 0x93,
+    0xec, 0x4a, 0x7d, 0x4c,
+};
+static const unsigned char kat230_addin0[] = {
+    0x19, 0x68, 0x69, 0x92, 0x21, 0xeb, 0x8b, 0x5e, 0xd0, 0x23, 0xa5, 0xd2,
+    0xd2, 0xd8, 0x12, 0x56,
+};
+static const unsigned char kat230_addin1[] = {
+    0x4b, 0x5e, 0x1b, 0xde, 0x38, 0xb2, 0xa9, 0x79, 0x3b, 0x16, 0x6d, 0x86,
+    0x81, 0x6e, 0xd2, 0x31,
+};
+static const unsigned char kat230_retbits[] = {
+    0x4b, 0xe9, 0x89, 0x89, 0xdf, 0x2f, 0xe6, 0x68, 0x7e, 0x50, 0x88, 0xe5,
+    0x06, 0x98, 0x50, 0x7d, 0x91, 0x06, 0x1a, 0x8d, 0x6e, 0xb9, 0x5d, 0x66,
+    0x27, 0xd2, 0xb8, 0x57, 0x25, 0x3f, 0x05, 0x3c, 0x99, 0xee, 0x79, 0x84,
+    0xa4, 0x98, 0xde, 0x4d, 0xf3, 0x12, 0x44, 0x42, 0x85, 0x6f, 0x18, 0xe9,
+    0x8e, 0x66, 0x41, 0xf1, 0x52, 0xcd, 0x12, 0x9b, 0xd0, 0x4e, 0x99, 0x71,
+    0x09, 0x30, 0xc3, 0xe1,
+};
+static const struct drbg_kat_no_reseed kat230_t = {
+    4, kat230_entropyin, kat230_nonce, kat230_persstr,
+    kat230_addin0, kat230_addin1, kat230_retbits
+};
+static const struct drbg_kat kat230 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat230_t
+};
+
+static const unsigned char kat231_entropyin[] = {
+    0xb6, 0xc4, 0xcd, 0x96, 0xf7, 0xfd, 0xe8, 0x3e, 0xb5, 0x71, 0x22, 0x9b,
+    0x53, 0x7a, 0xcf, 0x5a,
+};
+static const unsigned char kat231_nonce[] = {
+    0x4c, 0x4e, 0x0a, 0xac, 0xb5, 0xc5, 0x28, 0xe7,
+};
+static const unsigned char kat231_persstr[] = {
+    0x5c, 0xe1, 0x09, 0x4d, 0x0d, 0x30, 0x7b, 0x41, 0xdb, 0x9b, 0xf2, 0x6d,
+    0xa4, 0x1d, 0xb1, 0x00,
+};
+static const unsigned char kat231_addin0[] = {
+    0x98, 0x04, 0x7e, 0xe9, 0x87, 0x63, 0x7e, 0x45, 0x84, 0xfe, 0x7f, 0xe2,
+    0x86, 0x9c, 0x84, 0x5d,
+};
+static const unsigned char kat231_addin1[] = {
+    0x17, 0x7e, 0x3c, 0x29, 0xd4, 0xfa, 0xf0, 0x43, 0x07, 0x7f, 0xbe, 0xfe,
+    0x0b, 0x99, 0x4b, 0x91,
+};
+static const unsigned char kat231_retbits[] = {
+    0x5e, 0xaf, 0x01, 0x3f, 0xd3, 0x77, 0x5a, 0x2d, 0x3e, 0x97, 0x16, 0x6d,
+    0x23, 0x15, 0x3a, 0x00, 0xf1, 0x86, 0x44, 0x96, 0x3e, 0x69, 0xcb, 0x96,
+    0x2a, 0x7b, 0xd2, 0xc3, 0x0a, 0xf9, 0xbd, 0x6a, 0x29, 0xd4, 0xbc, 0x70,
+    0x93, 0x0a, 0x92, 0x9b, 0x92, 0x52, 0xd8, 0x08, 0xdb, 0x41, 0x0c, 0x66,
+    0x41, 0x23, 0xbd, 0x69, 0xc1, 0xd0, 0xc1, 0xd4, 0xba, 0x3c, 0x7d, 0x8f,
+    0xf7, 0xae, 0x00, 0xf0,
+};
+static const struct drbg_kat_no_reseed kat231_t = {
+    5, kat231_entropyin, kat231_nonce, kat231_persstr,
+    kat231_addin0, kat231_addin1, kat231_retbits
+};
+static const struct drbg_kat kat231 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat231_t
+};
+
+static const unsigned char kat232_entropyin[] = {
+    0x2d, 0x1b, 0x80, 0x61, 0xd7, 0xd5, 0x83, 0xf8, 0x3b, 0xe5, 0x53, 0xc4,
+    0x83, 0x72, 0x12, 0xa0,
+};
+static const unsigned char kat232_nonce[] = {
+    0x62, 0xa1, 0xfa, 0x74, 0x53, 0x62, 0xba, 0xce,
+};
+static const unsigned char kat232_persstr[] = {
+    0x4d, 0x97, 0x6a, 0xdd, 0x18, 0xd5, 0xe2, 0x48, 0x4f, 0x67, 0xf7, 0xc8,
+    0x4c, 0xc6, 0x8b, 0x52,
+};
+static const unsigned char kat232_addin0[] = {
+    0x57, 0x64, 0xde, 0x5d, 0xb9, 0x7e, 0x22, 0x3c, 0x04, 0x4a, 0x83, 0x3f,
+    0xa4, 0x2c, 0xf6, 0x29,
+};
+static const unsigned char kat232_addin1[] = {
+    0xde, 0xef, 0x8d, 0x58, 0x1f, 0x6e, 0x4f, 0x80, 0x89, 0x92, 0xfd, 0x20,
+    0xc0, 0x6e, 0x10, 0x2d,
+};
+static const unsigned char kat232_retbits[] = {
+    0xac, 0xb7, 0x8f, 0x27, 0x33, 0x50, 0xd4, 0x59, 0xc7, 0x98, 0x09, 0xd8,
+    0x9b, 0x40, 0x28, 0x25, 0xbb, 0x00, 0xe3, 0x8a, 0xbd, 0x5e, 0xc1, 0x2f,
+    0xea, 0xdc, 0xde, 0xf6, 0x11, 0x46, 0x84, 0xb6, 0xfc, 0xb0, 0xe1, 0x76,
+    0xcb, 0xe4, 0x65, 0x91, 0x0f, 0xc2, 0x84, 0x8f, 0x0a, 0x70, 0x88, 0x44,
+    0x79, 0x4c, 0x5e, 0xea, 0xfe, 0xad, 0xa7, 0x56, 0x3c, 0x38, 0xc3, 0xee,
+    0x63, 0xc9, 0x7e, 0xf9,
+};
+static const struct drbg_kat_no_reseed kat232_t = {
+    6, kat232_entropyin, kat232_nonce, kat232_persstr,
+    kat232_addin0, kat232_addin1, kat232_retbits
+};
+static const struct drbg_kat kat232 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat232_t
+};
+
+static const unsigned char kat233_entropyin[] = {
+    0xef, 0x30, 0xfd, 0x99, 0x5f, 0xf0, 0xef, 0x44, 0xcc, 0xe6, 0x07, 0x7b,
+    0xb2, 0x2d, 0xe6, 0x99,
+};
+static const unsigned char kat233_nonce[] = {
+    0x85, 0xc7, 0xd6, 0x05, 0x4a, 0x57, 0x76, 0x22,
+};
+static const unsigned char kat233_persstr[] = {
+    0x5d, 0x59, 0xb3, 0xf0, 0x25, 0x00, 0x60, 0xe2, 0x20, 0x02, 0xad, 0xf7,
+    0x06, 0x48, 0x6d, 0x85,
+};
+static const unsigned char kat233_addin0[] = {
+    0x79, 0x46, 0x81, 0xf7, 0x5d, 0xf9, 0xc9, 0x88, 0x30, 0x3f, 0x75, 0x1f,
+    0xb7, 0xe7, 0xfb, 0xa9,
+};
+static const unsigned char kat233_addin1[] = {
+    0x7b, 0x13, 0x74, 0xc8, 0x47, 0x25, 0x37, 0xfa, 0x31, 0x11, 0xeb, 0x44,
+    0xe5, 0x2a, 0xfa, 0x23,
+};
+static const unsigned char kat233_retbits[] = {
+    0xb0, 0x49, 0x50, 0xf1, 0xa3, 0x57, 0x52, 0xc0, 0x67, 0xbc, 0xe8, 0x35,
+    0x76, 0x35, 0xf4, 0x70, 0xd1, 0x0b, 0x3b, 0xae, 0x47, 0x46, 0x6f, 0xd1,
+    0x16, 0x6f, 0x9f, 0xfa, 0xef, 0xbd, 0x32, 0x4b, 0x26, 0x53, 0xc7, 0xf3,
+    0x0e, 0xe4, 0x84, 0x86, 0x73, 0xd7, 0x04, 0x18, 0x65, 0xd9, 0x95, 0x45,
+    0x12, 0x58, 0x94, 0x92, 0x98, 0x9a, 0x00, 0xea, 0x4d, 0xa1, 0xdd, 0x28,
+    0x9e, 0x87, 0x17, 0xc3,
+};
+static const struct drbg_kat_no_reseed kat233_t = {
+    7, kat233_entropyin, kat233_nonce, kat233_persstr,
+    kat233_addin0, kat233_addin1, kat233_retbits
+};
+static const struct drbg_kat kat233 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat233_t
+};
+
+static const unsigned char kat234_entropyin[] = {
+    0xee, 0x4b, 0xde, 0x4f, 0x71, 0x2d, 0xc9, 0xfc, 0x1f, 0x2c, 0x01, 0xf1,
+    0xc6, 0x08, 0x6f, 0x35,
+};
+static const unsigned char kat234_nonce[] = {
+    0xf6, 0x83, 0x7c, 0xfe, 0x53, 0xec, 0x48, 0x74,
+};
+static const unsigned char kat234_persstr[] = {
+    0xfd, 0xb8, 0xf6, 0x4d, 0x99, 0xbd, 0x71, 0x7e, 0xee, 0x3d, 0x89, 0x35,
+    0x3b, 0x73, 0xc9, 0xc1,
+};
+static const unsigned char kat234_addin0[] = {
+    0x09, 0xe5, 0xba, 0x3b, 0x23, 0x89, 0x5c, 0x5d, 0xff, 0x89, 0x38, 0x2d,
+    0x5e, 0x91, 0x70, 0x0d,
+};
+static const unsigned char kat234_addin1[] = {
+    0xeb, 0x1a, 0x98, 0xde, 0x89, 0x62, 0xbb, 0xc4, 0xcb, 0x75, 0xcf, 0x0b,
+    0xf0, 0xf8, 0xdf, 0xa4,
+};
+static const unsigned char kat234_retbits[] = {
+    0xaa, 0xcd, 0xee, 0x0f, 0x3d, 0x1f, 0x95, 0x5f, 0x89, 0x6d, 0x5a, 0x5a,
+    0x25, 0x30, 0xfd, 0x80, 0x9a, 0x20, 0x2c, 0x92, 0x1d, 0x90, 0xa9, 0xcf,
+    0x59, 0x3e, 0x03, 0x93, 0x4e, 0x07, 0xc3, 0x92, 0xcc, 0x55, 0x54, 0xf5,
+    0x99, 0x21, 0xb4, 0x0c, 0xc0, 0x03, 0xfc, 0x26, 0x82, 0xca, 0xef, 0x9e,
+    0x6e, 0x61, 0xee, 0x4a, 0xbf, 0x45, 0x14, 0x8e, 0x5f, 0xf3, 0xff, 0x65,
+    0x87, 0x1b, 0x0d, 0x81,
+};
+static const struct drbg_kat_no_reseed kat234_t = {
+    8, kat234_entropyin, kat234_nonce, kat234_persstr,
+    kat234_addin0, kat234_addin1, kat234_retbits
+};
+static const struct drbg_kat kat234 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat234_t
+};
+
+static const unsigned char kat235_entropyin[] = {
+    0xa6, 0xaa, 0x94, 0x5e, 0xbe, 0x19, 0x29, 0x98, 0xbe, 0x8e, 0x24, 0x7d,
+    0xb9, 0x9c, 0xe7, 0xd0,
+};
+static const unsigned char kat235_nonce[] = {
+    0x7d, 0xff, 0x26, 0xe9, 0x7a, 0x0a, 0x8d, 0xba,
+};
+static const unsigned char kat235_persstr[] = {
+    0x4b, 0x6c, 0xcf, 0xac, 0x6c, 0x47, 0xfd, 0x65, 0x64, 0xbc, 0xfd, 0x94,
+    0xfe, 0x9e, 0xb2, 0x8d,
+};
+static const unsigned char kat235_addin0[] = {
+    0x07, 0x83, 0x70, 0x53, 0xd2, 0x4c, 0xd0, 0xf4, 0xf4, 0x32, 0x7e, 0x97,
+    0xd2, 0x9d, 0x67, 0x95,
+};
+static const unsigned char kat235_addin1[] = {
+    0x3b, 0x17, 0x2d, 0xdc, 0x8d, 0x38, 0x3b, 0x98, 0xd4, 0x08, 0x39, 0x4c,
+    0x0b, 0xa1, 0x52, 0xc1,
+};
+static const unsigned char kat235_retbits[] = {
+    0xd9, 0x0a, 0xa4, 0x22, 0xa8, 0xd2, 0xb8, 0x6e, 0x1f, 0x09, 0xde, 0x29,
+    0xdd, 0x16, 0xd4, 0x60, 0x50, 0x98, 0xa4, 0x5a, 0xea, 0xbe, 0x69, 0xc6,
+    0xbc, 0x8a, 0xe0, 0xc8, 0xf0, 0x1b, 0x7c, 0xc7, 0x3f, 0x88, 0x50, 0xec,
+    0x0c, 0x47, 0xd6, 0x16, 0xcb, 0x6c, 0xca, 0xb7, 0x7f, 0x22, 0x07, 0x99,
+    0x38, 0xed, 0x11, 0xb4, 0x8f, 0xcf, 0x3c, 0xf4, 0x6a, 0x3f, 0x64, 0x2f,
+    0x05, 0xae, 0xb8, 0xb7,
+};
+static const struct drbg_kat_no_reseed kat235_t = {
+    9, kat235_entropyin, kat235_nonce, kat235_persstr,
+    kat235_addin0, kat235_addin1, kat235_retbits
+};
+static const struct drbg_kat kat235 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat235_t
+};
+
+static const unsigned char kat236_entropyin[] = {
+    0x7e, 0xb5, 0x0f, 0x53, 0x2b, 0x00, 0x76, 0x52, 0x8e, 0x2d, 0x1f, 0x26,
+    0x6b, 0x38, 0x14, 0x06,
+};
+static const unsigned char kat236_nonce[] = {
+    0x2a, 0x5e, 0x92, 0xe8, 0xfb, 0xf0, 0xe9, 0xee,
+};
+static const unsigned char kat236_persstr[] = {
+    0x7e, 0xcb, 0xfd, 0x22, 0x98, 0x87, 0x2a, 0x79, 0x34, 0xe4, 0xed, 0x61,
+    0xa9, 0xf0, 0x04, 0xcd,
+};
+static const unsigned char kat236_addin0[] = {
+    0x17, 0x9f, 0xa5, 0xd2, 0xeb, 0x90, 0xd4, 0x15, 0x48, 0x19, 0x2c, 0xc7,
+    0x44, 0x98, 0xbd, 0x42,
+};
+static const unsigned char kat236_addin1[] = {
+    0x92, 0xdc, 0x9d, 0x60, 0xd2, 0xe3, 0x6d, 0x4b, 0xfb, 0x97, 0x90, 0x78,
+    0x3d, 0x1c, 0x58, 0x19,
+};
+static const unsigned char kat236_retbits[] = {
+    0x9a, 0x17, 0x1b, 0x50, 0x48, 0xba, 0xf1, 0x37, 0x5c, 0x14, 0x07, 0xa8,
+    0xdc, 0x1c, 0x8e, 0xda, 0x53, 0x2d, 0xf5, 0x52, 0x96, 0x77, 0x06, 0x88,
+    0x4e, 0x5f, 0xe3, 0xd4, 0x67, 0x86, 0x07, 0x74, 0x48, 0xf2, 0x8f, 0x89,
+    0xb3, 0x8e, 0xb7, 0x64, 0xdf, 0x7e, 0x0e, 0x3b, 0x40, 0x1a, 0xed, 0x3a,
+    0x23, 0x06, 0xfa, 0x2b, 0xed, 0xe3, 0x82, 0xaa, 0xe1, 0x08, 0xe1, 0x6a,
+    0xb4, 0x85, 0x69, 0x1e,
+};
+static const struct drbg_kat_no_reseed kat236_t = {
+    10, kat236_entropyin, kat236_nonce, kat236_persstr,
+    kat236_addin0, kat236_addin1, kat236_retbits
+};
+static const struct drbg_kat kat236 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat236_t
+};
+
+static const unsigned char kat237_entropyin[] = {
+    0x7d, 0x33, 0x40, 0xa8, 0xb1, 0xe1, 0x51, 0x71, 0xee, 0x34, 0x03, 0xcc,
+    0x19, 0xd3, 0xfe, 0xa9,
+};
+static const unsigned char kat237_nonce[] = {
+    0xfd, 0xe6, 0x97, 0xac, 0xc7, 0xe7, 0x2b, 0x75,
+};
+static const unsigned char kat237_persstr[] = {
+    0xa1, 0x28, 0x79, 0x71, 0x79, 0xc5, 0xca, 0xd6, 0xa9, 0xb4, 0x76, 0xff,
+    0x99, 0xf9, 0x82, 0x8f,
+};
+static const unsigned char kat237_addin0[] = {
+    0x2d, 0xfa, 0x30, 0x85, 0xfa, 0x02, 0x3b, 0x53, 0x61, 0xdb, 0xa7, 0x9d,
+    0x40, 0x77, 0x38, 0xbc,
+};
+static const unsigned char kat237_addin1[] = {
+    0xae, 0xf5, 0x3a, 0xf3, 0xbe, 0x89, 0x41, 0xe7, 0xd2, 0x71, 0x3c, 0x71,
+    0x28, 0x41, 0xdc, 0x68,
+};
+static const unsigned char kat237_retbits[] = {
+    0xc1, 0xf7, 0x25, 0xb2, 0x90, 0xed, 0x13, 0x10, 0xdd, 0x3f, 0x39, 0xe9,
+    0x9c, 0x7a, 0x65, 0xb8, 0x01, 0xb4, 0x74, 0x2f, 0x50, 0x66, 0xb3, 0xc7,
+    0x1b, 0xb4, 0x6f, 0x3d, 0xe7, 0x4d, 0xd2, 0xca, 0xae, 0xa4, 0x08, 0x21,
+    0x17, 0x4f, 0x67, 0x67, 0x22, 0xdb, 0x38, 0xfe, 0xda, 0x5d, 0x10, 0x96,
+    0xc7, 0x9a, 0xd1, 0xea, 0xbe, 0xff, 0x78, 0xde, 0xf0, 0x84, 0x7a, 0x24,
+    0x23, 0xbb, 0x46, 0x02,
+};
+static const struct drbg_kat_no_reseed kat237_t = {
+    11, kat237_entropyin, kat237_nonce, kat237_persstr,
+    kat237_addin0, kat237_addin1, kat237_retbits
+};
+static const struct drbg_kat kat237 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat237_t
+};
+
+static const unsigned char kat238_entropyin[] = {
+    0x05, 0x71, 0xd4, 0x1f, 0x98, 0xb7, 0x1e, 0xad, 0x41, 0x5f, 0xcb, 0x97,
+    0xfd, 0x05, 0xa1, 0xf1,
+};
+static const unsigned char kat238_nonce[] = {
+    0x42, 0x16, 0x18, 0x2c, 0x09, 0x4c, 0x4b, 0x14,
+};
+static const unsigned char kat238_persstr[] = {
+    0x6b, 0xed, 0x5c, 0xc7, 0x26, 0x60, 0xf7, 0xfd, 0x4c, 0x32, 0xab, 0xe5,
+    0xcb, 0x1a, 0xef, 0xed,
+};
+static const unsigned char kat238_addin0[] = {
+    0xb1, 0x98, 0x97, 0x3f, 0x68, 0x9c, 0x37, 0xeb, 0x63, 0x76, 0xa0, 0x88,
+    0xa7, 0xc7, 0x3e, 0x97,
+};
+static const unsigned char kat238_addin1[] = {
+    0xdf, 0xf3, 0xa3, 0xb0, 0x72, 0x43, 0x02, 0xf8, 0x3b, 0x85, 0x4f, 0x2f,
+    0xa8, 0xec, 0x34, 0x96,
+};
+static const unsigned char kat238_retbits[] = {
+    0x66, 0x7d, 0xdb, 0x87, 0x07, 0x9b, 0x39, 0x49, 0x03, 0x0f, 0x41, 0xff,
+    0x91, 0xb2, 0xec, 0x0a, 0x59, 0x8a, 0xb2, 0xd5, 0x5c, 0x99, 0xd0, 0x17,
+    0xe4, 0xfc, 0x79, 0xe9, 0x4f, 0x15, 0xb4, 0x10, 0xcc, 0x29, 0x70, 0xff,
+    0x01, 0x74, 0x82, 0xb2, 0x9e, 0xef, 0x2c, 0x25, 0x0a, 0x09, 0x12, 0x8a,
+    0x18, 0x60, 0x5e, 0x0f, 0xa1, 0x4a, 0xcc, 0xe3, 0x7b, 0x89, 0xc4, 0x38,
+    0xc8, 0x21, 0x31, 0x94,
+};
+static const struct drbg_kat_no_reseed kat238_t = {
+    12, kat238_entropyin, kat238_nonce, kat238_persstr,
+    kat238_addin0, kat238_addin1, kat238_retbits
+};
+static const struct drbg_kat kat238 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat238_t
+};
+
+static const unsigned char kat239_entropyin[] = {
+    0x8e, 0xe3, 0xed, 0xc1, 0xc6, 0x4e, 0xa7, 0xd6, 0xf0, 0xba, 0xb9, 0x73,
+    0x1e, 0x5d, 0x17, 0x62,
+};
+static const unsigned char kat239_nonce[] = {
+    0x92, 0xa1, 0x42, 0x26, 0x08, 0x7a, 0xfa, 0xfb,
+};
+static const unsigned char kat239_persstr[] = {
+    0x2a, 0x24, 0x04, 0xbe, 0xf6, 0xf7, 0x11, 0x34, 0x17, 0xdf, 0x0b, 0x18,
+    0x54, 0xd8, 0x47, 0x3d,
+};
+static const unsigned char kat239_addin0[] = {
+    0xa2, 0x78, 0xe8, 0xa5, 0x0b, 0xcc, 0xd6, 0x12, 0x97, 0x4d, 0x02, 0x6e,
+    0xde, 0xf7, 0x50, 0x1c,
+};
+static const unsigned char kat239_addin1[] = {
+    0xe7, 0x48, 0xf5, 0xe2, 0xf9, 0x8b, 0x48, 0x8e, 0x74, 0xb0, 0xbb, 0xd5,
+    0x59, 0xb5, 0xba, 0xbc,
+};
+static const unsigned char kat239_retbits[] = {
+    0x81, 0xec, 0xf8, 0xb7, 0xb0, 0x7c, 0x64, 0xce, 0xd1, 0xa4, 0x9b, 0x21,
+    0x33, 0x54, 0x99, 0x5a, 0x7b, 0xf1, 0x68, 0xd3, 0x8a, 0x83, 0x0b, 0x15,
+    0x70, 0x41, 0x4f, 0x5a, 0x20, 0x15, 0x49, 0x9e, 0x09, 0xaf, 0xf3, 0xbf,
+    0x58, 0x37, 0x19, 0x88, 0x6f, 0xe9, 0x9d, 0x00, 0xe6, 0xd9, 0xeb, 0x9a,
+    0x4f, 0xde, 0x29, 0xd8, 0xd9, 0x78, 0x8d, 0xd6, 0xff, 0xe2, 0x09, 0x83,
+    0x9a, 0x73, 0x9c, 0xd2,
+};
+static const struct drbg_kat_no_reseed kat239_t = {
+    13, kat239_entropyin, kat239_nonce, kat239_persstr,
+    kat239_addin0, kat239_addin1, kat239_retbits
+};
+static const struct drbg_kat kat239 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat239_t
+};
+
+static const unsigned char kat240_entropyin[] = {
+    0x06, 0x18, 0xc2, 0x88, 0x49, 0x14, 0x71, 0x22, 0x26, 0xad, 0x4e, 0x95,
+    0x80, 0xc0, 0x95, 0x23,
+};
+static const unsigned char kat240_nonce[] = {
+    0x6e, 0xbc, 0x4d, 0x5d, 0xb4, 0x76, 0x7f, 0x5f,
+};
+static const unsigned char kat240_persstr[] = {
+    0x7a, 0x82, 0x50, 0xa3, 0xbc, 0xbd, 0x81, 0x54, 0xc5, 0x05, 0x8b, 0x55,
+    0x1c, 0xf2, 0x20, 0x36,
+};
+static const unsigned char kat240_addin0[] = {
+    0x30, 0x26, 0x05, 0x32, 0xb5, 0x6c, 0x0f, 0x8e, 0xde, 0x9b, 0x72, 0x5c,
+    0x32, 0x20, 0x8f, 0x31,
+};
+static const unsigned char kat240_addin1[] = {
+    0x1e, 0x90, 0xdc, 0x4f, 0x67, 0xc1, 0xcb, 0x2d, 0xa1, 0x2d, 0x10, 0xa0,
+    0xb0, 0xfb, 0xb6, 0x26,
+};
+static const unsigned char kat240_retbits[] = {
+    0x49, 0x93, 0x57, 0x58, 0x80, 0xd0, 0x01, 0x45, 0xc1, 0xf9, 0x67, 0xdb,
+    0x25, 0xcc, 0xc8, 0xf3, 0x4c, 0xf0, 0xc6, 0x2a, 0xcc, 0xcb, 0xcf, 0xa0,
+    0xe7, 0x2c, 0x89, 0xea, 0xcf, 0x9f, 0xbe, 0x56, 0x14, 0x50, 0x74, 0xe4,
+    0xd4, 0x7f, 0x2b, 0x76, 0x74, 0xf4, 0xb0, 0xe0, 0x7e, 0xe3, 0xb5, 0x10,
+    0x4b, 0xf7, 0xcc, 0xfe, 0xd8, 0x00, 0x1d, 0x67, 0x11, 0xc6, 0x6f, 0xda,
+    0x94, 0x44, 0xfb, 0x8a,
+};
+static const struct drbg_kat_no_reseed kat240_t = {
+    14, kat240_entropyin, kat240_nonce, kat240_persstr,
+    kat240_addin0, kat240_addin1, kat240_retbits
+};
+static const struct drbg_kat kat240 = {
+    NO_RESEED, USE_DF, NID_aes_128_ctr, 16, 8, 16, 16, 64, &kat240_t
+};
+
+static const unsigned char kat241_entropyin[] = {
+    0xc3, 0x5c, 0x2f, 0xa2, 0xa8, 0x9d, 0x52, 0xa1, 0x1f, 0xa3, 0x2a, 0xa9,
+    0x6c, 0x95, 0xb8, 0xf1, 0xc9, 0xa8, 0xf9, 0xcb, 0x24, 0x5a, 0x8b, 0x40,
+};
+static const unsigned char kat241_nonce[] = {
+    0xf3, 0xa6, 0xe5, 0xa7, 0xfb, 0xd9, 0xd3, 0xc6, 0x8e, 0x27, 0x7b, 0xa9,
+    0xac, 0x9b, 0xbb, 0x00,
+};
+static const unsigned char kat241_persstr[] = {0};
+static const unsigned char kat241_addin0[] = {0};
+static const unsigned char kat241_addin1[] = {0};
+static const unsigned char kat241_retbits[] = {
+    0x8c, 0x2e, 0x72, 0xab, 0xfd, 0x9b, 0xb8, 0x28, 0x4d, 0xb7, 0x9e, 0x17,
+    0xa4, 0x3a, 0x31, 0x46, 0xcd, 0x76, 0x94, 0xe3, 0x52, 0x49, 0xfc, 0x33,
+    0x83, 0x91, 0x4a, 0x71, 0x17, 0xf4, 0x13, 0x68, 0xe6, 0xd4, 0xf1, 0x48,
+    0xff, 0x49, 0xbf, 0x29, 0x07, 0x6b, 0x50, 0x15, 0xc5, 0x9f, 0x45, 0x79,
+    0x45, 0x66, 0x2e, 0x3d, 0x35, 0x03, 0x84, 0x3f, 0x4a, 0xa5, 0xa3, 0xdf,
+    0x9a, 0x9d, 0xf1, 0x0d,
+};
+static const struct drbg_kat_no_reseed kat241_t = {
+    0, kat241_entropyin, kat241_nonce, kat241_persstr,
+    kat241_addin0, kat241_addin1, kat241_retbits
+};
+static const struct drbg_kat kat241 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat241_t
+};
+
+static const unsigned char kat242_entropyin[] = {
+    0xc1, 0x5f, 0x9f, 0xc5, 0x74, 0x1f, 0x2c, 0xac, 0xe0, 0xb5, 0x8d, 0x72,
+    0x49, 0xbd, 0x03, 0x77, 0xbd, 0x57, 0x08, 0xe3, 0x65, 0x88, 0x4b, 0x59,
+};
+static const unsigned char kat242_nonce[] = {
+    0xc3, 0x34, 0x3e, 0x3a, 0x11, 0xb2, 0xdc, 0x15, 0x26, 0x1c, 0x51, 0x75,
+    0x1f, 0x51, 0x3b, 0x60,
+};
+static const unsigned char kat242_persstr[] = {0};
+static const unsigned char kat242_addin0[] = {0};
+static const unsigned char kat242_addin1[] = {0};
+static const unsigned char kat242_retbits[] = {
+    0x5c, 0x6c, 0xed, 0x80, 0x50, 0xbc, 0x5a, 0xde, 0x3f, 0x9a, 0xca, 0xcf,
+    0x23, 0x89, 0x9f, 0x98, 0xf5, 0xe0, 0x45, 0xa7, 0x68, 0xba, 0x53, 0x8f,
+    0xc3, 0x71, 0x74, 0x74, 0x62, 0xeb, 0x9b, 0x84, 0x82, 0x8c, 0x9c, 0xe8,
+    0x8e, 0x41, 0x99, 0x05, 0x23, 0x59, 0xb1, 0x58, 0x33, 0x66, 0x89, 0x44,
+    0xd6, 0x18, 0x76, 0x7d, 0x0c, 0x6c, 0xfc, 0x24, 0x11, 0xf8, 0x2e, 0x04,
+    0x12, 0x06, 0x7a, 0xf6,
+};
+static const struct drbg_kat_no_reseed kat242_t = {
+    1, kat242_entropyin, kat242_nonce, kat242_persstr,
+    kat242_addin0, kat242_addin1, kat242_retbits
+};
+static const struct drbg_kat kat242 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat242_t
+};
+
+static const unsigned char kat243_entropyin[] = {
+    0x34, 0xdb, 0xd5, 0xcf, 0xe7, 0x9c, 0xac, 0xa4, 0x25, 0x8c, 0xd1, 0xae,
+    0x24, 0xb5, 0xaf, 0xe2, 0xd3, 0x7c, 0xb4, 0x69, 0x5d, 0x65, 0x5a, 0x7b,
+};
+static const unsigned char kat243_nonce[] = {
+    0x55, 0xc2, 0x8f, 0xb4, 0x4e, 0x58, 0x49, 0xb5, 0x7a, 0x77, 0x87, 0x35,
+    0x13, 0xc6, 0x57, 0x05,
+};
+static const unsigned char kat243_persstr[] = {0};
+static const unsigned char kat243_addin0[] = {0};
+static const unsigned char kat243_addin1[] = {0};
+static const unsigned char kat243_retbits[] = {
+    0x9d, 0x47, 0x1d, 0x2c, 0xb8, 0xe4, 0x20, 0x02, 0xce, 0x24, 0xe0, 0xc6,
+    0xbe, 0x84, 0xc8, 0x99, 0x37, 0x59, 0x5e, 0x61, 0xfa, 0xf0, 0x37, 0x1c,
+    0xb7, 0xe8, 0x28, 0x5d, 0x76, 0xbe, 0x6b, 0x34, 0xef, 0x1d, 0xb5, 0xf7,
+    0xd2, 0xeb, 0xad, 0x4b, 0xf8, 0xff, 0x77, 0x65, 0x13, 0x89, 0xef, 0xcf,
+    0x13, 0xba, 0xe7, 0x2b, 0xd8, 0xa1, 0x3c, 0x8e, 0x9f, 0xc6, 0x18, 0x55,
+    0x58, 0x1b, 0x8e, 0xa9,
+};
+static const struct drbg_kat_no_reseed kat243_t = {
+    2, kat243_entropyin, kat243_nonce, kat243_persstr,
+    kat243_addin0, kat243_addin1, kat243_retbits
+};
+static const struct drbg_kat kat243 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat243_t
+};
+
+static const unsigned char kat244_entropyin[] = {
+    0x64, 0x3e, 0x95, 0xbf, 0xea, 0xca, 0xfc, 0x7d, 0x72, 0x1b, 0x48, 0xb9,
+    0xf1, 0x5a, 0x80, 0xce, 0x8a, 0xd7, 0x07, 0x7f, 0x30, 0x1f, 0x16, 0xc5,
+};
+static const unsigned char kat244_nonce[] = {
+    0x2d, 0x90, 0x8d, 0xd6, 0x95, 0x2f, 0x86, 0x2a, 0xda, 0x90, 0x2b, 0xc1,
+    0xa1, 0x4a, 0x61, 0x29,
+};
+static const unsigned char kat244_persstr[] = {0};
+static const unsigned char kat244_addin0[] = {0};
+static const unsigned char kat244_addin1[] = {0};
+static const unsigned char kat244_retbits[] = {
+    0xd6, 0xee, 0x5e, 0x37, 0x96, 0x34, 0x9d, 0x47, 0xc2, 0xed, 0xe3, 0x2c,
+    0x93, 0x8f, 0x2c, 0x06, 0xef, 0x8a, 0x65, 0x11, 0xb4, 0xe9, 0xbb, 0xbe,
+    0x74, 0xeb, 0x71, 0xbc, 0x3c, 0x47, 0x70, 0xd9, 0x0c, 0x70, 0xcd, 0xcd,
+    0xff, 0x6b, 0x3c, 0x9f, 0xbf, 0x4f, 0xa6, 0xbc, 0x38, 0x0a, 0xc2, 0xf2,
+    0xe1, 0x61, 0x96, 0xb4, 0xc4, 0xc8, 0xa6, 0x44, 0x8f, 0x04, 0x0d, 0x11,
+    0xd3, 0x6b, 0x42, 0x14,
+};
+static const struct drbg_kat_no_reseed kat244_t = {
+    3, kat244_entropyin, kat244_nonce, kat244_persstr,
+    kat244_addin0, kat244_addin1, kat244_retbits
+};
+static const struct drbg_kat kat244 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat244_t
+};
+
+static const unsigned char kat245_entropyin[] = {
+    0x0f, 0x47, 0x7a, 0x59, 0x14, 0x90, 0xa0, 0xac, 0xcf, 0x82, 0x9c, 0x67,
+    0x3f, 0x15, 0x06, 0xda, 0xca, 0x70, 0xdf, 0x96, 0x58, 0x2c, 0x3d, 0x3a,
+};
+static const unsigned char kat245_nonce[] = {
+    0x1a, 0x8d, 0xd4, 0x23, 0x3b, 0xed, 0xe3, 0xf2, 0x83, 0x86, 0x34, 0xc0,
+    0x95, 0x44, 0xab, 0x6e,
+};
+static const unsigned char kat245_persstr[] = {0};
+static const unsigned char kat245_addin0[] = {0};
+static const unsigned char kat245_addin1[] = {0};
+static const unsigned char kat245_retbits[] = {
+    0x43, 0x16, 0x75, 0x73, 0x86, 0x7d, 0x53, 0xca, 0x92, 0xe2, 0x96, 0x86,
+    0xd9, 0xfd, 0x99, 0x3c, 0x69, 0x80, 0x5a, 0x63, 0x11, 0xe3, 0x3e, 0xb9,
+    0x63, 0x30, 0xc5, 0x37, 0xdc, 0xbd, 0xea, 0xb1, 0x1b, 0x0b, 0xa1, 0x5e,
+    0xe5, 0xb2, 0x28, 0x7f, 0x24, 0x85, 0xe2, 0xe3, 0xa6, 0xe0, 0xed, 0x62,
+    0xd2, 0xeb, 0x81, 0x08, 0xc1, 0xfc, 0x73, 0x90, 0x8d, 0xfd, 0x4b, 0xc7,
+    0xb7, 0x1b, 0x16, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat245_t = {
+    4, kat245_entropyin, kat245_nonce, kat245_persstr,
+    kat245_addin0, kat245_addin1, kat245_retbits
+};
+static const struct drbg_kat kat245 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat245_t
+};
+
+static const unsigned char kat246_entropyin[] = {
+    0x00, 0xa6, 0xed, 0x77, 0x83, 0x11, 0x52, 0x81, 0x09, 0xe6, 0xfb, 0x5c,
+    0xbd, 0x60, 0xd1, 0xa7, 0x6c, 0x4b, 0xd5, 0xd0, 0x0d, 0xd1, 0x03, 0xa4,
+};
+static const unsigned char kat246_nonce[] = {
+    0x40, 0x89, 0xf2, 0xf0, 0xb7, 0x4c, 0x18, 0x4a, 0xc9, 0xaf, 0xc9, 0x56,
+    0x47, 0xcd, 0xe8, 0x4b,
+};
+static const unsigned char kat246_persstr[] = {0};
+static const unsigned char kat246_addin0[] = {0};
+static const unsigned char kat246_addin1[] = {0};
+static const unsigned char kat246_retbits[] = {
+    0xb9, 0x08, 0xd9, 0x3a, 0xb2, 0xfd, 0xeb, 0x1a, 0x54, 0x7b, 0x6d, 0x15,
+    0xeb, 0x95, 0x0e, 0xdd, 0xce, 0x25, 0x95, 0x6d, 0x8f, 0x5e, 0xe9, 0xa4,
+    0xb1, 0xd5, 0x08, 0xc0, 0x82, 0x77, 0xdd, 0x7a, 0x1a, 0x10, 0x60, 0xfc,
+    0xec, 0xaf, 0x93, 0xeb, 0x7a, 0x47, 0x2a, 0x36, 0x3e, 0x97, 0xd7, 0xe6,
+    0x3c, 0xde, 0xc7, 0xf9, 0x4a, 0x5d, 0xc2, 0x6d, 0xb7, 0xb2, 0xb7, 0xf1,
+    0x2c, 0xd8, 0xf3, 0xee,
+};
+static const struct drbg_kat_no_reseed kat246_t = {
+    5, kat246_entropyin, kat246_nonce, kat246_persstr,
+    kat246_addin0, kat246_addin1, kat246_retbits
+};
+static const struct drbg_kat kat246 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat246_t
+};
+
+static const unsigned char kat247_entropyin[] = {
+    0x5f, 0x34, 0x55, 0x2a, 0x45, 0x5a, 0x02, 0x9b, 0x4b, 0xac, 0xf1, 0xb8,
+    0x0c, 0xb1, 0xcf, 0xb4, 0x12, 0x56, 0x5f, 0xb7, 0x73, 0x4f, 0x7e, 0x0a,
+};
+static const unsigned char kat247_nonce[] = {
+    0xbd, 0x55, 0xae, 0xf0, 0x6d, 0xb6, 0xf2, 0x0d, 0xf2, 0x71, 0xcf, 0x60,
+    0x59, 0x4c, 0x22, 0xac,
+};
+static const unsigned char kat247_persstr[] = {0};
+static const unsigned char kat247_addin0[] = {0};
+static const unsigned char kat247_addin1[] = {0};
+static const unsigned char kat247_retbits[] = {
+    0xd4, 0xb1, 0x00, 0xef, 0x27, 0xd7, 0x9a, 0x5d, 0x10, 0x03, 0x1d, 0xb0,
+    0xcc, 0xc7, 0x2b, 0xa8, 0x9c, 0x68, 0x19, 0x77, 0x6c, 0x19, 0xf0, 0x2f,
+    0x9a, 0xfe, 0x4a, 0x44, 0x05, 0xc5, 0x84, 0xa0, 0x66, 0x21, 0xf1, 0xbb,
+    0x5b, 0xa2, 0x9a, 0xf5, 0xea, 0x69, 0x63, 0x83, 0xa6, 0x7a, 0x9e, 0xc6,
+    0x52, 0xbe, 0xe7, 0x59, 0x28, 0x11, 0x3d, 0xb2, 0x8f, 0x39, 0x40, 0x4f,
+    0xf0, 0xba, 0x37, 0x38,
+};
+static const struct drbg_kat_no_reseed kat247_t = {
+    6, kat247_entropyin, kat247_nonce, kat247_persstr,
+    kat247_addin0, kat247_addin1, kat247_retbits
+};
+static const struct drbg_kat kat247 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat247_t
+};
+
+static const unsigned char kat248_entropyin[] = {
+    0x6d, 0x7c, 0xb2, 0x32, 0xa3, 0x20, 0x3c, 0xa6, 0x95, 0x5c, 0x1f, 0x1e,
+    0xdd, 0xd6, 0xb8, 0xe0, 0x9d, 0x82, 0x0b, 0xf6, 0xc0, 0x5f, 0xfb, 0x6e,
+};
+static const unsigned char kat248_nonce[] = {
+    0xc0, 0x4f, 0x16, 0x27, 0xed, 0x1d, 0x7b, 0x31, 0x0a, 0xa4, 0x7e, 0xcc,
+    0x79, 0x83, 0x83, 0x6a,
+};
+static const unsigned char kat248_persstr[] = {0};
+static const unsigned char kat248_addin0[] = {0};
+static const unsigned char kat248_addin1[] = {0};
+static const unsigned char kat248_retbits[] = {
+    0x63, 0xd6, 0x96, 0x3e, 0xff, 0x3d, 0x50, 0xfc, 0x0c, 0x21, 0xab, 0xa6,
+    0x1d, 0x63, 0x65, 0x74, 0x2c, 0x4b, 0xce, 0xa7, 0xbf, 0x76, 0xc9, 0x5d,
+    0x64, 0x5e, 0x88, 0xcb, 0x13, 0x92, 0x53, 0xd5, 0x63, 0x50, 0x3e, 0xc3,
+    0x99, 0x9e, 0xe7, 0x72, 0xc8, 0x97, 0xc9, 0xd3, 0x66, 0x3f, 0x64, 0x5a,
+    0xb3, 0x04, 0x1d, 0xcf, 0x3d, 0x9e, 0xe8, 0xf4, 0xc9, 0x2e, 0x89, 0x5b,
+    0x76, 0x44, 0x41, 0x4d,
+};
+static const struct drbg_kat_no_reseed kat248_t = {
+    7, kat248_entropyin, kat248_nonce, kat248_persstr,
+    kat248_addin0, kat248_addin1, kat248_retbits
+};
+static const struct drbg_kat kat248 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat248_t
+};
+
+static const unsigned char kat249_entropyin[] = {
+    0x48, 0xbf, 0xce, 0xf7, 0xdb, 0xe6, 0x8d, 0x5e, 0x09, 0xdf, 0x38, 0xe9,
+    0x7f, 0x89, 0x77, 0xe2, 0xa1, 0x50, 0x14, 0xbf, 0x75, 0x1f, 0x9e, 0x27,
+};
+static const unsigned char kat249_nonce[] = {
+    0xee, 0xa0, 0x3c, 0x6d, 0x77, 0x80, 0x2a, 0xa2, 0xc5, 0xd5, 0xe1, 0x29,
+    0x36, 0x31, 0xe3, 0x9b,
+};
+static const unsigned char kat249_persstr[] = {0};
+static const unsigned char kat249_addin0[] = {0};
+static const unsigned char kat249_addin1[] = {0};
+static const unsigned char kat249_retbits[] = {
+    0xec, 0xdd, 0x8e, 0x7c, 0x78, 0x81, 0x94, 0x69, 0x82, 0xff, 0x3a, 0x11,
+    0xa4, 0x3b, 0xd0, 0x20, 0xe9, 0x70, 0xa3, 0xb8, 0x90, 0x13, 0x87, 0xa1,
+    0xcd, 0x3e, 0xb6, 0x3d, 0xf3, 0xfb, 0x51, 0x06, 0x60, 0xbc, 0x82, 0xa5,
+    0xe0, 0x29, 0xbe, 0xee, 0x26, 0xb4, 0xcc, 0x5d, 0x89, 0x1f, 0xaf, 0xcf,
+    0x5e, 0x42, 0xb6, 0xf4, 0xdc, 0x41, 0x49, 0x16, 0xfc, 0xd8, 0xb0, 0x5e,
+    0xd3, 0xf4, 0xa6, 0x85,
+};
+static const struct drbg_kat_no_reseed kat249_t = {
+    8, kat249_entropyin, kat249_nonce, kat249_persstr,
+    kat249_addin0, kat249_addin1, kat249_retbits
+};
+static const struct drbg_kat kat249 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat249_t
+};
+
+static const unsigned char kat250_entropyin[] = {
+    0x5b, 0xe9, 0x61, 0x75, 0x4f, 0xe9, 0xe9, 0x72, 0x06, 0x35, 0x87, 0x5f,
+    0xeb, 0x2f, 0x37, 0xc7, 0x4f, 0xb9, 0x62, 0x0e, 0x47, 0xb8, 0x81, 0x41,
+};
+static const unsigned char kat250_nonce[] = {
+    0x23, 0xd3, 0x5a, 0xac, 0xee, 0xfb, 0x41, 0x2a, 0x6f, 0xbd, 0x18, 0x7f,
+    0x57, 0x87, 0xbc, 0x53,
+};
+static const unsigned char kat250_persstr[] = {0};
+static const unsigned char kat250_addin0[] = {0};
+static const unsigned char kat250_addin1[] = {0};
+static const unsigned char kat250_retbits[] = {
+    0x8a, 0x8e, 0x0e, 0x44, 0x3b, 0x8e, 0x94, 0x4d, 0x58, 0xc8, 0x40, 0x73,
+    0x92, 0x29, 0x6a, 0x2c, 0x7f, 0xc4, 0xeb, 0x04, 0xfc, 0xb7, 0x2c, 0xc7,
+    0xea, 0x99, 0x51, 0x35, 0x59, 0xc0, 0x91, 0x76, 0x61, 0xdb, 0x2e, 0xda,
+    0x20, 0x9f, 0xbb, 0xed, 0x40, 0x00, 0x89, 0xe3, 0xfc, 0x48, 0xff, 0x69,
+    0x90, 0xd9, 0x7c, 0x04, 0x1b, 0xb5, 0x75, 0x27, 0x92, 0xd1, 0x30, 0xa1,
+    0x52, 0x57, 0xca, 0x44,
+};
+static const struct drbg_kat_no_reseed kat250_t = {
+    9, kat250_entropyin, kat250_nonce, kat250_persstr,
+    kat250_addin0, kat250_addin1, kat250_retbits
+};
+static const struct drbg_kat kat250 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat250_t
+};
+
+static const unsigned char kat251_entropyin[] = {
+    0x2a, 0x25, 0x35, 0xa5, 0xaf, 0xc9, 0xb1, 0x71, 0x75, 0x42, 0x92, 0x8a,
+    0x3d, 0x35, 0xe9, 0x5a, 0x7f, 0x63, 0xb8, 0x77, 0xa8, 0x38, 0x8a, 0x09,
+};
+static const unsigned char kat251_nonce[] = {
+    0xab, 0x21, 0x7b, 0x02, 0x9a, 0x33, 0xf0, 0x56, 0x35, 0x30, 0xd3, 0x7f,
+    0x4f, 0xbf, 0xf1, 0x0b,
+};
+static const unsigned char kat251_persstr[] = {0};
+static const unsigned char kat251_addin0[] = {0};
+static const unsigned char kat251_addin1[] = {0};
+static const unsigned char kat251_retbits[] = {
+    0x31, 0xa2, 0x10, 0x65, 0x55, 0x29, 0xfb, 0x46, 0xeb, 0x4e, 0x79, 0x97,
+    0x10, 0xc6, 0x31, 0x92, 0xe3, 0x65, 0x6c, 0xb1, 0xea, 0x24, 0x04, 0x08,
+    0x52, 0x7d, 0xf7, 0xfe, 0xf8, 0x2b, 0x30, 0x5c, 0x5f, 0xa9, 0x8a, 0x1d,
+    0x82, 0x4f, 0x78, 0x30, 0xd8, 0x4a, 0x53, 0x64, 0x3c, 0xfb, 0x52, 0x51,
+    0x76, 0x63, 0xd5, 0x16, 0x11, 0x5d, 0x45, 0x27, 0x2f, 0x59, 0x72, 0x24,
+    0x0f, 0xe8, 0x48, 0x27,
+};
+static const struct drbg_kat_no_reseed kat251_t = {
+    10, kat251_entropyin, kat251_nonce, kat251_persstr,
+    kat251_addin0, kat251_addin1, kat251_retbits
+};
+static const struct drbg_kat kat251 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat251_t
+};
+
+static const unsigned char kat252_entropyin[] = {
+    0xff, 0xd8, 0xb1, 0x50, 0xb2, 0x87, 0xb3, 0xed, 0x9d, 0x01, 0x28, 0xdc,
+    0xc8, 0xcc, 0x5d, 0xeb, 0x90, 0xbd, 0xa9, 0x8a, 0xca, 0x79, 0x14, 0x83,
+};
+static const unsigned char kat252_nonce[] = {
+    0xbc, 0x7b, 0x6a, 0x7f, 0xb0, 0x59, 0x2f, 0xda, 0x4a, 0xbc, 0x43, 0xee,
+    0xee, 0x42, 0xb1, 0xf6,
+};
+static const unsigned char kat252_persstr[] = {0};
+static const unsigned char kat252_addin0[] = {0};
+static const unsigned char kat252_addin1[] = {0};
+static const unsigned char kat252_retbits[] = {
+    0x3f, 0xdb, 0x4f, 0xf8, 0x3c, 0x36, 0x2b, 0x76, 0xa8, 0x3b, 0x00, 0xa8,
+    0x90, 0x5f, 0x2c, 0x05, 0x8b, 0xaf, 0xe8, 0xeb, 0xdf, 0xf8, 0xeb, 0x2e,
+    0x5f, 0x53, 0xcb, 0x9c, 0xa5, 0xc8, 0x2e, 0x32, 0x17, 0xc2, 0xc6, 0x03,
+    0x26, 0xb0, 0xbb, 0xa6, 0xc9, 0x1c, 0x44, 0x0a, 0x48, 0x52, 0xc7, 0x2c,
+    0xd7, 0x33, 0x45, 0xc5, 0xe0, 0xd4, 0xcc, 0x2e, 0x15, 0x84, 0x01, 0x04,
+    0x5a, 0x77, 0xe0, 0xf9,
+};
+static const struct drbg_kat_no_reseed kat252_t = {
+    11, kat252_entropyin, kat252_nonce, kat252_persstr,
+    kat252_addin0, kat252_addin1, kat252_retbits
+};
+static const struct drbg_kat kat252 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat252_t
+};
+
+static const unsigned char kat253_entropyin[] = {
+    0xcb, 0x33, 0xfc, 0x14, 0xf2, 0xb6, 0x94, 0x01, 0xb7, 0x8b, 0xbd, 0x78,
+    0x1c, 0xbf, 0xe6, 0x58, 0x5f, 0x1e, 0x73, 0x64, 0x59, 0x00, 0x0c, 0x26,
+};
+static const unsigned char kat253_nonce[] = {
+    0x5a, 0x91, 0x4f, 0x81, 0xd6, 0x5b, 0x19, 0x7a, 0x5d, 0x89, 0x24, 0xfa,
+    0x88, 0xfa, 0x9b, 0xa3,
+};
+static const unsigned char kat253_persstr[] = {0};
+static const unsigned char kat253_addin0[] = {0};
+static const unsigned char kat253_addin1[] = {0};
+static const unsigned char kat253_retbits[] = {
+    0x6c, 0x63, 0x20, 0x91, 0x88, 0x6e, 0x24, 0x26, 0x5d, 0x12, 0x3b, 0x5c,
+    0x7f, 0xca, 0x06, 0x3d, 0x70, 0xdf, 0xea, 0x32, 0xc7, 0x78, 0x0a, 0xfa,
+    0xab, 0x89, 0x5c, 0x10, 0xb5, 0x12, 0x62, 0xbc, 0x4d, 0x36, 0x3d, 0x21,
+    0x65, 0x99, 0x83, 0x67, 0xc9, 0xa8, 0xa5, 0x16, 0x47, 0x6b, 0xc7, 0x63,
+    0x99, 0x02, 0x41, 0xba, 0xf9, 0x2d, 0x6b, 0x87, 0xe4, 0xde, 0x62, 0x2d,
+    0x40, 0x19, 0xdb, 0x6c,
+};
+static const struct drbg_kat_no_reseed kat253_t = {
+    12, kat253_entropyin, kat253_nonce, kat253_persstr,
+    kat253_addin0, kat253_addin1, kat253_retbits
+};
+static const struct drbg_kat kat253 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat253_t
+};
+
+static const unsigned char kat254_entropyin[] = {
+    0xc4, 0x57, 0xe7, 0xd1, 0xc6, 0x9b, 0x1a, 0x53, 0x00, 0xb4, 0x75, 0xef,
+    0x80, 0x44, 0x1c, 0x40, 0x80, 0x0c, 0xd3, 0x76, 0x4e, 0x41, 0x4c, 0xe1,
+};
+static const unsigned char kat254_nonce[] = {
+    0x39, 0x33, 0xe4, 0x98, 0xa0, 0xf2, 0x0d, 0x3f, 0xcf, 0x05, 0xa3, 0xb8,
+    0x2b, 0x67, 0xac, 0x6d,
+};
+static const unsigned char kat254_persstr[] = {0};
+static const unsigned char kat254_addin0[] = {0};
+static const unsigned char kat254_addin1[] = {0};
+static const unsigned char kat254_retbits[] = {
+    0x26, 0x89, 0x41, 0x9f, 0xa0, 0xf9, 0xb3, 0xa4, 0xc5, 0xe9, 0x6a, 0x71,
+    0xf6, 0x76, 0xef, 0x7f, 0x76, 0x76, 0x7b, 0x51, 0xb3, 0xcd, 0x5c, 0xe8,
+    0x37, 0xe9, 0xd8, 0x28, 0x6f, 0xa8, 0x37, 0xa5, 0xa3, 0x45, 0x66, 0x95,
+    0xe3, 0xe9, 0xca, 0x93, 0x96, 0xe8, 0xd5, 0xb9, 0x47, 0x8a, 0x1e, 0x8c,
+    0xdd, 0x5c, 0x31, 0xfb, 0xaa, 0x5e, 0x07, 0x43, 0xd2, 0x77, 0xfd, 0xf4,
+    0xaf, 0xc7, 0x95, 0x9a,
+};
+static const struct drbg_kat_no_reseed kat254_t = {
+    13, kat254_entropyin, kat254_nonce, kat254_persstr,
+    kat254_addin0, kat254_addin1, kat254_retbits
+};
+static const struct drbg_kat kat254 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat254_t
+};
+
+static const unsigned char kat255_entropyin[] = {
+    0x49, 0xbc, 0x4a, 0xa4, 0xca, 0xba, 0x36, 0x42, 0x42, 0xdf, 0x51, 0x84,
+    0x90, 0x9c, 0xe5, 0x88, 0xf2, 0x4a, 0x2d, 0xe3, 0x40, 0xe3, 0x30, 0x82,
+};
+static const unsigned char kat255_nonce[] = {
+    0x51, 0x01, 0xf0, 0x0a, 0xc1, 0x89, 0x9c, 0x9b, 0xa4, 0x5e, 0x92, 0x3e,
+    0x07, 0x16, 0x64, 0x07,
+};
+static const unsigned char kat255_persstr[] = {0};
+static const unsigned char kat255_addin0[] = {0};
+static const unsigned char kat255_addin1[] = {0};
+static const unsigned char kat255_retbits[] = {
+    0x9b, 0x71, 0xe0, 0xa0, 0x9c, 0x39, 0x3e, 0xb0, 0xf0, 0x34, 0xa1, 0x2d,
+    0x3a, 0xd1, 0x32, 0x0a, 0xc1, 0xca, 0x42, 0x2a, 0x82, 0x96, 0x7c, 0xc5,
+    0x4d, 0x14, 0xed, 0x0e, 0x36, 0x42, 0x9a, 0xb2, 0xa0, 0xe8, 0xc6, 0x7a,
+    0x5c, 0x7f, 0x60, 0xe5, 0x37, 0xe4, 0x10, 0xeb, 0x5f, 0xf0, 0x75, 0xb7,
+    0xc6, 0x7a, 0xc4, 0x80, 0x52, 0x00, 0xa5, 0xab, 0x2f, 0xb6, 0x29, 0xb4,
+    0x84, 0x60, 0xcc, 0xe4,
+};
+static const struct drbg_kat_no_reseed kat255_t = {
+    14, kat255_entropyin, kat255_nonce, kat255_persstr,
+    kat255_addin0, kat255_addin1, kat255_retbits
+};
+static const struct drbg_kat kat255 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat255_t
+};
+
+static const unsigned char kat256_entropyin[] = {
+    0x89, 0xd3, 0x2f, 0x3d, 0xe1, 0x67, 0xde, 0xbe, 0xdf, 0xc1, 0x43, 0xe4,
+    0xda, 0x78, 0x9a, 0x5f, 0x83, 0x31, 0x2a, 0x9d, 0x42, 0x0c, 0x29, 0xd4,
+};
+static const unsigned char kat256_nonce[] = {
+    0x9a, 0xe3, 0xba, 0xb2, 0xd9, 0x65, 0xdb, 0xe9, 0x96, 0xa6, 0xc4, 0xc0,
+    0xde, 0x28, 0x05, 0x01,
+};
+static const unsigned char kat256_persstr[] = {0};
+static const unsigned char kat256_addin0[] = {
+    0xd5, 0x16, 0x5f, 0xbf, 0x88, 0x50, 0xe2, 0xec, 0xfb, 0x46, 0x87, 0xaf,
+    0x79, 0xdc, 0x62, 0x36, 0x1e, 0x75, 0x57, 0x70, 0x70, 0x51, 0xa1, 0x36,
+    0x80, 0x47, 0x1e, 0xe1, 0x29, 0xf2, 0x84, 0xf9,
+};
+static const unsigned char kat256_addin1[] = {
+    0x85, 0x22, 0x56, 0xde, 0x34, 0x79, 0xdc, 0x86, 0xa3, 0xb4, 0xd4, 0x04,
+    0xc2, 0x64, 0x7b, 0x74, 0xf5, 0xf8, 0xa1, 0xc0, 0x1b, 0x68, 0x1f, 0x1d,
+    0x8e, 0xfd, 0xfe, 0xdc, 0x54, 0xc1, 0x0c, 0x07,
+};
+static const unsigned char kat256_retbits[] = {
+    0xb0, 0x39, 0x7e, 0xda, 0x1d, 0xaf, 0x45, 0x44, 0x10, 0x4f, 0x73, 0x04,
+    0x01, 0xcb, 0xd1, 0xbe, 0x29, 0x98, 0x9c, 0xd2, 0x87, 0x97, 0xde, 0x2c,
+    0x13, 0xcd, 0xbf, 0x18, 0x4f, 0x86, 0xc6, 0x37, 0x8f, 0x8d, 0xfa, 0x39,
+    0x4e, 0x08, 0xd9, 0xa7, 0x1d, 0xe1, 0xf1, 0x63, 0x3b, 0x5b, 0x28, 0x36,
+    0x3d, 0xf2, 0x16, 0x59, 0xce, 0x58, 0xb1, 0x25, 0x92, 0xe8, 0xee, 0x4f,
+    0x55, 0xcb, 0x81, 0xac,
+};
+static const struct drbg_kat_no_reseed kat256_t = {
+    0, kat256_entropyin, kat256_nonce, kat256_persstr,
+    kat256_addin0, kat256_addin1, kat256_retbits
+};
+static const struct drbg_kat kat256 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat256_t
+};
+
+static const unsigned char kat257_entropyin[] = {
+    0xad, 0x3b, 0x6f, 0xa3, 0xd6, 0x32, 0xa4, 0x2f, 0x8c, 0x58, 0x0b, 0x59,
+    0xfa, 0xf8, 0x82, 0xc0, 0x33, 0x8c, 0x5b, 0xb0, 0x44, 0xb8, 0x8f, 0x37,
+};
+static const unsigned char kat257_nonce[] = {
+    0xf9, 0x99, 0x66, 0xdb, 0x52, 0xa2, 0xf7, 0x27, 0x11, 0xb5, 0xaf, 0x10,
+    0xef, 0xf4, 0x2f, 0xef,
+};
+static const unsigned char kat257_persstr[] = {0};
+static const unsigned char kat257_addin0[] = {
+    0xbe, 0xe5, 0x97, 0x4c, 0x34, 0x30, 0x2a, 0xee, 0xfe, 0x31, 0xc7, 0x32,
+    0x59, 0x87, 0xc1, 0x58, 0xdf, 0x80, 0x38, 0xa2, 0x37, 0xef, 0x9e, 0xcb,
+    0xb8, 0xfe, 0x74, 0xfe, 0xfb, 0xb3, 0xe2, 0x29,
+};
+static const unsigned char kat257_addin1[] = {
+    0x47, 0xb9, 0xbd, 0x9b, 0xab, 0xc4, 0x15, 0xaf, 0xaa, 0xed, 0xbb, 0x8a,
+    0xc9, 0xeb, 0xf0, 0x2e, 0xb5, 0x81, 0xd1, 0xeb, 0x5f, 0xb0, 0xb7, 0xd4,
+    0x34, 0x55, 0x84, 0x8d, 0x66, 0xce, 0xb5, 0x3b,
+};
+static const unsigned char kat257_retbits[] = {
+    0x75, 0x92, 0x2a, 0x7b, 0x19, 0x33, 0xf4, 0xbe, 0xc2, 0x75, 0xc1, 0x50,
+    0xe2, 0xf9, 0x89, 0x37, 0x14, 0xcb, 0xa1, 0x19, 0xc5, 0xdf, 0x7d, 0xc2,
+    0xcf, 0xaa, 0x96, 0x18, 0xf1, 0xeb, 0xa5, 0x4d, 0x68, 0xd5, 0x58, 0xe9,
+    0x76, 0xce, 0x29, 0x2e, 0x4b, 0x9f, 0x83, 0x06, 0xf1, 0xd1, 0x75, 0x59,
+    0x78, 0x04, 0x12, 0x24, 0x74, 0x80, 0x06, 0xbd, 0x57, 0x12, 0x31, 0x0f,
+    0xd0, 0x85, 0xaf, 0xa0,
+};
+static const struct drbg_kat_no_reseed kat257_t = {
+    1, kat257_entropyin, kat257_nonce, kat257_persstr,
+    kat257_addin0, kat257_addin1, kat257_retbits
+};
+static const struct drbg_kat kat257 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat257_t
+};
+
+static const unsigned char kat258_entropyin[] = {
+    0x16, 0xd3, 0x99, 0xb5, 0x26, 0xa8, 0x37, 0x66, 0xb5, 0xf9, 0x35, 0xe4,
+    0xc1, 0x23, 0x41, 0x98, 0x17, 0x24, 0xcd, 0x87, 0x24, 0x25, 0xd8, 0x59,
+};
+static const unsigned char kat258_nonce[] = {
+    0xc0, 0xf3, 0x83, 0x54, 0xae, 0x69, 0x68, 0x35, 0xf9, 0xc8, 0x56, 0x71,
+    0x6f, 0x18, 0x6e, 0x4d,
+};
+static const unsigned char kat258_persstr[] = {0};
+static const unsigned char kat258_addin0[] = {
+    0x56, 0x94, 0x3f, 0x5e, 0xf7, 0xee, 0xa6, 0x6a, 0xf2, 0xec, 0x60, 0x7f,
+    0xcf, 0xa2, 0xbd, 0x76, 0x69, 0x89, 0x9b, 0x6e, 0xce, 0x4c, 0xab, 0xac,
+    0x8d, 0x6e, 0x7a, 0x08, 0x68, 0xbe, 0x42, 0x2b,
+};
+static const unsigned char kat258_addin1[] = {
+    0x2f, 0x7e, 0x74, 0x6e, 0x2d, 0x05, 0xcd, 0x1e, 0x52, 0x33, 0x39, 0x92,
+    0x6e, 0x3e, 0x96, 0x56, 0x8f, 0x5d, 0x23, 0x1b, 0x80, 0xc2, 0x68, 0xf4,
+    0x4b, 0x1d, 0xf9, 0x62, 0x22, 0x9e, 0x5b, 0x27,
+};
+static const unsigned char kat258_retbits[] = {
+    0x0b, 0xd1, 0xc4, 0x1c, 0x30, 0x28, 0x4f, 0xad, 0xa0, 0x9e, 0xb2, 0x44,
+    0x7d, 0x56, 0x38, 0xa7, 0xa0, 0xb7, 0x3d, 0x99, 0xc6, 0x51, 0xed, 0xc5,
+    0xb8, 0xaa, 0x15, 0xd4, 0xe9, 0x81, 0x40, 0x48, 0xd7, 0x9c, 0x52, 0x38,
+    0x2b, 0xaa, 0x20, 0x3d, 0x3f, 0x72, 0x78, 0xf4, 0x86, 0x4d, 0x18, 0x36,
+    0x65, 0x66, 0x24, 0x80, 0x06, 0x58, 0x7c, 0xf3, 0xf9, 0x02, 0x71, 0xc4,
+    0x8c, 0x49, 0x3d, 0x5d,
+};
+static const struct drbg_kat_no_reseed kat258_t = {
+    2, kat258_entropyin, kat258_nonce, kat258_persstr,
+    kat258_addin0, kat258_addin1, kat258_retbits
+};
+static const struct drbg_kat kat258 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat258_t
+};
+
+static const unsigned char kat259_entropyin[] = {
+    0x8d, 0x2b, 0xcb, 0x66, 0xbd, 0x17, 0xe8, 0xb2, 0xe3, 0x6a, 0x2a, 0x5f,
+    0xd1, 0xc1, 0xa0, 0x86, 0x1f, 0xe3, 0x4e, 0x1c, 0xb8, 0xf2, 0x21, 0x9b,
+};
+static const unsigned char kat259_nonce[] = {
+    0x86, 0x8c, 0x2b, 0xab, 0xe9, 0x69, 0xd7, 0x77, 0x6f, 0x92, 0x92, 0x97,
+    0x95, 0xa9, 0x1e, 0xb7,
+};
+static const unsigned char kat259_persstr[] = {0};
+static const unsigned char kat259_addin0[] = {
+    0x46, 0x18, 0x36, 0x6b, 0x0d, 0x51, 0xf9, 0x09, 0x5f, 0xd8, 0x67, 0xfa,
+    0x7a, 0x40, 0xe7, 0x73, 0x62, 0x94, 0xa9, 0x2f, 0xdc, 0xc5, 0xd0, 0xec,
+    0xf2, 0x93, 0x04, 0x25, 0x66, 0x68, 0x34, 0x48,
+};
+static const unsigned char kat259_addin1[] = {
+    0xc4, 0x5c, 0x21, 0x8f, 0xc6, 0x48, 0xde, 0x1b, 0xfb, 0xaa, 0xa6, 0x3b,
+    0xe0, 0x27, 0xaf, 0xa0, 0x8c, 0xde, 0x5c, 0x7d, 0x84, 0xa6, 0x29, 0xdb,
+    0x9b, 0x54, 0xa2, 0x0c, 0xf6, 0x4c, 0x5a, 0x75,
+};
+static const unsigned char kat259_retbits[] = {
+    0xb8, 0x5b, 0x85, 0xcf, 0xf7, 0x18, 0x51, 0xce, 0x21, 0x1d, 0x4e, 0xb2,
+    0xdc, 0x56, 0x9a, 0xc2, 0xd4, 0x3c, 0xcf, 0x52, 0xff, 0x71, 0xcc, 0x00,
+    0x90, 0xed, 0x59, 0xc8, 0x7e, 0x78, 0x50, 0x61, 0xb9, 0x9f, 0x35, 0x2e,
+    0x39, 0x8f, 0x61, 0xd2, 0x3d, 0xc0, 0xa1, 0x7e, 0x44, 0x76, 0xda, 0x39,
+    0xc3, 0x1f, 0x7b, 0x81, 0x73, 0x8c, 0xaa, 0x61, 0x47, 0x53, 0x17, 0x36,
+    0x3c, 0x20, 0x5a, 0xba,
+};
+static const struct drbg_kat_no_reseed kat259_t = {
+    3, kat259_entropyin, kat259_nonce, kat259_persstr,
+    kat259_addin0, kat259_addin1, kat259_retbits
+};
+static const struct drbg_kat kat259 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat259_t
+};
+
+static const unsigned char kat260_entropyin[] = {
+    0xf3, 0xca, 0x9e, 0xe3, 0x24, 0xcb, 0x01, 0x11, 0xd5, 0xec, 0x08, 0x1e,
+    0xdf, 0x77, 0xd3, 0xfa, 0x0b, 0x77, 0x71, 0x8a, 0x87, 0xfb, 0xf4, 0xf5,
+};
+static const unsigned char kat260_nonce[] = {
+    0x98, 0xd1, 0x2b, 0xbe, 0x87, 0xe4, 0x76, 0x03, 0x7a, 0x5b, 0x24, 0x47,
+    0x35, 0xd2, 0x10, 0x2a,
+};
+static const unsigned char kat260_persstr[] = {0};
+static const unsigned char kat260_addin0[] = {
+    0x19, 0x06, 0x9b, 0x8f, 0xb8, 0x14, 0x8a, 0xc0, 0x0c, 0xf6, 0x07, 0xcf,
+    0xce, 0x76, 0xa9, 0x54, 0xf3, 0x12, 0x9c, 0x79, 0x75, 0x19, 0x6b, 0x8b,
+    0x61, 0x28, 0xa3, 0x00, 0xce, 0x0d, 0xc0, 0xa7,
+};
+static const unsigned char kat260_addin1[] = {
+    0x4f, 0x07, 0x8d, 0xaa, 0xbd, 0x37, 0x76, 0x80, 0xea, 0xe1, 0x82, 0x30,
+    0x74, 0xab, 0x0d, 0x40, 0xa6, 0x93, 0xd6, 0x81, 0x21, 0xbb, 0xa4, 0x29,
+    0xde, 0xbd, 0xfe, 0x0f, 0x88, 0x37, 0x03, 0xdd,
+};
+static const unsigned char kat260_retbits[] = {
+    0x67, 0x28, 0x47, 0x2e, 0xbc, 0x52, 0xa8, 0x75, 0xb1, 0xa1, 0x63, 0x21,
+    0x1c, 0x2b, 0x77, 0x1b, 0xdc, 0xa9, 0x9e, 0x03, 0xf0, 0xde, 0x54, 0xa6,
+    0xf4, 0xa1, 0x41, 0xa7, 0x69, 0x1d, 0x6f, 0x96, 0x79, 0xf9, 0x63, 0xc2,
+    0xfa, 0x37, 0x7f, 0x0a, 0xe4, 0x71, 0xec, 0xc4, 0x70, 0x76, 0x88, 0x18,
+    0xab, 0x4e, 0x62, 0x77, 0x11, 0xa0, 0xf9, 0x88, 0xff, 0x97, 0x3e, 0x4b,
+    0xce, 0x50, 0x1b, 0x69,
+};
+static const struct drbg_kat_no_reseed kat260_t = {
+    4, kat260_entropyin, kat260_nonce, kat260_persstr,
+    kat260_addin0, kat260_addin1, kat260_retbits
+};
+static const struct drbg_kat kat260 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat260_t
+};
+
+static const unsigned char kat261_entropyin[] = {
+    0x54, 0x47, 0x86, 0x8c, 0xd9, 0x25, 0x24, 0x23, 0xf0, 0x3c, 0xa3, 0xbd,
+    0x8b, 0x0a, 0x45, 0x43, 0x35, 0xd3, 0x2e, 0xa5, 0x4f, 0xbd, 0x3e, 0xdb,
+};
+static const unsigned char kat261_nonce[] = {
+    0x64, 0xf2, 0xde, 0x76, 0x5d, 0x20, 0x28, 0xa8, 0xba, 0x06, 0xe6, 0xd2,
+    0x04, 0xac, 0x4b, 0xc4,
+};
+static const unsigned char kat261_persstr[] = {0};
+static const unsigned char kat261_addin0[] = {
+    0x19, 0x1a, 0x39, 0xd6, 0x30, 0xd6, 0x6c, 0xa9, 0x46, 0x72, 0x0a, 0xef,
+    0xe8, 0x0c, 0x94, 0xbf, 0xdd, 0x3e, 0x24, 0xdd, 0xa3, 0xe3, 0x7c, 0x41,
+    0x4a, 0x93, 0xeb, 0xb7, 0x84, 0xd3, 0xe7, 0xc4,
+};
+static const unsigned char kat261_addin1[] = {
+    0x8b, 0x66, 0x4b, 0xa7, 0x4f, 0xd0, 0xbb, 0x50, 0x06, 0xed, 0xd3, 0x37,
+    0xa1, 0xc4, 0xdb, 0xbf, 0xe7, 0x73, 0x90, 0x2e, 0x08, 0x4c, 0x55, 0x8b,
+    0xa1, 0x45, 0xe8, 0xf8, 0xca, 0x34, 0x54, 0x87,
+};
+static const unsigned char kat261_retbits[] = {
+    0xce, 0x5f, 0x7a, 0x69, 0x68, 0xf3, 0xcf, 0x5f, 0xb0, 0x1e, 0x62, 0x08,
+    0xa1, 0x65, 0x17, 0x20, 0xfe, 0x1e, 0x90, 0x76, 0x4d, 0xea, 0x46, 0x50,
+    0x4e, 0x10, 0x6f, 0x13, 0xeb, 0xff, 0xf3, 0xd9, 0x79, 0x07, 0x2b, 0x6f,
+    0x54, 0x59, 0x06, 0x9a, 0x77, 0x30, 0x03, 0xe3, 0xec, 0xa4, 0xee, 0x3b,
+    0x73, 0x0a, 0xeb, 0xfe, 0x95, 0x7c, 0x0e, 0x68, 0x77, 0x4d, 0xdc, 0xb9,
+    0x71, 0xbf, 0x46, 0x03,
+};
+static const struct drbg_kat_no_reseed kat261_t = {
+    5, kat261_entropyin, kat261_nonce, kat261_persstr,
+    kat261_addin0, kat261_addin1, kat261_retbits
+};
+static const struct drbg_kat kat261 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat261_t
+};
+
+static const unsigned char kat262_entropyin[] = {
+    0xe8, 0xd9, 0x3d, 0x86, 0xc3, 0xe9, 0x8d, 0xe6, 0x4f, 0x40, 0x80, 0xbb,
+    0x64, 0x52, 0x05, 0x5c, 0xc7, 0xdb, 0x86, 0xd2, 0x5b, 0xb3, 0xa9, 0x23,
+};
+static const unsigned char kat262_nonce[] = {
+    0xa5, 0x44, 0x7f, 0x91, 0x15, 0x89, 0x1d, 0x48, 0x30, 0x37, 0xad, 0x4d,
+    0xd4, 0xc2, 0x2a, 0x8a,
+};
+static const unsigned char kat262_persstr[] = {0};
+static const unsigned char kat262_addin0[] = {
+    0x56, 0xc6, 0xce, 0xa0, 0x19, 0x72, 0x73, 0x74, 0x21, 0xa0, 0x7c, 0xb2,
+    0x0c, 0x79, 0xb8, 0xf7, 0x6b, 0x32, 0xa9, 0xe9, 0xfb, 0xbb, 0xe4, 0x6d,
+    0xd7, 0x1f, 0x02, 0xc7, 0x2d, 0x1e, 0x45, 0x0a,
+};
+static const unsigned char kat262_addin1[] = {
+    0x96, 0x42, 0xc8, 0x21, 0x59, 0xc3, 0x6a, 0x48, 0xa2, 0x52, 0xcc, 0xfe,
+    0xe6, 0x1c, 0x5c, 0x1c, 0xed, 0x6d, 0x3a, 0x04, 0x09, 0x9d, 0x98, 0xf9,
+    0xdb, 0xe5, 0x34, 0x87, 0x7b, 0x80, 0xa9, 0x8f,
+};
+static const unsigned char kat262_retbits[] = {
+    0x18, 0x7f, 0x40, 0x48, 0x9f, 0x22, 0xf3, 0x55, 0x83, 0xe7, 0x58, 0x21,
+    0xd6, 0x9f, 0x36, 0x9d, 0x12, 0x59, 0x35, 0x21, 0x71, 0xc5, 0x69, 0xf2,
+    0xd8, 0xe9, 0xa1, 0x50, 0x97, 0x87, 0x6c, 0xe5, 0x26, 0x1b, 0x41, 0x74,
+    0x53, 0x04, 0x69, 0x82, 0x9b, 0xa2, 0xc0, 0x01, 0x45, 0xcb, 0xf4, 0xd2,
+    0xa1, 0x20, 0x5e, 0x91, 0x1c, 0x2c, 0x32, 0xd3, 0x3b, 0x5d, 0x67, 0x06,
+    0x40, 0x97, 0x72, 0xd2,
+};
+static const struct drbg_kat_no_reseed kat262_t = {
+    6, kat262_entropyin, kat262_nonce, kat262_persstr,
+    kat262_addin0, kat262_addin1, kat262_retbits
+};
+static const struct drbg_kat kat262 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat262_t
+};
+
+static const unsigned char kat263_entropyin[] = {
+    0x59, 0xb9, 0xb4, 0xdf, 0x1b, 0xb4, 0xf7, 0x78, 0xea, 0x1a, 0x1b, 0xfc,
+    0x41, 0x25, 0x5c, 0xc3, 0x25, 0xd6, 0xbf, 0x4f, 0xfc, 0x42, 0x8c, 0xe1,
+};
+static const unsigned char kat263_nonce[] = {
+    0xe0, 0xfb, 0x72, 0xdd, 0x71, 0xff, 0x3c, 0x2e, 0x07, 0x2f, 0x27, 0xd6,
+    0x57, 0x26, 0x0d, 0xa2,
+};
+static const unsigned char kat263_persstr[] = {0};
+static const unsigned char kat263_addin0[] = {
+    0xcc, 0xfb, 0x64, 0xf4, 0x3f, 0x84, 0xf0, 0x3c, 0xd9, 0x8e, 0x1a, 0xa3,
+    0x56, 0x6c, 0xa0, 0xc9, 0xb7, 0x43, 0x82, 0x04, 0xc8, 0xe6, 0x5a, 0x9c,
+    0xb8, 0x22, 0x7e, 0x20, 0x11, 0xb9, 0xa7, 0x16,
+};
+static const unsigned char kat263_addin1[] = {
+    0x30, 0x64, 0xa3, 0x1a, 0x84, 0xc4, 0xea, 0xa6, 0x98, 0x0e, 0x6d, 0x41,
+    0x2c, 0xd4, 0xf4, 0x19, 0x11, 0x4b, 0xf0, 0xe8, 0xb2, 0x27, 0x45, 0x6a,
+    0x91, 0xda, 0x0f, 0xc0, 0xf7, 0xdc, 0xb7, 0x5f,
+};
+static const unsigned char kat263_retbits[] = {
+    0x7d, 0x48, 0x83, 0x6e, 0xd6, 0x57, 0x23, 0x1f, 0x62, 0x62, 0x7b, 0xa5,
+    0x08, 0x97, 0xca, 0x8f, 0x37, 0x9f, 0x68, 0xd8, 0x6f, 0xab, 0xe2, 0x6c,
+    0xaa, 0x7b, 0x44, 0x41, 0xcd, 0x2b, 0x6c, 0x2a, 0xd1, 0xda, 0xf4, 0xea,
+    0xbc, 0x2c, 0x34, 0xb3, 0x96, 0x34, 0x00, 0xd2, 0x36, 0x11, 0x74, 0xee,
+    0x22, 0x95, 0x2d, 0x6a, 0x28, 0xe8, 0x99, 0x37, 0xb2, 0x31, 0xc9, 0xbc,
+    0x22, 0x8a, 0x78, 0xc5,
+};
+static const struct drbg_kat_no_reseed kat263_t = {
+    7, kat263_entropyin, kat263_nonce, kat263_persstr,
+    kat263_addin0, kat263_addin1, kat263_retbits
+};
+static const struct drbg_kat kat263 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat263_t
+};
+
+static const unsigned char kat264_entropyin[] = {
+    0x0d, 0x03, 0xee, 0x60, 0xbc, 0xa7, 0x23, 0x99, 0x9d, 0x49, 0x58, 0x9e,
+    0xb6, 0xe4, 0x04, 0x2f, 0xf9, 0x7b, 0x22, 0x43, 0x3c, 0x81, 0x22, 0x42,
+};
+static const unsigned char kat264_nonce[] = {
+    0x8a, 0x2f, 0x6f, 0xc8, 0xd4, 0xc5, 0x4b, 0xf6, 0x85, 0x2b, 0x90, 0x2b,
+    0xcf, 0x2c, 0x41, 0xec,
+};
+static const unsigned char kat264_persstr[] = {0};
+static const unsigned char kat264_addin0[] = {
+    0xcb, 0x26, 0x94, 0x41, 0x03, 0x5e, 0x07, 0x11, 0x01, 0xac, 0x8e, 0xfb,
+    0x4e, 0xb7, 0xf9, 0xf1, 0xde, 0x21, 0x84, 0x77, 0x1e, 0xc0, 0xea, 0xc6,
+    0x2d, 0x06, 0x92, 0xe6, 0x7b, 0xdf, 0x1f, 0xae,
+};
+static const unsigned char kat264_addin1[] = {
+    0x90, 0x5e, 0x3d, 0x9c, 0x18, 0x00, 0xe1, 0x36, 0x6b, 0xc7, 0x49, 0xa6,
+    0x0d, 0x21, 0xce, 0x51, 0x8f, 0xde, 0xf2, 0xa3, 0x6f, 0x88, 0x0c, 0x26,
+    0xc1, 0x52, 0x8f, 0x12, 0xdf, 0xfb, 0x91, 0x76,
+};
+static const unsigned char kat264_retbits[] = {
+    0xa4, 0xcb, 0x87, 0xde, 0x76, 0xb2, 0xeb, 0x39, 0x59, 0x9f, 0x68, 0x40,
+    0x22, 0x93, 0xce, 0xe9, 0xc6, 0x1d, 0xc9, 0xdc, 0x12, 0x57, 0x78, 0x99,
+    0x64, 0xa2, 0xac, 0xf0, 0xc3, 0x2f, 0x61, 0xc9, 0x07, 0x29, 0x4b, 0xde,
+    0xca, 0x88, 0xb0, 0x5d, 0xaa, 0xe0, 0x75, 0x4d, 0x21, 0xf0, 0xc2, 0xb7,
+    0x56, 0x97, 0xd8, 0x61, 0x42, 0x37, 0x4f, 0x96, 0x76, 0xdb, 0x34, 0x75,
+    0x33, 0x71, 0xe6, 0x18,
+};
+static const struct drbg_kat_no_reseed kat264_t = {
+    8, kat264_entropyin, kat264_nonce, kat264_persstr,
+    kat264_addin0, kat264_addin1, kat264_retbits
+};
+static const struct drbg_kat kat264 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat264_t
+};
+
+static const unsigned char kat265_entropyin[] = {
+    0xb9, 0x5d, 0x8b, 0x26, 0x6a, 0xcc, 0xcd, 0x6c, 0xba, 0xc0, 0xc0, 0x61,
+    0xec, 0x32, 0xa1, 0xea, 0x71, 0x1f, 0xfe, 0xc8, 0x00, 0x6b, 0xc7, 0xcc,
+};
+static const unsigned char kat265_nonce[] = {
+    0xbf, 0xa0, 0x84, 0x02, 0xc0, 0xc6, 0xb8, 0x7d, 0xec, 0xa2, 0x24, 0x6d,
+    0x81, 0xf6, 0x7f, 0x58,
+};
+static const unsigned char kat265_persstr[] = {0};
+static const unsigned char kat265_addin0[] = {
+    0x72, 0xff, 0xd4, 0xa1, 0x83, 0x99, 0x0d, 0xac, 0x6b, 0xc7, 0xa9, 0x46,
+    0x47, 0x14, 0x27, 0x59, 0xbf, 0x88, 0x1c, 0xc0, 0xb3, 0x17, 0x8f, 0x60,
+    0xe0, 0xe2, 0xcb, 0xc3, 0x33, 0x79, 0xf7, 0xad,
+};
+static const unsigned char kat265_addin1[] = {
+    0x2e, 0x9f, 0xe4, 0xd1, 0xaf, 0x62, 0xb1, 0x5f, 0x85, 0x35, 0xe1, 0x98,
+    0xaa, 0xd7, 0x93, 0x61, 0xe9, 0x46, 0x16, 0x41, 0x8e, 0xd2, 0xd8, 0x01,
+    0xe7, 0x0f, 0xad, 0x9e, 0x0e, 0x9c, 0xa5, 0xb8,
+};
+static const unsigned char kat265_retbits[] = {
+    0x1b, 0x0d, 0x15, 0xfb, 0x4f, 0xcd, 0xca, 0x14, 0x97, 0xdc, 0xfe, 0x60,
+    0xe7, 0xd8, 0x2b, 0xd0, 0x40, 0x1b, 0x16, 0x23, 0x36, 0x6a, 0x71, 0xcf,
+    0x8f, 0xa5, 0x75, 0x4f, 0x87, 0x8e, 0x20, 0xd8, 0xf2, 0x54, 0x5b, 0xc3,
+    0xd4, 0x1e, 0x79, 0x73, 0xae, 0x32, 0x90, 0x50, 0x6b, 0xa2, 0xa9, 0x76,
+    0xb8, 0x3b, 0x7b, 0x98, 0xc7, 0x66, 0xd8, 0xec, 0x0c, 0x26, 0x4b, 0xe2,
+    0x87, 0xee, 0x63, 0xf5,
+};
+static const struct drbg_kat_no_reseed kat265_t = {
+    9, kat265_entropyin, kat265_nonce, kat265_persstr,
+    kat265_addin0, kat265_addin1, kat265_retbits
+};
+static const struct drbg_kat kat265 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat265_t
+};
+
+static const unsigned char kat266_entropyin[] = {
+    0x6d, 0x30, 0x46, 0x58, 0x37, 0xa6, 0x1e, 0x49, 0xda, 0xc0, 0xfc, 0x84,
+    0x48, 0xde, 0x3a, 0xfa, 0x2e, 0x22, 0xe0, 0x94, 0x28, 0x6a, 0x5a, 0xed,
+};
+static const unsigned char kat266_nonce[] = {
+    0x94, 0x18, 0xc0, 0x28, 0x70, 0xef, 0x4c, 0xd1, 0x19, 0xdd, 0xb6, 0x73,
+    0xee, 0x69, 0x9d, 0xde,
+};
+static const unsigned char kat266_persstr[] = {0};
+static const unsigned char kat266_addin0[] = {
+    0xac, 0x32, 0x2e, 0xcf, 0xff, 0x1f, 0x73, 0x26, 0xa4, 0xf4, 0xcb, 0x33,
+    0xc1, 0x76, 0xfe, 0x83, 0x1c, 0x0d, 0xdf, 0x37, 0x37, 0x69, 0xfd, 0xe6,
+    0x1a, 0x42, 0x42, 0x6f, 0xe9, 0x9e, 0xa8, 0x49,
+};
+static const unsigned char kat266_addin1[] = {
+    0x5b, 0x70, 0x52, 0x49, 0x1c, 0x3f, 0x53, 0x6e, 0xcb, 0x91, 0xfd, 0x04,
+    0x38, 0x0f, 0x9f, 0x03, 0x80, 0xa4, 0x15, 0xdc, 0xde, 0x60, 0x1a, 0x67,
+    0x0a, 0x1e, 0xe6, 0xb8, 0xf2, 0x2e, 0x96, 0xda,
+};
+static const unsigned char kat266_retbits[] = {
+    0xdc, 0xa3, 0xfd, 0xae, 0xf8, 0xbf, 0xb2, 0xd0, 0x9b, 0xb9, 0x06, 0xab,
+    0xcb, 0x21, 0x81, 0x8a, 0xa6, 0x6a, 0x06, 0x4e, 0x71, 0x18, 0xff, 0x3d,
+    0xac, 0x55, 0x66, 0xca, 0x99, 0x1e, 0xbb, 0x37, 0x33, 0x82, 0x41, 0xe0,
+    0xc8, 0x29, 0x76, 0x8f, 0x71, 0x5e, 0x4c, 0x2f, 0x11, 0x57, 0xeb, 0x0a,
+    0xc4, 0x73, 0xba, 0xd8, 0x6b, 0x05, 0x13, 0xb6, 0x48, 0x54, 0xf3, 0xed,
+    0x8d, 0xa4, 0x83, 0x28,
+};
+static const struct drbg_kat_no_reseed kat266_t = {
+    10, kat266_entropyin, kat266_nonce, kat266_persstr,
+    kat266_addin0, kat266_addin1, kat266_retbits
+};
+static const struct drbg_kat kat266 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat266_t
+};
+
+static const unsigned char kat267_entropyin[] = {
+    0xc6, 0x83, 0x21, 0x3a, 0x47, 0x37, 0x5e, 0x29, 0x75, 0xd3, 0x00, 0x4b,
+    0xcd, 0x6f, 0xb4, 0xaa, 0xb6, 0x55, 0x31, 0xc7, 0x52, 0x93, 0x1d, 0x6b,
+};
+static const unsigned char kat267_nonce[] = {
+    0x11, 0xf2, 0x78, 0xb8, 0x64, 0x4f, 0x52, 0xa0, 0xa4, 0x07, 0x41, 0x64,
+    0x09, 0x7d, 0xe4, 0x58,
+};
+static const unsigned char kat267_persstr[] = {0};
+static const unsigned char kat267_addin0[] = {
+    0x37, 0xc0, 0x65, 0x5e, 0xa6, 0xc2, 0x0e, 0xc4, 0x3c, 0x58, 0x85, 0x5b,
+    0xe3, 0x14, 0xaf, 0xde, 0x29, 0x32, 0x4a, 0x81, 0x86, 0xae, 0x9c, 0x08,
+    0xc8, 0xad, 0x4d, 0x85, 0x70, 0x08, 0x1a, 0x72,
+};
+static const unsigned char kat267_addin1[] = {
+    0xc3, 0x9b, 0xc5, 0x60, 0xc7, 0x1a, 0xa5, 0xcd, 0xf2, 0xa0, 0xec, 0xa0,
+    0xff, 0xa4, 0xfb, 0x56, 0x2c, 0xab, 0x13, 0x79, 0xbc, 0x90, 0x43, 0x25,
+    0x9e, 0xf8, 0x93, 0x44, 0x36, 0x14, 0x23, 0x23,
+};
+static const unsigned char kat267_retbits[] = {
+    0x7a, 0xf8, 0xcd, 0xc7, 0x05, 0xcb, 0x06, 0xc4, 0x08, 0xf7, 0x89, 0xb5,
+    0xa0, 0xd6, 0x77, 0xe6, 0x6f, 0xb3, 0x2b, 0xc7, 0xa5, 0x78, 0xc4, 0xcd,
+    0x6d, 0xe3, 0x42, 0x02, 0xf1, 0x7a, 0x88, 0xd9, 0x1a, 0x23, 0x85, 0x74,
+    0x66, 0x64, 0x49, 0xc4, 0x05, 0x9f, 0x2b, 0xdf, 0x59, 0x35, 0x57, 0xfb,
+    0x78, 0xd0, 0x77, 0x95, 0x37, 0x16, 0x46, 0xf0, 0x3c, 0xf3, 0x85, 0xf3,
+    0x05, 0x8b, 0x1d, 0x78,
+};
+static const struct drbg_kat_no_reseed kat267_t = {
+    11, kat267_entropyin, kat267_nonce, kat267_persstr,
+    kat267_addin0, kat267_addin1, kat267_retbits
+};
+static const struct drbg_kat kat267 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat267_t
+};
+
+static const unsigned char kat268_entropyin[] = {
+    0x8b, 0xd5, 0xa5, 0x95, 0x22, 0x83, 0x77, 0x67, 0xfb, 0xc7, 0x83, 0xca,
+    0xa9, 0xa7, 0xfe, 0xec, 0x68, 0xdf, 0x13, 0x56, 0x16, 0xe9, 0x88, 0x78,
+};
+static const unsigned char kat268_nonce[] = {
+    0x14, 0xaa, 0xa4, 0x14, 0xad, 0xe4, 0x8e, 0x33, 0xac, 0x5b, 0x44, 0x3b,
+    0x94, 0xa9, 0xf1, 0xac,
+};
+static const unsigned char kat268_persstr[] = {0};
+static const unsigned char kat268_addin0[] = {
+    0x23, 0x3b, 0x1e, 0x2c, 0x23, 0x0c, 0xea, 0xba, 0xf8, 0x8e, 0xc1, 0xba,
+    0x30, 0xef, 0xb7, 0x2e, 0x35, 0xcb, 0xf9, 0x9f, 0xdc, 0x92, 0x59, 0x51,
+    0x40, 0x19, 0xbc, 0x96, 0xf6, 0xee, 0xcb, 0xde,
+};
+static const unsigned char kat268_addin1[] = {
+    0xf8, 0xb1, 0x99, 0x22, 0xb8, 0x89, 0x61, 0x75, 0xad, 0xa1, 0x15, 0x24,
+    0xb9, 0x8f, 0xff, 0xc1, 0x15, 0x9f, 0x14, 0x56, 0xdd, 0x7a, 0xa6, 0x57,
+    0xb7, 0x54, 0x7f, 0x0b, 0xf9, 0xe4, 0xfd, 0xe4,
+};
+static const unsigned char kat268_retbits[] = {
+    0x49, 0x4a, 0x5d, 0x31, 0xa5, 0x8a, 0x50, 0xf5, 0x06, 0x82, 0x52, 0x79,
+    0xb2, 0x48, 0x83, 0x59, 0x14, 0x08, 0x1d, 0xdc, 0xcd, 0x63, 0x80, 0x67,
+    0xdf, 0x0e, 0x2d, 0x3c, 0x62, 0x00, 0x8a, 0x4f, 0x10, 0x8c, 0x81, 0x91,
+    0x59, 0x00, 0x0b, 0xc0, 0xd0, 0xc7, 0x51, 0x5d, 0xbe, 0x48, 0x8c, 0x3d,
+    0xc6, 0xca, 0x3f, 0x28, 0x78, 0xca, 0x58, 0x96, 0xb1, 0x33, 0x50, 0x98,
+    0x5e, 0xd7, 0x60, 0x2d,
+};
+static const struct drbg_kat_no_reseed kat268_t = {
+    12, kat268_entropyin, kat268_nonce, kat268_persstr,
+    kat268_addin0, kat268_addin1, kat268_retbits
+};
+static const struct drbg_kat kat268 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat268_t
+};
+
+static const unsigned char kat269_entropyin[] = {
+    0x97, 0xfe, 0xf1, 0xc3, 0x6e, 0x3c, 0xab, 0x72, 0xd5, 0x04, 0x3e, 0x41,
+    0x6c, 0xb1, 0x57, 0x06, 0xd6, 0xd7, 0x6e, 0xc5, 0x01, 0x64, 0x51, 0xe2,
+};
+static const unsigned char kat269_nonce[] = {
+    0xaa, 0x86, 0x57, 0x62, 0xb8, 0x01, 0x65, 0xe2, 0x39, 0xed, 0x79, 0x51,
+    0xb0, 0x56, 0xc7, 0x70,
+};
+static const unsigned char kat269_persstr[] = {0};
+static const unsigned char kat269_addin0[] = {
+    0x41, 0x89, 0x07, 0xa2, 0x53, 0x32, 0xb9, 0xd2, 0x42, 0xbb, 0x18, 0x77,
+    0x5f, 0xdc, 0xb0, 0xb4, 0xf2, 0xec, 0x98, 0x11, 0x75, 0x0e, 0x05, 0x1f,
+    0x96, 0xe3, 0xd6, 0xd2, 0x52, 0xeb, 0x87, 0xde,
+};
+static const unsigned char kat269_addin1[] = {
+    0x57, 0x4b, 0x64, 0x27, 0x93, 0x94, 0x23, 0x4f, 0xe5, 0x9a, 0x14, 0xcb,
+    0xc9, 0x40, 0x4a, 0x0b, 0xc1, 0x46, 0x9e, 0x6d, 0x18, 0x1e, 0xeb, 0x4e,
+    0x74, 0x14, 0xa4, 0xa6, 0xde, 0x0b, 0xab, 0x7d,
+};
+static const unsigned char kat269_retbits[] = {
+    0x8c, 0x6b, 0x47, 0x5b, 0xac, 0xf9, 0x33, 0xc0, 0xf7, 0xa0, 0x7c, 0x88,
+    0xa5, 0x28, 0xfe, 0xef, 0xc9, 0x52, 0xb9, 0x55, 0x31, 0x05, 0xb2, 0x0a,
+    0x17, 0xe3, 0xba, 0xd3, 0x93, 0x9e, 0x94, 0x32, 0x0f, 0xa8, 0xe2, 0x80,
+    0xfc, 0x54, 0xb4, 0x85, 0xd4, 0xcf, 0xe7, 0x94, 0x08, 0x1c, 0x05, 0x4e,
+    0xe8, 0xe7, 0xc2, 0x4c, 0x65, 0xf6, 0xbb, 0x95, 0xd8, 0x82, 0x72, 0x87,
+    0x4d, 0x2a, 0x04, 0x2f,
+};
+static const struct drbg_kat_no_reseed kat269_t = {
+    13, kat269_entropyin, kat269_nonce, kat269_persstr,
+    kat269_addin0, kat269_addin1, kat269_retbits
+};
+static const struct drbg_kat kat269 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat269_t
+};
+
+static const unsigned char kat270_entropyin[] = {
+    0x54, 0x32, 0xa3, 0x40, 0x20, 0x56, 0x25, 0xc2, 0x0a, 0xfd, 0xd4, 0x2e,
+    0xcd, 0x54, 0xe8, 0xd6, 0xef, 0x80, 0xb2, 0x9c, 0x73, 0xf6, 0x2d, 0xba,
+};
+static const unsigned char kat270_nonce[] = {
+    0xb8, 0xfb, 0x44, 0x40, 0xd8, 0x95, 0x54, 0x99, 0xcd, 0xad, 0x97, 0xb9,
+    0xb0, 0xe3, 0x3f, 0x63,
+};
+static const unsigned char kat270_persstr[] = {0};
+static const unsigned char kat270_addin0[] = {
+    0x9a, 0x53, 0x54, 0x10, 0x62, 0x6b, 0x87, 0x2d, 0xa5, 0x06, 0x43, 0x19,
+    0xdb, 0x92, 0x1d, 0x9f, 0xa0, 0x15, 0xa6, 0x75, 0x48, 0xf1, 0x2e, 0x8a,
+    0xf2, 0xb1, 0x55, 0x13, 0x0a, 0xb6, 0x32, 0xd0,
+};
+static const unsigned char kat270_addin1[] = {
+    0x3a, 0x12, 0x51, 0x9f, 0x49, 0x7a, 0x8c, 0x3a, 0xf0, 0xf3, 0x5f, 0xdf,
+    0xe4, 0xaa, 0x47, 0xfe, 0xf0, 0x39, 0x56, 0x3c, 0x03, 0x8c, 0x52, 0xaa,
+    0x4e, 0xe4, 0xce, 0xcd, 0x05, 0x5f, 0x1b, 0xb6,
+};
+static const unsigned char kat270_retbits[] = {
+    0x57, 0x01, 0xe2, 0xee, 0x57, 0x46, 0x84, 0xc8, 0x55, 0xd4, 0x03, 0xe5,
+    0xa6, 0x1b, 0x13, 0x2c, 0x21, 0x1e, 0x64, 0x6f, 0xf5, 0xed, 0x41, 0xcf,
+    0xcb, 0x81, 0xf7, 0x9b, 0xdd, 0x86, 0x7e, 0xf5, 0xcd, 0xa7, 0xf0, 0xba,
+    0x57, 0x99, 0xf9, 0x3c, 0x07, 0xf4, 0xb5, 0x58, 0x8c, 0x34, 0xd4, 0x33,
+    0xdf, 0x93, 0x35, 0x01, 0x0f, 0xb6, 0x01, 0x10, 0x91, 0x17, 0x7f, 0x5e,
+    0x0a, 0x7c, 0xed, 0xe7,
+};
+static const struct drbg_kat_no_reseed kat270_t = {
+    14, kat270_entropyin, kat270_nonce, kat270_persstr,
+    kat270_addin0, kat270_addin1, kat270_retbits
+};
+static const struct drbg_kat kat270 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 32, 64, &kat270_t
+};
+
+static const unsigned char kat271_entropyin[] = {
+    0xeb, 0x45, 0x53, 0xf7, 0x14, 0x1b, 0xc1, 0x08, 0x82, 0xf0, 0xa3, 0x74,
+    0x17, 0x80, 0xa4, 0x2d, 0xf8, 0xbc, 0x38, 0xa7, 0x12, 0x1d, 0x3b, 0x7e,
+};
+static const unsigned char kat271_nonce[] = {
+    0x6f, 0x34, 0x7f, 0x9c, 0x1d, 0xe8, 0x4f, 0xd5, 0x34, 0x16, 0x25, 0xae,
+    0x8d, 0x6b, 0xf5, 0x0c,
+};
+static const unsigned char kat271_persstr[] = {
+    0x5e, 0x2e, 0x73, 0xb8, 0x6c, 0xa2, 0xf3, 0x15, 0x0d, 0x53, 0xd2, 0x3d,
+    0x59, 0x0a, 0xcb, 0xee, 0xda, 0xaf, 0x91, 0x63, 0x8b, 0xdc, 0x3f, 0x9d,
+    0x58, 0x8e, 0x94, 0x5a, 0xf4, 0xbb, 0x6e, 0xa2,
+};
+static const unsigned char kat271_addin0[] = {0};
+static const unsigned char kat271_addin1[] = {0};
+static const unsigned char kat271_retbits[] = {
+    0xa1, 0xde, 0xb9, 0xa5, 0xaa, 0xd6, 0x08, 0xa5, 0x87, 0xd6, 0x1c, 0xe5,
+    0xe0, 0xd7, 0xc7, 0xdd, 0x44, 0x9b, 0x8c, 0x87, 0x89, 0x83, 0x54, 0xad,
+    0x1a, 0xdd, 0x6e, 0x05, 0x85, 0x38, 0x73, 0xd2, 0x79, 0xeb, 0xe4, 0x13,
+    0x2f, 0xc2, 0x36, 0xa4, 0x2d, 0x8f, 0xf0, 0xdc, 0x3a, 0xce, 0x95, 0xd2,
+    0xcd, 0xf9, 0xd0, 0xb0, 0x57, 0x11, 0x7c, 0xb1, 0x19, 0xee, 0x75, 0x50,
+    0xce, 0x03, 0x08, 0x5c,
+};
+static const struct drbg_kat_no_reseed kat271_t = {
+    0, kat271_entropyin, kat271_nonce, kat271_persstr,
+    kat271_addin0, kat271_addin1, kat271_retbits
+};
+static const struct drbg_kat kat271 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat271_t
+};
+
+static const unsigned char kat272_entropyin[] = {
+    0xf9, 0xce, 0x2d, 0x06, 0x49, 0xbc, 0x99, 0x28, 0x8a, 0xf1, 0x5f, 0xdf,
+    0xbc, 0x3d, 0xb8, 0x89, 0x56, 0xd9, 0x6c, 0x84, 0xc0, 0xd7, 0xe5, 0xd2,
+};
+static const unsigned char kat272_nonce[] = {
+    0x8c, 0xf0, 0x0c, 0x63, 0x7a, 0x07, 0x9a, 0x98, 0x36, 0x2e, 0xad, 0x51,
+    0x14, 0x9e, 0x55, 0x67,
+};
+static const unsigned char kat272_persstr[] = {
+    0xb2, 0x44, 0xd6, 0x8a, 0x9b, 0x30, 0xf3, 0xac, 0x88, 0x04, 0x0d, 0x64,
+    0x58, 0xa6, 0x25, 0x08, 0x00, 0x20, 0x53, 0x53, 0x41, 0x53, 0x3b, 0xe2,
+    0x70, 0xe8, 0x94, 0x00, 0x2c, 0x07, 0x69, 0x7d,
+};
+static const unsigned char kat272_addin0[] = {0};
+static const unsigned char kat272_addin1[] = {0};
+static const unsigned char kat272_retbits[] = {
+    0x28, 0x51, 0x19, 0x2f, 0xd3, 0xb3, 0x73, 0x51, 0xd0, 0x51, 0x10, 0x97,
+    0x43, 0x88, 0xec, 0xe0, 0x11, 0xd1, 0x0e, 0x7b, 0x9d, 0x38, 0x01, 0x40,
+    0x29, 0x10, 0x48, 0xce, 0x36, 0x72, 0xc1, 0x34, 0xbc, 0xb4, 0xa0, 0xcd,
+    0x07, 0x4f, 0xff, 0xf3, 0x89, 0xa0, 0x2a, 0xf5, 0x9c, 0x52, 0x26, 0xbe,
+    0x02, 0x53, 0xe7, 0xb7, 0x40, 0x0e, 0x63, 0x44, 0xb1, 0xa0, 0xd0, 0xd1,
+    0x45, 0xff, 0x36, 0x6c,
+};
+static const struct drbg_kat_no_reseed kat272_t = {
+    1, kat272_entropyin, kat272_nonce, kat272_persstr,
+    kat272_addin0, kat272_addin1, kat272_retbits
+};
+static const struct drbg_kat kat272 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat272_t
+};
+
+static const unsigned char kat273_entropyin[] = {
+    0x61, 0x8a, 0xb7, 0xda, 0x12, 0xa5, 0x83, 0x9b, 0x4d, 0x80, 0x8b, 0xc2,
+    0x7c, 0xd5, 0xd3, 0x25, 0x00, 0x00, 0x78, 0x14, 0xa5, 0x4e, 0x5d, 0xe0,
+};
+static const unsigned char kat273_nonce[] = {
+    0xc3, 0xef, 0xab, 0x85, 0x7f, 0x1f, 0xeb, 0x04, 0x9e, 0xe0, 0x60, 0xba,
+    0x76, 0x0f, 0x17, 0xe0,
+};
+static const unsigned char kat273_persstr[] = {
+    0x33, 0xc6, 0xaf, 0x4e, 0x26, 0x4f, 0x0d, 0x19, 0xc3, 0x61, 0xec, 0xec,
+    0xf8, 0x9b, 0xd7, 0x86, 0x9f, 0xb0, 0xaf, 0x7f, 0x9b, 0x39, 0x15, 0x9c,
+    0x0f, 0xab, 0xe0, 0x81, 0x14, 0x31, 0xe6, 0x2c,
+};
+static const unsigned char kat273_addin0[] = {0};
+static const unsigned char kat273_addin1[] = {0};
+static const unsigned char kat273_retbits[] = {
+    0x1d, 0x74, 0xba, 0x44, 0xea, 0xdb, 0xae, 0x17, 0x6a, 0x0a, 0x87, 0x06,
+    0x22, 0x17, 0x5e, 0x4b, 0x0e, 0xe4, 0xe4, 0x35, 0x2f, 0x8c, 0x2e, 0xe1,
+    0x95, 0x53, 0xdc, 0xb2, 0x10, 0x0f, 0x8e, 0x2f, 0x13, 0x2d, 0xfd, 0x4f,
+    0x4c, 0xad, 0x5e, 0x01, 0xe3, 0xb7, 0x02, 0x22, 0x89, 0x02, 0xdc, 0xbe,
+    0xe5, 0xaf, 0xd5, 0x39, 0x09, 0x39, 0xc3, 0x61, 0x88, 0x2a, 0x0b, 0x67,
+    0x9d, 0xc2, 0xcd, 0x69,
+};
+static const struct drbg_kat_no_reseed kat273_t = {
+    2, kat273_entropyin, kat273_nonce, kat273_persstr,
+    kat273_addin0, kat273_addin1, kat273_retbits
+};
+static const struct drbg_kat kat273 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat273_t
+};
+
+static const unsigned char kat274_entropyin[] = {
+    0x7d, 0xf2, 0xa3, 0xc0, 0xbd, 0x95, 0xc6, 0xba, 0x88, 0x73, 0xd6, 0xa5,
+    0xad, 0x5d, 0xbf, 0x0e, 0x06, 0x9d, 0xa3, 0xcd, 0xe1, 0xe3, 0x94, 0x3d,
+};
+static const unsigned char kat274_nonce[] = {
+    0xfa, 0x28, 0x22, 0x4a, 0x89, 0x49, 0x13, 0x4e, 0x28, 0x50, 0xc5, 0x2a,
+    0x28, 0x57, 0x6f, 0x65,
+};
+static const unsigned char kat274_persstr[] = {
+    0xe2, 0xde, 0xa1, 0x5d, 0x8d, 0x3a, 0xee, 0xd8, 0x7f, 0xf4, 0x5e, 0x79,
+    0xa4, 0xa7, 0x60, 0xa8, 0x96, 0x83, 0xdc, 0xf8, 0x2c, 0xfe, 0x35, 0x64,
+    0x67, 0xaf, 0xfc, 0x44, 0x59, 0x2e, 0x2b, 0xf5,
+};
+static const unsigned char kat274_addin0[] = {0};
+static const unsigned char kat274_addin1[] = {0};
+static const unsigned char kat274_retbits[] = {
+    0x3c, 0x48, 0x82, 0x3f, 0x45, 0x28, 0xb3, 0x96, 0xc8, 0x66, 0x74, 0x07,
+    0xcb, 0x88, 0x46, 0xa2, 0x29, 0x52, 0x7d, 0x95, 0x89, 0xf1, 0xce, 0xb2,
+    0xfe, 0xe6, 0x40, 0xa8, 0x3f, 0x93, 0x32, 0x71, 0x07, 0xc4, 0xc9, 0x91,
+    0xc2, 0xc8, 0xba, 0x3e, 0xe8, 0x18, 0x53, 0x14, 0x0a, 0x34, 0x8c, 0x1c,
+    0xa5, 0xce, 0x26, 0x4e, 0xf7, 0x5d, 0xb4, 0x95, 0x67, 0x94, 0x26, 0x8c,
+    0x55, 0x38, 0x10, 0x1f,
+};
+static const struct drbg_kat_no_reseed kat274_t = {
+    3, kat274_entropyin, kat274_nonce, kat274_persstr,
+    kat274_addin0, kat274_addin1, kat274_retbits
+};
+static const struct drbg_kat kat274 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat274_t
+};
+
+static const unsigned char kat275_entropyin[] = {
+    0x2d, 0x8a, 0x1a, 0x3a, 0x6a, 0x77, 0xe3, 0xcd, 0x46, 0x40, 0xa0, 0x78,
+    0x0f, 0x59, 0xcb, 0x97, 0x5f, 0x81, 0xc2, 0x73, 0x3a, 0xd7, 0xf4, 0x98,
+};
+static const unsigned char kat275_nonce[] = {
+    0x50, 0xfc, 0x6b, 0xcc, 0x7e, 0xcb, 0xdb, 0x3d, 0x57, 0xbe, 0xab, 0x7e,
+    0x28, 0xa4, 0x9b, 0xc0,
+};
+static const unsigned char kat275_persstr[] = {
+    0x95, 0xf9, 0xc3, 0x56, 0x3b, 0x53, 0x5e, 0x69, 0xa4, 0x91, 0x34, 0xc3,
+    0x36, 0xcb, 0x80, 0xfa, 0x9a, 0xd9, 0x51, 0x08, 0xc7, 0x56, 0xea, 0x26,
+    0x1f, 0x5b, 0x3a, 0xe9, 0xcb, 0xaf, 0xd4, 0x1b,
+};
+static const unsigned char kat275_addin0[] = {0};
+static const unsigned char kat275_addin1[] = {0};
+static const unsigned char kat275_retbits[] = {
+    0x86, 0x87, 0x1f, 0x9c, 0xb6, 0xb4, 0xed, 0x25, 0x2b, 0xd1, 0xe8, 0x68,
+    0xc8, 0x0a, 0x26, 0x3e, 0x02, 0x5b, 0xba, 0xe2, 0x28, 0x5c, 0xca, 0x59,
+    0xc6, 0x29, 0x98, 0x27, 0x32, 0xa5, 0x06, 0x3e, 0x5c, 0xbd, 0xa2, 0x76,
+    0xf2, 0x82, 0xfd, 0xaa, 0x90, 0xae, 0xf8, 0xec, 0x6d, 0xd3, 0x1d, 0x32,
+    0xb7, 0x04, 0xde, 0x50, 0x28, 0xdd, 0xd3, 0x2e, 0x22, 0xde, 0x36, 0x80,
+    0x08, 0x6f, 0x9a, 0x89,
+};
+static const struct drbg_kat_no_reseed kat275_t = {
+    4, kat275_entropyin, kat275_nonce, kat275_persstr,
+    kat275_addin0, kat275_addin1, kat275_retbits
+};
+static const struct drbg_kat kat275 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat275_t
+};
+
+static const unsigned char kat276_entropyin[] = {
+    0x13, 0x35, 0x24, 0xed, 0xab, 0xd5, 0xa7, 0xf7, 0x85, 0x8c, 0x13, 0xf2,
+    0x79, 0x53, 0xe9, 0x87, 0x28, 0x3c, 0xb1, 0x72, 0xa2, 0xc3, 0x7f, 0x17,
+};
+static const unsigned char kat276_nonce[] = {
+    0x5e, 0x6c, 0xb7, 0xf7, 0xc9, 0x8e, 0xe1, 0x3f, 0x46, 0x7d, 0x6b, 0xda,
+    0x28, 0x8b, 0x57, 0x7e,
+};
+static const unsigned char kat276_persstr[] = {
+    0x67, 0xd3, 0x91, 0x60, 0xcc, 0xee, 0x30, 0x40, 0xdb, 0x78, 0x20, 0xa3,
+    0x7a, 0xef, 0xb7, 0xd4, 0xa1, 0x0f, 0x7d, 0xcd, 0xf3, 0xbc, 0xa6, 0x69,
+    0xfe, 0x23, 0x5d, 0xb6, 0x3a, 0xb2, 0x47, 0x60,
+};
+static const unsigned char kat276_addin0[] = {0};
+static const unsigned char kat276_addin1[] = {0};
+static const unsigned char kat276_retbits[] = {
+    0x2d, 0x13, 0xee, 0x8b, 0x73, 0xd5, 0x18, 0xb0, 0xaf, 0xbf, 0x4e, 0x1e,
+    0xa6, 0xf6, 0x32, 0x00, 0x6b, 0xa5, 0x6e, 0x3f, 0x4e, 0x24, 0xa2, 0x1f,
+    0x68, 0x77, 0xed, 0x0f, 0x79, 0xc3, 0xec, 0x7f, 0xfd, 0x19, 0xce, 0x81,
+    0xbb, 0x17, 0x0b, 0x3a, 0xa9, 0x0d, 0xf6, 0x97, 0xf5, 0xcd, 0x98, 0x72,
+    0xcc, 0xb3, 0xd1, 0xe3, 0x38, 0x94, 0xdd, 0x16, 0xc6, 0xf5, 0xcf, 0x2f,
+    0xb1, 0x07, 0xae, 0xdd,
+};
+static const struct drbg_kat_no_reseed kat276_t = {
+    5, kat276_entropyin, kat276_nonce, kat276_persstr,
+    kat276_addin0, kat276_addin1, kat276_retbits
+};
+static const struct drbg_kat kat276 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat276_t
+};
+
+static const unsigned char kat277_entropyin[] = {
+    0xf2, 0x97, 0x47, 0x4b, 0x5b, 0x7e, 0x68, 0xd5, 0xae, 0xa9, 0x48, 0xf7,
+    0x51, 0xbc, 0x89, 0x9b, 0x36, 0xc2, 0x12, 0x63, 0x6f, 0x28, 0x8b, 0x84,
+};
+static const unsigned char kat277_nonce[] = {
+    0xb8, 0xa6, 0x0d, 0xd7, 0x26, 0xa0, 0x3f, 0xd0, 0xd2, 0xbf, 0x19, 0x5d,
+    0x2c, 0xb0, 0x9a, 0x03,
+};
+static const unsigned char kat277_persstr[] = {
+    0x8e, 0x32, 0xdb, 0x43, 0x66, 0x90, 0x7a, 0xbb, 0x98, 0xc0, 0xe0, 0x9c,
+    0x53, 0x60, 0xc5, 0x6f, 0xdb, 0x6f, 0x48, 0x3c, 0x84, 0xe6, 0x06, 0xf0,
+    0x7f, 0x5d, 0x1d, 0x45, 0xa0, 0x93, 0x46, 0xca,
+};
+static const unsigned char kat277_addin0[] = {0};
+static const unsigned char kat277_addin1[] = {0};
+static const unsigned char kat277_retbits[] = {
+    0x92, 0x08, 0x90, 0x94, 0xa8, 0x9f, 0xb5, 0x32, 0xf0, 0x68, 0xa8, 0x63,
+    0x0f, 0xa9, 0x47, 0xb8, 0xf8, 0x6e, 0xee, 0x22, 0xd5, 0x6f, 0x22, 0xa5,
+    0x14, 0xf8, 0xa6, 0x87, 0x1a, 0xa4, 0xc8, 0x08, 0xc8, 0xc9, 0xf4, 0x7c,
+    0x13, 0x54, 0xf1, 0x51, 0xc6, 0x8b, 0xc1, 0x30, 0xc8, 0xe8, 0x5f, 0xe4,
+    0x7e, 0x8b, 0xea, 0xc8, 0xcb, 0x34, 0x6b, 0x8e, 0xe2, 0xa7, 0xe0, 0x01,
+    0x59, 0xa0, 0xea, 0x80,
+};
+static const struct drbg_kat_no_reseed kat277_t = {
+    6, kat277_entropyin, kat277_nonce, kat277_persstr,
+    kat277_addin0, kat277_addin1, kat277_retbits
+};
+static const struct drbg_kat kat277 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat277_t
+};
+
+static const unsigned char kat278_entropyin[] = {
+    0x70, 0x50, 0x8f, 0x60, 0x35, 0xcd, 0xc4, 0x1a, 0xf6, 0x32, 0x52, 0xaf,
+    0x23, 0xbe, 0x67, 0xaf, 0x4a, 0x46, 0x8f, 0x45, 0x53, 0x31, 0x10, 0xc8,
+};
+static const unsigned char kat278_nonce[] = {
+    0x77, 0xc2, 0xbc, 0x1a, 0x84, 0xf4, 0xf9, 0x91, 0x79, 0x6f, 0x9c, 0x07,
+    0x09, 0x2a, 0xd5, 0xc7,
+};
+static const unsigned char kat278_persstr[] = {
+    0x47, 0x73, 0x82, 0xb2, 0xf6, 0xde, 0x44, 0xe2, 0xf0, 0x9a, 0x1d, 0x13,
+    0x5a, 0x35, 0xf1, 0xcc, 0xb0, 0x28, 0x51, 0xf9, 0xe1, 0xf0, 0x03, 0xf9,
+    0x8e, 0x02, 0x20, 0x43, 0x45, 0x8f, 0x5b, 0x66,
+};
+static const unsigned char kat278_addin0[] = {0};
+static const unsigned char kat278_addin1[] = {0};
+static const unsigned char kat278_retbits[] = {
+    0xfc, 0x63, 0x4f, 0xd4, 0xdc, 0xa7, 0xfc, 0xd6, 0x6c, 0x38, 0x92, 0x65,
+    0x18, 0xa8, 0xd6, 0xfd, 0xee, 0xca, 0x07, 0xf8, 0x7e, 0x9b, 0x9f, 0xe5,
+    0x40, 0x5e, 0xfd, 0x9a, 0xf9, 0xc9, 0x41, 0xcb, 0xf1, 0x56, 0xbc, 0x5b,
+    0x09, 0xa5, 0x3f, 0x5c, 0xc8, 0xb5, 0xbf, 0x94, 0x37, 0xe6, 0x76, 0x90,
+    0x5a, 0xfa, 0xee, 0x58, 0x02, 0x7b, 0xc2, 0x5a, 0xd4, 0x6c, 0x32, 0xab,
+    0xbe, 0xa0, 0x5c, 0x85,
+};
+static const struct drbg_kat_no_reseed kat278_t = {
+    7, kat278_entropyin, kat278_nonce, kat278_persstr,
+    kat278_addin0, kat278_addin1, kat278_retbits
+};
+static const struct drbg_kat kat278 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat278_t
+};
+
+static const unsigned char kat279_entropyin[] = {
+    0x2e, 0x5d, 0x95, 0x68, 0x7b, 0x0e, 0x9b, 0x77, 0x7f, 0x13, 0x94, 0xf1,
+    0x86, 0x63, 0xe7, 0x98, 0xed, 0xbd, 0x24, 0xcf, 0x0c, 0x3b, 0x94, 0x58,
+};
+static const unsigned char kat279_nonce[] = {
+    0x02, 0x05, 0x5f, 0xa3, 0xeb, 0x3d, 0x12, 0x04, 0xc2, 0x53, 0xeb, 0xf3,
+    0x5e, 0x31, 0x43, 0xbd,
+};
+static const unsigned char kat279_persstr[] = {
+    0x17, 0x56, 0x63, 0x5c, 0x33, 0xf8, 0x68, 0x6b, 0x45, 0x8d, 0xaa, 0xec,
+    0x9b, 0x9b, 0x44, 0x60, 0xb8, 0xa1, 0xd7, 0x5a, 0xa2, 0xe3, 0x00, 0xe7,
+    0x55, 0x57, 0x41, 0x12, 0x49, 0xab, 0xc0, 0x0f,
+};
+static const unsigned char kat279_addin0[] = {0};
+static const unsigned char kat279_addin1[] = {0};
+static const unsigned char kat279_retbits[] = {
+    0x91, 0xc7, 0xe7, 0x18, 0x3e, 0xed, 0x6b, 0xa6, 0x64, 0x96, 0x67, 0x8b,
+    0x9e, 0xe8, 0xec, 0x8b, 0x86, 0xde, 0x02, 0xfd, 0x7c, 0x6c, 0xb9, 0x77,
+    0x48, 0x2f, 0x0d, 0xf4, 0x84, 0x9a, 0x72, 0x85, 0x9a, 0x80, 0x4d, 0x26,
+    0x86, 0x68, 0xa8, 0xf4, 0xc9, 0x49, 0x34, 0x41, 0x3a, 0x94, 0xa2, 0xff,
+    0x0d, 0x9d, 0x39, 0xb5, 0x18, 0x86, 0x07, 0xcc, 0x75, 0xa0, 0x79, 0xa7,
+    0xe4, 0x84, 0x61, 0x69,
+};
+static const struct drbg_kat_no_reseed kat279_t = {
+    8, kat279_entropyin, kat279_nonce, kat279_persstr,
+    kat279_addin0, kat279_addin1, kat279_retbits
+};
+static const struct drbg_kat kat279 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat279_t
+};
+
+static const unsigned char kat280_entropyin[] = {
+    0x2e, 0x99, 0x70, 0x3a, 0x2b, 0xf1, 0x95, 0xa1, 0x82, 0xd2, 0x21, 0xce,
+    0x79, 0xbd, 0xbd, 0xfc, 0xa4, 0xdb, 0x53, 0xe1, 0x6e, 0x75, 0x7a, 0x5b,
+};
+static const unsigned char kat280_nonce[] = {
+    0x4b, 0xe5, 0x2f, 0xba, 0x5d, 0x1f, 0xbc, 0x7e, 0xa7, 0x7b, 0x4a, 0xe3,
+    0x0d, 0x16, 0xe0, 0xe9,
+};
+static const unsigned char kat280_persstr[] = {
+    0x8a, 0xf3, 0x46, 0xe5, 0x2f, 0x8c, 0x9b, 0xe6, 0x8a, 0x58, 0xf4, 0x0d,
+    0x50, 0x05, 0x70, 0x04, 0xb7, 0xd7, 0x58, 0x07, 0xaf, 0x92, 0x27, 0x32,
+    0x84, 0x36, 0x96, 0xc1, 0x82, 0x90, 0xd5, 0x89,
+};
+static const unsigned char kat280_addin0[] = {0};
+static const unsigned char kat280_addin1[] = {0};
+static const unsigned char kat280_retbits[] = {
+    0x23, 0x35, 0x2a, 0x39, 0x99, 0x4a, 0x03, 0xf4, 0x25, 0x06, 0xc3, 0x4d,
+    0xdb, 0x8e, 0x0d, 0x19, 0x12, 0x7e, 0xbb, 0xfe, 0x82, 0x39, 0xc3, 0x4a,
+    0x27, 0x11, 0xcd, 0xf1, 0xb1, 0xbe, 0xb1, 0xcf, 0x75, 0x40, 0x2a, 0x61,
+    0x3c, 0x85, 0x31, 0xd1, 0xdc, 0xce, 0xac, 0xdb, 0x49, 0x00, 0x73, 0xc7,
+    0xa5, 0x6f, 0x0a, 0xff, 0xb3, 0xf1, 0x1f, 0x26, 0xe8, 0xc1, 0x90, 0x1f,
+    0xaf, 0x3d, 0xfb, 0x2f,
+};
+static const struct drbg_kat_no_reseed kat280_t = {
+    9, kat280_entropyin, kat280_nonce, kat280_persstr,
+    kat280_addin0, kat280_addin1, kat280_retbits
+};
+static const struct drbg_kat kat280 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat280_t
+};
+
+static const unsigned char kat281_entropyin[] = {
+    0x23, 0x93, 0x1f, 0x7e, 0x10, 0xad, 0x6e, 0x55, 0x3a, 0x28, 0x54, 0x81,
+    0xac, 0xae, 0x7c, 0xfc, 0xb3, 0x2f, 0x64, 0x4e, 0x08, 0xc5, 0xb0, 0x09,
+};
+static const unsigned char kat281_nonce[] = {
+    0x7b, 0xc2, 0xb5, 0x7e, 0xde, 0x91, 0x35, 0xb4, 0x19, 0x2c, 0x51, 0x81,
+    0xf9, 0x08, 0x08, 0xc6,
+};
+static const unsigned char kat281_persstr[] = {
+    0x6e, 0xcd, 0x84, 0xef, 0x10, 0xb4, 0xe8, 0x62, 0xbc, 0x34, 0x47, 0x86,
+    0x7b, 0x3e, 0x80, 0x88, 0xe9, 0xdb, 0x4c, 0x5b, 0xe5, 0x38, 0x1d, 0xbc,
+    0xb6, 0x05, 0x14, 0x05, 0x13, 0x90, 0xbf, 0xaf,
+};
+static const unsigned char kat281_addin0[] = {0};
+static const unsigned char kat281_addin1[] = {0};
+static const unsigned char kat281_retbits[] = {
+    0xa5, 0xc1, 0x15, 0xbf, 0x8f, 0x95, 0x0b, 0x5d, 0x18, 0x71, 0x8a, 0x9a,
+    0x22, 0x69, 0x75, 0x9e, 0x78, 0xe4, 0xfb, 0x79, 0x89, 0x37, 0xaf, 0xd0,
+    0x6d, 0xaf, 0xc9, 0xea, 0xc9, 0xf5, 0x72, 0x60, 0x27, 0xd6, 0x39, 0xde,
+    0x08, 0xd0, 0xb7, 0xb0, 0x08, 0x53, 0x2f, 0x70, 0xbc, 0x48, 0xa8, 0xf8,
+    0x8f, 0x63, 0x7e, 0x67, 0xca, 0x7f, 0xb3, 0xfc, 0xe5, 0x19, 0x6e, 0x99,
+    0x3f, 0x6d, 0x3a, 0x25,
+};
+static const struct drbg_kat_no_reseed kat281_t = {
+    10, kat281_entropyin, kat281_nonce, kat281_persstr,
+    kat281_addin0, kat281_addin1, kat281_retbits
+};
+static const struct drbg_kat kat281 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat281_t
+};
+
+static const unsigned char kat282_entropyin[] = {
+    0x61, 0x96, 0x42, 0xe8, 0x63, 0xa8, 0xf8, 0xd2, 0xf7, 0xdb, 0x9c, 0x2e,
+    0xe5, 0x6c, 0x13, 0xa2, 0xf0, 0x39, 0x59, 0x5c, 0x29, 0xed, 0x74, 0x96,
+};
+static const unsigned char kat282_nonce[] = {
+    0x9c, 0x50, 0xab, 0x67, 0xfc, 0x76, 0x68, 0xde, 0xc6, 0x03, 0x4e, 0x82,
+    0x24, 0xae, 0x1d, 0x54,
+};
+static const unsigned char kat282_persstr[] = {
+    0x23, 0x0b, 0x18, 0x7d, 0x67, 0xc9, 0x31, 0x2e, 0xaf, 0x19, 0x23, 0x52,
+    0x6b, 0xfb, 0xcb, 0x31, 0x9d, 0x9d, 0x33, 0x9f, 0xe8, 0xc8, 0x62, 0xd1,
+    0xa9, 0xfa, 0x1e, 0xa7, 0x83, 0x09, 0x29, 0xb2,
+};
+static const unsigned char kat282_addin0[] = {0};
+static const unsigned char kat282_addin1[] = {0};
+static const unsigned char kat282_retbits[] = {
+    0x0e, 0xce, 0x18, 0x8d, 0x8d, 0x1a, 0x37, 0xf1, 0x58, 0xa6, 0xd0, 0x65,
+    0xf9, 0x07, 0x37, 0x69, 0xd7, 0x50, 0xb6, 0xd3, 0x3b, 0xf8, 0x49, 0x3d,
+    0xf9, 0x6d, 0x99, 0xfa, 0x98, 0xc9, 0x90, 0x00, 0x76, 0xf7, 0xab, 0xeb,
+    0x02, 0x31, 0x2a, 0xd4, 0xe0, 0xc6, 0xed, 0xde, 0x99, 0xeb, 0xd6, 0x1c,
+    0x39, 0x6a, 0x83, 0x75, 0xa1, 0xd7, 0x1f, 0x6b, 0x20, 0x86, 0xd9, 0x02,
+    0x1c, 0x11, 0xa1, 0x4c,
+};
+static const struct drbg_kat_no_reseed kat282_t = {
+    11, kat282_entropyin, kat282_nonce, kat282_persstr,
+    kat282_addin0, kat282_addin1, kat282_retbits
+};
+static const struct drbg_kat kat282 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat282_t
+};
+
+static const unsigned char kat283_entropyin[] = {
+    0xbf, 0x4e, 0x56, 0x6b, 0x60, 0xa5, 0x92, 0xf6, 0xc8, 0x89, 0xbb, 0x19,
+    0x25, 0x2b, 0x54, 0x48, 0x9a, 0x58, 0x15, 0xf2, 0xbd, 0x07, 0x4b, 0x41,
+};
+static const unsigned char kat283_nonce[] = {
+    0x32, 0xa2, 0xf8, 0xe7, 0x8e, 0x17, 0x57, 0x4d, 0x63, 0x84, 0xe1, 0xf5,
+    0x39, 0x95, 0x9a, 0xda,
+};
+static const unsigned char kat283_persstr[] = {
+    0xcf, 0x75, 0x8d, 0x77, 0x29, 0x63, 0xf5, 0x76, 0xb5, 0x1d, 0x32, 0x7d,
+    0xba, 0xa3, 0x51, 0x76, 0x13, 0xf3, 0x38, 0x7c, 0xb9, 0x0c, 0x85, 0x49,
+    0x7a, 0x93, 0x60, 0xe0, 0x4e, 0xbf, 0xb1, 0x79,
+};
+static const unsigned char kat283_addin0[] = {0};
+static const unsigned char kat283_addin1[] = {0};
+static const unsigned char kat283_retbits[] = {
+    0xf6, 0xbf, 0x71, 0x1d, 0x50, 0x02, 0x99, 0x7a, 0x3e, 0xca, 0xa3, 0x6c,
+    0xeb, 0x5e, 0xe6, 0x3c, 0xae, 0x53, 0x01, 0x72, 0x89, 0x07, 0x64, 0xae,
+    0xb8, 0xaf, 0xd5, 0xd8, 0x12, 0xc3, 0x68, 0x56, 0x8e, 0x4a, 0xb0, 0xaf,
+    0xd2, 0xdd, 0xf9, 0x7d, 0xc3, 0x10, 0xb1, 0xc3, 0x53, 0xe6, 0x73, 0xfd,
+    0xac, 0x59, 0x2a, 0xc6, 0x08, 0xe1, 0x30, 0x4f, 0x97, 0xa5, 0xf2, 0x57,
+    0x8c, 0x1e, 0xc1, 0xd4,
+};
+static const struct drbg_kat_no_reseed kat283_t = {
+    12, kat283_entropyin, kat283_nonce, kat283_persstr,
+    kat283_addin0, kat283_addin1, kat283_retbits
+};
+static const struct drbg_kat kat283 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat283_t
+};
+
+static const unsigned char kat284_entropyin[] = {
+    0x18, 0x01, 0x0f, 0xfb, 0xae, 0xac, 0xab, 0x06, 0xa4, 0xc5, 0x5a, 0x38,
+    0xe8, 0xe9, 0x36, 0xd7, 0x9a, 0xd4, 0x9a, 0xf9, 0x76, 0xb8, 0xf7, 0x48,
+};
+static const unsigned char kat284_nonce[] = {
+    0xcf, 0x55, 0xbc, 0x78, 0xa1, 0xf1, 0xee, 0x4a, 0xbd, 0xc5, 0x54, 0xe8,
+    0x7b, 0x3f, 0x11, 0x4d,
+};
+static const unsigned char kat284_persstr[] = {
+    0x53, 0xa9, 0x74, 0x38, 0x6b, 0xa1, 0x01, 0xba, 0x34, 0xea, 0x65, 0xb7,
+    0x5b, 0xc3, 0x60, 0xe9, 0xc1, 0xcb, 0x80, 0xc2, 0xa6, 0x50, 0x82, 0x90,
+    0xa7, 0x8a, 0xe2, 0x3e, 0x5c, 0x70, 0x15, 0x37,
+};
+static const unsigned char kat284_addin0[] = {0};
+static const unsigned char kat284_addin1[] = {0};
+static const unsigned char kat284_retbits[] = {
+    0x57, 0x26, 0xde, 0x68, 0x48, 0xee, 0x07, 0x4f, 0x35, 0x3c, 0xf1, 0x7b,
+    0xf3, 0xee, 0x0b, 0x09, 0xb6, 0xb6, 0x03, 0xb1, 0x24, 0x64, 0x25, 0xdd,
+    0xde, 0x1d, 0x01, 0xb5, 0xbf, 0x5a, 0xf0, 0xd8, 0x88, 0x88, 0x21, 0x7d,
+    0x59, 0x01, 0x8d, 0xb3, 0x17, 0x18, 0x11, 0xda, 0x02, 0xe6, 0x67, 0xfd,
+    0xdf, 0x8c, 0xb3, 0x51, 0x00, 0x36, 0x9d, 0xc9, 0xa8, 0xcf, 0x2a, 0xaf,
+    0xc5, 0x45, 0x21, 0x82,
+};
+static const struct drbg_kat_no_reseed kat284_t = {
+    13, kat284_entropyin, kat284_nonce, kat284_persstr,
+    kat284_addin0, kat284_addin1, kat284_retbits
+};
+static const struct drbg_kat kat284 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat284_t
+};
+
+static const unsigned char kat285_entropyin[] = {
+    0xf6, 0x20, 0x87, 0x73, 0xae, 0x06, 0xc6, 0x14, 0x10, 0x7a, 0x98, 0x65,
+    0xc3, 0x6e, 0xeb, 0x2a, 0xc2, 0xe3, 0x48, 0xee, 0x7c, 0xd6, 0x9d, 0xde,
+};
+static const unsigned char kat285_nonce[] = {
+    0xee, 0x7c, 0x9e, 0xc2, 0x68, 0x77, 0x03, 0xaa, 0x10, 0x30, 0x70, 0x57,
+    0x4d, 0x61, 0x67, 0xd9,
+};
+static const unsigned char kat285_persstr[] = {
+    0xa8, 0x5a, 0x25, 0xe5, 0xcd, 0x63, 0x90, 0xbe, 0xab, 0x64, 0xab, 0x8b,
+    0x4f, 0x53, 0x42, 0x80, 0xf3, 0xfc, 0x7b, 0x16, 0x9e, 0xb0, 0xa7, 0x5c,
+    0xb7, 0x7d, 0x9b, 0xf0, 0x62, 0x92, 0xab, 0xe8,
+};
+static const unsigned char kat285_addin0[] = {0};
+static const unsigned char kat285_addin1[] = {0};
+static const unsigned char kat285_retbits[] = {
+    0xcd, 0x5f, 0x73, 0xd4, 0xfe, 0xbc, 0x7f, 0xe1, 0x73, 0x51, 0xbb, 0xb9,
+    0x09, 0x47, 0x29, 0x75, 0x90, 0x16, 0xbd, 0x3e, 0xae, 0x0d, 0xd3, 0xd9,
+    0x12, 0x86, 0x97, 0x81, 0x3a, 0x0b, 0x92, 0x9d, 0xcf, 0xce, 0x6b, 0xfe,
+    0xfc, 0x1e, 0x08, 0xde, 0xdd, 0xf6, 0x17, 0xd4, 0xe7, 0x27, 0xaa, 0xa3,
+    0xc7, 0xcb, 0x1f, 0xf2, 0x3b, 0xf0, 0x2f, 0xcd, 0xa7, 0x7d, 0x0b, 0x15,
+    0x02, 0x39, 0x03, 0x49,
+};
+static const struct drbg_kat_no_reseed kat285_t = {
+    14, kat285_entropyin, kat285_nonce, kat285_persstr,
+    kat285_addin0, kat285_addin1, kat285_retbits
+};
+static const struct drbg_kat kat285 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 0, 64, &kat285_t
+};
+
+static const unsigned char kat286_entropyin[] = {
+    0xd5, 0x97, 0x3b, 0x5c, 0x91, 0x05, 0xcb, 0xf6, 0x7e, 0x97, 0x8f, 0x41,
+    0x99, 0x24, 0x79, 0x0d, 0x83, 0x02, 0x3e, 0x86, 0xa8, 0xb5, 0xdd, 0x6b,
+};
+static const unsigned char kat286_nonce[] = {
+    0x35, 0x8a, 0xf1, 0xae, 0x9a, 0x84, 0x2c, 0x6e, 0x03, 0xf8, 0x8d, 0xfa,
+    0x2a, 0x31, 0x11, 0x61,
+};
+static const unsigned char kat286_persstr[] = {
+    0x29, 0x4d, 0x7d, 0x35, 0xf5, 0x3a, 0x5d, 0x7d, 0xde, 0xf5, 0xca, 0x41,
+    0x00, 0xf3, 0x54, 0x71, 0x12, 0xc9, 0x3e, 0x41, 0x25, 0x12, 0x57, 0xdc,
+    0x0a, 0x19, 0xb6, 0xdf, 0xaa, 0x4a, 0x60, 0xa4,
+};
+static const unsigned char kat286_addin0[] = {
+    0x08, 0x05, 0xf3, 0x14, 0x46, 0xc5, 0x1d, 0x5d, 0x9d, 0x27, 0xb7, 0xcb,
+    0xb1, 0x6e, 0x84, 0x0b, 0x9e, 0x8b, 0x0d, 0xfe, 0x6f, 0xb4, 0xb6, 0x97,
+    0x92, 0xbc, 0x8d, 0xe9, 0xe3, 0xbd, 0x6d, 0x92,
+};
+static const unsigned char kat286_addin1[] = {
+    0x93, 0x4d, 0x7f, 0xd5, 0xe7, 0x16, 0x37, 0x63, 0x42, 0x60, 0x71, 0x23,
+    0xea, 0x11, 0x3d, 0x6b, 0x20, 0x17, 0x0c, 0xcd, 0xa5, 0x3f, 0xc8, 0x65,
+    0x41, 0x40, 0x7a, 0x15, 0x6c, 0xd9, 0x49, 0x04,
+};
+static const unsigned char kat286_retbits[] = {
+    0xcb, 0x95, 0x45, 0x9d, 0x17, 0x35, 0xcb, 0x9b, 0xce, 0x8a, 0x75, 0xbf,
+    0x09, 0x7a, 0x09, 0x9c, 0x9f, 0x7c, 0x70, 0xba, 0xd4, 0x3e, 0x3e, 0x43,
+    0x1f, 0x2d, 0x38, 0x29, 0xd7, 0xca, 0x9d, 0x06, 0x17, 0xb9, 0xa9, 0x93,
+    0x37, 0xaf, 0x52, 0x48, 0xd4, 0x74, 0x1c, 0xb5, 0xa6, 0x0d, 0xff, 0x6f,
+    0x8c, 0x52, 0x21, 0xe2, 0x3f, 0x3c, 0xb5, 0x24, 0xa9, 0x4f, 0xfd, 0xd2,
+    0x19, 0x0b, 0xfb, 0x3b,
+};
+static const struct drbg_kat_no_reseed kat286_t = {
+    0, kat286_entropyin, kat286_nonce, kat286_persstr,
+    kat286_addin0, kat286_addin1, kat286_retbits
+};
+static const struct drbg_kat kat286 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat286_t
+};
+
+static const unsigned char kat287_entropyin[] = {
+    0xa0, 0x44, 0x99, 0xcc, 0x2b, 0x36, 0x20, 0xa4, 0x7e, 0xe6, 0x6d, 0xe9,
+    0xce, 0x65, 0x10, 0x03, 0x39, 0x40, 0x95, 0x85, 0x39, 0xf7, 0x54, 0xfb,
+};
+static const unsigned char kat287_nonce[] = {
+    0xfa, 0xa4, 0x92, 0xb5, 0xee, 0xb6, 0x20, 0xe7, 0x8f, 0xb6, 0x37, 0x5c,
+    0x62, 0x0f, 0x49, 0x5c,
+};
+static const unsigned char kat287_persstr[] = {
+    0x31, 0x8a, 0x01, 0xb4, 0x75, 0x60, 0x11, 0x91, 0x43, 0x8c, 0xcf, 0x44,
+    0xfe, 0xd9, 0xc0, 0xc6, 0xaf, 0x5f, 0x44, 0x15, 0xc2, 0x66, 0x8b, 0x2d,
+    0x39, 0xf9, 0x59, 0xef, 0x6f, 0xa2, 0xe2, 0xee,
+};
+static const unsigned char kat287_addin0[] = {
+    0xf1, 0xb9, 0x2d, 0x7f, 0xb1, 0x26, 0x79, 0x9f, 0x08, 0x02, 0x64, 0xbb,
+    0xd2, 0xef, 0xf3, 0x9b, 0xd7, 0x55, 0xb8, 0xd1, 0xcb, 0xb8, 0x79, 0x63,
+    0xa7, 0x71, 0xe7, 0xac, 0x54, 0x94, 0xc1, 0x54,
+};
+static const unsigned char kat287_addin1[] = {
+    0xab, 0x79, 0x75, 0xe3, 0x42, 0xc2, 0x60, 0xf4, 0x01, 0x38, 0x56, 0xe5,
+    0x9d, 0x76, 0x77, 0xe7, 0x07, 0x18, 0x21, 0xe4, 0x2d, 0xcb, 0x0b, 0x14,
+    0x7d, 0xcc, 0x74, 0x07, 0x48, 0x32, 0x06, 0x1c,
+};
+static const unsigned char kat287_retbits[] = {
+    0x64, 0x7a, 0x3e, 0x82, 0xbe, 0x71, 0x73, 0xe4, 0x57, 0x82, 0xd4, 0x2e,
+    0xe0, 0xbc, 0x52, 0xff, 0xef, 0xc3, 0x07, 0x2e, 0xca, 0xb3, 0x06, 0x0a,
+    0xe6, 0x06, 0x31, 0xb8, 0x48, 0x62, 0x89, 0x23, 0x0c, 0x00, 0xb3, 0xe9,
+    0x64, 0x1f, 0x88, 0xd3, 0x42, 0x7f, 0xbf, 0xb1, 0x50, 0xfd, 0x14, 0xdc,
+    0xf8, 0xf2, 0xc8, 0xdb, 0x14, 0xc7, 0x15, 0x45, 0x78, 0x89, 0x51, 0xef,
+    0xa0, 0x74, 0xb2, 0x27,
+};
+static const struct drbg_kat_no_reseed kat287_t = {
+    1, kat287_entropyin, kat287_nonce, kat287_persstr,
+    kat287_addin0, kat287_addin1, kat287_retbits
+};
+static const struct drbg_kat kat287 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat287_t
+};
+
+static const unsigned char kat288_entropyin[] = {
+    0x56, 0x82, 0x91, 0x4c, 0x36, 0x77, 0x69, 0x45, 0xe0, 0x23, 0xf9, 0x8e,
+    0x14, 0x17, 0x17, 0x25, 0xa2, 0xc0, 0x20, 0x4d, 0xe7, 0x99, 0xa3, 0x6f,
+};
+static const unsigned char kat288_nonce[] = {
+    0x6d, 0x6f, 0x71, 0xcf, 0xef, 0x95, 0x7f, 0xf4, 0x75, 0x58, 0x33, 0x15,
+    0x12, 0x5e, 0xad, 0x6b,
+};
+static const unsigned char kat288_persstr[] = {
+    0x55, 0x7f, 0xde, 0x94, 0xd4, 0x1c, 0x13, 0xb2, 0x48, 0x29, 0xb8, 0xfd,
+    0x42, 0x41, 0x24, 0x82, 0x5a, 0xac, 0xb1, 0x40, 0x94, 0xe5, 0xe7, 0xd4,
+    0xf8, 0xde, 0xea, 0x7d, 0xb2, 0xac, 0x29, 0x40,
+};
+static const unsigned char kat288_addin0[] = {
+    0x4c, 0x64, 0xc5, 0xa5, 0xc1, 0xc6, 0x91, 0x4b, 0x61, 0xfa, 0xf2, 0x64,
+    0x92, 0x4c, 0x10, 0xde, 0xbc, 0x2f, 0x36, 0x7a, 0xc4, 0xcb, 0x1e, 0x01,
+    0x24, 0x88, 0x32, 0x2f, 0xb1, 0x9d, 0x69, 0xa8,
+};
+static const unsigned char kat288_addin1[] = {
+    0x71, 0x93, 0xe6, 0x1b, 0xb3, 0xe7, 0x5d, 0x48, 0xe4, 0xa3, 0xf9, 0x0b,
+    0x10, 0x8e, 0x07, 0x07, 0x4c, 0x35, 0x39, 0x06, 0x93, 0xcd, 0x0a, 0x4c,
+    0xd3, 0xbb, 0x6c, 0xd2, 0x46, 0xbe, 0xb7, 0x40,
+};
+static const unsigned char kat288_retbits[] = {
+    0x7a, 0xed, 0x93, 0x1e, 0xe1, 0x7c, 0x7b, 0x05, 0x53, 0x3b, 0x52, 0xf6,
+    0xb3, 0xdf, 0xc9, 0x76, 0x88, 0xf6, 0xf3, 0xb3, 0x97, 0x44, 0xed, 0xed,
+    0x73, 0xdd, 0xe2, 0x7e, 0x03, 0x4a, 0xfb, 0x18, 0x01, 0xb3, 0xd1, 0x16,
+    0x0d, 0xba, 0x79, 0x75, 0x59, 0xfd, 0x72, 0x16, 0x10, 0xf6, 0xd6, 0x2f,
+    0x6d, 0x0c, 0x48, 0xa6, 0x74, 0x03, 0x07, 0x5f, 0x6c, 0x24, 0x50, 0xe6,
+    0x24, 0x6a, 0x4d, 0x66,
+};
+static const struct drbg_kat_no_reseed kat288_t = {
+    2, kat288_entropyin, kat288_nonce, kat288_persstr,
+    kat288_addin0, kat288_addin1, kat288_retbits
+};
+static const struct drbg_kat kat288 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat288_t
+};
+
+static const unsigned char kat289_entropyin[] = {
+    0x19, 0x9c, 0xee, 0x8a, 0x88, 0x18, 0x88, 0x16, 0x6c, 0xb5, 0x2c, 0xf6,
+    0x8f, 0xde, 0x78, 0x0f, 0x32, 0x55, 0xb1, 0x3d, 0x37, 0x0b, 0x68, 0x9a,
+};
+static const unsigned char kat289_nonce[] = {
+    0x84, 0x80, 0x16, 0xaa, 0x71, 0x57, 0x1e, 0x1c, 0x63, 0xf3, 0x17, 0x4b,
+    0xf9, 0x35, 0x87, 0xc9,
+};
+static const unsigned char kat289_persstr[] = {
+    0x66, 0x21, 0x2f, 0x4c, 0x19, 0xb5, 0xcd, 0xf4, 0xa6, 0x59, 0x4f, 0xd4,
+    0xc4, 0xf7, 0xb7, 0x83, 0x72, 0x30, 0xde, 0x71, 0xb9, 0x8d, 0x50, 0x6d,
+    0x46, 0xde, 0xce, 0xac, 0xb5, 0xf0, 0xc6, 0x9c,
+};
+static const unsigned char kat289_addin0[] = {
+    0x59, 0x34, 0xb3, 0x95, 0x8e, 0xbe, 0x21, 0x54, 0xc2, 0x46, 0xce, 0xa5,
+    0x5d, 0xf2, 0x31, 0xe4, 0x1a, 0x86, 0x7e, 0x88, 0x44, 0x12, 0x9f, 0xd6,
+    0xc7, 0xde, 0x6c, 0x9c, 0xf8, 0xd4, 0xd7, 0xb8,
+};
+static const unsigned char kat289_addin1[] = {
+    0x0b, 0x4a, 0x32, 0xba, 0xb8, 0x42, 0xc4, 0xd2, 0x49, 0x99, 0xe9, 0xac,
+    0x6b, 0xb1, 0x02, 0x4b, 0x76, 0x73, 0x08, 0x68, 0x95, 0xe8, 0x9a, 0x70,
+    0x72, 0xa5, 0x9c, 0x8c, 0x75, 0xfe, 0x3e, 0x0a,
+};
+static const unsigned char kat289_retbits[] = {
+    0x84, 0x50, 0x41, 0x0e, 0x9a, 0x7f, 0xf9, 0xa1, 0x04, 0xd6, 0xd0, 0xec,
+    0xd2, 0x31, 0x5e, 0xa5, 0x40, 0xf5, 0x4c, 0xd8, 0x8d, 0x21, 0xac, 0x6d,
+    0x7c, 0xae, 0x8a, 0x86, 0x18, 0x1d, 0xcb, 0x53, 0xf1, 0x88, 0x3e, 0xe1,
+    0xdc, 0xe8, 0xa2, 0x86, 0x22, 0x61, 0x62, 0x08, 0x59, 0x33, 0x4f, 0xde,
+    0x9c, 0xe2, 0xde, 0xaf, 0x1b, 0x58, 0xd4, 0xd4, 0xd0, 0x1d, 0xbd, 0xfe,
+    0xe7, 0x73, 0x2e, 0x8e,
+};
+static const struct drbg_kat_no_reseed kat289_t = {
+    3, kat289_entropyin, kat289_nonce, kat289_persstr,
+    kat289_addin0, kat289_addin1, kat289_retbits
+};
+static const struct drbg_kat kat289 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat289_t
+};
+
+static const unsigned char kat290_entropyin[] = {
+    0x2f, 0xf3, 0xc6, 0x29, 0x0f, 0x51, 0x40, 0xb6, 0xc4, 0x96, 0x8a, 0xfe,
+    0x0c, 0x6a, 0xc1, 0x8e, 0x55, 0x74, 0xc7, 0x11, 0x73, 0x29, 0x2e, 0x54,
+};
+static const unsigned char kat290_nonce[] = {
+    0x93, 0xdd, 0x9d, 0xfd, 0xb4, 0x5f, 0x96, 0xb8, 0x05, 0x9c, 0xb3, 0xfd,
+    0xc1, 0x25, 0xa3, 0xb5,
+};
+static const unsigned char kat290_persstr[] = {
+    0xdb, 0xf6, 0x83, 0x70, 0x58, 0xa3, 0x74, 0x1a, 0xbf, 0x3a, 0xd0, 0x62,
+    0x97, 0xc1, 0x9b, 0x81, 0xf4, 0xc4, 0x6a, 0xdf, 0x7d, 0x46, 0xc5, 0x8b,
+    0xbb, 0xce, 0x5b, 0xcf, 0x29, 0x64, 0x00, 0xd5,
+};
+static const unsigned char kat290_addin0[] = {
+    0x32, 0x9d, 0x4f, 0xe2, 0x73, 0x66, 0x16, 0xb0, 0x65, 0x28, 0x7f, 0x3c,
+    0xad, 0x21, 0x63, 0x42, 0xb9, 0xbe, 0x26, 0xe8, 0xf2, 0xc5, 0x94, 0x64,
+    0x5e, 0x7e, 0x27, 0x88, 0x07, 0x09, 0x7d, 0x5c,
+};
+static const unsigned char kat290_addin1[] = {
+    0x8a, 0x1e, 0x25, 0x8c, 0x3a, 0x3f, 0xb9, 0xb0, 0x31, 0x45, 0x62, 0xa3,
+    0x20, 0xc0, 0xc1, 0x1e, 0x6f, 0x81, 0x37, 0xe2, 0x91, 0xa7, 0x9e, 0xd5,
+    0x68, 0x48, 0x9a, 0xd0, 0x56, 0x0c, 0x7c, 0x28,
+};
+static const unsigned char kat290_retbits[] = {
+    0x28, 0x1c, 0xd7, 0x62, 0xf1, 0x0d, 0xdd, 0x29, 0xe0, 0xab, 0x11, 0xcf,
+    0x79, 0x49, 0x4a, 0x7e, 0xb5, 0x92, 0xdd, 0x84, 0xdc, 0xe6, 0x58, 0x04,
+    0x28, 0x6e, 0xea, 0x86, 0x4d, 0x8b, 0x85, 0x44, 0x28, 0x2d, 0x3f, 0xe8,
+    0x0d, 0x76, 0xfe, 0x55, 0xf7, 0xfc, 0x66, 0xd0, 0x97, 0x1b, 0x8d, 0xcb,
+    0x84, 0xa3, 0xf2, 0x5d, 0x85, 0x97, 0x21, 0x33, 0xe0, 0x74, 0xcd, 0xf1,
+    0xe6, 0x0b, 0xf0, 0x69,
+};
+static const struct drbg_kat_no_reseed kat290_t = {
+    4, kat290_entropyin, kat290_nonce, kat290_persstr,
+    kat290_addin0, kat290_addin1, kat290_retbits
+};
+static const struct drbg_kat kat290 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat290_t
+};
+
+static const unsigned char kat291_entropyin[] = {
+    0x15, 0xb6, 0x96, 0xec, 0xc0, 0x14, 0x9b, 0x78, 0x05, 0xbd, 0xbe, 0xaa,
+    0x65, 0xb9, 0xea, 0x9b, 0x76, 0xe7, 0x6d, 0xd6, 0x8b, 0xb9, 0xba, 0x5f,
+};
+static const unsigned char kat291_nonce[] = {
+    0xee, 0x41, 0x74, 0xe0, 0x87, 0xf3, 0xe7, 0x4a, 0x3f, 0xd2, 0xfc, 0x40,
+    0x35, 0x59, 0x20, 0x9c,
+};
+static const unsigned char kat291_persstr[] = {
+    0xa4, 0x2d, 0xd8, 0x8c, 0xdb, 0xa2, 0x5d, 0x88, 0x9d, 0xbc, 0xd9, 0xc7,
+    0xb7, 0xa7, 0xbc, 0xfe, 0x25, 0xad, 0x1a, 0x81, 0xa1, 0x76, 0x1e, 0x24,
+    0xe0, 0x46, 0xca, 0xd4, 0x75, 0x91, 0x02, 0x5c,
+};
+static const unsigned char kat291_addin0[] = {
+    0xa3, 0x73, 0xc6, 0x7b, 0xf7, 0xa8, 0x78, 0x98, 0x70, 0x76, 0x8a, 0xf6,
+    0x01, 0x5a, 0x13, 0x39, 0x36, 0x82, 0x1d, 0x97, 0xcf, 0xe1, 0xdc, 0x49,
+    0x73, 0x1b, 0x14, 0x5f, 0x66, 0x66, 0xdf, 0xe3,
+};
+static const unsigned char kat291_addin1[] = {
+    0x7b, 0x93, 0xdd, 0x28, 0x55, 0xff, 0x93, 0xec, 0x1d, 0x19, 0x4c, 0x86,
+    0x71, 0xa6, 0x25, 0x99, 0x39, 0xbc, 0x4a, 0x57, 0x29, 0x94, 0xae, 0x3d,
+    0x52, 0xa8, 0x44, 0x11, 0x74, 0x90, 0x53, 0x3a,
+};
+static const unsigned char kat291_retbits[] = {
+    0x78, 0xca, 0x84, 0xfe, 0x42, 0xb1, 0x6e, 0xab, 0x52, 0x88, 0x8d, 0x54,
+    0x0c, 0x50, 0xe5, 0x21, 0x61, 0x5c, 0x5f, 0x4d, 0xff, 0x04, 0x56, 0xcb,
+    0x80, 0x8d, 0x10, 0xf6, 0x66, 0xd0, 0x8d, 0xd1, 0x9c, 0x68, 0x78, 0x9b,
+    0xe1, 0xd9, 0xd8, 0x55, 0xff, 0x99, 0x5d, 0xeb, 0x8e, 0x02, 0x61, 0xe8,
+    0xc4, 0x4b, 0x12, 0x48, 0xb0, 0xb2, 0xde, 0xc2, 0x59, 0x9d, 0x8e, 0x77,
+    0x9d, 0x24, 0xc8, 0x39,
+};
+static const struct drbg_kat_no_reseed kat291_t = {
+    5, kat291_entropyin, kat291_nonce, kat291_persstr,
+    kat291_addin0, kat291_addin1, kat291_retbits
+};
+static const struct drbg_kat kat291 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat291_t
+};
+
+static const unsigned char kat292_entropyin[] = {
+    0xdd, 0xc6, 0xe5, 0x0f, 0xf9, 0x08, 0x3f, 0xed, 0xf4, 0xa5, 0xd5, 0x6f,
+    0xd9, 0x23, 0x8a, 0x25, 0x65, 0xf5, 0x01, 0x84, 0xdf, 0x28, 0x3a, 0x78,
+};
+static const unsigned char kat292_nonce[] = {
+    0xa3, 0x06, 0x0e, 0x17, 0x32, 0xf1, 0xb1, 0xde, 0xfc, 0x8e, 0x5f, 0x39,
+    0xe0, 0x12, 0xe3, 0x03,
+};
+static const unsigned char kat292_persstr[] = {
+    0x86, 0x98, 0x83, 0x57, 0x95, 0x80, 0x4b, 0xa3, 0x46, 0x5f, 0x3e, 0xcd,
+    0xd4, 0xac, 0xe0, 0x47, 0x50, 0x6c, 0xb1, 0x5d, 0xd9, 0xc8, 0x72, 0x8f,
+    0x07, 0x5f, 0xce, 0xa5, 0x03, 0x3f, 0xa0, 0xd8,
+};
+static const unsigned char kat292_addin0[] = {
+    0xb1, 0x01, 0x1f, 0x40, 0xcf, 0x33, 0x1e, 0x33, 0xd2, 0x4f, 0xfe, 0x86,
+    0x17, 0x8f, 0x70, 0xe6, 0xc7, 0xd4, 0xd2, 0xb4, 0x43, 0xb6, 0x4f, 0xbd,
+    0x5c, 0x97, 0x9b, 0x94, 0x19, 0x3c, 0xac, 0x60,
+};
+static const unsigned char kat292_addin1[] = {
+    0x3a, 0x72, 0xe1, 0xe6, 0x63, 0x64, 0x04, 0xbe, 0x69, 0xf8, 0x53, 0xbe,
+    0xb0, 0x63, 0x3d, 0x5d, 0xef, 0x03, 0xb1, 0x6b, 0x4b, 0x20, 0x5a, 0x02,
+    0x38, 0x4c, 0x26, 0x95, 0x1c, 0xa0, 0xf2, 0x20,
+};
+static const unsigned char kat292_retbits[] = {
+    0x7d, 0xbe, 0xac, 0xe1, 0xa9, 0x0a, 0x28, 0x43, 0xc3, 0xde, 0x36, 0xf3,
+    0xbb, 0xac, 0x6e, 0x91, 0x40, 0xa9, 0x38, 0xce, 0xd6, 0x30, 0x41, 0x6e,
+    0xb1, 0xe1, 0x63, 0x87, 0x08, 0xec, 0x12, 0xe4, 0x80, 0xda, 0x65, 0xe0,
+    0x0c, 0x82, 0x94, 0x15, 0x1e, 0xa4, 0xb9, 0xa1, 0xd5, 0xb2, 0x59, 0x75,
+    0xd7, 0x94, 0x0d, 0x57, 0xc8, 0xde, 0x72, 0xe2, 0x03, 0x82, 0x99, 0x6f,
+    0xf4, 0xdc, 0x64, 0xc2,
+};
+static const struct drbg_kat_no_reseed kat292_t = {
+    6, kat292_entropyin, kat292_nonce, kat292_persstr,
+    kat292_addin0, kat292_addin1, kat292_retbits
+};
+static const struct drbg_kat kat292 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat292_t
+};
+
+static const unsigned char kat293_entropyin[] = {
+    0xdd, 0xe2, 0x70, 0x18, 0xcd, 0xea, 0x02, 0x7b, 0x27, 0x3a, 0x83, 0xab,
+    0x28, 0xf8, 0x18, 0x22, 0x93, 0xe5, 0x37, 0x32, 0x91, 0x64, 0x12, 0x62,
+};
+static const unsigned char kat293_nonce[] = {
+    0xe8, 0x81, 0x0e, 0x24, 0xfb, 0x96, 0xba, 0x67, 0x68, 0xb6, 0x57, 0x47,
+    0xbb, 0x27, 0x93, 0xb8,
+};
+static const unsigned char kat293_persstr[] = {
+    0xd8, 0xad, 0xa0, 0x62, 0xfb, 0x8a, 0x56, 0x7f, 0x42, 0x15, 0xeb, 0x1f,
+    0xf8, 0x7a, 0x2c, 0xd6, 0xfe, 0x96, 0x4d, 0x7b, 0xeb, 0xcc, 0x9c, 0xf4,
+    0xec, 0xc5, 0x31, 0xbe, 0x21, 0xad, 0x47, 0x8f,
+};
+static const unsigned char kat293_addin0[] = {
+    0xee, 0xa0, 0xc6, 0x51, 0xaf, 0xae, 0x1c, 0xca, 0x7d, 0x6b, 0x4a, 0xef,
+    0x4c, 0x1e, 0x0c, 0x22, 0x19, 0x4c, 0x70, 0xa6, 0x3f, 0xe4, 0x74, 0xa8,
+    0xb5, 0xfc, 0xbd, 0x26, 0xa5, 0x69, 0x6c, 0x3c,
+};
+static const unsigned char kat293_addin1[] = {
+    0x71, 0xee, 0xe7, 0x0d, 0x6b, 0x57, 0x85, 0x4d, 0xa6, 0x87, 0x89, 0xd9,
+    0x92, 0xe4, 0x13, 0x24, 0x85, 0xa9, 0xaa, 0xcc, 0x3f, 0xb8, 0xfa, 0xab,
+    0xc9, 0x08, 0xed, 0xda, 0x65, 0x3b, 0xf7, 0x40,
+};
+static const unsigned char kat293_retbits[] = {
+    0xce, 0x2f, 0x8c, 0x2a, 0xcc, 0xc4, 0xc4, 0x5f, 0x18, 0x3b, 0xfe, 0xbe,
+    0xcf, 0x1a, 0xdd, 0x4f, 0x32, 0xed, 0x36, 0x0d, 0x35, 0x6e, 0xfb, 0x90,
+    0x63, 0x15, 0xc0, 0x43, 0xd1, 0x50, 0x66, 0x0a, 0x35, 0xb5, 0xd0, 0x35,
+    0x0c, 0xb0, 0x53, 0xd4, 0x58, 0x16, 0x7e, 0xac, 0xf3, 0x5c, 0xc7, 0x01,
+    0x2b, 0xdd, 0x1e, 0xf7, 0x08, 0x18, 0xde, 0xdd, 0xf3, 0x8b, 0x4e, 0x85,
+    0x57, 0xbc, 0xc0, 0x3e,
+};
+static const struct drbg_kat_no_reseed kat293_t = {
+    7, kat293_entropyin, kat293_nonce, kat293_persstr,
+    kat293_addin0, kat293_addin1, kat293_retbits
+};
+static const struct drbg_kat kat293 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat293_t
+};
+
+static const unsigned char kat294_entropyin[] = {
+    0x49, 0xb2, 0xae, 0x2b, 0x29, 0x14, 0xd6, 0x88, 0x53, 0x8b, 0xb2, 0x91,
+    0x93, 0xae, 0x63, 0x78, 0xe0, 0xe8, 0xb9, 0x41, 0xdd, 0x3e, 0x31, 0x52,
+};
+static const unsigned char kat294_nonce[] = {
+    0x27, 0x9f, 0x5f, 0x18, 0x32, 0xcc, 0xd1, 0x0d, 0x08, 0x51, 0x40, 0x45,
+    0x27, 0xed, 0x25, 0xfc,
+};
+static const unsigned char kat294_persstr[] = {
+    0xee, 0x3a, 0x40, 0xee, 0x43, 0x22, 0xba, 0xb1, 0x68, 0x23, 0x59, 0x23,
+    0xb5, 0x2b, 0x80, 0xa3, 0xc7, 0x11, 0xcd, 0x7a, 0xd7, 0x61, 0x8e, 0x76,
+    0x40, 0x0e, 0x46, 0xf1, 0x53, 0xa1, 0x07, 0x22,
+};
+static const unsigned char kat294_addin0[] = {
+    0xca, 0x3e, 0x55, 0xa7, 0xe1, 0xa5, 0x1d, 0x7d, 0xa3, 0x37, 0x9a, 0x2c,
+    0xbc, 0x31, 0x62, 0xfe, 0xe7, 0x05, 0xff, 0xc8, 0xe2, 0xbb, 0x72, 0x94,
+    0xe9, 0xf2, 0xd9, 0xc2, 0x9f, 0xe8, 0xb3, 0x86,
+};
+static const unsigned char kat294_addin1[] = {
+    0x09, 0xac, 0xba, 0x8e, 0x05, 0x59, 0x39, 0x94, 0x24, 0x8d, 0x40, 0x66,
+    0xb3, 0xd7, 0x70, 0xf4, 0x1b, 0x47, 0xab, 0x82, 0x44, 0x96, 0x8b, 0xb6,
+    0x26, 0xbd, 0xfb, 0x6d, 0xb1, 0x41, 0x76, 0x0f,
+};
+static const unsigned char kat294_retbits[] = {
+    0xaf, 0x2e, 0xb7, 0x3e, 0x49, 0xb1, 0x3c, 0x1c, 0x42, 0x62, 0x95, 0xfa,
+    0x26, 0x43, 0xde, 0x08, 0xb1, 0x92, 0xac, 0x24, 0x07, 0x9b, 0x71, 0xc8,
+    0xc1, 0x75, 0x50, 0x96, 0x44, 0x93, 0x7f, 0x22, 0x2d, 0xfb, 0xd6, 0xc7,
+    0x7d, 0xd2, 0x5e, 0xa3, 0xea, 0xfe, 0xf7, 0x1d, 0xa2, 0xaa, 0x7b, 0xdb,
+    0x68, 0xab, 0x4c, 0x8e, 0x97, 0xbd, 0xeb, 0x7c, 0x70, 0x6d, 0x99, 0xb5,
+    0xb6, 0x7c, 0x6f, 0x9d,
+};
+static const struct drbg_kat_no_reseed kat294_t = {
+    8, kat294_entropyin, kat294_nonce, kat294_persstr,
+    kat294_addin0, kat294_addin1, kat294_retbits
+};
+static const struct drbg_kat kat294 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat294_t
+};
+
+static const unsigned char kat295_entropyin[] = {
+    0xe8, 0xc5, 0x38, 0xae, 0x11, 0x61, 0x98, 0x96, 0xbd, 0x34, 0x7d, 0x67,
+    0x90, 0x07, 0x66, 0x1a, 0xce, 0x7e, 0x51, 0x92, 0xb8, 0x39, 0x19, 0x42,
+};
+static const unsigned char kat295_nonce[] = {
+    0xf8, 0x26, 0x28, 0xa0, 0x5a, 0x8d, 0xfc, 0x06, 0x68, 0xf7, 0xf7, 0x54,
+    0xb1, 0x71, 0xd5, 0xdb,
+};
+static const unsigned char kat295_persstr[] = {
+    0x2c, 0x2a, 0x7e, 0xc3, 0x15, 0x64, 0xa3, 0x4e, 0x9c, 0xfb, 0x9f, 0x0f,
+    0x42, 0xd8, 0xba, 0xb6, 0x81, 0x2b, 0x4a, 0xde, 0x26, 0x3a, 0xf4, 0xf0,
+    0x02, 0x29, 0xe6, 0xeb, 0x99, 0x1e, 0x25, 0x92,
+};
+static const unsigned char kat295_addin0[] = {
+    0x8d, 0x9e, 0x18, 0x24, 0xd2, 0x77, 0x37, 0xaf, 0xc4, 0x11, 0xb2, 0x4b,
+    0xe6, 0x5e, 0xac, 0x50, 0x48, 0x0f, 0xce, 0x4a, 0xfb, 0xf7, 0x31, 0x7a,
+    0x24, 0xb0, 0x4e, 0x24, 0x67, 0x20, 0x6f, 0x54,
+};
+static const unsigned char kat295_addin1[] = {
+    0x3f, 0x02, 0x6a, 0x1a, 0x2b, 0xb8, 0xd0, 0x59, 0xc4, 0x95, 0xb0, 0xd4,
+    0xa4, 0xf9, 0x73, 0x2d, 0x94, 0xaa, 0xf1, 0x5d, 0xe4, 0x2b, 0xf3, 0x44,
+    0x12, 0xd7, 0x27, 0x0a, 0xaf, 0xca, 0x09, 0x9b,
+};
+static const unsigned char kat295_retbits[] = {
+    0xb3, 0x96, 0xa8, 0x56, 0x93, 0x88, 0x93, 0x2a, 0x6f, 0xd2, 0x8c, 0xab,
+    0x6c, 0xfb, 0x53, 0x37, 0x57, 0x1c, 0x1c, 0x91, 0xb8, 0xde, 0xf9, 0x83,
+    0x5a, 0x2d, 0xcf, 0x23, 0x53, 0x66, 0x93, 0xb6, 0xa2, 0x75, 0xab, 0xb4,
+    0xd4, 0xa3, 0xa2, 0xa1, 0xf4, 0x92, 0xb6, 0xfe, 0x5b, 0xce, 0x76, 0x30,
+    0xde, 0x03, 0x99, 0x4e, 0xf2, 0x34, 0xd4, 0x25, 0x5e, 0xa3, 0x38, 0xa1,
+    0x3a, 0xfb, 0x8e, 0x6d,
+};
+static const struct drbg_kat_no_reseed kat295_t = {
+    9, kat295_entropyin, kat295_nonce, kat295_persstr,
+    kat295_addin0, kat295_addin1, kat295_retbits
+};
+static const struct drbg_kat kat295 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat295_t
+};
+
+static const unsigned char kat296_entropyin[] = {
+    0x95, 0x44, 0xea, 0x65, 0x20, 0x52, 0x83, 0xf3, 0x66, 0x82, 0x4c, 0x55,
+    0x60, 0x21, 0x78, 0xeb, 0x82, 0x13, 0x5d, 0x01, 0x57, 0x78, 0x8f, 0x86,
+};
+static const unsigned char kat296_nonce[] = {
+    0x5e, 0x03, 0x79, 0xad, 0xec, 0x23, 0x87, 0xfc, 0xdb, 0xc6, 0x4d, 0x0f,
+    0x9e, 0x23, 0xcc, 0xb5,
+};
+static const unsigned char kat296_persstr[] = {
+    0xbe, 0x01, 0x6b, 0x1e, 0xf2, 0x74, 0xc7, 0x2c, 0x74, 0x97, 0x0c, 0x7f,
+    0x16, 0xff, 0x9f, 0x6d, 0xd5, 0x79, 0xad, 0x73, 0x6a, 0xb8, 0x02, 0x38,
+    0x5b, 0xb7, 0xc5, 0xee, 0xf7, 0x08, 0x6a, 0x95,
+};
+static const unsigned char kat296_addin0[] = {
+    0xaa, 0xbf, 0xe4, 0x85, 0x76, 0x08, 0x9e, 0x44, 0x43, 0x1a, 0xe8, 0x94,
+    0xcc, 0x31, 0x6e, 0xe9, 0x6b, 0xf7, 0xa4, 0x91, 0x89, 0xc7, 0xe4, 0x2a,
+    0xbc, 0xca, 0x27, 0x87, 0x8b, 0x30, 0xef, 0x24,
+};
+static const unsigned char kat296_addin1[] = {
+    0xb5, 0x29, 0xe2, 0xd3, 0x7b, 0x08, 0x08, 0xb1, 0xc9, 0x25, 0x34, 0x40,
+    0x19, 0xdd, 0xdd, 0x3e, 0xea, 0x22, 0x77, 0x68, 0x38, 0xa0, 0x6e, 0x67,
+    0x7f, 0xff, 0x67, 0x12, 0x7b, 0xb6, 0x8a, 0x6d,
+};
+static const unsigned char kat296_retbits[] = {
+    0xab, 0x1a, 0x41, 0x84, 0x13, 0x30, 0xdf, 0x7e, 0x73, 0x4a, 0x57, 0xbe,
+    0x20, 0x81, 0x71, 0x95, 0x0f, 0xa8, 0xe6, 0x4f, 0x4a, 0x2e, 0x26, 0xc7,
+    0x2a, 0x10, 0xb3, 0x3d, 0xf9, 0xa7, 0x7b, 0xb2, 0x42, 0x84, 0xbf, 0xa7,
+    0x22, 0x0b, 0xf8, 0xef, 0x03, 0x5e, 0x4d, 0x15, 0x84, 0x2b, 0xe5, 0x51,
+    0x03, 0xec, 0x47, 0x43, 0xe2, 0xa9, 0x5b, 0xad, 0xd9, 0x48, 0x4b, 0x36,
+    0x0d, 0x22, 0xe2, 0xdb,
+};
+static const struct drbg_kat_no_reseed kat296_t = {
+    10, kat296_entropyin, kat296_nonce, kat296_persstr,
+    kat296_addin0, kat296_addin1, kat296_retbits
+};
+static const struct drbg_kat kat296 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat296_t
+};
+
+static const unsigned char kat297_entropyin[] = {
+    0x25, 0xec, 0x07, 0x42, 0x27, 0x5e, 0x6f, 0xd6, 0xd3, 0x09, 0xa0, 0x26,
+    0x99, 0xb7, 0xf2, 0x1a, 0xa1, 0x83, 0x62, 0xea, 0x68, 0x3b, 0xa7, 0x32,
+};
+static const unsigned char kat297_nonce[] = {
+    0x54, 0x24, 0xe5, 0x50, 0x26, 0xf0, 0x28, 0x36, 0x9f, 0xd9, 0x6f, 0x57,
+    0x50, 0x9b, 0xfe, 0x92,
+};
+static const unsigned char kat297_persstr[] = {
+    0xef, 0xed, 0x65, 0x1e, 0x62, 0x79, 0x63, 0xc4, 0x3f, 0xbf, 0x16, 0x4b,
+    0xd7, 0xb9, 0xb3, 0xbc, 0xf1, 0x8c, 0xb7, 0x8a, 0xe9, 0x7d, 0xc4, 0x8a,
+    0x85, 0xd5, 0x21, 0x2a, 0xc7, 0x1a, 0x11, 0xfc,
+};
+static const unsigned char kat297_addin0[] = {
+    0x26, 0xb0, 0xf1, 0x02, 0x5f, 0x31, 0x83, 0x14, 0xb5, 0x5f, 0xc1, 0xa4,
+    0xdd, 0x32, 0x55, 0x13, 0xc4, 0x53, 0xb6, 0x6d, 0x0b, 0x21, 0x29, 0x3f,
+    0x77, 0x5c, 0xcd, 0x7d, 0x3b, 0x9f, 0x43, 0x43,
+};
+static const unsigned char kat297_addin1[] = {
+    0x2f, 0x94, 0xd7, 0xde, 0x2c, 0xe2, 0x5d, 0x12, 0x4d, 0x9d, 0xc6, 0x8b,
+    0x39, 0xf9, 0x07, 0x6e, 0xcd, 0x2f, 0xf1, 0x4f, 0xe4, 0xe1, 0xd5, 0xc1,
+    0x7c, 0x6e, 0x4d, 0xf2, 0x25, 0x7f, 0xc1, 0xde,
+};
+static const unsigned char kat297_retbits[] = {
+    0xf9, 0xfd, 0x57, 0x61, 0x04, 0xd7, 0xf6, 0x8a, 0x2a, 0xf7, 0xd6, 0xa6,
+    0x3f, 0x82, 0x44, 0xb0, 0x63, 0xe2, 0x87, 0x78, 0x7d, 0x8c, 0x93, 0xf3,
+    0x16, 0x7e, 0xed, 0x9f, 0x8f, 0x83, 0x20, 0xc8, 0x61, 0xcd, 0x8c, 0xcb,
+    0x51, 0x24, 0xd3, 0x2a, 0xc7, 0x5c, 0x57, 0x6d, 0xaa, 0xc3, 0x08, 0x2b,
+    0x3f, 0x5f, 0x75, 0x50, 0x64, 0x0b, 0x77, 0x9e, 0x6f, 0xbe, 0xb7, 0xa3,
+    0xf8, 0x9f, 0xcb, 0x11,
+};
+static const struct drbg_kat_no_reseed kat297_t = {
+    11, kat297_entropyin, kat297_nonce, kat297_persstr,
+    kat297_addin0, kat297_addin1, kat297_retbits
+};
+static const struct drbg_kat kat297 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat297_t
+};
+
+static const unsigned char kat298_entropyin[] = {
+    0xb7, 0x2b, 0xc2, 0xe7, 0x5e, 0x22, 0x7a, 0x5f, 0xab, 0xc2, 0x67, 0xc7,
+    0x7f, 0xc7, 0xf9, 0x9c, 0x81, 0xd2, 0xe4, 0xe4, 0x1e, 0xfc, 0x31, 0xb0,
+};
+static const unsigned char kat298_nonce[] = {
+    0x3e, 0x28, 0x60, 0x39, 0xed, 0x89, 0x9f, 0x2b, 0xdc, 0x70, 0x25, 0xa7,
+    0xd3, 0x07, 0x12, 0xdc,
+};
+static const unsigned char kat298_persstr[] = {
+    0x35, 0x90, 0x15, 0x3e, 0xf3, 0xb5, 0x80, 0x51, 0x6a, 0x0a, 0xae, 0x3e,
+    0x9c, 0xc7, 0xe3, 0x8c, 0x3e, 0xe6, 0xf1, 0x70, 0x3b, 0xf7, 0x7a, 0x3a,
+    0x6d, 0x8f, 0xdb, 0x58, 0x40, 0x0c, 0xf1, 0x20,
+};
+static const unsigned char kat298_addin0[] = {
+    0x7d, 0x62, 0xa4, 0x68, 0x7d, 0x5c, 0x11, 0xd3, 0x7c, 0x3a, 0x86, 0x47,
+    0x4a, 0x53, 0x22, 0x8c, 0xa5, 0x30, 0x7e, 0xc5, 0x80, 0x1d, 0xc2, 0x49,
+    0x53, 0xa0, 0x12, 0x88, 0xde, 0x86, 0x8b, 0xdb,
+};
+static const unsigned char kat298_addin1[] = {
+    0xf4, 0xce, 0x4d, 0x4b, 0x6c, 0xc8, 0x04, 0x1c, 0xc0, 0x94, 0xf0, 0x5f,
+    0xb4, 0x68, 0x36, 0xfe, 0x79, 0x4c, 0x81, 0x0a, 0x00, 0xea, 0x54, 0x54,
+    0x26, 0x29, 0x74, 0x96, 0xd1, 0xb3, 0xda, 0x84,
+};
+static const unsigned char kat298_retbits[] = {
+    0x91, 0x91, 0x88, 0x42, 0x1a, 0xc9, 0x04, 0xb1, 0x86, 0x98, 0x66, 0x2d,
+    0xf0, 0x6b, 0x1b, 0x2c, 0x61, 0xd9, 0x38, 0xee, 0x32, 0x45, 0x70, 0xa4,
+    0xd3, 0xfd, 0x84, 0x53, 0x47, 0xf7, 0x6a, 0xb9, 0x0e, 0xa8, 0x98, 0xe8,
+    0x74, 0xd5, 0x29, 0x07, 0x75, 0x42, 0x94, 0x1d, 0xf5, 0x47, 0xdc, 0xd1,
+    0xb0, 0xa3, 0x70, 0xad, 0xb8, 0xf3, 0xcf, 0x2b, 0x66, 0x50, 0x9f, 0x2a,
+    0xa0, 0x0c, 0xe0, 0x07,
+};
+static const struct drbg_kat_no_reseed kat298_t = {
+    12, kat298_entropyin, kat298_nonce, kat298_persstr,
+    kat298_addin0, kat298_addin1, kat298_retbits
+};
+static const struct drbg_kat kat298 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat298_t
+};
+
+static const unsigned char kat299_entropyin[] = {
+    0x80, 0x0e, 0xa2, 0xb7, 0xe2, 0xa3, 0x4b, 0xa4, 0xe0, 0x4a, 0x8b, 0x2e,
+    0x3f, 0x40, 0x4a, 0x4e, 0xbe, 0x78, 0xd1, 0xb1, 0x19, 0x64, 0x71, 0x0b,
+};
+static const unsigned char kat299_nonce[] = {
+    0x26, 0x14, 0xf4, 0x44, 0xb7, 0x0a, 0x50, 0xd8, 0xae, 0x85, 0x27, 0x07,
+    0x86, 0x74, 0x16, 0x35,
+};
+static const unsigned char kat299_persstr[] = {
+    0x61, 0x11, 0x2f, 0x45, 0x79, 0xe8, 0xda, 0x87, 0xf9, 0xbd, 0x33, 0xaa,
+    0xd0, 0x8f, 0xbe, 0xea, 0x17, 0xe7, 0x8d, 0xe3, 0xdb, 0xf6, 0xa7, 0x55,
+    0x49, 0xdc, 0x50, 0xd2, 0xa9, 0x22, 0x72, 0x16,
+};
+static const unsigned char kat299_addin0[] = {
+    0x67, 0x1b, 0x8c, 0xc5, 0x1f, 0x1c, 0x53, 0xe4, 0x25, 0xd5, 0xf9, 0x7d,
+    0x73, 0x05, 0x30, 0x21, 0xdd, 0x6a, 0xf2, 0x3f, 0x6a, 0xbd, 0xa8, 0x2e,
+    0xfb, 0x00, 0x63, 0x75, 0xfd, 0xfe, 0x68, 0x18,
+};
+static const unsigned char kat299_addin1[] = {
+    0x50, 0x2f, 0xc3, 0xd1, 0xe8, 0x9e, 0x17, 0xf0, 0xf1, 0x11, 0xdf, 0xa3,
+    0x2c, 0x74, 0x8a, 0x79, 0xdd, 0x1b, 0x1e, 0x19, 0x02, 0x40, 0x27, 0xbc,
+    0x0d, 0x92, 0xed, 0x30, 0x63, 0x85, 0x5b, 0x07,
+};
+static const unsigned char kat299_retbits[] = {
+    0xad, 0xfc, 0xe1, 0x6f, 0x2f, 0x64, 0x82, 0xd0, 0x19, 0x0d, 0xdd, 0xbb,
+    0x89, 0xea, 0xd4, 0x48, 0xe3, 0x32, 0x64, 0xfb, 0xe9, 0xf7, 0x6e, 0xf7,
+    0x53, 0x07, 0x62, 0x25, 0xf1, 0xc4, 0x30, 0x68, 0x6f, 0x33, 0x2c, 0xba,
+    0x84, 0x54, 0xab, 0x81, 0xef, 0x91, 0x86, 0xa8, 0x2a, 0x81, 0x45, 0x31,
+    0xc4, 0x9a, 0x1e, 0x46, 0xa2, 0x37, 0x2f, 0xd0, 0x6f, 0xfc, 0x57, 0x68,
+    0x23, 0x00, 0x1b, 0x97,
+};
+static const struct drbg_kat_no_reseed kat299_t = {
+    13, kat299_entropyin, kat299_nonce, kat299_persstr,
+    kat299_addin0, kat299_addin1, kat299_retbits
+};
+static const struct drbg_kat kat299 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat299_t
+};
+
+static const unsigned char kat300_entropyin[] = {
+    0x46, 0xbc, 0x30, 0x11, 0x14, 0x29, 0x14, 0xe8, 0x7f, 0x3b, 0xed, 0xea,
+    0x5d, 0x09, 0xed, 0xc1, 0x88, 0xac, 0xdb, 0x2b, 0xd4, 0x96, 0x2d, 0x5e,
+};
+static const unsigned char kat300_nonce[] = {
+    0x99, 0xb0, 0xb4, 0xb4, 0x42, 0xe8, 0x5e, 0xaf, 0x63, 0x8a, 0xb4, 0x65,
+    0x44, 0x37, 0xc6, 0xbf,
+};
+static const unsigned char kat300_persstr[] = {
+    0x5b, 0xe5, 0x1d, 0x43, 0x7e, 0x75, 0x05, 0x7d, 0xd2, 0xef, 0x4c, 0xa7,
+    0x44, 0x3f, 0xad, 0xe0, 0x7d, 0x52, 0x0d, 0x17, 0x07, 0x4b, 0x5b, 0xd7,
+    0x3a, 0xca, 0x11, 0x17, 0x31, 0xb5, 0x08, 0xa5,
+};
+static const unsigned char kat300_addin0[] = {
+    0x81, 0xa5, 0x40, 0xc5, 0xf3, 0x37, 0x9a, 0x46, 0xa2, 0xea, 0x35, 0xcf,
+    0xa3, 0x58, 0xd6, 0x7f, 0x6b, 0x35, 0xc0, 0x23, 0xf9, 0x10, 0x30, 0x4b,
+    0x87, 0x37, 0x44, 0xaa, 0xb6, 0x32, 0x55, 0xbf,
+};
+static const unsigned char kat300_addin1[] = {
+    0x55, 0xa2, 0xe3, 0x45, 0x99, 0xb0, 0x05, 0x08, 0xea, 0x03, 0x89, 0x56,
+    0x3c, 0xf5, 0xc6, 0x63, 0x77, 0x5e, 0x4c, 0x19, 0x13, 0x01, 0x3e, 0x65,
+    0x99, 0x9e, 0xa1, 0x52, 0x94, 0x78, 0x84, 0xfb,
+};
+static const unsigned char kat300_retbits[] = {
+    0x56, 0x22, 0xea, 0x84, 0x41, 0x40, 0x52, 0x21, 0x81, 0xd8, 0x3c, 0x5d,
+    0xb4, 0x31, 0x8e, 0xfe, 0xa2, 0x59, 0x07, 0x80, 0x70, 0x5b, 0x94, 0x9a,
+    0x94, 0x22, 0xf0, 0xee, 0x57, 0x0c, 0x3e, 0x61, 0x35, 0x61, 0x64, 0xc2,
+    0xe8, 0xc3, 0x27, 0x5f, 0x5e, 0xdc, 0x8c, 0xf1, 0x8b, 0x71, 0xec, 0xd6,
+    0x34, 0xea, 0xe5, 0x29, 0x01, 0xca, 0xa5, 0x23, 0x04, 0x7d, 0xc1, 0x78,
+    0xf0, 0x2f, 0x2c, 0xc6,
+};
+static const struct drbg_kat_no_reseed kat300_t = {
+    14, kat300_entropyin, kat300_nonce, kat300_persstr,
+    kat300_addin0, kat300_addin1, kat300_retbits
+};
+static const struct drbg_kat kat300 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 32, 32, 64, &kat300_t
+};
+
+static const unsigned char kat301_entropyin[] = {
+    0xa5, 0x7c, 0xc3, 0xb9, 0x95, 0xf3, 0x55, 0x62, 0xba, 0x30, 0x61, 0x9c,
+    0xe6, 0xc2, 0xb5, 0x1f, 0x22, 0x17, 0xbf, 0xf0, 0x14, 0x00, 0x6e, 0xf1,
+};
+static const unsigned char kat301_nonce[] = {
+    0xe5, 0x0a, 0x31, 0x2b, 0x22, 0xd6, 0x8f, 0x32, 0x0d, 0x4b, 0xac, 0x24,
+    0x0d, 0x41, 0x4f, 0x47,
+};
+static const unsigned char kat301_persstr[] = {0};
+static const unsigned char kat301_addin0[] = {0};
+static const unsigned char kat301_addin1[] = {0};
+static const unsigned char kat301_retbits[] = {
+    0xf2, 0xcf, 0xfe, 0xb0, 0xf4, 0xff, 0xbe, 0x77, 0x3d, 0xc8, 0x04, 0x72,
+    0x08, 0x2b, 0x3c, 0x0a, 0x87, 0x7a, 0xaa, 0x11, 0x3d, 0xc4, 0xd8, 0x67,
+    0x8b, 0x25, 0xd8, 0x42, 0x02, 0x70, 0xe3, 0x50, 0x88, 0xcd, 0x9e, 0xb2,
+    0xcb, 0xaa, 0xd9, 0xbc, 0x3d, 0x5b, 0x51, 0x86, 0x54, 0x47, 0x24, 0x5a,
+    0x3a, 0x78, 0xb3, 0x8c, 0x51, 0xd0, 0xa1, 0x9c, 0xa0, 0x8c, 0x61, 0x95,
+    0x58, 0x7d, 0xfd, 0x7a,
+};
+static const struct drbg_kat_no_reseed kat301_t = {
+    0, kat301_entropyin, kat301_nonce, kat301_persstr,
+    kat301_addin0, kat301_addin1, kat301_retbits
+};
+static const struct drbg_kat kat301 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat301_t
+};
+
+static const unsigned char kat302_entropyin[] = {
+    0x0b, 0x61, 0x0e, 0x89, 0x79, 0x68, 0x2f, 0x44, 0xd9, 0x37, 0xc9, 0x74,
+    0xe7, 0x3a, 0x4c, 0x3d, 0xf9, 0x5a, 0x34, 0xb0, 0x92, 0x40, 0x5f, 0xe4,
+};
+static const unsigned char kat302_nonce[] = {
+    0x08, 0x55, 0x81, 0xc0, 0x1f, 0xb9, 0x16, 0x15, 0x84, 0xb9, 0xf6, 0x52,
+    0x6f, 0x54, 0x7b, 0x44,
+};
+static const unsigned char kat302_persstr[] = {0};
+static const unsigned char kat302_addin0[] = {0};
+static const unsigned char kat302_addin1[] = {0};
+static const unsigned char kat302_retbits[] = {
+    0x28, 0x2d, 0xfb, 0x8a, 0x9e, 0xd6, 0x72, 0x12, 0x29, 0xf7, 0x81, 0xa1,
+    0x5a, 0x70, 0x33, 0xad, 0xbc, 0xd4, 0x9a, 0x21, 0x0a, 0x23, 0x1e, 0x17,
+    0xeb, 0x70, 0xd6, 0x4c, 0xa8, 0x03, 0x75, 0xa8, 0xff, 0xcb, 0x4e, 0x9a,
+    0xc6, 0xe2, 0x32, 0x73, 0xca, 0x96, 0x54, 0xe6, 0x71, 0xcc, 0xb1, 0xae,
+    0x3b, 0xb5, 0x96, 0xbf, 0x7a, 0x8d, 0xf5, 0xdd, 0x23, 0x0b, 0xf4, 0xa2,
+    0xb3, 0x9b, 0xf9, 0x6f,
+};
+static const struct drbg_kat_no_reseed kat302_t = {
+    1, kat302_entropyin, kat302_nonce, kat302_persstr,
+    kat302_addin0, kat302_addin1, kat302_retbits
+};
+static const struct drbg_kat kat302 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat302_t
+};
+
+static const unsigned char kat303_entropyin[] = {
+    0xf9, 0x3e, 0x04, 0x17, 0x48, 0x91, 0x02, 0x81, 0xa4, 0xff, 0x37, 0xef,
+    0xe8, 0x30, 0xac, 0x02, 0x64, 0xe4, 0xb1, 0x2e, 0xce, 0x06, 0x78, 0xee,
+};
+static const unsigned char kat303_nonce[] = {
+    0x7d, 0x4d, 0x6c, 0x54, 0x5d, 0xe8, 0xc8, 0x11, 0x84, 0x55, 0x59, 0x54,
+    0x34, 0x65, 0x1b, 0xbc,
+};
+static const unsigned char kat303_persstr[] = {0};
+static const unsigned char kat303_addin0[] = {0};
+static const unsigned char kat303_addin1[] = {0};
+static const unsigned char kat303_retbits[] = {
+    0xa7, 0x3e, 0x59, 0xa6, 0x6d, 0xe5, 0x02, 0x29, 0x8a, 0x81, 0x06, 0x93,
+    0x9f, 0xfa, 0xf8, 0x56, 0xaf, 0x9f, 0x17, 0x2b, 0x85, 0xf5, 0xe9, 0x9b,
+    0x05, 0x7d, 0x6b, 0x4d, 0x6e, 0xf0, 0x52, 0xf1, 0x22, 0x67, 0x00, 0xe5,
+    0xe3, 0x98, 0xe6, 0x80, 0x2f, 0x2a, 0x4a, 0xfa, 0x04, 0xe7, 0xff, 0x00,
+    0xc4, 0x6f, 0x57, 0xf3, 0x45, 0xeb, 0x03, 0xde, 0x8f, 0xa7, 0x79, 0x5a,
+    0x06, 0x0c, 0xf3, 0x40,
+};
+static const struct drbg_kat_no_reseed kat303_t = {
+    2, kat303_entropyin, kat303_nonce, kat303_persstr,
+    kat303_addin0, kat303_addin1, kat303_retbits
+};
+static const struct drbg_kat kat303 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat303_t
+};
+
+static const unsigned char kat304_entropyin[] = {
+    0x81, 0x48, 0x86, 0xa6, 0xb9, 0xa3, 0xcf, 0xc3, 0x18, 0x78, 0x5b, 0x41,
+    0x93, 0x9f, 0x7b, 0x07, 0x5e, 0xc6, 0xb0, 0x0f, 0xc7, 0xff, 0x1c, 0x9c,
+};
+static const unsigned char kat304_nonce[] = {
+    0xd1, 0x33, 0x13, 0x12, 0x3f, 0xbc, 0x45, 0xce, 0x8b, 0x9e, 0x8a, 0x0a,
+    0x4d, 0x82, 0xb2, 0x7a,
+};
+static const unsigned char kat304_persstr[] = {0};
+static const unsigned char kat304_addin0[] = {0};
+static const unsigned char kat304_addin1[] = {0};
+static const unsigned char kat304_retbits[] = {
+    0xba, 0x2a, 0x7c, 0x50, 0xc6, 0xd3, 0xe7, 0xef, 0x2d, 0x84, 0x91, 0x06,
+    0xc6, 0xe8, 0x33, 0x10, 0xd9, 0xad, 0x1c, 0x1d, 0x0e, 0xf5, 0x3e, 0x61,
+    0xc8, 0xb9, 0x55, 0xac, 0xb4, 0xef, 0x43, 0x42, 0xe1, 0xc0, 0xf5, 0xf2,
+    0x2e, 0x19, 0xbb, 0x1e, 0xea, 0x5d, 0x0f, 0x03, 0xb6, 0xd5, 0x96, 0x92,
+    0x91, 0xc4, 0x01, 0xfb, 0x6c, 0x55, 0xc9, 0x9f, 0x42, 0x52, 0xb6, 0xca,
+    0x7f, 0x34, 0x19, 0x35,
+};
+static const struct drbg_kat_no_reseed kat304_t = {
+    3, kat304_entropyin, kat304_nonce, kat304_persstr,
+    kat304_addin0, kat304_addin1, kat304_retbits
+};
+static const struct drbg_kat kat304 = {
+    NO_RESEED, USE_DF, NID_aes_192_ctr, 24, 16, 0, 0, 64, &kat304_t
+};
+
+static const unsigned char kat305_entropyin[] = {
+    0x69, 0xce, 0x9b, 0xc6, 0xa2, 0x66, 0x95, 0x02, 0x70, 0xba, 0xb4, 0x7f,
+    0x50, 0x19, 0xf5, 0x76, 0xfb, 0x9d, 0xee, 0x08, 0x17, 0x9b, 0x34, 0xeb,
+};
+static const unsigned char kat305_nonce[] = {
+    0x63, 0x02, 0x5d, 0x58, 0x8f, 0x1d, 0x08, 0xf3, 0x81, 0x16, 0x96, 0xa6,
+    0x3a, 0x10, 0x02, 0xe7,
+};
+static const unsigned char kat305_persstr[] = {0};
+static const unsigned char kat305_addin0[] = {0};
+static const unsigned char kat305_addin1[] = {0};
+static const unsigned char kat305_retbits[] = {
+    0x5e, 0x52, 0xaf, 0xd2, 0xa8, 0x67, 0x01, 0xcb, 0x40, 0xbd, 0x77, 0xba,
+    0xf5, 0x5e, 0xff, 0x3a, 0x6c, 0x9f, 0x84, 0x34, 0x56, 0xed, 0x64, 0xd4,
+    0x01, 0x53, 0x32, 0x77, 0x9f, 0xe0, 0xb2, 0x6a, 0xea, 0xc6, 0x34, 0xcb,
+    0x06, 0x21, 0xc4, 0x3b, 0x3a, 0xb7, 0x1e, 0xea, 0x2a, 0xdf, 0x96, 0x31,
+    0x2d, 0x38, 0x5c, 0x62, 0xc3, 0x1c, 0x09, 0x51, 0x52, 0x32, 0x60, 0xc4,
+    0x69, 0xb2, 0x7d, 0x88,
+};
+static const struct drbg_kat_no_reseed kat305_t = {
+    4, kat305_entropyin, kat305_nonce, kat305_persstr,
+    kat305_addin0, kat305_addin1, kat305_retbits
+};
+static const struct drbg_