refactoring

59 files changed, 1159 insertions, 1159 deletions

diff --git a/examples/aes128cbc.c b/examples/aes128cbc.c
index 986be2e..b2eb14a 100644
--- a/examples/aes128cbc.c
+++ b/examples/aes128cbc.c
@@ -12,55 +12,55 @@
 
 int main()
 {
-    AesBlock128 plain, key, cipher, decrypted, iv, next_iv;
-    Aes128KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 plain, key, cipher, decrypted, iv, next_iv;
+    AesNI_KeySchedule128 key_schedule, inverted_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block128(&key).str);
-    print_aes_block128_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block128(&key).str);
+    aesni_print_block128_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes128_expand_key_schedule(key, &key_schedule);
+    aesni_expand_key_schedule128(key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes128cbc_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_cbc128(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    aes128_invert_key_schedule(&key_schedule, &inverted_schedule);
+    aesni_invert_key_schedule128(&key_schedule, &inverted_schedule);
 
     printf("\n");
     printf("Inverted key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str);
 
-    decrypted = aes128cbc_decrypt_block(cipher, &inverted_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_cbc128(cipher, &inverted_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes128cfb.c b/examples/aes128cfb.c
index 2d209ca..31ad748 100644
--- a/examples/aes128cfb.c
+++ b/examples/aes128cfb.c
@@ -12,48 +12,48 @@
 
 int main()
 {
-    AesBlock128 plain, key, cipher, decrypted, iv, next_iv;
-    Aes128KeySchedule key_schedule;
+    AesNI_Block128 plain, key, cipher, decrypted, iv, next_iv;
+    AesNI_KeySchedule128 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block128(&key).str);
-    print_aes_block128_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block128(&key).str);
+    aesni_print_block128_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes128_expand_key_schedule(key, &key_schedule);
+    aesni_expand_key_schedule128(key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes128cfb_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_cfb128(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    decrypted = aes128cfb_decrypt_block(cipher, &key_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_cfb128(cipher, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes128ctr.c b/examples/aes128ctr.c
index c645da7..1efe4e2 100644
--- a/examples/aes128ctr.c
+++ b/examples/aes128ctr.c
@@ -12,40 +12,40 @@
 
 int main()
 {
-    AesBlock128 plain, key, cipher, decrypted, iv;
-    Aes128KeySchedule key_schedule;
+    AesNI_Block128 plain, key, cipher, decrypted, iv;
+    AesNI_KeySchedule128 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block128(&key).str);
-    print_aes_block128_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block128(&key).str);
+    aesni_print_block128_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes128_expand_key_schedule(key, &key_schedule);
+    aesni_expand_key_schedule128(key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes128ctr_encrypt_block(plain, &key_schedule, iv, 0);
+    cipher = aesni_encrypt_block_ctr128(plain, &key_schedule, iv, 0);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
-    decrypted = aes128ctr_decrypt_block(cipher, &key_schedule, iv, 0);
+    decrypted = aesni_decrypt_block_ctr128(cipher, &key_schedule, iv, 0);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     return 0;
 }
diff --git a/examples/aes128ecb.c b/examples/aes128ecb.c
index e36cd66..4f999d4 100644
--- a/examples/aes128ecb.c
+++ b/examples/aes128ecb.c
@@ -12,42 +12,42 @@
 
 int main()
 {
-    AesBlock128 plain, key, cipher, decrypted;
-    Aes128KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 plain, key, cipher, decrypted;
+    AesNI_KeySchedule128 key_schedule, inverted_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block128(&key).str);
-    print_aes_block128_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block128(&key).str);
+    aesni_print_block128_as_matrix(&key);
 
-    aes128_expand_key_schedule(key, &key_schedule);
+    aesni_expand_key_schedule128(key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes128ecb_encrypt_block(plain, &key_schedule);
+    cipher = aesni_encrypt_block_ecb128(plain, &key_schedule);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
-    aes128_invert_key_schedule(&key_schedule, &inverted_schedule);
+    aesni_invert_key_schedule128(&key_schedule, &inverted_schedule);
 
     printf("\n");
     printf("Inverted key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str);
 
-    decrypted = aes128ecb_decrypt_block(cipher, &inverted_schedule);
+    decrypted = aesni_decrypt_block_ecb128(cipher, &inverted_schedule);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     return 0;
 }
diff --git a/examples/aes128ofb.c b/examples/aes128ofb.c
index 12ef468..49a97ed 100644
--- a/examples/aes128ofb.c
+++ b/examples/aes128ofb.c
@@ -12,48 +12,48 @@
 
 int main()
 {
-    AesBlock128 plain, key, cipher, decrypted, iv, next_iv;
-    Aes128KeySchedule key_schedule;
+    AesNI_Block128 plain, key, cipher, decrypted, iv, next_iv;
+    AesNI_KeySchedule128 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block128(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block128(&key).str);
-    print_aes_block128_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block128(&key).str);
+    aesni_print_block128_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes128_expand_key_schedule(key, &key_schedule);
+    aesni_expand_key_schedule128(key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 11; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes128ofb_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_ofb128(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    decrypted = aes128ofb_decrypt_block(cipher, &key_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_ofb128(cipher, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes192cbc.c b/examples/aes192cbc.c
index 406575c..67adf95 100644
--- a/examples/aes192cbc.c
+++ b/examples/aes192cbc.c
@@ -12,56 +12,56 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv, next_iv;
-    AesBlock192 key;
-    Aes192KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv, next_iv;
+    AesNI_Block192 key;
+    AesNI_KeySchedule192 key_schedule, inverted_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block192(&key).str);
-    print_aes_block192_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block192(&key).str);
+    aesni_print_block192_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes192_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule192(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes192cbc_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_cbc192(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    aes192_invert_key_schedule(&key_schedule, &inverted_schedule);
+    aesni_invert_key_schedule192(&key_schedule, &inverted_schedule);
 
     printf("\n");
     printf("Inverted key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str);
 
-    decrypted = aes192cbc_decrypt_block(cipher, &inverted_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_cbc192(cipher, &inverted_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes192cfb.c b/examples/aes192cfb.c
index 103ac12..d5bf554 100644
--- a/examples/aes192cfb.c
+++ b/examples/aes192cfb.c
@@ -12,49 +12,49 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv, next_iv;
-    AesBlock192 key;
-    Aes192KeySchedule key_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv, next_iv;
+    AesNI_Block192 key;
+    AesNI_KeySchedule192 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block192(&key).str);
-    print_aes_block192_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block192(&key).str);
+    aesni_print_block192_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes192_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule192(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes192cfb_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_cfb192(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    decrypted = aes192cfb_decrypt_block(cipher, &key_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_cfb192(cipher, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes192ctr.c b/examples/aes192ctr.c
index 48d4b14..3ce7c76 100644
--- a/examples/aes192ctr.c
+++ b/examples/aes192ctr.c
@@ -12,41 +12,41 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv;
-    AesBlock192 key;
-    Aes192KeySchedule key_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv;
+    AesNI_Block192 key;
+    AesNI_KeySchedule192 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block192(&key).str);
-    print_aes_block192_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block192(&key).str);
+    aesni_print_block192_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes192_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule192(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes192ctr_encrypt_block(plain, &key_schedule, iv, 0);
+    cipher = aesni_encrypt_block_ctr192(plain, &key_schedule, iv, 0);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
-    decrypted = aes192ctr_decrypt_block(cipher, &key_schedule, iv, 0);
+    decrypted = aesni_decrypt_block_ctr192(cipher, &key_schedule, iv, 0);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     return 0;
 }
diff --git a/examples/aes192ecb.c b/examples/aes192ecb.c
index f7a05af..775ca7d 100644
--- a/examples/aes192ecb.c
+++ b/examples/aes192ecb.c
@@ -12,43 +12,43 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted;
-    AesBlock192 key;
-    Aes192KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 plain, cipher, decrypted;
+    AesNI_Block192 key;
+    AesNI_KeySchedule192 key_schedule, inverted_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block192(&key).str);
-    print_aes_block192_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block192(&key).str);
+    aesni_print_block192_as_matrix(&key);
 
-    aes192_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule192(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes192ecb_encrypt_block(plain, &key_schedule);
+    cipher = aesni_encrypt_block_ecb192(plain, &key_schedule);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
-    aes192_invert_key_schedule(&key_schedule, &inverted_schedule);
+    aesni_invert_key_schedule192(&key_schedule, &inverted_schedule);
 
     printf("\n");
     printf("Inverted key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str);
 
-    decrypted = aes192ecb_decrypt_block(cipher, &inverted_schedule);
+    decrypted = aesni_decrypt_block_ecb192(cipher, &inverted_schedule);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     return 0;
 }
diff --git a/examples/aes192ofb.c b/examples/aes192ofb.c
index 3c4f025..33e9429 100644
--- a/examples/aes192ofb.c
+++ b/examples/aes192ofb.c
@@ -12,49 +12,49 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv, next_iv;
-    AesBlock192 key;
-    Aes192KeySchedule key_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv, next_iv;
+    AesNI_Block192 key;
+    AesNI_KeySchedule192 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block192(0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block192(&key).str);
-    print_aes_block192_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block192(&key).str);
+    aesni_print_block192_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes192_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule192(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 13; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes192ofb_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_ofb192(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    decrypted = aes192ofb_decrypt_block(cipher, &key_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_ofb192(cipher, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes256cbc.c b/examples/aes256cbc.c
index 0a148e1..3af1015 100644
--- a/examples/aes256cbc.c
+++ b/examples/aes256cbc.c
@@ -12,56 +12,56 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv, next_iv;
-    AesBlock256 key;
-    Aes256KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv, next_iv;
+    AesNI_Block256 key;
+    AesNI_KeySchedule256 key_schedule, inverted_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block256(&key).str);
-    print_aes_block256_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block256(&key).str);
+    aesni_print_block256_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes256_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule256(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes256cbc_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_cbc256(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    aes256_invert_key_schedule(&key_schedule, &inverted_schedule);
+    aesni_invert_key_schedule256(&key_schedule, &inverted_schedule);
 
     printf("\n");
     printf("Inverted key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str);
 
-    decrypted = aes256cbc_decrypt_block(cipher, &inverted_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_cbc256(cipher, &inverted_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes256cfb.c b/examples/aes256cfb.c
index 44d5f30..6ee1134 100644
--- a/examples/aes256cfb.c
+++ b/examples/aes256cfb.c
@@ -12,49 +12,49 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv, next_iv;
-    AesBlock256 key;
-    Aes256KeySchedule key_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv, next_iv;
+    AesNI_Block256 key;
+    AesNI_KeySchedule256 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block256(&key).str);
-    print_aes_block256_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block256(&key).str);
+    aesni_print_block256_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes256_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule256(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes256cfb_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_cfb256(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    decrypted = aes256cfb_decrypt_block(cipher, &key_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_cfb256(cipher, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/examples/aes256ctr.c b/examples/aes256ctr.c
index 0a47004..05c5090 100644
--- a/examples/aes256ctr.c
+++ b/examples/aes256ctr.c
@@ -12,41 +12,41 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv;
-    AesBlock256 key;
-    Aes256KeySchedule key_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv;
+    AesNI_Block256 key;
+    AesNI_KeySchedule256 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block256(&key).str);
-    print_aes_block256_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block256(&key).str);
+    aesni_print_block256_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes256_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule256(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes256ctr_encrypt_block(plain, &key_schedule, iv, 0);
+    cipher = aesni_encrypt_block_ctr256(plain, &key_schedule, iv, 0);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
-    decrypted = aes256ctr_decrypt_block(cipher, &key_schedule, iv, 0);
+    decrypted = aesni_decrypt_block_ctr256(cipher, &key_schedule, iv, 0);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     return 0;
 }
diff --git a/examples/aes256ecb.c b/examples/aes256ecb.c
index f96a368..ead4c15 100644
--- a/examples/aes256ecb.c
+++ b/examples/aes256ecb.c
@@ -12,43 +12,43 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted;
-    AesBlock256 key;
-    Aes256KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 plain, cipher, decrypted;
+    AesNI_Block256 key;
+    AesNI_KeySchedule256 key_schedule, inverted_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block256(&key).str);
-    print_aes_block256_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block256(&key).str);
+    aesni_print_block256_as_matrix(&key);
 
-    aes256_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule256(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes256ecb_encrypt_block(plain, &key_schedule);
+    cipher = aesni_encrypt_block_ecb256(plain, &key_schedule);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
-    aes256_invert_key_schedule(&key_schedule, &inverted_schedule);
+    aesni_invert_key_schedule256(&key_schedule, &inverted_schedule);
 
     printf("\n");
     printf("Inverted key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&inverted_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&inverted_schedule.keys[i]).str);
 
-    decrypted = aes256ecb_decrypt_block(cipher, &inverted_schedule);
+    decrypted = aesni_decrypt_block_ecb256(cipher, &inverted_schedule);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     return 0;
 }
diff --git a/examples/aes256ofb.c b/examples/aes256ofb.c
index 1104438..098b321 100644
--- a/examples/aes256ofb.c
+++ b/examples/aes256ofb.c
@@ -12,49 +12,49 @@
 
 int main()
 {
-    AesBlock128 plain, cipher, decrypted, iv, next_iv;
-    AesBlock256 key;
-    Aes256KeySchedule key_schedule;
+    AesNI_Block128 plain, cipher, decrypted, iv, next_iv;
+    AesNI_Block256 key;
+    AesNI_KeySchedule256 key_schedule;
 
-    plain = make_aes_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
-    key = make_aes_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
-    iv = make_aes_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
+    plain = aesni_make_block128(0xffeeddcc, 0xbbaa9988, 0x77665544, 0x33221100);
+    key = aesni_make_block256(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110, 0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+    iv = aesni_make_block128(0xfedcba98, 0x76543210, 0xfedcba98, 0x76543210);
 
-    printf("Plain: %s\n", format_aes_block128(&plain).str);
-    print_aes_block128_as_matrix(&plain);
+    printf("Plain: %s\n", aesni_format_block128(&plain).str);
+    aesni_print_block128_as_matrix(&plain);
 
     printf("\n");
-    printf("Key: %s\n", format_aes_block256(&key).str);
-    print_aes_block256_as_matrix(&key);
+    printf("Key: %s\n", aesni_format_block256(&key).str);
+    aesni_print_block256_as_matrix(&key);
 
     printf("\n");
-    printf("Initialization vector: %s\n", format_aes_block128(&iv).str);
-    print_aes_block128_as_matrix(&iv);
+    printf("Initialization vector: %s\n", aesni_format_block128(&iv).str);
+    aesni_print_block128_as_matrix(&iv);
 
-    aes256_expand_key_schedule(&key, &key_schedule);
+    aesni_expand_key_schedule256(&key, &key_schedule);
 
     printf("\n");
     printf("Key schedule:\n");
     for (int i = 0; i < 15; ++i)
-        printf("\t[%d]: %s\n", i, format_aes_block128(&key_schedule.keys[i]).str);
+        printf("\t[%d]: %s\n", i, aesni_format_block128(&key_schedule.keys[i]).str);
 
-    cipher = aes256ofb_encrypt_block(plain, &key_schedule, iv, &next_iv);
+    cipher = aesni_encrypt_block_ofb256(plain, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Cipher: %s\n", format_aes_block128(&cipher).str);
-    print_aes_block128_as_matrix(&cipher);
+    printf("Cipher: %s\n", aesni_format_block128(&cipher).str);
+    aesni_print_block128_as_matrix(&cipher);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
-    decrypted = aes256ofb_decrypt_block(cipher, &key_schedule, iv, &next_iv);
+    decrypted = aesni_decrypt_block_ofb256(cipher, &key_schedule, iv, &next_iv);
     printf("\n");
-    printf("Decrypted: %s\n", format_aes_block128(&decrypted).str);
-    print_aes_block128_as_matrix(&decrypted);
+    printf("Decrypted: %s\n", aesni_format_block128(&decrypted).str);
+    aesni_print_block128_as_matrix(&decrypted);
 
     printf("\n");
-    printf("Next initialization vector: %s\n", format_aes_block128(&next_iv).str);
-    print_aes_block128_as_matrix(&next_iv);
+    printf("Next initialization vector: %s\n", aesni_format_block128(&next_iv).str);
+    aesni_print_block128_as_matrix(&next_iv);
 
     return 0;
 }
diff --git a/include/aesni/block.h b/include/aesni/block.h
index 6de2632..7f8be7b 100644
--- a/include/aesni/block.h
+++ b/include/aesni/block.h
@@ -16,358 +16,358 @@ extern "C"
 {
 #endif
 
-static __inline void __fastcall aes128_expand_key_schedule(
-    AesBlock128 key,
-    Aes128KeySchedule* key_schedule)
+static __inline void __fastcall aesni_expand_key_schedule128(
+    AesNI_Block128 key,
+    AesNI_KeySchedule128* key_schedule)
 {
-    raw_aes128_expand_key_schedule(key, key_schedule);
+    aesni_raw_expand_key_schedule128(key, key_schedule);
 }
 
-static __inline void __fastcall aes128_invert_key_schedule(
-    Aes128KeySchedule* key_schedule,
-    Aes128KeySchedule* inverted_schedule)
+static __inline void __fastcall aesni_invert_key_schedule128(
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_KeySchedule128* inverted_schedule)
 {
-    raw_aes128_invert_key_schedule(key_schedule, inverted_schedule);
+    aesni_raw_invert_key_schedule128(key_schedule, inverted_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes128ecb_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule)
 {
-    return raw_aes128_encrypt_block(plain, key_schedule);
+    return aesni_raw_encrypt_block128(plain, key_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes128ecb_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* inverted_schedule)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* inverted_schedule)
 {
-    return raw_aes128_decrypt_block(cipher, inverted_schedule);
+    return aesni_raw_decrypt_block128(cipher, inverted_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes128cbc_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 cipher = raw_aes128_encrypt_block(_mm_xor_si128(plain, init_vector), key_schedule);
+    AesNI_Block128 cipher = aesni_raw_encrypt_block128(_mm_xor_si128(plain, init_vector), key_schedule);
     *next_init_vector = cipher;
     return cipher;
 }
 
-static __inline AesBlock128 __fastcall aes128cbc_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* inverted_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* inverted_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 plain = _mm_xor_si128(raw_aes128_decrypt_block(cipher, inverted_schedule), init_vector);
+    AesNI_Block128 plain = _mm_xor_si128(aesni_raw_decrypt_block128(cipher, inverted_schedule), init_vector);
     *next_init_vector = cipher;
     return plain;
 }
 
-static __inline AesBlock128 __fastcall aes128cfb_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 cipher = _mm_xor_si128(raw_aes128_encrypt_block(init_vector, key_schedule), plain);
+    AesNI_Block128 cipher = _mm_xor_si128(aesni_raw_encrypt_block128(init_vector, key_schedule), plain);
     *next_init_vector = cipher;
     return cipher;
 }
 
-static __inline AesBlock128 __fastcall aes128cfb_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 plain = _mm_xor_si128(raw_aes128_encrypt_block(init_vector, key_schedule), cipher);
+    AesNI_Block128 plain = _mm_xor_si128(aesni_raw_encrypt_block128(init_vector, key_schedule), cipher);
     *next_init_vector = cipher;
     return plain;
 }
 
-static __inline AesBlock128 __fastcall aes128ofb_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 tmp = raw_aes128_encrypt_block(init_vector, key_schedule);
+    AesNI_Block128 tmp = aesni_raw_encrypt_block128(init_vector, key_schedule);
     *next_init_vector = tmp;
     return _mm_xor_si128(tmp, plain);
 }
 
-static __inline AesBlock128 __fastcall aes128ofb_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 tmp = raw_aes128_encrypt_block(init_vector, key_schedule);
+    AesNI_Block128 tmp = aesni_raw_encrypt_block128(init_vector, key_schedule);
     *next_init_vector = tmp;
     return _mm_xor_si128(tmp, cipher);
 }
 
-static __inline AesBlock128 __fastcall aes128ctr_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
     int counter)
 {
-    init_vector = aes128_le2be(init_vector);
-    init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter));
-    init_vector = aes128_be2le(init_vector);
-    return _mm_xor_si128(plain, raw_aes128_encrypt_block(init_vector, key_schedule));
+    init_vector = aesni_le2be128(init_vector);
+    init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter));
+    init_vector = aesni_be2le128(init_vector);
+    return _mm_xor_si128(plain, aesni_raw_encrypt_block128(init_vector, key_schedule));
 }
 
-static __inline AesBlock128 __fastcall aes128ctr_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* key_schedule,
-    AesBlock128 init_vector,
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_Block128 init_vector,
     int counter)
 {
-    init_vector = aes128_le2be(init_vector);
-    init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter));
-    init_vector = aes128_be2le(init_vector);
-    return _mm_xor_si128(cipher, raw_aes128_encrypt_block(init_vector, key_schedule));
+    init_vector = aesni_le2be128(init_vector);
+    init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter));
+    init_vector = aesni_be2le128(init_vector);
+    return _mm_xor_si128(cipher, aesni_raw_encrypt_block128(init_vector, key_schedule));
 }
 
-static __inline void __fastcall aes192_expand_key_schedule(
-    AesBlock192* key,
-    Aes192KeySchedule* key_schedule)
+static __inline void __fastcall aesni_expand_key_schedule192(
+    AesNI_Block192* key,
+    AesNI_KeySchedule192* key_schedule)
 {
-    raw_aes192_expand_key_schedule(key->lo, key->hi, key_schedule);
+    aesni_raw_expand_key_schedule192(key->lo, key->hi, key_schedule);
 }
 
-static __inline void __fastcall aes192_invert_key_schedule(
-    Aes192KeySchedule* key_schedule,
-    Aes192KeySchedule* inverted_schedule)
+static __inline void __fastcall aesni_invert_key_schedule192(
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_KeySchedule192* inverted_schedule)
 {
-    raw_aes192_invert_key_schedule(key_schedule, inverted_schedule);
+    aesni_raw_invert_key_schedule192(key_schedule, inverted_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes192ecb_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule)
 {
-    return raw_aes192_encrypt_block(plain, key_schedule);
+    return aesni_raw_encrypt_block192(plain, key_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes192ecb_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* inverted_schedule)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* inverted_schedule)
 {
-    return raw_aes192_decrypt_block(cipher, inverted_schedule);
+    return aesni_raw_decrypt_block192(cipher, inverted_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes192cbc_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 cipher = raw_aes192_encrypt_block(_mm_xor_si128(plain, init_vector), key_schedule);
+    AesNI_Block128 cipher = aesni_raw_encrypt_block192(_mm_xor_si128(plain, init_vector), key_schedule);
     *next_init_vector = cipher;
     return cipher;
 }
 
-static __inline AesBlock128 __fastcall aes192cbc_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* inverted_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* inverted_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 plain = _mm_xor_si128(raw_aes192_decrypt_block(cipher, inverted_schedule), init_vector);
+    AesNI_Block128 plain = _mm_xor_si128(aesni_raw_decrypt_block192(cipher, inverted_schedule), init_vector);
     *next_init_vector = cipher;
     return plain;
 }
 
-static __inline AesBlock128 __fastcall aes192cfb_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 cipher = _mm_xor_si128(raw_aes192_encrypt_block(init_vector, key_schedule), plain);
+    AesNI_Block128 cipher = _mm_xor_si128(aesni_raw_encrypt_block192(init_vector, key_schedule), plain);
     *next_init_vector = cipher;
     return cipher;
 }
 
-static __inline AesBlock128 __fastcall aes192cfb_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 plain = _mm_xor_si128(raw_aes192_encrypt_block(init_vector, key_schedule), cipher);
+    AesNI_Block128 plain = _mm_xor_si128(aesni_raw_encrypt_block192(init_vector, key_schedule), cipher);
     *next_init_vector = cipher;
     return plain;
 }
 
-static __inline AesBlock128 __fastcall aes192ofb_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 tmp = raw_aes192_encrypt_block(init_vector, key_schedule);
+    AesNI_Block128 tmp = aesni_raw_encrypt_block192(init_vector, key_schedule);
     *next_init_vector = tmp;
     return _mm_xor_si128(tmp, plain);
 }
 
-static __inline AesBlock128 __fastcall aes192ofb_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 tmp = raw_aes192_encrypt_block(init_vector, key_schedule);
+    AesNI_Block128 tmp = aesni_raw_encrypt_block192(init_vector, key_schedule);
     *next_init_vector = tmp;
     return _mm_xor_si128(tmp, cipher);
 }
 
-static __inline AesBlock128 __fastcall aes192ctr_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
     int counter)
 {
-    init_vector = aes128_le2be(init_vector);
-    init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter));
-    init_vector = aes128_be2le(init_vector);
-    return _mm_xor_si128(plain, raw_aes192_encrypt_block(init_vector, key_schedule));
+    init_vector = aesni_le2be128(init_vector);
+    init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter));
+    init_vector = aesni_be2le128(init_vector);
+    return _mm_xor_si128(plain, aesni_raw_encrypt_block192(init_vector, key_schedule));
 }
 
