finally, perfect .clang-format settings?

8 files changed, 545 insertions, 347 deletions

diff --git a/aes/src/aes.c b/aes/src/aes.c
index a409b5e..95b532d 100644
--- a/aes/src/aes.c
+++ b/aes/src/aes.c
@@ -11,9 +11,11 @@
 #include <stdio.h>
 #include <string.h>
 
-AES_StatusCode aes_AES_format_block(AES_AES_BlockString* str,
-                                    const AES_AES_Block* block,
-                                    AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES_format_block(
+    AES_AES_BlockString* str,
+    const AES_AES_Block* block,
+    AES_ErrorDetails* err_details
+) {
     assert(str);
     assert(block);
 
@@ -34,9 +36,11 @@ AES_StatusCode aes_AES_format_block(AES_AES_BlockString* str,
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES_format_block_as_matrix(AES_AES_BlockMatrixString* str,
-                                              const AES_AES_Block* block,
-                                              AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES_format_block_as_matrix(
+    AES_AES_BlockMatrixString* str,
+    const AES_AES_Block* block,
+    AES_ErrorDetails* err_details
+) {
     assert(str);
     assert(block);
 
@@ -76,8 +80,10 @@ AES_StatusCode aes_AES_print_block(const AES_AES_Block* block, AES_ErrorDetails*
     return ec;
 }
 
-AES_StatusCode aes_AES_print_block_as_matrix(const AES_AES_Block* block,
-                                             AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES_print_block_as_matrix(
+    const AES_AES_Block* block,
+    AES_ErrorDetails* err_details
+) {
     assert(block);
 
     if (block == NULL)
@@ -93,9 +99,11 @@ AES_StatusCode aes_AES_print_block_as_matrix(const AES_AES_Block* block,
     return ec;
 }
 
-AES_StatusCode aes_AES_parse_block(AES_AES_Block* dest,
-                                   const char* src,
-                                   AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES_parse_block(
+    AES_AES_Block* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     assert(dest);
     assert(src);
 
@@ -121,9 +129,11 @@ AES_StatusCode aes_AES_parse_block(AES_AES_Block* dest,
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES128_format_key(AES_AES128_KeyString* str,
-                                     const AES_AES128_Key* key,
-                                     AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES128_format_key(
+    AES_AES128_KeyString* str,
+    const AES_AES128_Key* key,
+    AES_ErrorDetails* err_details
+) {
     assert(str);
     assert(key);
 
@@ -144,9 +154,11 @@ AES_StatusCode aes_AES128_format_key(AES_AES128_KeyString* str,
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES192_format_key(AES_AES192_KeyString* str,
-                                     const AES_AES192_Key* key,
-                                     AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES192_format_key(
+    AES_AES192_KeyString* str,
+    const AES_AES192_Key* key,
+    AES_ErrorDetails* err_details
+) {
     assert(str);
     assert(key);
 
@@ -177,9 +189,11 @@ AES_StatusCode aes_AES192_format_key(AES_AES192_KeyString* str,
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES256_format_key(AES_AES256_KeyString* str,
-                                     const AES_AES256_Key* key,
-                                     AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES256_format_key(
+    AES_AES256_KeyString* str,
+    const AES_AES256_Key* key,
+    AES_ErrorDetails* err_details
+) {
     assert(str);
     assert(key);
 
@@ -246,15 +260,19 @@ AES_StatusCode aes_AES256_print_key(const AES_AES256_Key* key, AES_ErrorDetails*
     return ec;
 }
 
-AES_StatusCode aes_AES128_parse_key(AES_AES128_Key* dest,
-                                    const char* src,
-                                    AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES128_parse_key(
+    AES_AES128_Key* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     return aes_AES_parse_block(&dest->key, src, err_details);
 }
 
-AES_StatusCode aes_AES192_parse_key(AES_AES192_Key* dest,
-                                    const char* src,
-                                    AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES192_parse_key(
+    AES_AES192_Key* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     assert(dest);
     assert(src);
 
@@ -299,9 +317,11 @@ AES_StatusCode aes_AES192_parse_key(AES_AES192_Key* dest,
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES256_parse_key(AES_AES256_Key* dest,
-                                    const char* src,
-                                    AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES256_parse_key(
+    AES_AES256_Key* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     assert(dest);
     assert(src);
 
diff --git a/aes/src/box.c b/aes/src/box.c
index 48457c9..8d2c202 100644
--- a/aes/src/box.c
+++ b/aes/src/box.c
@@ -16,18 +16,22 @@ static const AES_BoxAlgorithmInterface* aes_box_algorithms[] = {
     &aes_box_algorithm_aes256,
 };
 
-AES_StatusCode aes_box_init(AES_Box* box,
-                            AES_Algorithm algorithm,
-                            const AES_BoxKey* box_key,
-                            AES_Mode mode,
-                            const AES_BoxBlock* iv,
-                            AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_init(
+    AES_Box* box,
+    AES_Algorithm algorithm,
+    const AES_BoxKey* box_key,
+    AES_Mode mode,
+    const AES_BoxBlock* iv,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     box->algorithm = aes_box_algorithms[algorithm];
 
-    if (aes_is_error(status = box->algorithm->calc_round_keys(
-                         box_key, &box->encryption_keys, &box->decryption_keys, err_details)))
+    status = box->algorithm->calc_round_keys(
+        box_key, &box->encryption_keys, &box->decryption_keys, err_details
+    );
+    if (aes_is_error(status))
         return status;
 
     box->mode = mode;
@@ -37,89 +41,107 @@ AES_StatusCode aes_box_init(AES_Box* box,
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_ecb(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_ecb(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     return box->algorithm->encrypt_block(input, &box->encryption_keys, output, err_details);
 }
 
-static AES_StatusCode aes_box_encrypt_block_cbc(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_cbc(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
     AES_BoxBlock xored_input = *input;
 
-    if (aes_is_error(status = box->algorithm->xor_block(&xored_input, &box->iv, err_details)))
+    status = box->algorithm->xor_block(&xored_input, &box->iv, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->encrypt_block(
-                         &xored_input, &box->encryption_keys, output, err_details)))
+    status =
+        box->algorithm->encrypt_block(&xored_input, &box->encryption_keys, output, err_details);
+    if (aes_is_error(status))
         return status;
 
     box->iv = *output;
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_cfb(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_cfb(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
-    if (aes_is_error(status = box->algorithm->encrypt_block(
-                         &box->iv, &box->encryption_keys, output, err_details)))
+    status = box->algorithm->encrypt_block(&box->iv, &box->encryption_keys, output, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
+    status = box->algorithm->xor_block(output, input, err_details);
+    if (aes_is_error(status))
         return status;
 
     box->iv = *output;
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_ofb(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_ofb(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
-    if (aes_is_error(status = box->algorithm->encrypt_block(
-                         &box->iv, &box->encryption_keys, &box->iv, err_details)))
+    status = box->algorithm->encrypt_block(&box->iv, &box->encryption_keys, &box->iv, err_details);
+    if (aes_is_error(status))
         return status;
 
     *output = box->iv;
 
-    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
+    status = box->algorithm->xor_block(output, input, err_details);
+    if (aes_is_error(status))
         return status;
 
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_ctr(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_ctr(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
-    if (aes_is_error(status = box->algorithm->encrypt_block(
-                         &box->iv, &box->encryption_keys, output, err_details)))
+    status = box->algorithm->encrypt_block(&box->iv, &box->encryption_keys, output, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
+    status = box->algorithm->xor_block(output, input, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->inc_block(&box->iv, err_details)))
+    status = box->algorithm->inc_block(&box->iv, err_details);
+    if (aes_is_error(status))
         return status;
 
     return status;
 }
 
-typedef AES_StatusCode (*AES_BoxEncryptBlockInMode)(AES_Box*,
-                                                    const AES_BoxBlock*,
-                                                    AES_BoxBlock*,
-                                                    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxEncryptBlockInMode)(
+    AES_Box*,
+    const AES_BoxBlock*,
+    AES_BoxBlock*,
+    AES_ErrorDetails*
+);
 
 static AES_BoxEncryptBlockInMode aes_box_encrypt_block_in_mode[] = {
     &aes_box_encrypt_block_ecb,
@@ -129,48 +151,58 @@ static AES_BoxEncryptBlockInMode aes_box_encrypt_block_in_mode[] = {
     &aes_box_encrypt_block_ctr,
 };
 
-AES_StatusCode aes_box_encrypt_block(AES_Box* box,
-                                     const AES_BoxBlock* input,
-                                     AES_BoxBlock* output,
-                                     AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_encrypt_block(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     return aes_box_encrypt_block_in_mode[box->mode](box, input, output, err_details);
 }
 
-static AES_StatusCode aes_box_decrypt_block_ecb(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_block_ecb(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     return box->algorithm->decrypt_block(input, &box->decryption_keys, output, err_details);
 }
 
-static AES_StatusCode aes_box_decrypt_block_cbc(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_block_cbc(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
-    if (aes_is_error(status = box->algorithm->decrypt_block(
-                         input, &box->decryption_keys, output, err_details)))
+    status = box->algorithm->decrypt_block(input, &box->decryption_keys, output, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(output, &box->iv, err_details)))
+    status = box->algorithm->xor_block(output, &box->iv, err_details);
+    if (aes_is_error(status))
         return status;
 
     box->iv = *input;
     return status;
 }
 
-static AES_StatusCode aes_box_decrypt_block_cfb(AES_Box* box,
-                                                const AES_BoxBlock* input,
-                                                AES_BoxBlock* output,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_block_cfb(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
-    if (aes_is_error(status = box->algorithm->encrypt_block(
-                         &box->iv, &box->encryption_keys, output, err_details)))
+    status = box->algorithm->encrypt_block(&box->iv, &box->encryption_keys, output, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
+    status = box->algorithm->xor_block(output, input, err_details);
+    if (aes_is_error(status))
         return status;
 
     box->iv = *input;
@@ -187,18 +219,22 @@ static AES_BoxDecryptBlockInMode aes_box_decrypt_block_in_mode[] = {
     &aes_box_encrypt_block_ctr,
 };
 
-AES_StatusCode aes_box_decrypt_block(AES_Box* box,
-                                     const AES_BoxBlock* input,
-                                     AES_BoxBlock* output,
-                                     AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_decrypt_block(
+    AES_Box* box,
+    const AES_BoxBlock* input,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     return aes_box_decrypt_block_in_mode[box->mode](box, input, output, err_details);
 }
 
-static AES_StatusCode aes_box_get_encrypted_buffer_size(AES_Box* box,
-                                                        size_t src_size,
-                                                        size_t* dest_size,
-                                                        size_t* padding_size,
-                                                        AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_get_encrypted_buffer_size(
+    AES_Box* box,
+    size_t src_size,
+    size_t* dest_size,
+    size_t* padding_size,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     switch (box->mode) {
@@ -206,7 +242,8 @@ static AES_StatusCode aes_box_get_encrypted_buffer_size(AES_Box* box,
         case AES_CBC: {
             size_t block_size;
 
-            if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+            status = box->algorithm->get_block_size(&block_size, err_details);
+            if (aes_is_error(status))
                 return status;
 
             *padding_size = block_size - src_size % block_size;
@@ -226,23 +263,27 @@ static AES_StatusCode aes_box_get_encrypted_buffer_size(AES_Box* box,
     }
 }
 
-static AES_StatusCode aes_box_encrypt_buffer_block(AES_Box* box,
-                                                   const void* src,
-                                                   void* dest,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_buffer_block(
+    AES_Box* box,
+    const void* src,
+    void* dest,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
-
     AES_BoxBlock plaintext;
 
-    if (aes_is_error(status = box->algorithm->load_block(&plaintext, src, err_details)))
+    status = box->algorithm->load_block(&plaintext, src, err_details);
+    if (aes_is_error(status))
         return status;
 
     AES_BoxBlock ciphertext;
 
-    if (aes_is_error(status = aes_box_encrypt_block(box, &plaintext, &ciphertext, err_details)))
+    status = aes_box_encrypt_block(box, &plaintext, &ciphertext, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->store_block(dest, &ciphertext, err_details)))
+    status = box->algorithm->store_block(dest, &ciphertext, err_details);
+    if (aes_is_error(status))
         return status;
 
     return status;
@@ -254,12 +295,14 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block_with_padding(
     size_t src_size,
     void* dest,
     size_t padding_size,
-    AES_ErrorDetails* err_details) {
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+    status = box->algorithm->get_block_size(&block_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     void* plaintext_buf = malloc(block_size);
@@ -269,12 +312,14 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block_with_padding(
 
     memcpy(plaintext_buf, src, src_size);
 
-    if (aes_is_error(
-            status = aes_fill_with_padding(
-                AES_PADDING_PKCS7, (char*)plaintext_buf + src_size, padding_size, err_details)))
+    status = aes_fill_with_padding(
+        AES_PADDING_PKCS7, (char*)plaintext_buf + src_size, padding_size, err_details
+    );
+    if (aes_is_error(status))
         goto FREE_PLAINTEXT_BUF;
 
-    if (aes_is_error(status = aes_box_encrypt_buffer_block(box, plaintext_buf, dest, err_details)))
+    status = aes_box_encrypt_buffer_block(box, plaintext_buf, dest, err_details);
+    if (aes_is_error(status))
         goto FREE_PLAINTEXT_BUF;
 
 FREE_PLAINTEXT_BUF:
@@ -283,11 +328,13 @@ FREE_PLAINTEXT_BUF:
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_buffer_partial_block(AES_Box* box,
-                                                           const void* src,
-                                                           size_t src_size,
-                                                           void* dest,
-                                                           AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_buffer_partial_block(
+    AES_Box* box,
+    const void* src,
+    size_t src_size,
+    void* dest,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (src_size == 0)
@@ -295,7 +342,8 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block(AES_Box* box,
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+    status = box->algorithm->get_block_size(&block_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     void* plaintext_buf = malloc(block_size);
@@ -313,8 +361,8 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block(AES_Box* box,
         goto FREE_PLAINTEXT_BUF;
     }
 
-    if (aes_is_error(
-            status = aes_box_encrypt_buffer_block(box, plaintext_buf, ciphertext_buf, err_details)))
+    status = aes_box_encrypt_buffer_block(box, plaintext_buf, ciphertext_buf, err_details);
+    if (aes_is_error(status))
         goto FREE_CIPHERTEXT_BUF;
 
     memcpy(dest, ciphertext_buf, src_size);
@@ -328,12 +376,14 @@ FREE_PLAINTEXT_BUF:
     return status;
 }
 
-AES_StatusCode aes_box_encrypt_buffer(AES_Box* box,
-                                      const void* src,
-                                      size_t src_size,
-                                      void* dest,
-                                      size_t* dest_size,
-                                      AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_encrypt_buffer(
+    AES_Box* box,
+    const void* src,
+    size_t src_size,
+    void* dest,
+    size_t* dest_size,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (box == NULL)
@@ -343,8 +393,9 @@ AES_StatusCode aes_box_encrypt_buffer(AES_Box* box,
 
     size_t padding_size = 0;
 
-    if (aes_is_error(status = aes_box_get_encrypted_buffer_size(
-                         box, src_size, dest_size, &padding_size, err_details)))
+    status =
+        aes_box_get_encrypted_buffer_size(box, src_size, dest_size, &padding_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     if (dest == NULL)
@@ -354,13 +405,15 @@ AES_StatusCode aes_box_encrypt_buffer(AES_Box* box,
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+    status = box->algorithm->get_block_size(&block_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     const size_t src_len = src_size / block_size;
 
     for (size_t i = 0; i < src_len; ++i) {
-        if (aes_is_error(status = aes_box_encrypt_buffer_block(box, src, dest, err_details)))
+        status = aes_box_encrypt_buffer_block(box, src, dest, err_details);
+        if (aes_is_error(status))
             return status;
 
         src = (char*)src + block_size;
@@ -369,17 +422,21 @@ AES_StatusCode aes_box_encrypt_buffer(AES_Box* box,
 
     if (padding_size == 0)
         return aes_box_encrypt_buffer_partial_block(
-            box, src, src_size % block_size, dest, err_details);
+            box, src, src_size % block_size, dest, err_details
+        );
     else
         return aes_box_encrypt_buffer_partial_block_with_padding(
-            box, src, src_size % block_size, dest, padding_size, err_details);
+            box, src, src_size % block_size, dest, padding_size, err_details
+        );
 }
 
-static AES_StatusCode aes_box_get_decrypted_buffer_size(AES_Box* box,
-                                                        size_t src_size,
-                                                        size_t* dest_size,
-                                                        size_t* max_padding_size,
-                                                        AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_get_decrypted_buffer_size(
+    AES_Box* box,
+    size_t src_size,
+    size_t* dest_size,
+    size_t* max_padding_size,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     switch (box->mode) {
@@ -387,7 +444,8 @@ static AES_StatusCode aes_box_get_decrypted_buffer_size(AES_Box* box,
         case AES_CBC: {
             size_t block_size;
 
-            if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+            status = box->algorithm->get_block_size(&block_size, err_details);
+            if (aes_is_error(status))
                 return status;
 
             if (src_size == 0 || src_size % block_size != 0)
@@ -410,33 +468,39 @@ static AES_StatusCode aes_box_get_decrypted_buffer_size(AES_Box* box,
     }
 }
 
-static AES_StatusCode aes_box_decrypt_buffer_block(AES_Box* box,
-                                                   const void* src,
-                                                   void* dest,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_buffer_block(
+    AES_Box* box,
+    const void* src,
+    void* dest,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
-
     AES_BoxBlock ciphertext;
 
-    if (aes_is_error(status = box->algorithm->load_block(&ciphertext, src, err_details)))
+    status = box->algorithm->load_block(&ciphertext, src, err_details);
+    if (aes_is_error(status))
         return status;
 
     AES_BoxBlock plaintext;
 
-    if (aes_is_error(status = aes_box_decrypt_block(box, &ciphertext, &plaintext, err_details)))
+    status = aes_box_decrypt_block(box, &ciphertext, &plaintext, err_details);
+    if (aes_is_error(status))
         return status;
 
-    if (aes_is_error(status = box->algorithm->store_block(dest, &plaintext, err_details)))
+    status = box->algorithm->store_block(dest, &plaintext, err_details);
+    if (aes_is_error(status))
         return status;
 
     return status;
 }
 
-static AES_StatusCode aes_box_decrypt_buffer_partial_block(AES_Box* box,
-                                                           const void* src,
-                                                           size_t src_size,
-                                                           void* dest,
-                                                           AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_buffer_partial_block(
+    AES_Box* box,
+    const void* src,
+    size_t src_size,
+    void* dest,
+    AES_ErrorDetails* err_details
+) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (src_size == 0)
@@ -444,7 +508,8 @@ static AES_StatusCode aes_box_decrypt_buffer_partial_block(AES_Box* box,
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+    status = box->algorithm->get_block_size(&block_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     void* ciphertext_buf = malloc(block_size);
@@ -462,8 +527,8 @@ static AES_StatusCode aes_box_decrypt_buffer_partial_block(AES_Box* box,
         goto FREE_CIPHERTEXT_BUF;
     }
 
-    if (aes_is_error(
-            status = aes_box_decrypt_buffer_block(box, ciphertext_buf, plaintext_buf, err_details)))
+    status = aes_box_decrypt_buffer_block(box, ciphertext_buf, plaintext_buf, err_details);
+    if (aes_is_error(status))
         goto FREE_PLAINTEXT_BUF;
 
     memcpy(dest, plaintext_buf, src_size);
@@ -477,12 +542,14 @@ FREE_CIPHERTEXT_BUF:
     return status;
 }
 
-AES_StatusCode aes_box_decrypt_buffer(AES_Box* box,
-                                      const void* src,
-                                      size_t src_size,
-                                      void* dest,
-                                      size_t* dest_size,
-                                      AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_decrypt_buffer(
+    AES_Box* box,
+    const void* src,
+    size_t src_size,
+    void* dest,
+    size_t* dest_size,
+    AES_ErrorDetails* err_details
+) {
     if (box == NULL)
         return aes_error_null_argument(err_details, "box");
     if (dest_size == NULL)
@@ -491,8 +558,9 @@ AES_StatusCode aes_box_decrypt_buffer(AES_Box* box,
     AES_StatusCode status = AES_SUCCESS;
     size_t max_padding_size = 0;
 
-    if (aes_is_error(status = aes_box_get_decrypted_buffer_size(
-                         box, src_size, dest_size, &max_padding_size, err_details)))
+    status =
+        aes_box_get_decrypted_buffer_size(box, src_size, dest_size, &max_padding_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     if (dest == NULL)
@@ -502,13 +570,15 @@ AES_StatusCode aes_box_decrypt_buffer(AES_Box* box,
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
+    status = box->algorithm->get_block_size(&block_size, err_details);
+    if (aes_is_error(status))
         return status;
 
     const size_t src_len = src_size / block_size;
 
     for (size_t i = 0; i < src_len; ++i) {
-        if (aes_is_error(status = aes_box_decrypt_buffer_block(box, src, dest, err_details)))
+        status = aes_box_decrypt_buffer_block(box, src, dest, err_details);
+        if (aes_is_error(status))
             return status;
 
         src = (char*)src + block_size;
@@ -517,15 +587,15 @@ AES_StatusCode aes_box_decrypt_buffer(AES_Box* box,
 
     if (max_padding_size == 0) {
         return aes_box_decrypt_buffer_partial_block(
-            box, src, src_size % block_size, dest, err_details);
+            box, src, src_size % block_size, dest, err_details
+        );
     } else {
         size_t padding_size;
 
-        if (aes_is_error(status = aes_extract_padding_size(AES_PADDING_PKCS7,
-                                                           (char*)dest - block_size,
-                                                           block_size,
-                                                           &padding_size,
-                                                           err_details)))
+        status = aes_extract_padding_size(
+            AES_PADDING_PKCS7, (char*)dest - block_size, block_size, &padding_size, err_details
+        );
+        if (aes_is_error(status))
             return status;
 
         *dest_size -= padding_size;
@@ -533,10 +603,12 @@ AES_StatusCode aes_box_decrypt_buffer(AES_Box* box,
     }
 }
 
-AES_StatusCode aes_box_parse_block(AES_BoxBlock* dest,
-                                   AES_Algorithm algorithm,
-                                   const char* src,
-                                   AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_parse_block(
+    AES_BoxBlock* dest,
+    AES_Algorithm algorithm,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -545,10 +617,12 @@ AES_StatusCode aes_box_parse_block(AES_BoxBlock* dest,
     return aes_box_algorithms[algorithm]->parse_block(dest, src, err_details);
 }
 
-AES_StatusCode aes_box_parse_key(AES_BoxKey* dest,
-                                 AES_Algorithm algorithm,
-                                 const char* src,
-                                 AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_parse_key(
+    AES_BoxKey* dest,
+    AES_Algorithm algorithm,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -557,10 +631,12 @@ AES_StatusCode aes_box_parse_key(AES_BoxKey* dest,
     return aes_box_algorithms[algorithm]->parse_key(dest, src, err_details);
 }
 
-AES_StatusCode aes_box_format_block(AES_BoxBlockString* dest,
-                                    AES_Algorithm algorithm,
-                                    const AES_BoxBlock* src,
-                                    AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_format_block(
+    AES_BoxBlockString* dest,
+    AES_Algorithm algorithm,
+    const AES_BoxBlock* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -569,10 +645,12 @@ AES_StatusCode aes_box_format_block(AES_BoxBlockString* dest,
     return aes_box_algorithms[algorithm]->format_block(dest, src, err_details);
 }
 
-AES_StatusCode aes_box_format_key(AES_BoxKeyString* dest,
-                                  AES_Algorithm algorithm,
-                                  const AES_BoxKey* src,
-                                  AES_ErrorDetails* err_details) {
+AES_StatusCode aes_box_format_key(
+    AES_BoxKeyString* dest,
+    AES_Algorithm algorithm,
+    const AES_BoxKey* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
diff --git a/aes/src/box_aes.c b/aes/src/box_aes.c
index 7e78a2c..4a91e97 100644
--- a/aes/src/box_aes.c
+++ b/aes/src/box_aes.c
@@ -10,80 +10,101 @@
 #include <stdlib.h>
 #include <string.h>
 
-static AES_StatusCode aes_box_derive_params_aes128(const AES_BoxKey* box_key,
-                                                   AES_BoxEncryptionRoundKeys* encryption_keys,
-                                                   AES_BoxDecryptionRoundKeys* decryption_keys,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_derive_params_aes128(
+    const AES_BoxKey* box_key,
+    AES_BoxEncryptionRoundKeys* encryption_keys,
+    AES_BoxDecryptionRoundKeys* decryption_keys,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     aes_AES128_expand_key_(box_key->aes128_key.key, &encryption_keys->aes128_encryption_keys);
-    aes_AES128_derive_decryption_keys_(&encryption_keys->aes128_encryption_keys,
-                                       &decryption_keys->aes128_decryption_keys);
+    aes_AES128_derive_decryption_keys_(
+        &encryption_keys->aes128_encryption_keys, &decryption_keys->aes128_decryption_keys
+    );
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_derive_params_aes192(const AES_BoxKey* box_key,
-                                                   AES_BoxEncryptionRoundKeys* encryption_keys,
-                                                   AES_BoxDecryptionRoundKeys* decryption_keys,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_derive_params_aes192(
+    const AES_BoxKey* box_key,
+    AES_BoxEncryptionRoundKeys* encryption_keys,
+    AES_BoxDecryptionRoundKeys* decryption_keys,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     aes_AES192_expand_key_(
-        box_key->aes192_key.lo, box_key->aes192_key.hi, &encryption_keys->aes192_encryption_keys);
-    aes_AES192_derive_decryption_keys_(&encryption_keys->aes192_encryption_keys,
-                                       &decryption_keys->aes192_decryption_keys);
+        box_key->aes192_key.lo, box_key->aes192_key.hi, &encryption_keys->aes192_encryption_keys
+    );
+    aes_AES192_derive_decryption_keys_(
+        &encryption_keys->aes192_encryption_keys, &decryption_keys->aes192_decryption_keys
+    );
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_derive_params_aes256(const AES_BoxKey* box_key,
-                                                   AES_BoxEncryptionRoundKeys* encryption_keys,
-                                                   AES_BoxDecryptionRoundKeys* decryption_keys,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_derive_params_aes256(
+    const AES_BoxKey* box_key,
+    AES_BoxEncryptionRoundKeys* encryption_keys,
+    AES_BoxDecryptionRoundKeys* decryption_keys,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     aes_AES256_expand_key_(
-        box_key->aes256_key.lo, box_key->aes256_key.hi, &encryption_keys->aes256_encryption_keys);
-    aes_AES256_derive_decryption_keys_(&encryption_keys->aes256_encryption_keys,
-                                       &decryption_keys->aes256_decryption_keys);
+        box_key->aes256_key.lo, box_key->aes256_key.hi, &encryption_keys->aes256_encryption_keys
+    );
+    aes_AES256_derive_decryption_keys_(
+        &encryption_keys->aes256_encryption_keys, &decryption_keys->aes256_decryption_keys
+    );
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_parse_block_aes(AES_BoxBlock* dest,
-                                              const char* src,
-                                              AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_parse_block_aes(
+    AES_BoxBlock* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES_parse_block(&dest->aes_block, src, err_details);
 }
 
-static AES_StatusCode aes_box_parse_key_aes128(AES_BoxKey* dest,
-                                               const char* src,
-                                               AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_parse_key_aes128(
+    AES_BoxKey* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES128_parse_key(&dest->aes128_key, src, err_details);
 }
 
-static AES_StatusCode aes_box_parse_key_aes192(AES_BoxKey* dest,
-                                               const char* src,
-                                               AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_parse_key_aes192(
+    AES_BoxKey* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES192_parse_key(&dest->aes192_key, src, err_details);
 }
 
-static AES_StatusCode aes_box_parse_key_aes256(AES_BoxKey* dest,
-                                               const char* src,
-                                               AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_parse_key_aes256(
+    AES_BoxKey* dest,
+    const char* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES256_parse_key(&dest->aes256_key, src, err_details);
 }
 
-static AES_StatusCode aes_box_format_block_aes(AES_BoxBlockString* dest,
-                                               const AES_BoxBlock* src,
-                                               AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_format_block_aes(
+    AES_BoxBlockString* dest,
+    const AES_BoxBlock* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -92,9 +113,11 @@ static AES_StatusCode aes_box_format_block_aes(AES_BoxBlockString* dest,
     return aes_AES128_format_block(&dest->aes, &src->aes_block, err_details);
 }
 
-static AES_StatusCode aes_box_format_key_aes128(AES_BoxKeyString* dest,
-                                                const AES_BoxKey* src,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_format_key_aes128(
+    AES_BoxKeyString* dest,
+    const AES_BoxKey* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -103,9 +126,11 @@ static AES_StatusCode aes_box_format_key_aes128(AES_BoxKeyString* dest,
     return aes_AES128_format_key(&dest->aes128, &src->aes128_key, err_details);
 }
 
-static AES_StatusCode aes_box_format_key_aes192(AES_BoxKeyString* dest,
-                                                const AES_BoxKey* src,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_format_key_aes192(
+    AES_BoxKeyString* dest,
+    const AES_BoxKey* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -114,9 +139,11 @@ static AES_StatusCode aes_box_format_key_aes192(AES_BoxKeyString* dest,
     return aes_AES192_format_key(&dest->aes192, &src->aes192_key, err_details);
 }
 
-static AES_StatusCode aes_box_format_key_aes256(AES_BoxKeyString* dest,
-                                                const AES_BoxKey* src,
-                                                AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_format_key_aes256(
+    AES_BoxKeyString* dest,
+    const AES_BoxKey* src,
+    AES_ErrorDetails* err_details
+) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -125,9 +152,11 @@ static AES_StatusCode aes_box_format_key_aes256(AES_BoxKeyString* dest,
     return aes_AES256_format_key(&dest->aes256, &src->aes256_key, err_details);
 }
 
-static AES_StatusCode aes_box_xor_block_aes(AES_BoxBlock* dest,
-                                            const AES_BoxBlock* src,
-                                            AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_xor_block_aes(
+    AES_BoxBlock* dest,
+    const AES_BoxBlock* src,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     dest->aes_block = aes_AES_xor_blocks(dest->aes_block, src->aes_block);
     return AES_SUCCESS;
@@ -139,83 +168,101 @@ static AES_StatusCode aes_box_inc_block_aes(AES_BoxBlock* ctr, AES_ErrorDetails*
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_get_block_size_aes(size_t* block_size,
-                                                 AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_get_block_size_aes(
+    size_t* block_size,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     *block_size = 16;
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_store_block_aes(void* dest,
-                                              const AES_BoxBlock* src,
-                                              AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_store_block_aes(
+    void* dest,
+    const AES_BoxBlock* src,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     aes_store_block128(dest, src->aes_block);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_load_block_aes(AES_BoxBlock* dest,
-                                             const void* src,
-                                             AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_load_block_aes(
+    AES_BoxBlock* dest,
+    const void* src,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     dest->aes_block = aes_load_block128(src);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_encrypt_block_aes128(const AES_BoxBlock* input,
-                                                   const AES_BoxEncryptionRoundKeys* params,
-                                                   AES_BoxBlock* output,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_aes128(
+    const AES_BoxBlock* input,
+    const AES_BoxEncryptionRoundKeys* params,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     output->aes_block =
         aes_AES128_encrypt_block_(input->aes_block, &params->aes128_encryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_decrypt_block_aes128(const AES_BoxBlock* input,
-                                                   const AES_BoxDecryptionRoundKeys* params,
-                                                   AES_BoxBlock* output,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_block_aes128(
+    const AES_BoxBlock* input,
+    const AES_BoxDecryptionRoundKeys* params,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     output->aes_block =
         aes_AES128_decrypt_block_(input->aes_block, &params->aes128_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_encrypt_block_aes192(const AES_BoxBlock* input,
-                                                   const AES_BoxEncryptionRoundKeys* params,
-                                                   AES_BoxBlock* output,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_aes192(
+    const AES_BoxBlock* input,
+    const AES_BoxEncryptionRoundKeys* params,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     output->aes_block =
         aes_AES192_encrypt_block_(input->aes_block, &params->aes192_encryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_decrypt_block_aes192(const AES_BoxBlock* input,
-                                                   const AES_BoxDecryptionRoundKeys* params,
-                                                   AES_BoxBlock* output,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_block_aes192(
+    const AES_BoxBlock* input,
+    const AES_BoxDecryptionRoundKeys* params,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     output->aes_block =
         aes_AES192_decrypt_block_(input->aes_block, &params->aes192_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_encrypt_block_aes256(const AES_BoxBlock* input,
-                                                   const AES_BoxEncryptionRoundKeys* params,
-                                                   AES_BoxBlock* output,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_encrypt_block_aes256(
+    const AES_BoxBlock* input,
+    const AES_BoxEncryptionRoundKeys* params,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     output->aes_block =
         aes_AES256_encrypt_block_(input->aes_block, &params->aes256_encryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_decrypt_block_aes256(const AES_BoxBlock* input,
-                                                   const AES_BoxDecryptionRoundKeys* params,
-                                                   AES_BoxBlock* output,
-                                                   AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_box_decrypt_block_aes256(
+    const AES_BoxBlock* input,
+    const AES_BoxDecryptionRoundKeys* params,
+    AES_BoxBlock* output,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     output->aes_block =
         aes_AES256_decrypt_block_(input->aes_block, &params->aes256_decryption_keys);
diff --git a/aes/src/c/aes128.c b/aes/src/c/aes128.c
index 6b3a96a..d7b7243 100644
--- a/aes/src/c/aes128.c
+++ b/aes/src/c/aes128.c
@@ -10,8 +10,10 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AES_AES_Block __fastcall aes_AES128_encrypt_block_(AES_AES_Block plaintext,
-                                                   const AES_AES128_RoundKeys* encryption_keys) {
+AES_AES_Block __fastcall aes_AES128_encrypt_block_(
+    AES_AES_Block plaintext,
+    const AES_AES128_RoundKeys* encryption_keys
+) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[2]);
@@ -25,8 +27,10 @@ AES_AES_Block __fastcall aes_AES128_encrypt_block_(AES_AES_Block plaintext,
     return _mm_aesenclast_si128(plaintext, encryption_keys->keys[10]);
 }
 
-AES_AES_Block __fastcall aes_AES128_decrypt_block_(AES_AES_Block ciphertext,
-                                                   const AES_AES128_RoundKeys* decryption_keys) {
+AES_AES_Block __fastcall aes_AES128_decrypt_block_(
+    AES_AES_Block ciphertext,
+    const AES_AES128_RoundKeys* decryption_keys
+) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[2]);
@@ -40,8 +44,10 @@ AES_AES_Block __fastcall aes_AES128_decrypt_block_(AES_AES_Block ciphertext,
     return _mm_aesdeclast_si128(ciphertext, decryption_keys->keys[10]);
 }
 
-static AES_AES_Block __fastcall aes_aes128_expand_key_assist(AES_AES_Block prev,
-                                                             AES_AES_Block hwgen) {
+static AES_AES_Block __fastcall aes_aes128_expand_key_assist(
+    AES_AES_Block prev,
+    AES_AES_Block hwgen
+) {
     AES_AES_Block tmp = prev;
 
     tmp = _mm_slli_si128(tmp, 4);
@@ -81,8 +87,10 @@ void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys*
         aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36));
 }
 
-void __fastcall aes_AES128_derive_decryption_keys_(const AES_AES128_RoundKeys* encryption_keys,
-                                                   AES_AES128_RoundKeys* decryption_keys) {
+void __fastcall aes_AES128_derive_decryption_keys_(
+    const AES_AES128_RoundKeys* encryption_keys,
+    AES_AES128_RoundKeys* decryption_keys
+) {
     decryption_keys->keys[0] = encryption_keys->keys[10];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[9]);
     decryption_keys->keys[2] = _mm_aesimc_si128(encryption_keys->keys[8]);
diff --git a/aes/src/c/aes192.c b/aes/src/c/aes192.c
index 01f6698..901b548 100644
--- a/aes/src/c/aes192.c
+++ b/aes/src/c/aes192.c
@@ -10,8 +10,10 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AES_AES_Block __fastcall aes_AES192_encrypt_block_(AES_AES_Block plaintext,
-                                                   const AES_AES192_RoundKeys* encryption_keys) {
+AES_AES_Block __fastcall aes_AES192_encrypt_block_(
+    AES_AES_Block plaintext,
+    const AES_AES192_RoundKeys* encryption_keys
+) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[2]);
@@ -27,8 +29,10 @@ AES_AES_Block __fastcall aes_AES192_encrypt_block_(AES_AES_Block plaintext,
     return _mm_aesenclast_si128(plaintext, encryption_keys->keys[12]);
 }
 
-AES_AES_Block __fastcall aes_AES192_decrypt_block_(AES_AES_Block ciphertext,
-                                                   const AES_AES192_RoundKeys* decryption_keys) {
+AES_AES_Block __fastcall aes_AES192_decrypt_block_(
+    AES_AES_Block ciphertext,
+    const AES_AES192_RoundKeys* decryption_keys
+) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[2]);
@@ -44,9 +48,11 @@ AES_AES_Block __fastcall aes_AES192_decrypt_block_(AES_AES_Block ciphertext,
     return _mm_aesdeclast_si128(ciphertext, decryption_keys->keys[12]);
 }
 
-static void __fastcall aes_aes192_expand_key_assist(AES_AES_Block* prev_lo,
-                                                    AES_AES_Block* prev_hi,
-                                                    AES_AES_Block hwgen) {
+static void __fastcall aes_aes192_expand_key_assist(
+    AES_AES_Block* prev_lo,
+    AES_AES_Block* prev_hi,
+    AES_AES_Block hwgen
+) {
     AES_AES_Block tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
@@ -67,15 +73,18 @@ static void __fastcall aes_aes192_expand_key_assist(AES_AES_Block* prev_lo,
     *prev_hi = _mm_xor_si128(*prev_hi, tmp);
 }
 
-void __fastcall aes_AES192_expand_key_(AES_AES_Block key_lo,
-                                       AES_AES_Block key_hi,
-                                       AES_AES192_RoundKeys* encryption_keys) {
+void __fastcall aes_AES192_expand_key_(
+    AES_AES_Block key_lo,
+    AES_AES_Block key_hi,
+    AES_AES192_RoundKeys* encryption_keys
+) {
     encryption_keys->keys[0] = key_lo;
     encryption_keys->keys[1] = key_hi;
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x01));
     encryption_keys->keys[1] = _mm_castpd_si128(
-        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[1]), _mm_castsi128_pd(key_lo), 0));
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[1]), _mm_castsi128_pd(key_lo), 0)
+    );
     encryption_keys->keys[2] =
         _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
@@ -85,7 +94,8 @@ void __fastcall aes_AES192_expand_key_(AES_AES_Block key_lo,
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x04));
     encryption_keys->keys[4] = _mm_castpd_si128(
-        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[4]), _mm_castsi128_pd(key_lo), 0));
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[4]), _mm_castsi128_pd(key_lo), 0)
+    );
     encryption_keys->keys[5] =
         _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
@@ -95,7 +105,8 @@ void __fastcall aes_AES192_expand_key_(AES_AES_Block key_lo,
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x10));
     encryption_keys->keys[7] = _mm_castpd_si128(
-        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[7]), _mm_castsi128_pd(key_lo), 0));
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[7]), _mm_castsi128_pd(key_lo), 0)
+    );
     encryption_keys->keys[8] =
         _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
@@ -105,7 +116,8 @@ void __fastcall aes_AES192_expand_key_(AES_AES_Block key_lo,
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x40));
     encryption_keys->keys[10] = _mm_castpd_si128(
-        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[10]), _mm_castsi128_pd(key_lo), 0));
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[10]), _mm_castsi128_pd(key_lo), 0)
+    );
     encryption_keys->keys[11] =
         _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
@@ -113,8 +125,10 @@ void __fastcall aes_AES192_expand_key_(AES_AES_Block key_lo,
     encryption_keys->keys[12] = key_lo;
 }
 
-void __fastcall aes_AES192_derive_decryption_keys_(const AES_AES192_RoundKeys* encryption_keys,
-                                                   AES_AES192_RoundKeys* decryption_keys) {
+void __fastcall aes_AES192_derive_decryption_keys_(
+    const AES_AES192_RoundKeys* encryption_keys,
+    AES_AES192_RoundKeys* decryption_keys
+) {
     decryption_keys->keys[0] = encryption_keys->keys[12];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[11]);
     decryption_keys->keys[2] = _mm_aesimc_si128(encryption_keys->keys[10]);
diff --git a/aes/src/c/aes256.c b/aes/src/c/aes256.c
index ea64f0f..5bce5b5 100644
--- a/aes/src/c/aes256.c
+++ b/aes/src/c/aes256.c
@@ -10,8 +10,10 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AES_AES_Block __fastcall aes_AES256_encrypt_block_(AES_AES_Block plaintext,
-                                                   const AES_AES256_RoundKeys* encryption_keys) {
+AES_AES_Block __fastcall aes_AES256_encrypt_block_(
+    AES_AES_Block plaintext,
+    const AES_AES256_RoundKeys* encryption_keys
+) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[2]);
@@ -29,8 +31,10 @@ AES_AES_Block __fastcall aes_AES256_encrypt_block_(AES_AES_Block plaintext,
     return _mm_aesenclast_si128(plaintext, encryption_keys->keys[14]);
 }
 
-AES_AES_Block __fastcall aes_AES256_decrypt_block_(AES_AES_Block ciphertext,
-                                                   const AES_AES256_RoundKeys* decryption_keys) {
+AES_AES_Block __fastcall aes_AES256_decrypt_block_(
+    AES_AES_Block ciphertext,
+    const AES_AES256_RoundKeys* decryption_keys
+) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[2]);
@@ -48,9 +52,11 @@ AES_AES_Block __fastcall aes_AES256_decrypt_block_(AES_AES_Block ciphertext,
     return _mm_aesdeclast_si128(ciphertext, decryption_keys->keys[14]);
 }
 
-static AES_AES_Block __fastcall aes_aes256_expand_key_assist(AES_AES_Block* prev_lo,
-                                                             AES_AES_Block* prev_hi,
-                                                             AES_AES_Block hwgen) {
+static AES_AES_Block __fastcall aes_aes256_expand_key_assist(
+    AES_AES_Block* prev_lo,
+    AES_AES_Block* prev_hi,
+    AES_AES_Block hwgen
+) {
     AES_AES_Block tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
@@ -69,9 +75,11 @@ static AES_AES_Block __fastcall aes_aes256_expand_key_assist(AES_AES_Block* prev
     return *prev_hi;
 }
 
-void __fastcall aes_AES256_expand_key_(AES_AES_Block key_lo,
-                                       AES_AES_Block key_hi,
-                                       AES_AES256_RoundKeys* encryption_keys) {
+void __fastcall aes_AES256_expand_key_(
+    AES_AES_Block key_lo,
+    AES_AES_Block key_hi,
+    AES_AES256_RoundKeys* encryption_keys
+) {
     AES_AES_Block prev_lo, prev_hi;
     AES_AES_Block hwgen;
 
@@ -131,8 +139,10 @@ void __fastcall aes_AES256_expand_key_(AES_AES_Block key_lo,
     encryption_keys->keys[14] = aes_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen);
 }
 
-void __fastcall aes_AES256_derive_decryption_keys_(const AES_AES256_RoundKeys* encryption_keys,
-                                                   AES_AES256_RoundKeys* decryption_keys) {
+void __fastcall aes_AES256_derive_decryption_keys_(
+    const AES_AES256_RoundKeys* encryption_keys,
+    AES_AES256_RoundKeys* decryption_keys
+) {
     decryption_keys->keys[0] = encryption_keys->keys[14];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[13]);
     decryption_keys->keys[2] = _mm_aesimc_si128(encryption_keys->keys[12]);
diff --git a/aes/src/error.c b/aes/src/error.c
index e498458..7c6594f 100644
--- a/aes/src/error.c
+++ b/aes/src/error.c
@@ -61,9 +61,11 @@ const char* aes_strerror(AES_StatusCode ec) {
     return aes_strerror_messages[ec];
 }
 
-static size_t aes_format_error_strerror(const AES_ErrorDetails* err_details,
-                                        char* dest,
-                                        size_t dest_size) {
+static size_t aes_format_error_strerror(
+    const AES_ErrorDetails* err_details,
+    char* dest,
+    size_t dest_size
+) {
     const AES_StatusCode ec = aes_get_error_code(err_details);
     const char* const msg = aes_strerror(ec);
 
@@ -74,9 +76,11 @@ static size_t aes_format_error_strerror(const AES_ErrorDetails* err_details,
     return strlen(dest);
 }
 
-static size_t aes_format_null_argument_error(const AES_ErrorDetails* err_details,
-                                             char* dest,
-                                             size_t dest_size) {
+static size_t aes_format_null_argument_error(
+    const AES_ErrorDetails* err_details,
+    char* dest,
+    size_t dest_size
+) {
     static const char* const fmt = "Invalid argument value NULL for parameter '%s'";
     const char* const param_name = err_details->params.null_arg.param_name;
 
@@ -87,9 +91,11 @@ static size_t aes_format_null_argument_error(const AES_ErrorDetails* err_details
     return strlen(dest);
 }
 
-static size_t aes_format_parse_error(const AES_ErrorDetails* err_details,
-                                     char* dest,
-                                     size_t dest_size) {
+static size_t aes_format_parse_error(
+    const AES_ErrorDetails* err_details,
+    char* dest,
+    size_t dest_size
+) {
     static const char* const fmt = "Couldn't parse '%s' (possibly not complete input) as %s";
     const char* const src = err_details->params.parse_error.src;
     const char* const what = err_details->params.parse_error.what;
@@ -101,9 +107,11 @@ static size_t aes_format_parse_error(const AES_ErrorDetails* err_details,
     return strlen(dest);
 }
 
-static size_t aes_format_not_implemented_error(const AES_ErrorDetails* err_details,
-                                               char* dest,
-                                               size_t dest_size) {
+static size_t aes_format_not_implemented_error(
+    const AES_ErrorDetails* err_details,
+    char* dest,
+    size_t dest_size
+) {
     static const char* const fmt = "Not implemented: %s";
     const char* const src = err_details->params.not_implemented.what;
 
@@ -163,9 +171,11 @@ AES_StatusCode aes_error_null_argument(AES_ErrorDetails* err_details, const char
     AES_StatusCode status = aes_make_error(err_details, AES_NULL_ARGUMENT_ERROR);
 
     if (err_details != NULL)
-        aes_fill_string(err_details->params.null_arg.param_name,
-                        sizeof(err_details->params.null_arg.param_name),
-                        param_name);
+        aes_fill_string(
+            err_details->params.null_arg.param_name,
+            sizeof(err_details->params.null_arg.param_name),
+            param_name
+        );
 
     return status;
 }
@@ -175,10 +185,11 @@ AES_StatusCode aes_error_parse(AES_ErrorDetails* err_details, const char* src, c
 
     if (err_details != NULL) {
         aes_fill_string(
-            err_details->params.parse_error.src, sizeof(err_details->params.parse_error.src), src);
-        aes_fill_string(err_details->params.parse_error.what,
-                        sizeof(err_details->params.parse_error.what),
-                        what);
+            err_details->params.parse_error.src, sizeof(err_details->params.parse_error.src), src
+        );
+        aes_fill_string(
+            err_details->params.parse_error.what, sizeof(err_details->params.parse_error.what), what
+        );
     }
 
     return status;
@@ -192,9 +203,11 @@ AES_StatusCode aes_error_not_implemented(AES_ErrorDetails* err_details, const ch
     AES_StatusCode status = aes_make_error(err_details, AES_NOT_IMPLEMENTED_ERROR);
 
     if (err_details != NULL)
-        aes_fill_string(err_details->params.not_implemented.what,
-                        sizeof(err_details->params.not_implemented.what),
-                        what);
+        aes_fill_string(
+            err_details->params.not_implemented.what,
+            sizeof(err_details->params.not_implemented.what),
+            what
+        );
 
     return status;
 }
diff --git a/aes/src/padding.c b/aes/src/padding.c
index 5647ea6..54c6c9c 100644
--- a/aes/src/padding.c
+++ b/aes/src/padding.c
@@ -11,10 +11,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-static AES_StatusCode aes_extract_padding_size_pkcs7(const void* src,
-                                                     size_t src_size,
-                                                     size_t* padding_size,
-                                                     AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_extract_padding_size_pkcs7(
+    const void* src,
+    size_t src_size,
+    size_t* padding_size,
+    AES_ErrorDetails* err_details
+) {
     const unsigned char* cursor = (const unsigned char*)src + src_size - 1;
     *padding_size = *cursor;
 
@@ -25,11 +27,13 @@ static AES_StatusCode aes_extract_padding_size_pkcs7(const void* src,
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_extract_padding_size(AES_PaddingMethod method,
-                                        const void* src,
-                                        size_t src_size,
-                                        size_t* padding_size,
-                                        AES_ErrorDetails* err_details) {
+AES_StatusCode aes_extract_padding_size(
+    AES_PaddingMethod method,
+    const void* src,
+    size_t src_size,
+    size_t* padding_size,
+    AES_ErrorDetails* err_details
+) {
     assert(src);
     assert(padding_size);
 
@@ -47,18 +51,22 @@ AES_StatusCode aes_extract_padding_size(AES_PaddingMethod method,
     }
 }
 
-static AES_StatusCode aes_fill_with_padding_pkcs7(void* dest,
-                                                  size_t padding_size,
-                                                  AES_ErrorDetails* err_details) {
+static AES_StatusCode aes_fill_with_padding_pkcs7(
+    void* dest,
+    size_t padding_size,
+    AES_ErrorDetails* err_details
+) {
     AES_UNUSED_PARAMETER(err_details);
     memset(dest, (int)padding_size, padding_size);
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_fill_with_padding(AES_PaddingMethod method,
-                                     void* dest,
-                                     size_t padding_size,
-                                     AES_ErrorDetails* err_details) {
+AES_StatusCode aes_fill_with_padding(
+    AES_PaddingMethod method,
+    void* dest,
+    size_t padding_size,
+    AES_ErrorDetails* err_details
+) {
     assert(dest);
 
     if (dest == NULL)