-static __inline AesBlock128 __fastcall aes192ctr_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* key_schedule,
-    AesBlock128 init_vector,
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_Block128 init_vector,
     int counter)
 {
-    init_vector = aes128_le2be(init_vector);
-    init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter));
-    init_vector = aes128_be2le(init_vector);
-    return _mm_xor_si128(cipher, raw_aes192_encrypt_block(init_vector, key_schedule));
+    init_vector = aesni_le2be128(init_vector);
+    init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter));
+    init_vector = aesni_be2le128(init_vector);
+    return _mm_xor_si128(cipher, aesni_raw_encrypt_block192(init_vector, key_schedule));
 }
 
-static __inline void __fastcall aes256_expand_key_schedule(
-    AesBlock256* key,
-    Aes256KeySchedule* key_schedule)
+static __inline void __fastcall aesni_expand_key_schedule256(
+    AesNI_Block256* key,
+    AesNI_KeySchedule256* key_schedule)
 {
-    raw_aes256_expand_key_schedule(key->lo, key->hi, key_schedule);
+    aesni_raw_expand_key_schedule256(key->lo, key->hi, key_schedule);
 }
 
-static __inline void __fastcall aes256_invert_key_schedule(
-    Aes256KeySchedule* key_schedule,
-    Aes256KeySchedule* inverted_schedule)
+static __inline void __fastcall aesni_invert_key_schedule256(
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_KeySchedule256* inverted_schedule)
 {
-    raw_aes256_invert_key_schedule(key_schedule, inverted_schedule);
+    aesni_raw_invert_key_schedule256(key_schedule, inverted_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes256ecb_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule)
 {
-    return raw_aes256_encrypt_block(plain, key_schedule);
+    return aesni_raw_encrypt_block256(plain, key_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes256ecb_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* inverted_schedule)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* inverted_schedule)
 {
-    return raw_aes256_decrypt_block(cipher, inverted_schedule);
+    return aesni_raw_decrypt_block256(cipher, inverted_schedule);
 }
 
-static __inline AesBlock128 __fastcall aes256cbc_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 cipher = raw_aes256_encrypt_block(_mm_xor_si128(plain, init_vector), key_schedule);
+    AesNI_Block128 cipher = aesni_raw_encrypt_block256(_mm_xor_si128(plain, init_vector), key_schedule);
     *next_init_vector = cipher;
     return cipher;
 }
 
-static __inline AesBlock128 __fastcall aes256cbc_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* inverted_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* inverted_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 plain = _mm_xor_si128(raw_aes256_decrypt_block(cipher, inverted_schedule), init_vector);
+    AesNI_Block128 plain = _mm_xor_si128(aesni_raw_decrypt_block256(cipher, inverted_schedule), init_vector);
     *next_init_vector = cipher;
     return plain;
 }
 
-static __inline AesBlock128 __fastcall aes256cfb_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 cipher = _mm_xor_si128(raw_aes256_encrypt_block(init_vector, key_schedule), plain);
+    AesNI_Block128 cipher = _mm_xor_si128(aesni_raw_encrypt_block256(init_vector, key_schedule), plain);
     *next_init_vector = cipher;
     return cipher;
 }
 
-static __inline AesBlock128 __fastcall aes256cfb_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 plain = _mm_xor_si128(raw_aes256_encrypt_block(init_vector, key_schedule), cipher);
+    AesNI_Block128 plain = _mm_xor_si128(aesni_raw_encrypt_block256(init_vector, key_schedule), cipher);
     *next_init_vector = cipher;
     return plain;
 }
 
-static __inline AesBlock128 __fastcall aes256ofb_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 tmp = raw_aes256_encrypt_block(init_vector, key_schedule);
+    AesNI_Block128 tmp = aesni_raw_encrypt_block256(init_vector, key_schedule);
     *next_init_vector = tmp;
     return _mm_xor_si128(tmp, plain);
 }
 
-static __inline AesBlock128 __fastcall aes256ofb_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
-    AesBlock128* next_init_vector)
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
+    AesNI_Block128* next_init_vector)
 {
-    AesBlock128 tmp = raw_aes256_encrypt_block(init_vector, key_schedule);
+    AesNI_Block128 tmp = aesni_raw_encrypt_block256(init_vector, key_schedule);
     *next_init_vector = tmp;
     return _mm_xor_si128(tmp, cipher);
 }
 
-static __inline AesBlock128 __fastcall aes256ctr_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
+static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
     int counter)
 {
-    init_vector = aes128_le2be(init_vector);
-    init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter));
-    init_vector = aes128_be2le(init_vector);
-    return _mm_xor_si128(plain, raw_aes256_encrypt_block(init_vector, key_schedule));
+    init_vector = aesni_le2be128(init_vector);
+    init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter));
+    init_vector = aesni_be2le128(init_vector);
+    return _mm_xor_si128(plain, aesni_raw_encrypt_block256(init_vector, key_schedule));
 }
 
-static __inline AesBlock128 __fastcall aes256ctr_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* key_schedule,
-    AesBlock128 init_vector,
+static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_Block128 init_vector,
     int counter)
 {
-    init_vector = aes128_le2be(init_vector);
-    init_vector = _mm_add_epi32(init_vector, make_aes_block128(0, 0, 0, counter));
-    init_vector = aes128_be2le(init_vector);
-    return _mm_xor_si128(cipher, raw_aes256_encrypt_block(init_vector, key_schedule));
+    init_vector = aesni_le2be128(init_vector);
+    init_vector = _mm_add_epi32(init_vector, aesni_make_block128(0, 0, 0, counter));
+    init_vector = aesni_be2le128(init_vector);
+    return _mm_xor_si128(cipher, aesni_raw_encrypt_block256(init_vector, key_schedule));
 }
 
 #ifdef __cplusplus
diff --git a/include/aesni/buffer.h b/include/aesni/buffer.h
index c0a3805..daafc3e 100644
--- a/include/aesni/buffer.h
+++ b/include/aesni/buffer.h
@@ -8,23 +8,23 @@
 
 #pragma once
 
-#include <stdio.h>
+#include <stdlib.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-size_t aes128ecb_encrypt_buffer(
-    const unsigned char* src,
+size_t aesni_encrypt_buffer_ecb128(
+    const void* src,
     size_t src_size,
-    unsigned char* dest,
-    Aes128KeySchedule* key_schedule);
-size_t aes128ecb_decrypt_buffer(
-    const unsigned char* src,
+    void* dest,
+    AesNI_KeySchedule128* key_schedule);
+size_t aesni_decrypt_buffer_ecb128(
+    const void* src,
     size_t src_size,
-    unsigned char* dest,
-    Aes128KeySchedule* inverted_schedule);
+    void* dest,
+    AesNI_KeySchedule128* inverted_schedule);
 
 #ifdef __cplusplus
 }
diff --git a/include/aesni/data.h b/include/aesni/data.h
index d104f9d..de03110 100644
--- a/include/aesni/data.h
+++ b/include/aesni/data.h
@@ -16,146 +16,146 @@ extern "C"
 {
 #endif
 
-typedef __m128i AesBlock128;
+typedef __m128i AesNI_Block128;
 
-static __inline AesBlock128 load_aes_block128(const unsigned char* src)
+static __inline AesNI_Block128 aesni_load_block128(const void* src)
 {
-    return _mm_loadu_si128((AesBlock128*) src);
+    return _mm_loadu_si128((AesNI_Block128*) src);
 }
 
-static __inline void __fastcall store_aes_block128(AesBlock128 block,
-                                                   unsigned char* dest)
+static __inline void __fastcall aesni_store_block128(
+    void* dest, AesNI_Block128 block)
 {
-    _mm_storeu_si128((AesBlock128*) dest, block);
+    _mm_storeu_si128((AesNI_Block128*) dest, block);
 }
 
-static __inline AesBlock128 __fastcall make_aes_block128(int hi3, int hi2, int lo1, int lo0)
+static __inline AesNI_Block128 __fastcall aesni_make_block128(int hi3, int hi2, int lo1, int lo0)
 {
     return _mm_set_epi32(hi3, hi2, lo1, lo0);
 }
 
 typedef struct
 {
-    AesBlock128 hi;
-    AesBlock128 lo;
+    AesNI_Block128 hi;
+    AesNI_Block128 lo;
 }
-AesBlock192;
+AesNI_Block192;
 
-static __inline AesBlock192 __fastcall make_aes_block192(int hi5, int hi4, int lo3, int lo2, int lo1, int lo0)
+static __inline AesNI_Block192 __fastcall aesni_make_block192(int hi5, int hi4, int lo3, int lo2, int lo1, int lo0)
 {
-    AesBlock192 result;
-    result.hi = make_aes_block128(  0,   0, hi5, hi4);
-    result.lo = make_aes_block128(lo3, lo2, lo1, lo0);
+    AesNI_Block192 result;
+    result.hi = aesni_make_block128(  0,   0, hi5, hi4);
+    result.lo = aesni_make_block128(lo3, lo2, lo1, lo0);
     return result;
 }
 
 typedef struct
 {
-    AesBlock128 hi;
-    AesBlock128 lo;
+    AesNI_Block128 hi;
+    AesNI_Block128 lo;
 }
-AesBlock256;
+AesNI_Block256;
 
-static __inline AesBlock256 __fastcall make_aes_block256(int hi7, int hi6, int hi5, int hi4, int lo3, int lo2, int lo1, int lo0)
+static __inline AesNI_Block256 __fastcall aesni_make_block256(int hi7, int hi6, int hi5, int hi4, int lo3, int lo2, int lo1, int lo0)
 {
-    AesBlock256 result;
-    result.hi = make_aes_block128(hi7, hi6, hi5, hi4);
-    result.lo = make_aes_block128(lo3, lo2, lo1, lo0);
+    AesNI_Block256 result;
+    result.hi = aesni_make_block128(hi7, hi6, hi5, hi4);
+    result.lo = aesni_make_block128(lo3, lo2, lo1, lo0);
     return result;
 }
 
 typedef struct
 {
-    AesBlock128 keys[11];
+    AesNI_Block128 keys[11];
 }
-Aes128KeySchedule;
+AesNI_KeySchedule128;
 
 typedef struct
 {
-    AesBlock128 keys[13];
+    AesNI_Block128 keys[13];
 }
-Aes192KeySchedule;
+AesNI_KeySchedule192;
 
 typedef struct
 {
-    AesBlock128 keys[15];
+    AesNI_Block128 keys[15];
 }
-Aes256KeySchedule;
+AesNI_KeySchedule256;
 
-static __inline AesBlock128 __fastcall aes128_reverse_byte_order(AesBlock128 block)
+static __inline AesNI_Block128 __fastcall aesni_reverse_byte_order128(AesNI_Block128 block)
 {
-    return _mm_shuffle_epi8(block, make_aes_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f));
+    return _mm_shuffle_epi8(block, aesni_make_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f));
 }
 
-static __inline AesBlock128 __fastcall aes128_le2be(AesBlock128 block)
+static __inline AesNI_Block128 __fastcall aesni_le2be128(AesNI_Block128 block)
 {
-    return aes128_reverse_byte_order(block);
+    return aesni_reverse_byte_order128(block);
 }
 
-static __inline AesBlock128 __fastcall aes128_be2le(AesBlock128 block)
+static __inline AesNI_Block128 __fastcall aesni_be2le128(AesNI_Block128 block)
 {
-    return aes128_reverse_byte_order(block);
+    return aesni_reverse_byte_order128(block);
 }
 
-typedef struct { char str[33]; } AesBlockString128;
-typedef struct { char str[49]; } AesBlockString192;
-typedef struct { char str[65]; } AesBlockString256;
+typedef struct { char str[33]; } AesNI_BlockString128;
+typedef struct { char str[49]; } AesNI_BlockString192;
+typedef struct { char str[65]; } AesNI_BlockString256;
 
-AesBlockString128 format_aes_block128(AesBlock128*);
-AesBlockString192 format_aes_block192(AesBlock192*);
-AesBlockString256 format_aes_block256(AesBlock256*);
+AesNI_BlockString128 aesni_format_block128(AesNI_Block128*);
+AesNI_BlockString192 aesni_format_block192(AesNI_Block192*);
+AesNI_BlockString256 aesni_format_block256(AesNI_Block256*);
 
-AesBlockString128 format_aes_block128_le(AesBlock128*);
-AesBlockString192 format_aes_block192_le(AesBlock192*);
-AesBlockString256 format_aes_block256_le(AesBlock256*);
+AesNI_BlockString128 aesni_format_block128_le(AesNI_Block128*);
+AesNI_BlockString192 aesni_format_block192_le(AesNI_Block192*);
+AesNI_BlockString256 aesni_format_block256_le(AesNI_Block256*);
 
-AesBlockString128 format_aes_block128_be(AesBlock128*);
-AesBlockString192 format_aes_block192_be(AesBlock192*);
-AesBlockString256 format_aes_block256_be(AesBlock256*);
+AesNI_BlockString128 aesni_format_block128_be(AesNI_Block128*);
+AesNI_BlockString192 aesni_format_block192_be(AesNI_Block192*);
+AesNI_BlockString256 aesni_format_block256_be(AesNI_Block256*);
 
-typedef struct { char str[49]; } AesBlockMatrixString128;
-typedef struct { char str[73]; } AesBlockMatrixString192;
-typedef struct { char str[97]; } AesBlockMatrixString256;
+typedef struct { char str[49]; } AesNI_BlockMatrixString128;
+typedef struct { char str[73]; } AesNI_BlockMatrixString192;
+typedef struct { char str[97]; } AesNI_BlockMatrixString256;
 
-AesBlockMatrixString128 format_aes_block128_as_matrix(AesBlock128*);
-AesBlockMatrixString192 format_aes_block192_as_matrix(AesBlock192*);
-AesBlockMatrixString256 format_aes_block256_as_matrix(AesBlock256*);
+AesNI_BlockMatrixString128 aesni_format_block128_as_matrix(AesNI_Block128*);
+AesNI_BlockMatrixString192 aesni_format_block192_as_matrix(AesNI_Block192*);
+AesNI_BlockMatrixString256 aesni_format_block256_as_matrix(AesNI_Block256*);
 
-AesBlockMatrixString128 format_aes_block128_be_as_matrix(AesBlock128*);
-AesBlockMatrixString192 format_aes_block192_be_as_matrix(AesBlock192*);
-AesBlockMatrixString256 format_aes_block256_be_as_matrix(AesBlock256*);
+AesNI_BlockMatrixString128 aesni_format_block128_be_as_matrix(AesNI_Block128*);
+AesNI_BlockMatrixString192 aesni_format_block192_be_as_matrix(AesNI_Block192*);
+AesNI_BlockMatrixString256 aesni_format_block256_be_as_matrix(AesNI_Block256*);
 
-void print_aes_block128(AesBlock128*);
-void print_aes_block192(AesBlock192*);
-void print_aes_block256(AesBlock256*);
+void aesni_print_block128(AesNI_Block128*);
+void aesni_print_block192(AesNI_Block192*);
+void aesni_print_block256(AesNI_Block256*);
 
-void print_aes_block128_le(AesBlock128*);
-void print_aes_block192_le(AesBlock192*);
-void print_aes_block256_le(AesBlock256*);
+void aesni_print_block128_le(AesNI_Block128*);
+void aesni_print_block192_le(AesNI_Block192*);
+void aesni_print_block256_le(AesNI_Block256*);
 
-void print_aes_block128_be(AesBlock128*);
-void print_aes_block192_be(AesBlock192*);
-void print_aes_block256_be(AesBlock256*);
+void aesni_print_block128_be(AesNI_Block128*);
+void aesni_print_block192_be(AesNI_Block192*);
+void aesni_print_block256_be(AesNI_Block256*);
 
-void print_aes_block128_as_matrix(AesBlock128*);
-void print_aes_block192_as_matrix(AesBlock192*);
-void print_aes_block256_as_matrix(AesBlock256*);
+void aesni_print_block128_as_matrix(AesNI_Block128*);
+void aesni_print_block192_as_matrix(AesNI_Block192*);
+void aesni_print_block256_as_matrix(AesNI_Block256*);
 
-void print_aes_block128_be_as_matrix(AesBlock128*);
-void print_aes_block192_be_as_matrix(AesBlock192*);
-void print_aes_block256_be_as_matrix(AesBlock256*);
+void aesni_print_block128_be_as_matrix(AesNI_Block128*);
+void aesni_print_block192_be_as_matrix(AesNI_Block192*);
+void aesni_print_block256_be_as_matrix(AesNI_Block256*);
 
-int parse_aes_block128(AesBlock128*, const char*);
-int parse_aes_block192(AesBlock192*, const char*);
-int parse_aes_block256(AesBlock256*, const char*);
+int aesni_parse_block128(AesNI_Block128*, const char*);
+int aesni_parse_block192(AesNI_Block192*, const char*);
+int aesni_parse_block256(AesNI_Block256*, const char*);
 
-int parse_aes_block128_le(AesBlock128*, const char*);
-int parse_aes_block192_le(AesBlock192*, const char*);
-int parse_aes_block256_le(AesBlock256*, const char*);
+int aesni_parse_block128_le(AesNI_Block128*, const char*);
+int aesni_parse_block192_le(AesNI_Block192*, const char*);
+int aesni_parse_block256_le(AesNI_Block256*, const char*);
 
-int parse_aes_block128_be(AesBlock128*, const char*);
-int parse_aes_block192_be(AesBlock192*, const char*);
-int parse_aes_block256_be(AesBlock256*, const char*);
+int aesni_parse_block128_be(AesNI_Block128*, const char*);
+int aesni_parse_block192_be(AesNI_Block192*, const char*);
+int aesni_parse_block256_be(AesNI_Block256*, const char*);
 
 #ifdef __cplusplus
 }
diff --git a/include/aesni/raw.h b/include/aesni/raw.h
index 562ac0c..4432231 100644
--- a/include/aesni/raw.h
+++ b/include/aesni/raw.h
@@ -15,49 +15,49 @@ extern "C"
 {
 #endif
 
-void __fastcall raw_aes128_expand_key_schedule(
-    AesBlock128 key,
-    Aes128KeySchedule* key_schedule);
-void __fastcall raw_aes128_invert_key_schedule(
-    Aes128KeySchedule* key_schedule,
-    Aes128KeySchedule* inverted_schedule);
+void __fastcall aesni_raw_expand_key_schedule128(
+    AesNI_Block128 key,
+    AesNI_KeySchedule128* key_schedule);
+void __fastcall aesni_raw_invert_key_schedule128(
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_KeySchedule128* inverted_schedule);
 
-AesBlock128 __fastcall raw_aes128_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule);
-AesBlock128 __fastcall raw_aes128_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* inverted_schedule);
+AesNI_Block128 __fastcall aesni_raw_encrypt_block128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule);
+AesNI_Block128 __fastcall aesni_raw_decrypt_block128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* inverted_schedule);
 
-void __fastcall raw_aes192_expand_key_schedule(
-    AesBlock128 key_lo,
-    AesBlock128 key_hi,
-    Aes192KeySchedule* key_schedule);
-void __fastcall raw_aes192_invert_key_schedule(
-    Aes192KeySchedule* key_schedule,
-    Aes192KeySchedule* inverted_schedule);
+void __fastcall aesni_raw_expand_key_schedule192(
+    AesNI_Block128 key_lo,
+    AesNI_Block128 key_hi,
+    AesNI_KeySchedule192* key_schedule);
+void __fastcall aesni_raw_invert_key_schedule192(
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_KeySchedule192* inverted_schedule);
 
-AesBlock128 __fastcall raw_aes192_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule);
-AesBlock128 __fastcall raw_aes192_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* inverted_schedule);
+AesNI_Block128 __fastcall aesni_raw_encrypt_block192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule);
+AesNI_Block128 __fastcall aesni_raw_decrypt_block192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* inverted_schedule);
 
-void __fastcall raw_aes256_expand_key_schedule(
-    AesBlock128 key_lo,
-    AesBlock128 key_hi,
-    Aes256KeySchedule* key_schedule);
-void __fastcall raw_aes256_invert_key_schedule(
-    Aes256KeySchedule* key_schedule,
-    Aes256KeySchedule* inverted_schedule);
+void __fastcall aesni_raw_expand_key_schedule256(
+    AesNI_Block128 key_lo,
+    AesNI_Block128 key_hi,
+    AesNI_KeySchedule256* key_schedule);
+void __fastcall aesni_raw_invert_key_schedule256(
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_KeySchedule256* inverted_schedule);
 
-AesBlock128 __fastcall raw_aes256_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule);
-AesBlock128 __fastcall raw_aes256_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* inverted_schedule);
+AesNI_Block128 __fastcall aesni_raw_encrypt_block256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule);
+AesNI_Block128 __fastcall aesni_raw_decrypt_block256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* inverted_schedule);
 
 #ifdef __cplusplus
 }
diff --git a/src/asm/aes128.asm b/src/asm/aes128.asm
index 874f876..4f88f09 100644
--- a/src/asm/aes128.asm
+++ b/src/asm/aes128.asm
@@ -8,7 +8,7 @@
 
 .code
 
-@raw_aes128_encrypt_block@20 proc
+@aesni_raw_encrypt_block128@20 proc
     pxor xmm0, [ecx]
     aesenc xmm0, [ecx + 10h]
     aesenc xmm0, [ecx + 20h]
@@ -21,9 +21,9 @@
     aesenc xmm0, [ecx + 90h]
     aesenclast xmm0, [ecx + 0A0h]
     ret
-@raw_aes128_encrypt_block@20 endp
+@aesni_raw_encrypt_block128@20 endp
 
-@raw_aes128_decrypt_block@20 proc
+@aesni_raw_decrypt_block128@20 proc
     pxor xmm0, [ecx]
     aesdec xmm0, [ecx + 10h]
     aesdec xmm0, [ecx + 20h]
@@ -36,9 +36,9 @@
     aesdec xmm0, [ecx + 90h]
     aesdeclast xmm0, [ecx + 0A0h]
     ret
-@raw_aes128_decrypt_block@20 endp
+@aesni_raw_decrypt_block128@20 endp
 
-@raw_aes128_expand_key_schedule@20 proc
+@aesni_raw_expand_key_schedule128@20 proc
     ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block.
     ; Words are denoted by `w[N]`.
     ;
@@ -165,9 +165,9 @@ aes128_keygen_assist:
     add ecx, 10h          ; ecx = &w[i+8]
 
     ret
-@raw_aes128_expand_key_schedule@20 endp
+@aesni_raw_expand_key_schedule128@20 endp
 
-@raw_aes128_invert_key_schedule@8 proc
+@aesni_raw_invert_key_schedule128@8 proc
     movdqa xmm5, [ecx]
     movdqa xmm4, [ecx + 0A0h]
     movdqa [edx], xmm4
@@ -197,6 +197,6 @@ aes128_keygen_assist:
     movdqa [edx + 50h], xmm5
 
     ret
-@raw_aes128_invert_key_schedule@8 endp
+@aesni_raw_invert_key_schedule128@8 endp
 
 end
diff --git a/src/asm/aes192.asm b/src/asm/aes192.asm
index adbc690..e045910 100644
--- a/src/asm/aes192.asm
+++ b/src/asm/aes192.asm
@@ -8,7 +8,7 @@
 
 .code
 
-@raw_aes192_encrypt_block@20 proc
+@aesni_raw_encrypt_block192@20 proc
     pxor xmm0, [ecx]
     aesenc xmm0, [ecx + 10h]
     aesenc xmm0, [ecx + 20h]
@@ -23,9 +23,9 @@
     aesenc xmm0, [ecx + 0B0h]
     aesenclast xmm0, [ecx + 0C0h]
     ret
-@raw_aes192_encrypt_block@20 endp
+@aesni_raw_encrypt_block192@20 endp
 
-@raw_aes192_decrypt_block@20 proc
+@aesni_raw_decrypt_block192@20 proc
     pxor xmm0, [ecx]
     aesdec xmm0, [ecx + 10h]
     aesdec xmm0, [ecx + 20h]
@@ -40,9 +40,9 @@
     aesdec xmm0, [ecx + 0B0h]
     aesdeclast xmm0, [ecx + 0C0h]
     ret
-@raw_aes192_decrypt_block@20 endp
+@aesni_raw_decrypt_block192@20 endp
 
-@raw_aes192_expand_key_schedule@36 proc
+@aesni_raw_expand_key_schedule192@36 proc
     ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block.
     ; Words are denoted by `w[N]`.
     ;
@@ -206,9 +206,9 @@ aes192_keygen_assist:
                                ; xmm1[31:0]  == w[i+10] == RotWord(SubWord(w[i+5]))^Rcon^w[i+4]^w[i+3]^w[i+2]^w[i+1]^w[i]
 
     ret
-@raw_aes192_expand_key_schedule@36 endp
+@aesni_raw_expand_key_schedule192@36 endp
 
-@raw_aes192_invert_key_schedule@8 proc
+@aesni_raw_invert_key_schedule192@8 proc
     movdqa xmm5, [ecx]
     movdqa xmm4, [ecx + 0C0h]
     movdqa [edx], xmm4
@@ -243,6 +243,6 @@ aes192_keygen_assist:
     movdqa [edx + 60h], xmm5
 
     ret
-@raw_aes192_invert_key_schedule@8 endp
+@aesni_raw_invert_key_schedule192@8 endp
 
 end
diff --git a/src/asm/aes256.asm b/src/asm/aes256.asm
index 479b0f5..285cf69 100644
--- a/src/asm/aes256.asm
+++ b/src/asm/aes256.asm
@@ -8,7 +8,7 @@
 
 .code
 
-@raw_aes256_encrypt_block@20 proc
+@aesni_raw_encrypt_block256@20 proc
     pxor xmm0, [ecx]
     aesenc xmm0, [ecx + 10h]
     aesenc xmm0, [ecx + 20h]
@@ -25,9 +25,9 @@
     aesenc xmm0, [ecx + 0D0h]
     aesenclast xmm0, [ecx + 0E0h]
     ret
-@raw_aes256_encrypt_block@20 endp
+@aesni_raw_encrypt_block256@20 endp
 
-@raw_aes256_decrypt_block@20 proc
+@aesni_raw_decrypt_block256@20 proc
     pxor xmm0, [ecx]
     aesdec xmm0, [ecx + 10h]
     aesdec xmm0, [ecx + 20h]
@@ -44,9 +44,9 @@
     aesdec xmm0, [ecx + 0D0h]
     aesdeclast xmm0, [ecx + 0E0h]
     ret
-@raw_aes256_decrypt_block@20 endp
+@aesni_raw_decrypt_block256@20 endp
 
-@raw_aes256_expand_key_schedule@36 proc
+@aesni_raw_expand_key_schedule256@36 proc
     ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block.
     ; Words are denoted by `w[N]`.
     ;
@@ -239,9 +239,9 @@ aes256_keygen_assist:
     pxor xmm0, xmm1
 
     ret
-@raw_aes256_expand_key_schedule@36 endp
+@aesni_raw_expand_key_schedule256@36 endp
 
-@raw_aes256_invert_key_schedule@8 proc
+@aesni_raw_invert_key_schedule256@8 proc
     movdqa xmm5, [ecx]
     movdqa xmm4, [ecx + 0E0h]
     movdqa [edx], xmm4
@@ -281,6 +281,6 @@ aes256_keygen_assist:
     movdqa [edx + 70h], xmm5
 
     ret
-@raw_aes256_invert_key_schedule@8 endp
+@aesni_raw_invert_key_schedule256@8 endp
 
 end
diff --git a/src/buffer.c b/src/buffer.c
index ff14f18..b4896f7 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -13,11 +13,11 @@
 
 static unsigned char FULL_BLOCK_PADDING[16] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 };
 
-size_t aes128ecb_encrypt_buffer(
-    const unsigned char* src,
+size_t aesni_encrypt_buffer_ecb128(
+    const void* src,
     size_t src_size,
-    unsigned char* dest,
-    Aes128KeySchedule* key_schedule)
+    void* dest,
+    AesNI_KeySchedule128* key_schedule)
 {
     size_t rem_size = src_size % 16;
     size_t padding_size = 16 - rem_size;
@@ -28,11 +28,11 @@ size_t aes128ecb_encrypt_buffer(
 
     size_t src_len = src_size / 16;
 
-    for (size_t i = 0; i < src_len; ++i, src += 16, dest += 16)
+    for (size_t i = 0; i < src_len; ++i, (char*) src += 16, (char*) dest += 16)
     {
-        AesBlock128 plaintext = load_aes_block128(src);
-        AesBlock128 ciphertext = aes128ecb_encrypt_block(plaintext, key_schedule);
-        store_aes_block128(ciphertext, dest);
+        AesNI_Block128 plaintext = aesni_load_block128(src);
+        AesNI_Block128 ciphertext = aesni_encrypt_block_ecb128(plaintext, key_schedule);
+        aesni_store_block128(dest, ciphertext);
     }
 
     unsigned char padding[16];
@@ -47,9 +47,9 @@ size_t aes128ecb_encrypt_buffer(
         memset(padding + rem_size, padding_size, padding_size);
     }
 
-    AesBlock128 plaintext = load_aes_block128(padding);
-    AesBlock128 ciphertext = aes128ecb_encrypt_block(plaintext, key_schedule);
-    store_aes_block128(ciphertext, dest);
+    AesNI_Block128 plaintext = aesni_load_block128(padding);
+    AesNI_Block128 ciphertext = aesni_encrypt_block_ecb128(plaintext, key_schedule);
+    aesni_store_block128(dest, ciphertext);
 
     return dest_size;
 }
@@ -66,11 +66,11 @@ static unsigned char get_padding_size(const unsigned char* padding)
     return padding[15];
 }
 
-size_t aes128ecb_decrypt_buffer(
-    const unsigned char* src,
+size_t aesni_decrypt_buffer_ecb128(
+    const void* src,
     size_t src_size,
-    unsigned char* dest,
-    Aes128KeySchedule* inverted_schedule)
+    void* dest,
+    AesNI_KeySchedule128* inverted_schedule)
 {
     size_t dest_size = src_size;
 
@@ -79,17 +79,17 @@ size_t aes128ecb_decrypt_buffer(
 
     size_t src_len = src_size / 16;
 
-    for (size_t i = 0; i < src_len - 1; ++i, src += 16, dest += 16)
+    for (size_t i = 0; i < src_len - 1; ++i, (char*) src += 16, (char*) dest += 16)
     {
-        AesBlock128 ciphertext = load_aes_block128(src);
-        AesBlock128 plaintext = aes128ecb_decrypt_block(ciphertext, inverted_schedule);
-        store_aes_block128(plaintext, dest);
+        AesNI_Block128 ciphertext = aesni_load_block128(src);
+        AesNI_Block128 plaintext = aesni_decrypt_block_ecb128(ciphertext, inverted_schedule);
+        aesni_store_block128(dest, plaintext);
     }
 
-    AesBlock128 ciphertext = load_aes_block128(src);
-    AesBlock128 plaintext = aes128ecb_decrypt_block(ciphertext, inverted_schedule);
+    AesNI_Block128 ciphertext = aesni_load_block128(src);
+    AesNI_Block128 plaintext = aesni_decrypt_block_ecb128(ciphertext, inverted_schedule);
     unsigned char padding[16];
-    store_aes_block128(plaintext, padding);
+    aesni_store_block128(padding, plaintext);
 
     unsigned char padding_size = get_padding_size(padding);
 
diff --git a/src/c/aes128.c b/src/c/aes128.c
index d4c609d..ac1b4f5 100644
--- a/src/c/aes128.c
+++ b/src/c/aes128.c
@@ -11,9 +11,9 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AesBlock128 __fastcall raw_aes128_encrypt_block(
-    AesBlock128 plain,
-    Aes128KeySchedule* key_schedule)
+AesNI_Block128 __fastcall aesni_raw_encrypt_block128(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule128* key_schedule)
 {
     plain = _mm_xor_si128(plain, key_schedule->keys[0]);
     plain = _mm_aesenc_si128(plain, key_schedule->keys[1]);
@@ -28,9 +28,9 @@ AesBlock128 __fastcall raw_aes128_encrypt_block(
     return _mm_aesenclast_si128(plain, key_schedule->keys[10]);
 }
 
-AesBlock128 __fastcall raw_aes128_decrypt_block(
-    AesBlock128 cipher,
-    Aes128KeySchedule* inverted_schedule)
+AesNI_Block128 __fastcall aesni_raw_decrypt_block128(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule128* inverted_schedule)
 {
     cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]);
     cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]);
@@ -45,11 +45,11 @@ AesBlock128 __fastcall raw_aes128_decrypt_block(
     return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[10]);
 }
 
-static AesBlock128 __fastcall aes128_keygen_assist(
-    AesBlock128 prev,
-    AesBlock128 hwgen)
+static AesNI_Block128 __fastcall aes128_keygen_assist(
+    AesNI_Block128 prev,
+    AesNI_Block128 hwgen)
 {
-    AesBlock128 tmp = prev;
+    AesNI_Block128 tmp = prev;
 
     tmp = _mm_slli_si128(tmp, 4);
     prev = _mm_xor_si128(prev, tmp);
@@ -64,11 +64,11 @@ static AesBlock128 __fastcall aes128_keygen_assist(
     return prev;
 }
 
-void __fastcall raw_aes128_expand_key_schedule(
-    AesBlock128 key,
-    Aes128KeySchedule* key_schedule)
+void __fastcall aesni_raw_expand_key_schedule128(
+    AesNI_Block128 key,
+    AesNI_KeySchedule128* key_schedule)
 {
-    AesBlock128 prev = key_schedule->keys[0] = key;
+    AesNI_Block128 prev = key_schedule->keys[0] = key;
     prev = key_schedule->keys[1] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01));
     prev = key_schedule->keys[2] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02));
     prev = key_schedule->keys[3] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04));
@@ -81,9 +81,9 @@ void __fastcall raw_aes128_expand_key_schedule(
     prev = key_schedule->keys[10] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36));
 }
 
-void __fastcall raw_aes128_invert_key_schedule(
-    Aes128KeySchedule* key_schedule,
-    Aes128KeySchedule* inverted_schedule)
+void __fastcall aesni_raw_invert_key_schedule128(
+    AesNI_KeySchedule128* key_schedule,
+    AesNI_KeySchedule128* inverted_schedule)
 {
     inverted_schedule->keys[0] = key_schedule->keys[10];
     inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[9]);
diff --git a/src/c/aes192.c b/src/c/aes192.c
index fec8f06..c0d410a 100644
--- a/src/c/aes192.c
+++ b/src/c/aes192.c
@@ -11,9 +11,9 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AesBlock128 __fastcall raw_aes192_encrypt_block(
-    AesBlock128 plain,
-    Aes192KeySchedule* key_schedule)
+AesNI_Block128 __fastcall aesni_raw_encrypt_block192(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule192* key_schedule)
 {
     plain = _mm_xor_si128(plain, key_schedule->keys[0]);
     plain = _mm_aesenc_si128(plain, key_schedule->keys[1]);
@@ -30,9 +30,9 @@ AesBlock128 __fastcall raw_aes192_encrypt_block(
     return _mm_aesenclast_si128(plain, key_schedule->keys[12]);
 }
 
-AesBlock128 __fastcall raw_aes192_decrypt_block(
-    AesBlock128 cipher,
-    Aes192KeySchedule* inverted_schedule)
+AesNI_Block128 __fastcall aesni_raw_decrypt_block192(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule192* inverted_schedule)
 {
     cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]);
     cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]);
@@ -50,11 +50,11 @@ AesBlock128 __fastcall raw_aes192_decrypt_block(
 }
 
 static void __fastcall aes192_keygen_assist(
-    AesBlock128* prev_lo,
-    AesBlock128* prev_hi,
-    AesBlock128 hwgen)
+    AesNI_Block128* prev_lo,
+    AesNI_Block128* prev_hi,
+    AesNI_Block128 hwgen)
 {
-    AesBlock128 tmp = *prev_lo;
+    AesNI_Block128 tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
     *prev_lo = _mm_xor_si128(*prev_lo, tmp);
@@ -74,10 +74,10 @@ static void __fastcall aes192_keygen_assist(
     *prev_hi = _mm_xor_si128(*prev_hi, tmp);
 }
 
-void __fastcall raw_aes192_expand_key_schedule(
-    AesBlock128 key_lo,
-    AesBlock128 key_hi,
-    Aes192KeySchedule* key_schedule)
+void __fastcall aesni_raw_expand_key_schedule192(
+    AesNI_Block128 key_lo,
+    AesNI_Block128 key_hi,
+    AesNI_KeySchedule192* key_schedule)
 {
     key_schedule->keys[0] = key_lo;
     key_schedule->keys[1] = key_hi;
@@ -114,9 +114,9 @@ void __fastcall raw_aes192_expand_key_schedule(
     key_schedule->keys[12] = key_lo;
 }
 
-void __fastcall raw_aes192_invert_key_schedule(
-    Aes192KeySchedule* key_schedule,
-    Aes192KeySchedule* inverted_schedule)
+void __fastcall aesni_raw_invert_key_schedule192(
+    AesNI_KeySchedule192* key_schedule,
+    AesNI_KeySchedule192* inverted_schedule)
 {
     inverted_schedule->keys[0] = key_schedule->keys[12];
     inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[11]);
diff --git a/src/c/aes256.c b/src/c/aes256.c
index be4f783..a9042c6 100644
--- a/src/c/aes256.c
+++ b/src/c/aes256.c
@@ -11,9 +11,9 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AesBlock128 __fastcall raw_aes256_encrypt_block(
-    AesBlock128 plain,
-    Aes256KeySchedule* key_schedule)
+AesNI_Block128 __fastcall aesni_raw_encrypt_block256(
+    AesNI_Block128 plain,
+    AesNI_KeySchedule256* key_schedule)
 {
     plain = _mm_xor_si128(plain, key_schedule->keys[0]);
     plain = _mm_aesenc_si128(plain, key_schedule->keys[1]);
@@ -32,9 +32,9 @@ AesBlock128 __fastcall raw_aes256_encrypt_block(
     return _mm_aesenclast_si128(plain, key_schedule->keys[14]);
 }
 
-AesBlock128 __fastcall raw_aes256_decrypt_block(
-    AesBlock128 cipher,
-    Aes256KeySchedule* inverted_schedule)
+AesNI_Block128 __fastcall aesni_raw_decrypt_block256(
+    AesNI_Block128 cipher,
+    AesNI_KeySchedule256* inverted_schedule)
 {
     cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]);
     cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]);
@@ -53,12 +53,12 @@ AesBlock128 __fastcall raw_aes256_decrypt_block(
     return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[14]);
 }
 
-static AesBlock128 __fastcall aes256_keygen_assist(
-    AesBlock128* prev_lo,
-    AesBlock128* prev_hi,
-    AesBlock128 hwgen)
+static AesNI_Block128 __fastcall aes256_keygen_assist(
+    AesNI_Block128* prev_lo,
+    AesNI_Block128* prev_hi,
+    AesNI_Block128 hwgen)
 {
-    AesBlock128 tmp = *prev_lo;
+    AesNI_Block128 tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
     *prev_lo = _mm_xor_si128(*prev_lo, tmp);
@@ -76,13 +76,13 @@ static AesBlock128 __fastcall aes256_keygen_assist(
     return *prev_hi;
 }
 
-void __fastcall raw_aes256_expand_key_schedule(
-    AesBlock128 key_lo,
-    AesBlock128 key_hi,
-    Aes256KeySchedule* key_schedule)
+void __fastcall aesni_raw_expand_key_schedule256(
+    AesNI_Block128 key_lo,
+    AesNI_Block128 key_hi,
+    AesNI_KeySchedule256* key_schedule)
 {
-    AesBlock128 prev_lo, prev_hi;
-    AesBlock128 hwgen;
+    AesNI_Block128 prev_lo, prev_hi;
+    AesNI_Block128 hwgen;
 
     prev_lo = key_schedule->keys[0] = key_lo;
     prev_hi = key_schedule->keys[1] = key_hi;
@@ -140,9 +140,9 @@ void __fastcall raw_aes256_expand_key_schedule(
     key_schedule->keys[14] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen);
 }
 
-void __fastcall raw_aes256_invert_key_schedule(
-    Aes256KeySchedule* key_schedule,
-    Aes256KeySchedule* inverted_schedule)
+void __fastcall aesni_raw_invert_key_schedule256(
+    AesNI_KeySchedule256* key_schedule,
+    AesNI_KeySchedule256* inverted_schedule)
 {
     inverted_schedule->keys[0] = key_schedule->keys[14];
     inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[13]);
diff --git a/src/common.c b/src/common.c
index c2e7530..e8d6e5b 100644
--- a/src/common.c
+++ b/src/common.c
@@ -13,36 +13,36 @@
 #include <stdio.h>
 #include <string.h>
 
-AesBlockString128 format_aes_block128(AesBlock128* block)
+AesNI_BlockString128 aesni_format_block128(AesNI_Block128* block)
 {
 #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO
-    return format_aes_block128_le(block);
+    return aesni_format_block128_le(block);
 #else
-    return format_aes_block128_be(block);
+    return aesni_format_block128_be(block);
 #endif
 }
 
-AesBlockString192 format_aes_block192(AesBlock192* block)
+AesNI_BlockString192 aesni_format_block192(AesNI_Block192* block)
 {
 #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO
-    return format_aes_block192_le(block);
+    return aesni_format_block192_le(block);
 #else
-    return format_aes_block192_be(block);
+    return aesni_format_block192_be(block);
 #endif
 }
 
-AesBlockString256 format_aes_block256(AesBlock256* block)
+AesNI_BlockString256 aesni_format_block256(AesNI_Block256* block)
 {
 #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO
-    return format_aes_block256_le(block);
+    return aesni_format_block256_le(block);
 #else
-    return format_aes_block256_be(block);
+    return aesni_format_block256_be(block);
 #endif
 }
 
-AesBlockString128 format_aes_block128_le(AesBlock128* block)
+AesNI_BlockString128 aesni_format_block128_le(AesNI_Block128* block)
 {
-    AesBlockString128 result;
+    AesNI_BlockString128 result;
     char *cursor = result.str;
 
     for (int i = 0; i < 16; ++i, cursor += 2)
@@ -52,9 +52,9 @@ AesBlockString128 format_aes_block128_le(AesBlock128* block)
     return result;
 }
 
-AesBlockString192 format_aes_block192_le(AesBlock192* block)
+AesNI_BlockString192 aesni_format_block192_le(AesNI_Block192* block)
 {
-    AesBlockString192 result;
+    AesNI_BlockString192 result;
     char *cursor = result.str;
 
     for (int i = 0; i < 8; ++i, cursor += 2)
@@ -66,9 +66,9 @@ AesBlockString192 format_aes_block192_le(AesBlock192* block)
     return result;
 }
 
-AesBlockString256 format_aes_block256_le(AesBlock256* block)
+AesNI_BlockString256 aesni_format_block256_le(AesNI_Block256* block)
 {
-    AesBlockString256 result;
+    AesNI_BlockString256 result;
     char *cursor = result.str;
 
     for (int i = 0; i < 16; ++i, cursor += 2)
@@ -80,9 +80,9 @@ AesBlockString256 format_aes_block256_le(AesBlock256* block)
     return result;
 }
 
-AesBlockString128 format_aes_block128_be(AesBlock128* block)
+AesNI_BlockString128 aesni_format_block128_be(AesNI_Block128* block)
 {
-    AesBlockString128 result;
+    AesNI_BlockString128 result;
     char *cursor = result.str;
 
     for (int i = 0; i < 16; ++i, cursor += 2)
@@ -92,9 +92,9 @@ AesBlockString128 format_aes_block128_be(AesBlock128* block)
     return result;
 }
 
-AesBlockString192 format_aes_block192_be(AesBlock192* block)
+AesNI_BlockString192 aesni_format_block192_be(AesNI_Block192* block)
 {
-    AesBlockString192 result;
+    AesNI_BlockString192 result;
     char *cursor = result.str;
 
     for (int i = 0; i < 16; ++i, cursor += 2)
@@ -106,9 +106,9 @@ AesBlockString192 format_aes_block192_be(AesBlock192* block)
     return result;
 }
 
-AesBlockString256 format_aes_block256_be(AesBlock256* block)
+AesNI_BlockString256 aesni_format_block256_be(AesNI_Block256* block)
 {
-    AesBlockString256 result;
+    AesNI_BlockString256 result;
     char *cursor = result.str;
 
     for (int i = 0; i < 16; ++i, cursor += 2)
@@ -120,28 +120,28 @@ AesBlockString256 format_aes_block256_be(AesBlock256* block)
     return result;
 }
 
-AesBlockMatrixString128 format_aes_block128_as_matrix(AesBlock128* block)
+AesNI_BlockMatrixString128 aesni_format_block128_as_matrix(AesNI_Block128* block)
 {
-    return format_aes_block128_be_as_matrix(block);
+    return aesni_format_block128_be_as_matrix(block);
 }
 
-AesBlockMatrixString192 format_aes_block192_as_matrix(AesBlock192* block)
+AesNI_BlockMatrixString192 aesni_format_block192_as_matrix(AesNI_Block192* block)
 {
-    return format_aes_block192_be_as_matrix(block);
+    return aesni_format_block192_be_as_matrix(block);
 }
 
-AesBlockMatrixString256 format_aes_block256_as_matrix(AesBlock256* block)
+AesNI_BlockMatrixString256 aesni_format_block256_as_matrix(AesNI_Block256* block)
 {
-    return format_aes_block256_be_as_matrix(block);
+    return aesni_format_block256_be_as_matrix(block);
 }
 
-AesBlockMatrixString128 format_aes_block128_be_as_matrix(AesBlock128* block)
+AesNI_BlockMatrixString128 aesni_format_block128_be_as_matrix(AesNI_Block128* block)
 {
     __declspec(align(16)) unsigned char bytes[4][4];
-    AesBlockMatrixString128 result;
+    AesNI_BlockMatrixString128 result;
     char* cursor = result.str;
 
-    _mm_store_si128((AesBlock128*) bytes, *block);
+    _mm_store_si128((AesNI_Block128*) bytes, *block);
 
     for (int i = 0; i < 4; ++i, cursor += 3)
     {
@@ -154,14 +154,14 @@ AesBlockMatrixString128 format_aes_block128_be_as_matrix(AesBlock128* block)
     return result;
 }
 
-AesBlockMatrixString192 format_aes_block192_be_as_matrix(AesBlock192* block)
+AesNI_BlockMatrixString192 aesni_format_block192_be_as_matrix(AesNI_Block192* block)
 {
     __declspec(align(16)) unsigned char bytes[8][4];
-    AesBlockMatrixString192 result;
+    AesNI_BlockMatrixString192 result;
     char* cursor = result.str;
 
-    _mm_store_si128((AesBlock128*) bytes, block->lo);
-    _mm_store_si128((AesBlock128*) bytes + 1, block->hi);
+    _mm_store_si128((AesNI_Block128*) bytes, block->lo);
+    _mm_store_si128((AesNI_Block128*) bytes + 1, block->hi);
 
     for (int i = 0; i < 4; ++i, cursor += 3)
     {
@@ -174,14 +174,14 @@ AesBlockMatrixString192 format_aes_block192_be_as_matrix(AesBlock192* block)
     return result;
 }
 
-AesBlockMatrixString256 format_aes_block256_be_as_matrix(AesBlock256* block)
+AesNI_BlockMatrixString256 aesni_format_block256_be_as_matrix(AesNI_Block256* block)
 {
     __declspec(align(16)) unsigned char bytes[8][4];
-    AesBlockMatrixString256 result;
+    AesNI_BlockMatrixString256 result;
     char* cursor = result.str;
 
-    _mm_store_si128((AesBlock128*) bytes, block->lo);
-    _mm_store_si128((AesBlock128*) bytes + 1, block->hi);
+    _mm_store_si128((AesNI_Block128*) bytes, block->lo);
+    _mm_store_si128((AesNI_Block128*) bytes + 1, block->hi);
 
     for (int i = 0; i < 4; ++i, cursor += 3)
     {
@@ -194,139 +194,139 @@ AesBlockMatrixString256 format_aes_block256_be_as_matrix(AesBlock256* block)
     return result;
 }
 
-void print_aes_block128(AesBlock128* block)
+void aesni_print_block128(AesNI_Block128* block)
 {
-    printf("%s\n", format_aes_block128(block).str);
+    printf("%s\n", aesni_format_block128(block).str);
 }
 
-void print_aes_block192(AesBlock192* block)
+void aesni_print_block192(AesNI_Block192* block)
 {
-    printf("%s\n", format_aes_block192(block).str);
+    printf("%s\n", aesni_format_block192(block).str);
 }
 
-void print_aes_block256(AesBlock256* block)
+void aesni_print_block256(AesNI_Block256* block)
 {
-    printf("%s\n", format_aes_block256(block).str);
+    printf("%s\n", aesni_format_block256(block).str);
 }
 
-void print_aes_block128_le(AesBlock128* block)
+void aesni_print_block128_le(AesNI_Block128* block)
 {
-    printf("%s\n", format_aes_block128_le(block).str);
+    printf("%s\n", aesni_format_block128_le(block).str);
 }
 
-void print_aes_block192_le(AesBlock192* block)
+void aesni_print_block192_le(AesNI_Block192* block)
 {
-    printf("%s\n", format_aes_block192_le(block).str);
+    printf("%s\n", aesni_format_block192_le(block).str);
 }
 
-void print_aes_block256_le(AesBlock256* block)
+void aesni_print_block256_le(AesNI_Block256* block)
 {
-    printf("%s\n", format_aes_block256_le(block).str);
+    printf("%s\n", aesni_format_block256_le(block).str);
 }
 
-void print_aes_block128_be(AesBlock128* block)
+void aesni_print_block128_be(AesNI_Block128* block)
 {
-    printf("%s\n", format_aes_block128_be(block).str);
+    printf("%s\n", aesni_format_block128_be(block).str);
 }
 
-void print_aes_block192_be(AesBlock192* block)
+void aesni_print_block192_be(AesNI_Block192* block)
 {
-    printf("%s\n", format_aes_block192_be(block).str);
+    printf("%s\n", aesni_format_block192_be(block).str);
 }
 
-void print_aes_block256_be(AesBlock256* block)
+void aesni_print_block256_be(AesNI_Block256* block)
 {
-    printf("%s\n", format_aes_block256_be(block).str);
+    printf("%s\n", aesni_format_block256_be(block).str);
 }
 
-void print_aes_block128_as_matrix(AesBlock128* block)
+void aesni_print_block128_as_matrix(AesNI_Block128* block)
 {
-    printf("%s", format_aes_block128_as_matrix(block).str);
+    printf("%s", aesni_format_block128_as_matrix(block).str);
 }
 
-void print_aes_block192_as_matrix(AesBlock192* block)
+void aesni_print_block192_as_matrix(AesNI_Block192* block)
 {
-    printf("%s", format_aes_block192_as_matrix(block).str);
+    printf("%s", aesni_format_block192_as_matrix(block).str);
 }
 
-void print_aes_block256_as_matrix(AesBlock256* block)
+void aesni_print_block256_as_matrix(AesNI_Block256* block)
 {
-    printf("%s", format_aes_block256_as_matrix(block).str);
+    printf("%s", aesni_format_block256_as_matrix(block).str);
 }
 
-void print_aes_block128_be_as_matrix(AesBlock128* block)
+void aesni_print_block128_be_as_matrix(AesNI_Block128* block)
 {
-    printf("%s", format_aes_block128_be_as_matrix(block).str);
+    printf("%s", aesni_format_block128_be_as_matrix(block).str);
 }
 
-void print_aes_block192_be_as_matrix(AesBlock192* block)
+void aesni_print_block192_be_as_matrix(AesNI_Block192* block)
 {
-    printf("%s", format_aes_block192_be_as_matrix(block).str);
+    printf("%s", aesni_format_block192_be_as_matrix(block).str);
 }
 
-void print_aes_block256_be_as_matrix(AesBlock256* block)
+void aesni_print_block256_be_as_matrix(AesNI_Block256* block)
 {
-    printf("%s", format_aes_block256_be_as_matrix(block).str);
+    printf("%s", aesni_format_block256_be_as_matrix(block).str);
 }
 
-int parse_aes_block128(AesBlock128* block, const char* src)
+int aesni_parse_block128(AesNI_Block128* block, const char* src)
 {
 #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO
-    return parse_aes_block128_le(block, src);
+    return aesni_parse_block128_le(block, src);
 #else
-    return parse_aes_block128_be(block, src);
+    return aesni_parse_block128_be(block, src);
 #endif
 }
 
-int parse_aes_block192(AesBlock192* block, const char* src)
+int aesni_parse_block192(AesNI_Block192* block, const char* src)
 {
 #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO
-    return parse_aes_block192_le(block, src);
+    return aesni_parse_block192_le(block, src);
 #else
-    return parse_aes_block192_be(block, src);
+    return aesni_parse_block192_be(block, src);
 #endif
 }
 
-int parse_aes_block256(AesBlock256* block, const char* src)
+int aesni_parse_block256(AesNI_Block256* block, const char* src)
 {
 #if defined AESNI_LE_BLOCK_IO && AESNI_LE_BLOCK_IO
-    return parse_aes_block256_le(block, src);
+    return aesni_parse_block256_le(block, src);
 #else
-    return parse_aes_block256_be(block, src);
+    return aesni_parse_block256_be(block, src);
 #endif
 }
 
-int parse_aes_block128_le(AesBlock128* block, const char* src)
+int aesni_parse_block128_le(AesNI_Block128* block, const char* src)
 {
     int n, xs[4];
     if (sscanf(src, "%8x%8x%8x%8x%n", &xs[0], &xs[1], &xs[2], &xs[3], &n) != 4
         || n != strlen(src))
         return 1;
-    *block = make_aes_block128(xs[0], xs[1], xs[2], xs[3]);
+    *block = aesni_make_block128(xs[0], xs[1], xs[2], xs[3]);
     return 0;
 }
 
-int parse_aes_block192_le(AesBlock192* block, const char* src)
+int aesni_parse_block192_le(AesNI_Block192* block, const char* src)
 {
     int n, xs[6];
     if (sscanf(src, "%8x%8x%8x%8x%8x%8x%n", &xs[0], &xs[1], &xs[2], &xs[3], &xs[4], &xs[5], &n) != 6
         || n != strlen(src))
         return 1;
-    *block = make_aes_block192(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5]);
+    *block = aesni_make_block192(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5]);
     return 0;
 }
 
-int parse_aes_block256_le(AesBlock256* block, const char* src)
+int aesni_parse_block256_le(AesNI_Block256* block, const char* src)
 {
     int n, xs[8];
     if (sscanf(src, "%8x%8x%8x%8x%8x%8x%8x%8x%n", &xs[0], &xs[1], &xs[2], &xs[3], &xs[4], &xs[5], &xs[6], &xs[7], &n) != 8
         || n != strlen(src))
         return 1;
-    *block = make_aes_block256(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5], xs[6], xs[7]);
+    *block = aesni_make_block256(xs[0], xs[1], xs[2], xs[3], xs[4], xs[5], xs[6], xs[7]);
     return 0;
 }
 
-int parse_aes_block128_be(AesBlock128* block, const char* src)
+int aesni_parse_block128_be(AesNI_Block128* block, const char* src)
 {
     unsigned char bytes[16];
 
@@ -340,13 +340,13 @@ int parse_aes_block128_be(AesBlock128* block, const char* src)
         src += n;
     }
 
-    *block = _mm_loadu_si128((AesBlock128*) bytes);
+    *block = _mm_loadu_si128((AesNI_Block128*) bytes);
     return 0;
 }
 
-int parse_aes_block192_be(AesBlock192* block, const char* src)
+int aesni_parse_block192_be(AesNI_Block192* block, const char* src)
 {
-    AesBlock128 lo, hi;
+    AesNI_Block128 lo, hi;
     unsigned char lo_bytes[16], hi_bytes[16] = { 0 };
 
     for (int i = 0; i < 16; ++i)
@@ -359,7 +359,7 @@ int parse_aes_block192_be(AesBlock192* block, const char* src)
         src += n;
     }
 
-    lo = _mm_loadu_si128((AesBlock128*) lo_bytes);
+    lo = _mm_loadu_si128((AesNI_Block128*) lo_bytes);
 
     for (int i = 0; i < 8; ++i)
     {
@@ -371,16 +371,16 @@ int parse_aes_block192_be(AesBlock192* block, const char* src)
         src += n;
     }
 
-    hi = _mm_loadu_si128((AesBlock128*) hi_bytes);
+    hi = _mm_loadu_si128((AesNI_Block128*) hi_bytes);
 
     block->hi = hi;
     block->lo = lo;
     return 0;
 }
 
-int parse_aes_block256_be(AesBlock256* block, const char* src)
+int aesni_parse_block256_be(AesNI_Block256* block, const char* src)
 {
-    AesBlock128 lo, hi;
+    AesNI_Block128 lo, hi;
     unsigned char lo_bytes[16], hi_bytes[16];
 
     for (int i = 0; i < 16; ++i)
@@ -393,7 +393,7 @@ int parse_aes_block256_be(AesBlock256* block, const char* src)
         src += n;
     }
 
-    lo = _mm_loadu_si128((AesBlock128*) lo_bytes);
+    lo = _mm_loadu_si128((AesNI_Block128*) lo_bytes);
 
     for (int i = 0; i < 16; ++i)
     {
@@ -405,7 +405,7 @@ int parse_aes_block256_be(AesBlock256* block, const char* src)
         src += n;
     }
 
-    hi = _mm_loadu_si128((AesBlock128*) hi_bytes);
+    hi = _mm_loadu_si128((AesNI_Block128*) hi_bytes);
 
     block->hi = hi;
     block->lo = lo;
diff --git a/test/aes128cbc_decrypt_block.c b/test/aes128cbc_decrypt_block.c
index 3aacb83..b160cfa 100644
--- a/test/aes128cbc_decrypt_block.c
+++ b/test/aes128cbc_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128cbc_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_cbc128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule, inverted_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule, inverted_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
-        aes128_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
+        aesni_invert_key_schedule128(&key_schedule, &inverted_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes128cbc_decrypt_block(cipher, &inverted_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_cbc128(cipher, &inverted_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes128cbc_encrypt_block.c b/test/aes128cbc_encrypt_block.c
index 2d831ad..73ec1e0 100644
--- a/test/aes128cbc_encrypt_block.c
+++ b/test/aes128cbc_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128cbc_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_cbc128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,38 +22,38 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes128cbc_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_cbc128(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes128cfb_decrypt_block.c b/test/aes128cfb_decrypt_block.c
index 7bffd4f..c556d3d 100644
--- a/test/aes128cfb_decrypt_block.c
+++ b/test/aes128cfb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128cfb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_cfb128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,38 +22,38 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes128cfb_decrypt_block(cipher, &key_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_cfb128(cipher, &key_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes128cfb_encrypt_block.c b/test/aes128cfb_encrypt_block.c
index a991864..c1db28c 100644
--- a/test/aes128cfb_encrypt_block.c
+++ b/test/aes128cfb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128cfb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_cfb128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,38 +22,38 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes128cfb_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_cfb128(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes128ctr_decrypt_block.c b/test/aes128ctr_decrypt_block.c
index e6f9cee..61d9931 100644
--- a/test/aes128ctr_decrypt_block.c
+++ b/test/aes128ctr_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128ctr_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ctr128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,25 +22,25 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         int ctr = 0;
 
@@ -49,13 +49,13 @@ int main(int argc, char** argv)
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes128ctr_decrypt_block(cipher, &key_schedule, iv, ctr++);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ctr128(cipher, &key_schedule, iv, ctr++);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes128ctr_encrypt_block.c b/test/aes128ctr_encrypt_block.c
index 6baa266..8191172 100644
--- a/test/aes128ctr_encrypt_block.c
+++ b/test/aes128ctr_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128ctr_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ctr128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,25 +22,25 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         int ctr = 0;
 
@@ -49,13 +49,13 @@ int main(int argc, char** argv)
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes128ctr_encrypt_block(plain, &key_schedule, iv, ctr++);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ctr128(plain, &key_schedule, iv, ctr++);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes128ecb_decrypt_block.c b/test/aes128ecb_decrypt_block.c
index 54b890d..79f47ed 100644
--- a/test/aes128ecb_decrypt_block.c
+++ b/test/aes128ecb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128ecb_decrypt_block.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ecb128.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,33 +22,33 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher;
-        Aes128KeySchedule key_schedule, inverted_schedule;
+        AesNI_Block128 plain, key, cipher;
+        AesNI_KeySchedule128 key_schedule, inverted_schedule;
 
         if (argc < 1)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
-        aes128_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
+        aesni_invert_key_schedule128(&key_schedule, &inverted_schedule);
 
         for (--argc, ++argv; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes128ecb_decrypt_block(cipher, &inverted_schedule);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ecb128(cipher, &inverted_schedule);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes128ecb_encrypt_block.c b/test/aes128ecb_encrypt_block.c
index 43b1c1a..17ec89e 100644
--- a/test/aes128ecb_encrypt_block.c
+++ b/test/aes128ecb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128ecb_encrypt_block.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ecb128.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,32 +22,32 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 1)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         for (--argc, ++argv; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes128ecb_encrypt_block(plain, &key_schedule);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ecb128(plain, &key_schedule);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes128ofb_decrypt_block.c b/test/aes128ofb_decrypt_block.c
index edcbe77..84b220d 100644
--- a/test/aes128ofb_decrypt_block.c
+++ b/test/aes128ofb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128ofb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ofb128.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,38 +22,38 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes128ofb_decrypt_block(cipher, &key_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ofb128(cipher, &key_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes128ofb_encrypt_block.c b/test/aes128ofb_encrypt_block.c
index d1ff412..f52affa 100644
--- a/test/aes128ofb_encrypt_block.c
+++ b/test/aes128ofb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes128ofb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ofb128.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,38 +22,38 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, key, cipher, iv;
-        Aes128KeySchedule key_schedule;
+        AesNI_Block128 plain, key, cipher, iv;
+        AesNI_KeySchedule128 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block128(&key, *argv) != 0)
+        if (aesni_parse_block128(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes128ofb_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ofb128(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes192cbc_decrypt_block.c b/test/aes192cbc_decrypt_block.c
index a714c2b..f7eb235 100644
--- a/test/aes192cbc_decrypt_block.c
+++ b/test/aes192cbc_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192cbc_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_cbc192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,40 +22,40 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule, inverted_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule, inverted_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
-        aes192_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
+        aesni_invert_key_schedule192(&key_schedule, &inverted_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes192cbc_decrypt_block(cipher, &inverted_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_cbc192(cipher, &inverted_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes192cbc_encrypt_block.c b/test/aes192cbc_encrypt_block.c
index f0a23bc..ba04d9c 100644
--- a/test/aes192cbc_encrypt_block.c
+++ b/test/aes192cbc_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192cbc_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_cbc192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes192cbc_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_cbc192(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes192cfb_decrypt_block.c b/test/aes192cfb_decrypt_block.c
index d8096a5..5048804 100644
--- a/test/aes192cfb_decrypt_block.c
+++ b/test/aes192cfb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192cfb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_cfb192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes192cfb_decrypt_block(cipher, &key_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_cfb192(cipher, &key_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes192cfb_encrypt_block.c b/test/aes192cfb_encrypt_block.c
index 9ee207f..4a81432 100644
--- a/test/aes192cfb_encrypt_block.c
+++ b/test/aes192cfb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192cfb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_cfb192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes192cfb_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_cfb192(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes192ctr_decrypt_block.c b/test/aes192ctr_decrypt_block.c
index 0c818cf..501c27a 100644
--- a/test/aes192ctr_decrypt_block.c
+++ b/test/aes192ctr_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192ctr_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ctr192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,26 +22,26 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         int ctr = 0;
 
@@ -50,13 +50,13 @@ int main(int argc, char** argv)
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes192ctr_decrypt_block(cipher, &key_schedule, iv, ctr++);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ctr192(cipher, &key_schedule, iv, ctr++);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes192ctr_encrypt_block.c b/test/aes192ctr_encrypt_block.c
index 1a494c3..af73a98 100644
--- a/test/aes192ctr_encrypt_block.c
+++ b/test/aes192ctr_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192ctr_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ctr192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,26 +22,26 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         int ctr = 0;
 
@@ -50,13 +50,13 @@ int main(int argc, char** argv)
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes192ctr_encrypt_block(plain, &key_schedule, iv, ctr++);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ctr192(plain, &key_schedule, iv, ctr++);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes192ecb_decrypt_block.c b/test/aes192ecb_decrypt_block.c
index c034236..be4eeee 100644
--- a/test/aes192ecb_decrypt_block.c
+++ b/test/aes192ecb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192ecb_decrypt_block.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ecb192.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,34 +22,34 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule, inverted_schedule;
+        AesNI_Block128 plain, cipher;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule, inverted_schedule;
 
         if (argc < 1)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
-        aes192_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
+        aesni_invert_key_schedule192(&key_schedule, &inverted_schedule);
 
         for (--argc, ++argv; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes192ecb_decrypt_block(cipher, &inverted_schedule);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ecb192(cipher, &inverted_schedule);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes192ecb_encrypt_block.c b/test/aes192ecb_encrypt_block.c
index 9af1e3e..b652ee5 100644
--- a/test/aes192ecb_encrypt_block.c
+++ b/test/aes192ecb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192ecb_encrypt_block.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ecb192.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,33 +22,33 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 1)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         for (--argc, ++argv; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes192ecb_encrypt_block(plain, &key_schedule);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ecb192(plain, &key_schedule);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes192ofb_decrypt_block.c b/test/aes192ofb_decrypt_block.c
index 4044435..2f830e1 100644
--- a/test/aes192ofb_decrypt_block.c
+++ b/test/aes192ofb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192ofb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ofb192.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes192ofb_decrypt_block(cipher, &key_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ofb192(cipher, &key_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes192ofb_encrypt_block.c b/test/aes192ofb_encrypt_block.c
index 8d57208..e541496 100644
--- a/test/aes192ofb_encrypt_block.c
+++ b/test/aes192ofb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes192ofb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ofb192.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock192 key;
-        Aes192KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block192 key;
+        AesNI_KeySchedule192 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block192(&key, *argv) != 0)
+        if (aesni_parse_block192(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 192-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes192_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule192(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes192ofb_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ofb192(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes256cbc_decrypt_block.c b/test/aes256cbc_decrypt_block.c
index 7a1defe..f58dfa7 100644
--- a/test/aes256cbc_decrypt_block.c
+++ b/test/aes256cbc_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256cbc_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_cbc256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,40 +22,40 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule, inverted_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule, inverted_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
-        aes256_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
+        aesni_invert_key_schedule256(&key_schedule, &inverted_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes256cbc_decrypt_block(cipher, &inverted_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_cbc256(cipher, &inverted_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes256cbc_encrypt_block.c b/test/aes256cbc_encrypt_block.c
index 81ffcc8..5bc2af8 100644
--- a/test/aes256cbc_encrypt_block.c
+++ b/test/aes256cbc_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256cbc_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_cbc256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes256cbc_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_cbc256(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes256cfb_decrypt_block.c b/test/aes256cfb_decrypt_block.c
index ffa352a..5839a36 100644
--- a/test/aes256cfb_decrypt_block.c
+++ b/test/aes256cfb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256cfb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_cfb256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes256cfb_decrypt_block(cipher, &key_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_cfb256(cipher, &key_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes256cfb_encrypt_block.c b/test/aes256cfb_encrypt_block.c
index 5afb7ab..acff8d7 100644
--- a/test/aes256cfb_encrypt_block.c
+++ b/test/aes256cfb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256cfb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_cfb256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes256cfb_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_cfb256(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes256ctr_decrypt_block.c b/test/aes256ctr_decrypt_block.c
index 79d60e4..0bf1545 100644
--- a/test/aes256ctr_decrypt_block.c
+++ b/test/aes256ctr_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256ctr_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ctr256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,26 +22,26 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         int ctr = 0;
 
@@ -50,13 +50,13 @@ int main(int argc, char** argv)
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes256ctr_decrypt_block(cipher, &key_schedule, iv, ctr++);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ctr256(cipher, &key_schedule, iv, ctr++);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes256ctr_encrypt_block.c b/test/aes256ctr_encrypt_block.c
index 3b384dc..a8894ea 100644
--- a/test/aes256ctr_encrypt_block.c
+++ b/test/aes256ctr_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256ctr_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ctr256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,26 +22,26 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         int ctr = 0;
 
@@ -50,13 +50,13 @@ int main(int argc, char** argv)
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes256ctr_encrypt_block(plain, &key_schedule, iv, ctr++);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ctr256(plain, &key_schedule, iv, ctr++);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes256ecb_decrypt_block.c b/test/aes256ecb_decrypt_block.c
index 106aa8b..203d1d5 100644
--- a/test/aes256ecb_decrypt_block.c
+++ b/test/aes256ecb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256ecb_decrypt_block.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ecb256.exe KEY0 [CIPHER0...] [-- KEY1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,34 +22,34 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule, inverted_schedule;
+        AesNI_Block128 plain, cipher;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule, inverted_schedule;
 
         if (argc < 1)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
-        aes256_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
+        aesni_invert_key_schedule256(&key_schedule, &inverted_schedule);
 
         for (--argc, ++argv; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes256ecb_decrypt_block(cipher, &inverted_schedule);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ecb256(cipher, &inverted_schedule);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes256ecb_encrypt_block.c b/test/aes256ecb_encrypt_block.c
index 4f550b6..ff11ce7 100644
--- a/test/aes256ecb_encrypt_block.c
+++ b/test/aes256ecb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256ecb_encrypt_block.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ecb256.exe KEY0 [PLAIN0...] [-- KEY1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,33 +22,33 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 1)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         for (--argc, ++argv; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes256ecb_encrypt_block(plain, &key_schedule);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ecb256(plain, &key_schedule);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/test/aes256ofb_decrypt_block.c b/test/aes256ofb_decrypt_block.c
index 7b4c614..ddc0024 100644
--- a/test/aes256ofb_decrypt_block.c
+++ b/test/aes256ofb_decrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256ofb_decrypt_block.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
+    puts("Usage: aesni_decrypt_block_ofb256.exe KEY0 IV0 [CIPHER0...] [-- KEY1 IV1 [CIPHER1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&cipher, *argv) != 0)
+            if (aesni_parse_block128(&cipher, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            plain = aes256ofb_decrypt_block(cipher, &key_schedule, iv, &iv);
-            print_aes_block128(&plain);
+            plain = aesni_decrypt_block_ofb256(cipher, &key_schedule, iv, &iv);
+            aesni_print_block128(&plain);
         }
     }
 
diff --git a/test/aes256ofb_encrypt_block.c b/test/aes256ofb_encrypt_block.c
index 09d2edb..94138ca 100644
--- a/test/aes256ofb_encrypt_block.c
+++ b/test/aes256ofb_encrypt_block.c
@@ -14,7 +14,7 @@
 
 static void exit_with_usage()
 {
-    puts("Usage: aes256ofb_encrypt_block.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
+    puts("Usage: aesni_encrypt_block_ofb256.exe KEY0 IV0 [PLAIN0...] [-- KEY1 IV1 [PLAIN1...]...]");
     exit(EXIT_FAILURE);
 }
 
@@ -22,39 +22,39 @@ int main(int argc, char** argv)
 {
     for (--argc, ++argv; argc > -1; --argc, ++argv)
     {
-        AesBlock128 plain, cipher, iv;
-        AesBlock256 key;
-        Aes256KeySchedule key_schedule;
+        AesNI_Block128 plain, cipher, iv;
+        AesNI_Block256 key;
+        AesNI_KeySchedule256 key_schedule;
 
         if (argc < 2)
             exit_with_usage();
 
-        if (parse_aes_block256(&key, *argv) != 0)
+        if (aesni_parse_block256(&key, *argv) != 0)
         {
             fprintf(stderr, "Invalid 256-bit AES block '%s'\n", *argv);
             exit_with_usage();
         }
 
-        if (parse_aes_block128(&iv, argv[1]) != 0)
+        if (aesni_parse_block128(&iv, argv[1]) != 0)
         {
             fprintf(stderr, "Invalid 128-bit AES block '%s'\n", argv[1]);
             exit_with_usage();
         }
 
-        aes256_expand_key_schedule(&key, &key_schedule);
+        aesni_expand_key_schedule256(&key, &key_schedule);
 
         for (argc -= 2, argv += 2; argc > 0; --argc, ++argv)
         {
             if (strcmp("--", *argv) == 0)
                 break;
 
-            if (parse_aes_block128(&plain, *argv) != 0)
+            if (aesni_parse_block128(&plain, *argv) != 0)
             {
                 fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv);
                 continue;
             }
-            cipher = aes256ofb_encrypt_block(plain, &key_schedule, iv, &iv);
-            print_aes_block128(&cipher);
+            cipher = aesni_encrypt_block_ofb256(plain, &key_schedule, iv, &iv);
+            aesni_print_block128(&cipher);
         }
     }
 
diff --git a/utils/aes128ecb_decrypt_file.cpp b/utils/aes128ecb_decrypt_file.cpp
index 60b1546..6be3f94 100644
--- a/utils/aes128ecb_decrypt_file.cpp
+++ b/utils/aes128ecb_decrypt_file.cpp
@@ -34,13 +34,13 @@ namespace
 
 int main(int argc, char** argv)
 {
-    AesBlock128 key;
-    Aes128KeySchedule key_schedule, inverted_schedule;
+    AesNI_Block128 key;
+    AesNI_KeySchedule128 key_schedule, inverted_schedule;
 
     if (argc != 4)
         exit_with_usage();
 
-    if (parse_aes_block128(&key, argv[1]) != 0)
+    if (aesni_parse_block128(&key, argv[1]) != 0)
     {
         std::cerr << "Invalid 128-bit AES block '" << argv[1] << "'\n";
         exit_with_usage();
@@ -62,15 +62,15 @@ int main(int argc, char** argv)
         src_buf.assign(std::istreambuf_iterator<char>(src_ifs),
                        std::istreambuf_iterator<char>());
 
-        aes128_expand_key_schedule(key, &key_schedule);
-        aes128_invert_key_schedule(&key_schedule, &inverted_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
+        aesni_invert_key_schedule128(&key_schedule, &inverted_schedule);
 
-        auto dest_size = aes128ecb_decrypt_buffer(
+        auto dest_size = aesni_decrypt_buffer_ecb128(
             src_buf.data(), static_cast<std::size_t>(src_size), NULL, &inverted_schedule);
 
         std::vector<unsigned char> dest_buf(static_cast<std::vector<char>::size_type>(dest_size));
 
-        dest_size = aes128ecb_decrypt_buffer(
+        dest_size = aesni_decrypt_buffer_ecb128(
             src_buf.data(), static_cast<std::size_t>(src_size), dest_buf.data(), &inverted_schedule);
 
         std::ofstream dest_ofs;
diff --git a/utils/aes128ecb_encrypt_file.cpp b/utils/aes128ecb_encrypt_file.cpp
index 2e24f04..34a7dae 100644
--- a/utils/aes128ecb_encrypt_file.cpp
+++ b/utils/aes128ecb_encrypt_file.cpp
@@ -34,13 +34,13 @@ namespace
 
 int main(int argc, char** argv)
 {
-    AesBlock128 key;
-    Aes128KeySchedule key_schedule;
+    AesNI_Block128 key;
+    AesNI_KeySchedule128 key_schedule;
 
     if (argc != 4)
         exit_with_usage();
 
-    if (parse_aes_block128(&key, argv[1]) != 0)
+    if (aesni_parse_block128(&key, argv[1]) != 0)
     {
         std::cerr << "Invalid 128-bit AES block '" << argv[1] << "'\n";
         exit_with_usage();
@@ -62,9 +62,9 @@ int main(int argc, char** argv)
         src_buf.assign(std::istreambuf_iterator<char>(src_ifs),
                        std::istreambuf_iterator<char>());
 
-        aes128_expand_key_schedule(key, &key_schedule);
+        aesni_expand_key_schedule128(key, &key_schedule);
 
-        const auto dest_size = aes128ecb_encrypt_buffer(
+        const auto dest_size = aesni_encrypt_buffer_ecb128(
             src_buf.data(),
             static_cast<std::size_t>(src_size),
             NULL,
@@ -72,7 +72,7 @@ int main(int argc, char** argv)
 
         std::vector<unsigned char> dest_buf(static_cast<std::vector<char>::size_type>(dest_size));
 
-        aes128ecb_encrypt_buffer(
+        aesni_encrypt_buffer_ecb128(
             src_buf.data(),
             static_cast<std::size_t>(src_size),
             dest_buf.data(),