add .clang-format

18 files changed, 880 insertions, 1358 deletions

diff --git a/aes/include/aes/aes.h b/aes/include/aes/aes.h
index 1108235..2b3e9ff 100644
--- a/aes/include/aes/aes.h
+++ b/aes/include/aes/aes.h
@@ -12,8 +12,7 @@
 #include <assert.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 typedef AES_Block128 AES_AES_Block;
@@ -21,390 +20,301 @@ typedef AES_AES_Block AES_AES128_Block;
 typedef AES_AES_Block AES_AES192_Block;
 typedef AES_AES_Block AES_AES256_Block;
 
-typedef struct
-{
+typedef struct {
     AES_AES_Block key;
-}
-AES_AES128_Key;
+} AES_AES128_Key;
 
-typedef struct
-{
+typedef struct {
     AES_AES_Block hi;
     AES_AES_Block lo;
-}
-AES_AES192_Key;
+} AES_AES192_Key;
 
-typedef struct
-{
+typedef struct {
     AES_AES_Block hi;
     AES_AES_Block lo;
-}
-AES_AES256_Key;
+} AES_AES256_Key;
 
-static __inline AES_AES_Block aes_AES_make_block(
-    int hi3, int hi2, int lo1, int lo0)
-{
+static __inline AES_AES_Block aes_AES_make_block(int hi3, int hi2, int lo1, int lo0) {
     return aes_make_block128(hi3, hi2, lo1, lo0);
 }
 
-static __inline AES_AES128_Block aes_AES128_make_block(
-    int hi3, int hi2, int lo1, int lo0)
-{
+static __inline AES_AES128_Block aes_AES128_make_block(int hi3, int hi2, int lo1, int lo0) {
     return aes_AES_make_block(hi3, hi2, lo1, lo0);
 }
 
-static __inline AES_AES192_Block aes_AES192_make_block(
-    int hi3, int hi2, int lo1, int lo0)
-{
+static __inline AES_AES192_Block aes_AES192_make_block(int hi3, int hi2, int lo1, int lo0) {
     return aes_AES_make_block(hi3, hi2, lo1, lo0);
 }
 
-static __inline AES_AES256_Block aes_AES256_make_block(
-    int hi3, int hi2, int lo1, int lo0)
-{
+static __inline AES_AES256_Block aes_AES256_make_block(int hi3, int hi2, int lo1, int lo0) {
     return aes_AES_make_block(hi3, hi2, lo1, lo0);
 }
 
-static __inline AES_AES128_Key aes_AES128_make_key(
-    int hi3, int hi2, int lo1, int lo0)
-{
+static __inline AES_AES128_Key aes_AES128_make_key(int hi3, int hi2, int lo1, int lo0) {
     AES_AES128_Key key;
     key.key = aes_AES_make_block(hi3, hi2, lo1, lo0);
     return key;
 }
 
-static __inline AES_AES192_Key aes_AES192_make_key(
-    int hi5, int hi4,
-    int lo3, int lo2, int lo1, int lo0)
-{
+static __inline AES_AES192_Key aes_AES192_make_key(int hi5,
+                                                   int hi4,
+                                                   int lo3,
+                                                   int lo2,
+                                                   int lo1,
+                                                   int lo0) {
     AES_AES192_Key key;
-    key.hi = aes_AES_make_block(  0,   0, hi5, hi4);
+    key.hi = aes_AES_make_block(0, 0, hi5, hi4);
     key.lo = aes_AES_make_block(lo3, lo2, lo1, lo0);
     return key;
 }
 
-static __inline AES_AES256_Key aes_AES256_make_key(
-    int hi7, int hi6, int hi5, int hi4,
-    int lo3, int lo2, int lo1, int lo0)
-{
+static __inline AES_AES256_Key
+aes_AES256_make_key(int hi7, int hi6, int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) {
     AES_AES256_Key key;
     key.hi = aes_AES_make_block(hi7, hi6, hi5, hi4);
     key.lo = aes_AES_make_block(lo3, lo2, lo1, lo0);
     return key;
 }
 
-typedef struct { char str[33]; } AES_AES_BlockString;
+typedef struct {
+    char str[33];
+} AES_AES_BlockString;
+
 typedef AES_AES_BlockString AES_AES128_BlockString;
 typedef AES_AES_BlockString AES_AES192_BlockString;
 typedef AES_AES_BlockString AES_AES256_BlockString;
 
-typedef struct { char str[49]; } AES_AES_BlockMatrixString;
+typedef struct {
+    char str[49];
+} AES_AES_BlockMatrixString;
+
 typedef AES_AES_BlockMatrixString AES_AES128_BlockMatrixString;
 typedef AES_AES_BlockMatrixString AES_AES192_BlockMatrixString;
 typedef AES_AES_BlockMatrixString AES_AES256_BlockMatrixString;
 
-AES_StatusCode aes_AES_format_block(
-    AES_AES_BlockString*,
-    const AES_AES_Block*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES_format_block(AES_AES_BlockString*, const AES_AES_Block*, AES_ErrorDetails*);
 
-static __inline AES_StatusCode aes_AES128_format_block(
-    AES_AES128_BlockString* dest,
-    const AES_AES128_Block* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES128_format_block(AES_AES128_BlockString* dest,
+                                                       const AES_AES128_Block* src,
+                                                       AES_ErrorDetails* err_details) {
     return aes_AES_format_block(dest, src, err_details);
 }
 
-static __inline AES_StatusCode aes_AES192_format_block(
-    AES_AES192_BlockString* dest,
-    const AES_AES192_Block* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES192_format_block(AES_AES192_BlockString* dest,
+                                                       const AES_AES192_Block* src,
+                                                       AES_ErrorDetails* err_details) {
     return aes_AES_format_block(dest, src, err_details);
 }
 
-static __inline AES_StatusCode aes_AES256_format_block(
-    AES_AES256_BlockString* dest,
-    const AES_AES256_Block* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES256_format_block(AES_AES256_BlockString* dest,
+                                                       const AES_AES256_Block* src,
+                                                       AES_ErrorDetails* err_details) {
     return aes_AES_format_block(dest, src, err_details);
 }
 
-AES_StatusCode aes_AES_format_block_as_matrix(
-    AES_AES_BlockMatrixString*,
-    const AES_AES_Block*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES_format_block_as_matrix(AES_AES_BlockMatrixString*,
+                                              const AES_AES_Block*,
+                                              AES_ErrorDetails*);
 
-static __inline AES_StatusCode aes_AES128_format_block_as_matrix(
-    AES_AES128_BlockMatrixString* dest,
-    const AES_AES128_Block* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES128_format_block_as_matrix(AES_AES128_BlockMatrixString* dest,
+                                                                 const AES_AES128_Block* src,
+                                                                 AES_ErrorDetails* err_details) {
     return aes_AES_format_block_as_matrix(dest, src, err_details);
 }
 
-static __inline AES_StatusCode aes_AES192_format_block_as_matrix(
-    AES_AES192_BlockMatrixString* dest,
-    const AES_AES192_Block* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES192_format_block_as_matrix(AES_AES192_BlockMatrixString* dest,
+                                                                 const AES_AES192_Block* src,
+                                                                 AES_ErrorDetails* err_details) {
     return aes_AES_format_block_as_matrix(dest, src, err_details);
 }
 
-static __inline AES_StatusCode aes_AES256_format_block_as_matrix(
-    AES_AES256_BlockMatrixString* dest,
-    const AES_AES256_Block* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES256_format_block_as_matrix(AES_AES256_BlockMatrixString* dest,
+                                                                 const AES_AES256_Block* src,
+                                                                 AES_ErrorDetails* err_details) {
     return aes_AES_format_block_as_matrix(dest, src, err_details);
 }
 
-AES_StatusCode aes_AES_print_block(
-    const AES_AES_Block*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES_print_block(const AES_AES_Block*, AES_ErrorDetails*);
 
-static __inline AES_StatusCode aes_AES128_print_block(
-    const AES_AES128_Block* block,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES128_print_block(const AES_AES128_Block* block,
+                                                      AES_ErrorDetails* err_details) {
     return aes_AES_print_block(block, err_details);
 }
 
-static __inline AES_StatusCode aes_AES192_print_block(
-    const AES_AES192_Block* block,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES192_print_block(const AES_AES192_Block* block,
+                                                      AES_ErrorDetails* err_details) {
     return aes_AES_print_block(block, err_details);
 }
 
-static __inline AES_StatusCode aes_AES256_print_block(
-    const AES_AES256_Block* block,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES256_print_block(const AES_AES256_Block* block,
+                                                      AES_ErrorDetails* err_details) {
     return aes_AES_print_block(block, err_details);
 }
 
-AES_StatusCode aes_AES_print_block_as_matrix(
-    const AES_AES_Block*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES_print_block_as_matrix(const AES_AES_Block*, AES_ErrorDetails*);
 
-static __inline AES_StatusCode aes_AES128_print_block_as_matrix(
-    const AES_AES128_Block* block,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES128_print_block_as_matrix(const AES_AES128_Block* block,
+                                                                AES_ErrorDetails* err_details) {
     return aes_AES_print_block_as_matrix(block, err_details);
 }
 
-static __inline AES_StatusCode aes_AES192_print_block_as_matrix(
-    const AES_AES192_Block* block,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES192_print_block_as_matrix(const AES_AES192_Block* block,
+                                                                AES_ErrorDetails* err_details) {
     return aes_AES_print_block_as_matrix(block, err_details);
 }
 
-static __inline AES_StatusCode aes_AES256_print_block_as_matrix(
-    const AES_AES256_Block* block,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES256_print_block_as_matrix(const AES_AES256_Block* block,
+                                                                AES_ErrorDetails* err_details) {
     return aes_AES_print_block_as_matrix(block, err_details);
 }
 
-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);
 
-static __inline AES_StatusCode aes_AES128_parse_block(
-    AES_AES128_Block* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES128_parse_block(AES_AES128_Block* dest,
+                                                      const char* src,
+                                                      AES_ErrorDetails* err_details) {
     return aes_AES_parse_block(dest, src, err_details);
 }
 
-static __inline AES_StatusCode aes_AES192_parse_block(
-    AES_AES192_Block* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES192_parse_block(AES_AES192_Block* dest,
+                                                      const char* src,
+                                                      AES_ErrorDetails* err_details) {
     return aes_AES_parse_block(dest, src, err_details);
 }
 
-static __inline AES_StatusCode aes_AES256_parse_block(
-    AES_AES256_Block* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_AES256_parse_block(AES_AES256_Block* dest,
+                                                      const char* src,
+                                                      AES_ErrorDetails* err_details) {
     return aes_AES_parse_block(dest, src, err_details);
 }
 
-typedef struct { char str[33]; } AES_AES128_KeyString;
-typedef struct { char str[49]; } AES_AES192_KeyString;
-typedef struct { char str[65]; } AES_AES256_KeyString;
+typedef struct {
+    char str[33];
+} AES_AES128_KeyString;
+
+typedef struct {
+    char str[49];
+} AES_AES192_KeyString;
+
+typedef struct {
+    char str[65];
+} AES_AES256_KeyString;
 
-AES_StatusCode aes_AES128_format_key(
-    AES_AES128_KeyString*,
-    const AES_AES128_Key*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES128_format_key(AES_AES128_KeyString*,
+                                     const AES_AES128_Key*,
+                                     AES_ErrorDetails*);
 
-AES_StatusCode aes_AES192_format_key(
-    AES_AES192_KeyString*,
-    const AES_AES192_Key*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES192_format_key(AES_AES192_KeyString*,
+                                     const AES_AES192_Key*,
+                                     AES_ErrorDetails*);
 
-AES_StatusCode aes_AES256_format_key(
-    AES_AES256_KeyString*,
-    const AES_AES256_Key*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES256_format_key(AES_AES256_KeyString*,
+                                     const AES_AES256_Key*,
+                                     AES_ErrorDetails*);
 
-AES_StatusCode aes_AES128_print_key(
-    const AES_AES128_Key*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES128_print_key(const AES_AES128_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES192_print_key(
-    const AES_AES192_Key*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES192_print_key(const AES_AES192_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES256_print_key(
-    const AES_AES256_Key*,
-    AES_ErrorDetails*);
+AES_StatusCode aes_AES256_print_key(const AES_AES256_Key*, AES_ErrorDetails*);
 
-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);
 
-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);
 
-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);
 
-typedef struct
-{
+typedef struct {
     AES_AES_Block keys[11];
-}
-AES_AES128_RoundKeys;
+} AES_AES128_RoundKeys;
 
-typedef struct
-{
+typedef struct {
     AES_AES_Block keys[13];
-}
-AES_AES192_RoundKeys;
+} AES_AES192_RoundKeys;
 
-typedef struct
-{
+typedef struct {
     AES_AES_Block keys[15];
-}
-AES_AES256_RoundKeys;
+} AES_AES256_RoundKeys;
 
-void __fastcall aes_AES128_expand_key_(
-    AES_AES_Block key,
-    AES_AES128_RoundKeys* encryption_keys);
+void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys* encryption_keys);
 
-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);
 
-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);
 
-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);
 
-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);
 
-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);
 
-AES_AES_Block __fastcall aes_AES128_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES128_RoundKeys*);
+AES_AES_Block __fastcall aes_AES128_encrypt_block_(AES_AES_Block plaintext,
+                                                   const AES_AES128_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES192_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES192_RoundKeys*);
+AES_AES_Block __fastcall aes_AES192_encrypt_block_(AES_AES_Block plaintext,
+                                                   const AES_AES192_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES256_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES256_RoundKeys*);
+AES_AES_Block __fastcall aes_AES256_encrypt_block_(AES_AES_Block plaintext,
+                                                   const AES_AES256_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES128_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES128_RoundKeys*);
+AES_AES_Block __fastcall aes_AES128_decrypt_block_(AES_AES_Block ciphertext,
+                                                   const AES_AES128_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES192_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES192_RoundKeys*);
+AES_AES_Block __fastcall aes_AES192_decrypt_block_(AES_AES_Block ciphertext,
+                                                   const AES_AES192_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES256_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES256_RoundKeys*);
+AES_AES_Block __fastcall aes_AES256_decrypt_block_(AES_AES_Block ciphertext,
+                                                   const AES_AES256_RoundKeys*);
 
-static __inline AES_AES_Block __fastcall aes_AES_xor_blocks(
-    AES_AES_Block a,
-    AES_AES_Block b)
-{
+static __inline AES_AES_Block __fastcall aes_AES_xor_blocks(AES_AES_Block a, AES_AES_Block b) {
     return aes_xor_block128(a, b);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES128_xor_blocks(
-    AES_AES128_Block a,
-    AES_AES128_Block b)
-{
+static __inline AES_AES_Block __fastcall aes_AES128_xor_blocks(AES_AES128_Block a,
+                                                               AES_AES128_Block b) {
     return aes_AES_xor_blocks(a, b);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES192_xor_blocks(
-    AES_AES192_Block a,
-    AES_AES192_Block b)
-{
+static __inline AES_AES_Block __fastcall aes_AES192_xor_blocks(AES_AES192_Block a,
+                                                               AES_AES192_Block b) {
     return aes_AES_xor_blocks(a, b);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES256_xor_blocks(
-    AES_AES256_Block a,
-    AES_AES256_Block b)
-{
+static __inline AES_AES_Block __fastcall aes_AES256_xor_blocks(AES_AES256_Block a,
+                                                               AES_AES256_Block b) {
     return aes_AES_xor_blocks(a, b);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES_inc_block(
-    AES_AES_Block block)
-{
+static __inline AES_AES_Block __fastcall aes_AES_inc_block(AES_AES_Block block) {
     block = aes_reverse_byte_order_block128(block);
     block = aes_inc_block128(block);
     return aes_reverse_byte_order_block128(block);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES128_inc_block(
-    AES_AES128_Block block)
-{
+static __inline AES_AES_Block __fastcall aes_AES128_inc_block(AES_AES128_Block block) {
     return aes_AES_inc_block(block);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES192_inc_block(
-    AES_AES192_Block block)
-{
+static __inline AES_AES_Block __fastcall aes_AES192_inc_block(AES_AES192_Block block) {
     return aes_AES_inc_block(block);
 }
 
-static __inline AES_AES_Block __fastcall aes_AES256_inc_block(
-    AES_AES256_Block block)
-{
+static __inline AES_AES_Block __fastcall aes_AES256_inc_block(AES_AES256_Block block) {
     return aes_AES_inc_block(block);
 }
 
@@ -447,10 +357,8 @@ AES_DECRYPT_BLOCK_CTR(AES256);
  * \param[in] key The AES-128 key.
  * \param[out] encryption_keys The AES-128 encryption round keys. Must not be `NULL`.
  */
-static __inline void __fastcall aes_AES128_expand_key(
-    const AES_AES128_Key* key,
-    AES_AES128_RoundKeys* encryption_keys)
-{
+static __inline void __fastcall aes_AES128_expand_key(const AES_AES128_Key* key,
+                                                      AES_AES128_RoundKeys* encryption_keys) {
     assert(encryption_keys);
 
     aes_AES128_expand_key_(key->key, encryption_keys);
@@ -464,8 +372,7 @@ static __inline void __fastcall aes_AES128_expand_key(
  */
 static __inline void __fastcall aes_AES128_derive_decryption_keys(
     const AES_AES128_RoundKeys* encryption_keys,
-    AES_AES128_RoundKeys* decryption_keys)
-{
+    AES_AES128_RoundKeys* decryption_keys) {
     assert(encryption_keys);
     assert(decryption_keys);
 
@@ -478,10 +385,8 @@ static __inline void __fastcall aes_AES128_derive_decryption_keys(
  * \param[in] key The AES-192 key.
  * \param[out] encryption_keys The AES-192 encryption round keys. Must not be `NULL`.
  */
-static __inline void __fastcall aes_AES192_expand_key(
-    const AES_AES192_Key* key,
-    AES_AES192_RoundKeys* encryption_keys)
-{
+static __inline void __fastcall aes_AES192_expand_key(const AES_AES192_Key* key,
+                                                      AES_AES192_RoundKeys* encryption_keys) {
     assert(key);
     assert(encryption_keys);
 
@@ -496,8 +401,7 @@ static __inline void __fastcall aes_AES192_expand_key(
  */
 static __inline void __fastcall aes_AES192_derive_decryption_keys(
     const AES_AES192_RoundKeys* encryption_keys,
-    AES_AES192_RoundKeys* decryption_keys)
-{
+    AES_AES192_RoundKeys* decryption_keys) {
     assert(encryption_keys);
     assert(decryption_keys);
 
@@ -510,10 +414,8 @@ static __inline void __fastcall aes_AES192_derive_decryption_keys(
  * \param[in] key The AES-256 key.
  * \param[out] encryption_keys The AES-256 encryption round keys. Must not be `NULL`.
  */
-static __inline void __fastcall aes_AES256_expand_key(
-    const AES_AES256_Key* key,
-    AES_AES256_RoundKeys* encryption_keys)
-{
+static __inline void __fastcall aes_AES256_expand_key(const AES_AES256_Key* key,
+                                                      AES_AES256_RoundKeys* encryption_keys) {
     assert(key);
     assert(encryption_keys);
 
@@ -528,8 +430,7 @@ static __inline void __fastcall aes_AES256_expand_key(
  */
 static __inline void __fastcall aes_AES256_derive_decryption_keys(
     const AES_AES256_RoundKeys* encryption_keys,
-    AES_AES256_RoundKeys* decryption_keys)
-{
+    AES_AES256_RoundKeys* decryption_keys) {
     assert(encryption_keys);
     assert(decryption_keys);
 
diff --git a/aes/include/aes/algorithm.h b/aes/include/aes/algorithm.h
index d88cf59..e17a75a 100644
--- a/aes/include/aes/algorithm.h
+++ b/aes/include/aes/algorithm.h
@@ -6,17 +6,14 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-typedef enum
-{
+typedef enum {
     AES_AES128,
     AES_AES192,
     AES_AES256,
-}
-AES_Algorithm;
+} AES_Algorithm;
 
 #ifdef __cplusplus
 }
diff --git a/aes/include/aes/box.h b/aes/include/aes/box.h
index 2051d3d..4960fcd 100644
--- a/aes/include/aes/box.h
+++ b/aes/include/aes/box.h
@@ -12,69 +12,59 @@
 #include <stdlib.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-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 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);
 
-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);
 
-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);
 
-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);
 
-AES_StatusCode aes_box_encrypt_block(
-    AES_Box* box,
-    const AES_BoxBlock* plaintext,
-    AES_BoxBlock* ciphertext,
-    AES_ErrorDetails* err_details);
+AES_StatusCode aes_box_encrypt_block(AES_Box* box,
+                                     const AES_BoxBlock* plaintext,
+                                     AES_BoxBlock* ciphertext,
+                                     AES_ErrorDetails* err_details);
 
-AES_StatusCode aes_box_decrypt_block(
-    AES_Box* box,
-    const AES_BoxBlock* ciphertext,
-    AES_BoxBlock* plaintext,
-    AES_ErrorDetails* err_details);
+AES_StatusCode aes_box_decrypt_block(AES_Box* box,
+                                     const AES_BoxBlock* ciphertext,
+                                     AES_BoxBlock* plaintext,
+                                     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 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_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);
 
 #ifdef __cplusplus
 }
diff --git a/aes/include/aes/box_aes.h b/aes/include/aes/box_aes.h
index c92d883..e15f0cb 100644
--- a/aes/include/aes/box_aes.h
+++ b/aes/include/aes/box_aes.h
@@ -8,8 +8,7 @@
 #include "box_data.h"
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 extern AES_BoxAlgorithmInterface aes_box_algorithm_aes128;
diff --git a/aes/include/aes/box_data.h b/aes/include/aes/box_data.h
index e2315eb..296afa0 100644
--- a/aes/include/aes/box_data.h
+++ b/aes/include/aes/box_data.h
@@ -12,117 +12,83 @@
 #include <stdlib.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-typedef union
-{
+typedef union {
     AES_AES128_Key aes128_key;
     AES_AES192_Key aes192_key;
     AES_AES256_Key aes256_key;
-}
-AES_BoxKey;
+} AES_BoxKey;
 
-typedef union
-{
+typedef union {
     AES_AES128_RoundKeys aes128_encryption_keys;
     AES_AES192_RoundKeys aes192_encryption_keys;
     AES_AES256_RoundKeys aes256_encryption_keys;
-}
-AES_BoxEncryptionRoundKeys;
+} AES_BoxEncryptionRoundKeys;
 
-typedef union
-{
+typedef union {
     AES_AES128_RoundKeys aes128_decryption_keys;
     AES_AES192_RoundKeys aes192_decryption_keys;
     AES_AES256_RoundKeys aes256_decryption_keys;
-}
-AES_BoxDecryptionRoundKeys;
+} AES_BoxDecryptionRoundKeys;
 
-typedef union
-{
+typedef union {
     AES_AES128_KeyString aes128;
     AES_AES192_KeyString aes192;
     AES_AES256_KeyString aes256;
-}
-AES_BoxKeyString;
+} AES_BoxKeyString;
 
-typedef union
-{
+typedef union {
     AES_AES_Block aes_block;
-}
-AES_BoxBlock;
+} AES_BoxBlock;
 
-typedef union
-{
+typedef union {
     AES_AES_BlockString aes;
-}
-AES_BoxBlockString;
+} AES_BoxBlockString;
 
-typedef AES_StatusCode (*AES_BoxCalculateRoundKeys)(
-    const AES_BoxKey* params,
-    AES_BoxEncryptionRoundKeys*,
-    AES_BoxDecryptionRoundKeys*,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxCalculateRoundKeys)(const AES_BoxKey* params,
+                                                    AES_BoxEncryptionRoundKeys*,
+                                                    AES_BoxDecryptionRoundKeys*,
+                                                    AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxParseBlock)(
-    AES_BoxBlock* dest,
-    const char* src,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxParseBlock)(AES_BoxBlock* dest,
+                                            const char* src,
+                                            AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxParseKey)(
-    AES_BoxKey* dest,
-    const char* src,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxParseKey)(AES_BoxKey* dest,
+                                          const char* src,
+                                          AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxFormatBlock)(
-    AES_BoxBlockString* dest,
-    const AES_BoxBlock* src,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxFormatBlock)(AES_BoxBlockString* dest,
+                                             const AES_BoxBlock* src,
+                                             AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxFormatKey)(
-    AES_BoxKeyString* dest,
-    const AES_BoxKey* src,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxFormatKey)(AES_BoxKeyString* dest,
+                                           const AES_BoxKey* src,
+                                           AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxEncryptBlock)(
-    const AES_BoxBlock* plaintext,
-    const AES_BoxEncryptionRoundKeys* params,
-    AES_BoxBlock* ciphertext,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxEncryptBlock)(const AES_BoxBlock* plaintext,
+                                              const AES_BoxEncryptionRoundKeys* params,
+                                              AES_BoxBlock* ciphertext,
+                                              AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxDecryptBlock)(
-    const AES_BoxBlock* ciphertext,
-    const AES_BoxDecryptionRoundKeys* params,
-    AES_BoxBlock* plaintext,
-    AES_ErrorDetails* err_details);
+typedef AES_StatusCode (*AES_BoxDecryptBlock)(const AES_BoxBlock* ciphertext,
+                                              const AES_BoxDecryptionRoundKeys* params,
+                                              AES_BoxBlock* plaintext,
+                                              AES_ErrorDetails* err_details);
 
-typedef AES_StatusCode (*AES_BoxXorBlock)(
-    AES_BoxBlock*,
-    const AES_BoxBlock*,
-    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxXorBlock)(AES_BoxBlock*, const AES_BoxBlock*, AES_ErrorDetails*);
 
-typedef AES_StatusCode (*AES_BoxIncBlock)(
-    AES_BoxBlock*,
-    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxIncBlock)(AES_BoxBlock*, AES_ErrorDetails*);
 
-typedef AES_StatusCode (*AES_BoxGetBlockSize)(
-    size_t*,
-    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxGetBlockSize)(size_t*, AES_ErrorDetails*);
 
-typedef AES_StatusCode (*AES_BoxStoreBlock)(
-    void*,
-    const AES_BoxBlock*,
-    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxStoreBlock)(void*, const AES_BoxBlock*, AES_ErrorDetails*);
 
-typedef AES_StatusCode (*AES_BoxLoadBlock)(
-    AES_BoxBlock*,
-    const void*,
-    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxLoadBlock)(AES_BoxBlock*, const void*, AES_ErrorDetails*);
 
-typedef struct
-{
+typedef struct {
     AES_BoxCalculateRoundKeys calc_round_keys;
     AES_BoxParseBlock parse_block;
     AES_BoxParseKey parse_key;
@@ -135,18 +101,15 @@ typedef struct
     AES_BoxGetBlockSize get_block_size;
     AES_BoxStoreBlock store_block;
     AES_BoxLoadBlock load_block;
-}
-AES_BoxAlgorithmInterface;
+} AES_BoxAlgorithmInterface;
 
-typedef struct
-{
+typedef struct {
     const AES_BoxAlgorithmInterface* algorithm;
     AES_BoxEncryptionRoundKeys encryption_keys;
     AES_BoxDecryptionRoundKeys decryption_keys;
     AES_Mode mode;
     AES_BoxBlock iv;
-}
-AES_Box;
+} AES_Box;
 
 #ifdef __cplusplus
 }
diff --git a/aes/include/aes/data.h b/aes/include/aes/data.h
index a441939..71b339a 100644
--- a/aes/include/aes/data.h
+++ b/aes/include/aes/data.h
@@ -9,8 +9,7 @@
 #include <tmmintrin.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 /**
@@ -25,9 +24,8 @@ typedef __m128i AES_Block128;
  *
  * \return The loaded 128-bit block.
  */
-static __inline AES_Block128 aes_load_block128(const void* src)
-{
-    return _mm_loadu_si128((AES_Block128*) src);
+static __inline AES_Block128 aes_load_block128(const void* src) {
+    return _mm_loadu_si128((AES_Block128*)src);
 }
 
 /**
@@ -37,9 +35,8 @@ static __inline AES_Block128 aes_load_block128(const void* src)
  *
  * \return The loaded 128-bit block.
  */
-static __inline AES_Block128 aes_load_block128_aligned(const void* src)
-{
-    return _mm_load_si128((AES_Block128*) src);
+static __inline AES_Block128 aes_load_block128_aligned(const void* src) {
+    return _mm_load_si128((AES_Block128*)src);
 }
 
 /**
@@ -49,11 +46,8 @@ static __inline AES_Block128 aes_load_block128_aligned(const void* src)
  *
  * \param[in] block The block to be stored.
  */
-static __inline void __fastcall aes_store_block128(
-    void* dest,
-    AES_Block128 block)
-{
-    _mm_storeu_si128((AES_Block128*) dest, block);
+static __inline void __fastcall aes_store_block128(void* dest, AES_Block128 block) {
+    _mm_storeu_si128((AES_Block128*)dest, block);
 }
 
 /**
@@ -63,11 +57,8 @@ static __inline void __fastcall aes_store_block128(
  *
  * \param[in] block The block to be stored.
  */
-static __inline void __fastcall aes_store_block128_aligned(
-    void* dest,
-    AES_Block128 block)
-{
-    _mm_store_si128((AES_Block128*) dest, block);
+static __inline void __fastcall aes_store_block128_aligned(void* dest, AES_Block128 block) {
+    _mm_store_si128((AES_Block128*)dest, block);
 }
 
 /**
@@ -78,10 +69,7 @@ static __inline void __fastcall aes_store_block128_aligned(
  *
  * \return `a^b`.
  */
-static __inline AES_Block128 __fastcall aes_xor_block128(
-    AES_Block128 a,
-    AES_Block128 b)
-{
+static __inline AES_Block128 __fastcall aes_xor_block128(AES_Block128 a, AES_Block128 b) {
     return _mm_xor_si128(a, b);
 }
 
@@ -102,18 +90,16 @@ static __inline AES_Block128 __fastcall aes_xor_block128(
  *
  * \return The built 128-bit block.
  */
-static __inline AES_Block128 __fastcall aes_make_block128(int hi3, int hi2, int lo1, int lo0)
-{
+static __inline AES_Block128 __fastcall aes_make_block128(int hi3, int hi2, int lo1, int lo0) {
     return _mm_set_epi32(hi3, hi2, lo1, lo0);
 }
 
-static __inline AES_Block128 __fastcall aes_reverse_byte_order_block128(AES_Block128 block)
-{
-    return _mm_shuffle_epi8(block, aes_make_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f));
+static __inline AES_Block128 __fastcall aes_reverse_byte_order_block128(AES_Block128 block) {
+    return _mm_shuffle_epi8(block,
+                            aes_make_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f));
 }
 
-static __inline AES_Block128 __fastcall aes_inc_block128(AES_Block128 x)
-{
+static __inline AES_Block128 __fastcall aes_inc_block128(AES_Block128 x) {
     return _mm_add_epi32(x, aes_make_block128(0, 0, 0, 1));
 }
 
diff --git a/aes/include/aes/error.h b/aes/include/aes/error.h
index e094f8a..2c93ab0 100644
--- a/aes/include/aes/error.h
+++ b/aes/include/aes/error.h
@@ -8,12 +8,10 @@
 #include <stdlib.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-typedef enum
-{
+typedef enum {
     AES_SUCCESS,
     AES_NULL_ARGUMENT_ERROR,
     AES_PARSE_ERROR,
@@ -21,11 +19,9 @@ typedef enum
     AES_NOT_IMPLEMENTED_ERROR,
     AES_MISSING_PADDING_ERROR,
     AES_MEMORY_ALLOCATION_ERROR,
-}
-AES_StatusCode;
+} AES_StatusCode;
 
-static __inline int aes_is_error(AES_StatusCode ec)
-{
+static __inline int aes_is_error(AES_StatusCode ec) {
     return ec != AES_SUCCESS;
 }
 
@@ -33,63 +29,45 @@ const char* aes_strerror(AES_StatusCode ec);
 
 #define AES_MAX_CALL_STACK_LENGTH 32
 
-typedef struct
-{
+typedef struct {
     AES_StatusCode ec; ///< Error code
 
-    union
-    {
-        struct { char param_name[32]; } null_arg;
-        struct
-        {
+    union {
+        struct {
+            char param_name[32];
+        } null_arg;
+        struct {
             char src[128];
             char what[32];
-        }
-        parse_error;
-        struct { char what[128]; } not_implemented;
-    }
-    params;
+        } parse_error;
+        struct {
+            char what[128];
+        } not_implemented;
+    } params;
 
     void* call_stack[AES_MAX_CALL_STACK_LENGTH];
     size_t call_stack_len;
-}
-AES_ErrorDetails;
+} AES_ErrorDetails;
 
-static __inline AES_StatusCode aes_get_error_code(
-    const AES_ErrorDetails* err_details)
-{
+static __inline AES_StatusCode aes_get_error_code(const AES_ErrorDetails* err_details) {
     return err_details->ec;
 }
 
-size_t aes_format_error(
-    const AES_ErrorDetails* err_details,
-    char* dest,
-    size_t dest_size);
+size_t aes_format_error(const AES_ErrorDetails* err_details, char* dest, size_t dest_size);
 
-AES_StatusCode aes_success(
-    AES_ErrorDetails* err_details);
+AES_StatusCode aes_success(AES_ErrorDetails* err_details);
 
-AES_StatusCode aes_error_null_argument(
-    AES_ErrorDetails* err_details,
-    const char* param_name);
+AES_StatusCode aes_error_null_argument(AES_ErrorDetails* err_details, const char* param_name);
 
-AES_StatusCode aes_error_parse(
-    AES_ErrorDetails* err_details,
-    const char* src,
-    const char* what);
+AES_StatusCode aes_error_parse(AES_ErrorDetails* err_details, const char* src, const char* what);
 
-AES_StatusCode aes_error_invalid_pkcs7_padding(
-    AES_ErrorDetails* err_details);
+AES_StatusCode aes_error_invalid_pkcs7_padding(AES_ErrorDetails* err_details);
 
-AES_StatusCode aes_error_not_implemented(
-    AES_ErrorDetails* err_details,
-    const char* what);
+AES_StatusCode aes_error_not_implemented(AES_ErrorDetails* err_details, const char* what);
 
-AES_StatusCode aes_error_missing_padding(
-    AES_ErrorDetails* err_details);
+AES_StatusCode aes_error_missing_padding(AES_ErrorDetails* err_details);
 
-AES_StatusCode aes_error_memory_allocation(
-    AES_ErrorDetails* err_details);
+AES_StatusCode aes_error_memory_allocation(AES_ErrorDetails* err_details);
 
 #ifdef __cplusplus
 }
diff --git a/aes/include/aes/mode.h b/aes/include/aes/mode.h
index 090628b..4c5e931 100644
--- a/aes/include/aes/mode.h
+++ b/aes/include/aes/mode.h
@@ -8,158 +8,143 @@
 #include <assert.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-typedef enum
-{
+typedef enum {
     AES_ECB,
     AES_CBC,
     AES_CFB,
     AES_OFB,
     AES_CTR,
-}
-AES_Mode;
+} AES_Mode;
 
-#define AES_ENCRYPT_BLOCK_ECB(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_encrypt_block_ECB( \
-    AES_## prefix ##_Block plaintext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys) \
-{ \
-    assert(encryption_keys); \
-\
-    return aes_## prefix ##_encrypt_block_(plaintext, encryption_keys); \
-}
+#define AES_ENCRYPT_BLOCK_ECB(prefix)                                                      \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_ECB(      \
+        AES_##prefix##_Block plaintext, const AES_##prefix##_RoundKeys* encryption_keys) { \
+        assert(encryption_keys);                                                           \
+                                                                                           \
+        return aes_##prefix##_encrypt_block_(plaintext, encryption_keys);                  \
+    }
 
-#define AES_DECRYPT_BLOCK_ECB(prefix) \
-static __inline AES_## prefix ##_Block  __fastcall aes_## prefix ##_decrypt_block_ECB( \
-    AES_## prefix ##_Block ciphertext, \
-    const AES_## prefix ##_RoundKeys* decryption_keys) \
-{ \
-    assert(decryption_keys); \
-\
-    return aes_## prefix ##_decrypt_block_(ciphertext, decryption_keys); \
-}
+#define AES_DECRYPT_BLOCK_ECB(prefix)                                                       \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_ECB(       \
+        AES_##prefix##_Block ciphertext, const AES_##prefix##_RoundKeys* decryption_keys) { \
+        assert(decryption_keys);                                                            \
+                                                                                            \
+        return aes_##prefix##_decrypt_block_(ciphertext, decryption_keys);                  \
+    }
 
-#define AES_ENCRYPT_BLOCK_CBC(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_encrypt_block_CBC( \
-    AES_## prefix ##_Block plaintext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    return *next_init_vector = aes_## prefix ##_encrypt_block_( \
-        aes_## prefix ##_xor_blocks(plaintext, init_vector), encryption_keys); \
-}
+#define AES_ENCRYPT_BLOCK_CBC(prefix)                                                   \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_CBC(   \
+        AES_##prefix##_Block plaintext,                                                 \
+        const AES_##prefix##_RoundKeys* encryption_keys,                                \
+        AES_##prefix##_Block init_vector,                                               \
+        AES_##prefix##_Block* next_init_vector) {                                       \
+        assert(encryption_keys);                                                        \
+        assert(next_init_vector);                                                       \
+                                                                                        \
+        return *next_init_vector = aes_##prefix##_encrypt_block_(                       \
+                   aes_##prefix##_xor_blocks(plaintext, init_vector), encryption_keys); \
+    }
 
-#define AES_DECRYPT_BLOCK_CBC(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_decrypt_block_CBC( \
-    AES_## prefix ##_Block ciphertext, \
-    const AES_## prefix ##_RoundKeys* decryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(decryption_keys); \
-    assert(next_init_vector); \
-\
-    AES_## prefix ##_Block plaintext = aes_## prefix ##_xor_blocks( \
-        aes_## prefix ##_decrypt_block_(ciphertext, decryption_keys), init_vector); \
-    *next_init_vector = ciphertext; \
-    return plaintext; \
-}
+#define AES_DECRYPT_BLOCK_CBC(prefix)                                                 \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_CBC( \
+        AES_##prefix##_Block ciphertext,                                              \
+        const AES_##prefix##_RoundKeys* decryption_keys,                              \
+        AES_##prefix##_Block init_vector,                                             \
+        AES_##prefix##_Block* next_init_vector) {                                     \
+        assert(decryption_keys);                                                      \
+        assert(next_init_vector);                                                     \
+                                                                                      \
+        AES_##prefix##_Block plaintext = aes_##prefix##_xor_blocks(                   \
+            aes_##prefix##_decrypt_block_(ciphertext, decryption_keys), init_vector); \
+        *next_init_vector = ciphertext;                                               \
+        return plaintext;                                                             \
+    }
 
-#define AES_ENCRYPT_BLOCK_CFB(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_encrypt_block_CFB( \
-    AES_## prefix ##_Block plaintext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    return *next_init_vector = aes_## prefix ##_xor_blocks( \
-        aes_## prefix ##_encrypt_block_(init_vector, encryption_keys), plaintext); \
-}
+#define AES_ENCRYPT_BLOCK_CFB(prefix)                                                       \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_CFB(       \
+        AES_##prefix##_Block plaintext,                                                     \
+        const AES_##prefix##_RoundKeys* encryption_keys,                                    \
+        AES_##prefix##_Block init_vector,                                                   \
+        AES_##prefix##_Block* next_init_vector) {                                           \
+        assert(encryption_keys);                                                            \
+        assert(next_init_vector);                                                           \
+                                                                                            \
+        return *next_init_vector = aes_##prefix##_xor_blocks(                               \
+                   aes_##prefix##_encrypt_block_(init_vector, encryption_keys), plaintext); \
+    }
 
-#define AES_DECRYPT_BLOCK_CFB(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_decrypt_block_CFB( \
-    AES_## prefix ##_Block ciphertext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    AES_## prefix ##_Block plaintext = aes_## prefix ##_xor_blocks( \
-        aes_## prefix ##_encrypt_block_(init_vector, encryption_keys), ciphertext); \
-    *next_init_vector = ciphertext; \
-    return plaintext; \
-}
+#define AES_DECRYPT_BLOCK_CFB(prefix)                                                 \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_CFB( \
+        AES_##prefix##_Block ciphertext,                                              \
+        const AES_##prefix##_RoundKeys* encryption_keys,                              \
+        AES_##prefix##_Block init_vector,                                             \
+        AES_##prefix##_Block* next_init_vector) {                                     \
+        assert(encryption_keys);                                                      \
+        assert(next_init_vector);                                                     \
+                                                                                      \
+        AES_##prefix##_Block plaintext = aes_##prefix##_xor_blocks(                   \
+            aes_##prefix##_encrypt_block_(init_vector, encryption_keys), ciphertext); \
+        *next_init_vector = ciphertext;                                               \
+        return plaintext;                                                             \
+    }
 
-#define AES_ENCRYPT_BLOCK_OFB(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_encrypt_block_OFB( \
-    AES_## prefix ##_Block plaintext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    AES_## prefix ##_Block tmp = aes_## prefix ##_encrypt_block_(init_vector, encryption_keys); \
-    *next_init_vector = tmp; \
-    return aes_## prefix ##_xor_blocks(tmp, plaintext); \
-}
+#define AES_ENCRYPT_BLOCK_OFB(prefix)                                                           \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_OFB(           \
+        AES_##prefix##_Block plaintext,                                                         \
+        const AES_##prefix##_RoundKeys* encryption_keys,                                        \
+        AES_##prefix##_Block init_vector,                                                       \
+        AES_##prefix##_Block* next_init_vector) {                                               \
+        assert(encryption_keys);                                                                \
+        assert(next_init_vector);                                                               \
+                                                                                                \
+        AES_##prefix##_Block tmp = aes_##prefix##_encrypt_block_(init_vector, encryption_keys); \
+        *next_init_vector = tmp;                                                                \
+        return aes_##prefix##_xor_blocks(tmp, plaintext);                                       \
+    }
 
-#define AES_DECRYPT_BLOCK_OFB(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_decrypt_block_OFB( \
-    AES_## prefix ##_Block ciphertext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    return aes_## prefix ##_encrypt_block_OFB( \
-        ciphertext, encryption_keys, init_vector, next_init_vector); \
-}
+#define AES_DECRYPT_BLOCK_OFB(prefix)                                                 \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_OFB( \
+        AES_##prefix##_Block ciphertext,                                              \
+        const AES_##prefix##_RoundKeys* encryption_keys,                              \
+        AES_##prefix##_Block init_vector,                                             \
+        AES_##prefix##_Block* next_init_vector) {                                     \
+        assert(encryption_keys);                                                      \
+        assert(next_init_vector);                                                     \
+                                                                                      \
+        return aes_##prefix##_encrypt_block_OFB(                                      \
+            ciphertext, encryption_keys, init_vector, next_init_vector);              \
+    }
 
-#define AES_ENCRYPT_BLOCK_CTR(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_encrypt_block_CTR( \
-    AES_## prefix ##_Block plaintext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    AES_## prefix ##_Block ciphertext = aes_## prefix ##_xor_blocks( \
-        plaintext, aes_## prefix ##_encrypt_block_(init_vector, encryption_keys)); \
-    *next_init_vector = aes_## prefix ##_inc_block(init_vector); \
-    return ciphertext; \
-}
+#define AES_ENCRYPT_BLOCK_CTR(prefix)                                                 \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_CTR( \
+        AES_##prefix##_Block plaintext,                                               \
+        const AES_##prefix##_RoundKeys* encryption_keys,                              \
+        AES_##prefix##_Block init_vector,                                             \
+        AES_##prefix##_Block* next_init_vector) {                                     \
+        assert(encryption_keys);                                                      \
+        assert(next_init_vector);                                                     \
+                                                                                      \
+        AES_##prefix##_Block ciphertext = aes_##prefix##_xor_blocks(                  \
+            plaintext, aes_##prefix##_encrypt_block_(init_vector, encryption_keys));  \
+        *next_init_vector = aes_##prefix##_inc_block(init_vector);                    \
+        return ciphertext;                                                            \
+    }
 
-#define AES_DECRYPT_BLOCK_CTR(prefix) \
-static __inline AES_## prefix ##_Block __fastcall aes_## prefix ##_decrypt_block_CTR( \
-    AES_## prefix ##_Block ciphertext, \
-    const AES_## prefix ##_RoundKeys* encryption_keys, \
-    AES_## prefix ##_Block init_vector, \
-    AES_## prefix ##_Block* next_init_vector) \
-{ \
-    assert(encryption_keys); \
-    assert(next_init_vector); \
-\
-    return aes_## prefix ##_encrypt_block_CTR( \
-        ciphertext, encryption_keys, init_vector, next_init_vector); \
-}
+#define AES_DECRYPT_BLOCK_CTR(prefix)                                                 \
+    static __inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_CTR( \
+        AES_##prefix##_Block ciphertext,                                              \
+        const AES_##prefix##_RoundKeys* encryption_keys,                              \
+        AES_##prefix##_Block init_vector,                                             \
+        AES_##prefix##_Block* next_init_vector) {                                     \
+        assert(encryption_keys);                                                      \
+        assert(next_init_vector);                                                     \
+                                                                                      \
+        return aes_##prefix##_encrypt_block_CTR(                                      \
+            ciphertext, encryption_keys, init_vector, next_init_vector);              \
+    }
 
 #ifdef __cplusplus
 }
diff --git a/aes/include/aes/padding.h b/aes/include/aes/padding.h
index ba316f5..727196b 100644
--- a/aes/include/aes/padding.h
+++ b/aes/include/aes/padding.h
@@ -10,28 +10,23 @@
 #include <stdlib.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-typedef enum
-{
+typedef enum {
     AES_PADDING_PKCS7,
-}
-AES_PaddingMethod;
+} AES_PaddingMethod;
 
-AES_StatusCode aes_extract_padding_size(
-    AES_PaddingMethod,
-    const void* src,
-    size_t src_size,
-    size_t* padding_size,
-    AES_ErrorDetails*);
+AES_StatusCode aes_extract_padding_size(AES_PaddingMethod,
+                                        const void* src,
+                                        size_t src_size,
+                                        size_t* padding_size,
+                                        AES_ErrorDetails*);
 
-AES_StatusCode aes_fill_with_padding(
-    AES_PaddingMethod,
-    void* dest,
-    size_t padding_size,
-    AES_ErrorDetails*);
+AES_StatusCode aes_fill_with_padding(AES_PaddingMethod,
+                                     void* dest,
+                                     size_t padding_size,
+                                     AES_ErrorDetails*);
 
 #ifdef __cplusplus
 }
diff --git a/aes/include/aes/workarounds.h b/aes/include/aes/workarounds.h
index 914bd21..c3ffae7 100644
--- a/aes/include/aes/workarounds.h
+++ b/aes/include/aes/workarounds.h
@@ -13,4 +13,4 @@
 #warning "couldn't determine alignment attribute"
 #endif
 
-#define AES_UNUSED_PARAMETER(...) (void) (__VA_ARGS__)
+#define AES_UNUSED_PARAMETER(...) (void)(__VA_ARGS__)
diff --git a/aes/src/aes.c b/aes/src/aes.c
index 1f7da13..a409b5e 100644
--- a/aes/src/aes.c
+++ b/aes/src/aes.c
@@ -11,11 +11,9 @@
 #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);
 
@@ -36,11 +34,9 @@ AES_StatusCode aes_AES_format_block(
     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);
 
@@ -54,8 +50,7 @@ AES_StatusCode aes_AES_format_block_as_matrix(
     AES_ALIGN(unsigned char, 16) bytes[4][4];
     aes_store_block128_aligned(bytes, *block);
 
-    for (int i = 0; i < 4; ++i, cursor += 3)
-    {
+    for (int i = 0; i < 4; ++i, cursor += 3) {
         for (int j = 0; j < 3; ++j, cursor += 3)
             sprintf(cursor, "%02x ", bytes[j][i]);
         sprintf(cursor, "%02x\n", bytes[3][i]);
@@ -65,10 +60,7 @@ AES_StatusCode aes_AES_format_block_as_matrix(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES_print_block(
-    const AES_AES_Block* block,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES_print_block(const AES_AES_Block* block, AES_ErrorDetails* err_details) {
     assert(block);
 
     if (block == NULL)
@@ -84,10 +76,8 @@ AES_StatusCode aes_AES_print_block(
     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)
@@ -103,11 +93,9 @@ AES_StatusCode aes_AES_print_block_as_matrix(
     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);
 
@@ -120,13 +108,12 @@ AES_StatusCode aes_AES_parse_block(
 
     AES_ALIGN(unsigned char, 16) bytes[16];
 
-    for (int i = 0; i < 16; ++i)
-    {
+    for (int i = 0; i < 16; ++i) {
         int n;
         unsigned int byte;
         if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
             return aes_error_parse(err_details, src, "a 128-bit block");
-        bytes[i] = (unsigned char) byte;
+        bytes[i] = (unsigned char)byte;
         cursor += n;
     }
 
@@ -134,11 +121,9 @@ AES_StatusCode aes_AES_parse_block(
     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);
 
@@ -159,11 +144,9 @@ AES_StatusCode aes_AES128_format_key(
     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);
 
@@ -194,11 +177,9 @@ AES_StatusCode aes_AES192_format_key(
     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);
 
@@ -229,17 +210,11 @@ AES_StatusCode aes_AES256_format_key(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES128_print_key(
-    const AES_AES128_Key* key,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES128_print_key(const AES_AES128_Key* key, AES_ErrorDetails* err_details) {
     return aes_AES_print_block(&key->key, err_details);
 }
 
-AES_StatusCode aes_AES192_print_key(
-    const AES_AES192_Key* key,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES192_print_key(const AES_AES192_Key* key, AES_ErrorDetails* err_details) {
     assert(key);
 
     if (key == NULL)
@@ -255,10 +230,7 @@ AES_StatusCode aes_AES192_print_key(
     return ec;
 }
 
-AES_StatusCode aes_AES256_print_key(
-    const AES_AES256_Key* key,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES256_print_key(const AES_AES256_Key* key, AES_ErrorDetails* err_details) {
     assert(key);
 
     if (key == NULL)
@@ -274,19 +246,15 @@ AES_StatusCode aes_AES256_print_key(
     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);
 
@@ -300,13 +268,12 @@ AES_StatusCode aes_AES192_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 16; ++i)
-        {
+        for (int i = 0; i < 16; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 192-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
@@ -316,13 +283,12 @@ AES_StatusCode aes_AES192_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 8; ++i)
-        {
+        for (int i = 0; i < 8; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 192-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
@@ -333,11 +299,9 @@ AES_StatusCode aes_AES192_parse_key(
     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);
 
@@ -351,13 +315,12 @@ AES_StatusCode aes_AES256_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 16; ++i)
-        {
+        for (int i = 0; i < 16; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 256-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
@@ -367,13 +330,12 @@ AES_StatusCode aes_AES256_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 16; ++i)
-        {
+        for (int i = 0; i < 16; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 256-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
diff --git a/aes/src/box.c b/aes/src/box.c
index c7e1e90..48457c9 100644
--- a/aes/src/box.c
+++ b/aes/src/box.c
@@ -10,30 +10,24 @@
 #include <stdlib.h>
 #include <string.h>
 
-static const AES_BoxAlgorithmInterface* aes_box_algorithms[] =
-{
+static const AES_BoxAlgorithmInterface* aes_box_algorithms[] = {
     &aes_box_algorithm_aes128,
     &aes_box_algorithm_aes192,
     &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)))
+                         box_key, &box->encryption_keys, &box->decryption_keys, err_details)))
         return status;
 
     box->mode = mode;
@@ -43,109 +37,91 @@ AES_StatusCode aes_box_init(
     return status;
 }
 
-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_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)))
+    if (aes_is_error(status = box->algorithm->xor_block(&xored_input, &box->iv, err_details)))
         return status;
 
     if (aes_is_error(status = box->algorithm->encrypt_block(
-            &xored_input, &box->encryption_keys, output, err_details)))
+                         &xored_input, &box->encryption_keys, output, err_details)))
         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)))
+                         &box->iv, &box->encryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         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)))
+                         &box->iv, &box->encryption_keys, &box->iv, err_details)))
         return status;
 
     *output = box->iv;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         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)))
+                         &box->iv, &box->encryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->inc_block(
-            &box->iv, err_details)))
+    if (aes_is_error(status = box->algorithm->inc_block(&box->iv, err_details)))
         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[] =
-{
+static AES_BoxEncryptBlockInMode aes_box_encrypt_block_in_mode[] = {
     &aes_box_encrypt_block_ecb,
     &aes_box_encrypt_block_cbc,
     &aes_box_encrypt_block_cfb,
@@ -153,60 +129,48 @@ 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)
-{
-    return aes_box_encrypt_block_in_mode[box->mode](
-        box, input, output, 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)
-{
-    return box->algorithm->decrypt_block(
-        input, &box->decryption_keys, 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) {
+    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)))
+                         input, &box->decryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, &box->iv, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, &box->iv, err_details)))
         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)))
+                         &box->iv, &box->encryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         return status;
 
     box->iv = *input;
@@ -215,8 +179,7 @@ static AES_StatusCode aes_box_decrypt_block_cfb(
 
 typedef AES_BoxEncryptBlockInMode AES_BoxDecryptBlockInMode;
 
-static AES_BoxDecryptBlockInMode aes_box_decrypt_block_in_mode[] =
-{
+static AES_BoxDecryptBlockInMode aes_box_decrypt_block_in_mode[] = {
     &aes_box_decrypt_block_ecb,
     &aes_box_decrypt_block_cbc,
     &aes_box_decrypt_block_cfb,
@@ -224,34 +187,26 @@ 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)
-{
-    return aes_box_decrypt_block_in_mode[box->mode](
-        box, input, output, 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)
-    {
+    switch (box->mode) {
         case AES_ECB:
-        case AES_CBC:
-        {
+        case AES_CBC: {
             size_t block_size;
 
-            if (aes_is_error(status = box->algorithm->get_block_size(
-                    &block_size, err_details)))
+            if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
                 return status;
 
             *padding_size = block_size - src_size % block_size;
@@ -267,33 +222,27 @@ static AES_StatusCode aes_box_get_encrypted_buffer_size(
             return status;
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported mode of operation");
+            return aes_error_not_implemented(err_details, "unsupported mode of operation");
     }
 }
 
-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)))
+    if (aes_is_error(status = box->algorithm->load_block(&plaintext, src, err_details)))
         return status;
 
     AES_BoxBlock ciphertext;
 
-    if (aes_is_error(status = aes_box_encrypt_block(
-            box, &plaintext, &ciphertext, err_details)))
+    if (aes_is_error(status = aes_box_encrypt_block(box, &plaintext, &ciphertext, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->store_block(
-            dest, &ciphertext, err_details)))
+    if (aes_is_error(status = box->algorithm->store_block(dest, &ciphertext, err_details)))
         return status;
 
     return status;
@@ -305,14 +254,12 @@ 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)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     void* plaintext_buf = malloc(block_size);
@@ -322,15 +269,12 @@ 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)))
+    if (aes_is_error(
+            status = aes_fill_with_padding(
+                AES_PADDING_PKCS7, (char*)plaintext_buf + src_size, padding_size, err_details)))
         goto FREE_PLAINTEXT_BUF;
 
-    if (aes_is_error(status = aes_box_encrypt_buffer_block(
-            box, plaintext_buf, dest, err_details)))
+    if (aes_is_error(status = aes_box_encrypt_buffer_block(box, plaintext_buf, dest, err_details)))
         goto FREE_PLAINTEXT_BUF;
 
 FREE_PLAINTEXT_BUF:
@@ -339,13 +283,11 @@ 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)
@@ -353,8 +295,7 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     void* plaintext_buf = malloc(block_size);
@@ -367,14 +308,13 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block(
 
     void* ciphertext_buf = malloc(block_size);
 
-    if (ciphertext_buf == NULL)
-    {
+    if (ciphertext_buf == NULL) {
         status = aes_error_memory_allocation(err_details);
         goto FREE_PLAINTEXT_BUF;
     }
 
-    if (aes_is_error(status = aes_box_encrypt_buffer_block(
-            box, plaintext_buf, ciphertext_buf, err_details)))
+    if (aes_is_error(
+            status = aes_box_encrypt_buffer_block(box, plaintext_buf, ciphertext_buf, err_details)))
         goto FREE_CIPHERTEXT_BUF;
 
     memcpy(dest, ciphertext_buf, src_size);
@@ -388,14 +328,12 @@ 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)
@@ -406,7 +344,7 @@ AES_StatusCode aes_box_encrypt_buffer(
     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)))
+                         box, src_size, dest_size, &padding_size, err_details)))
         return status;
 
     if (dest == NULL)
@@ -416,20 +354,17 @@ AES_StatusCode aes_box_encrypt_buffer(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         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)))
+    for (size_t i = 0; i < src_len; ++i) {
+        if (aes_is_error(status = aes_box_encrypt_buffer_block(box, src, dest, err_details)))
             return status;
 
-        src = (char*) src + block_size;
-        dest = (char*) dest + block_size;
+        src = (char*)src + block_size;
+        dest = (char*)dest + block_size;
     }
 
     if (padding_size == 0)
@@ -440,24 +375,19 @@ AES_StatusCode aes_box_encrypt_buffer(
             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)
-    {
+    switch (box->mode) {
         case AES_ECB:
-        case AES_CBC:
-        {
+        case AES_CBC: {
             size_t block_size;
 
-            if (aes_is_error(status = box->algorithm->get_block_size(
-                    &block_size, err_details)))
+            if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
                 return status;
 
             if (src_size == 0 || src_size % block_size != 0)
@@ -476,45 +406,37 @@ static AES_StatusCode aes_box_get_decrypted_buffer_size(
             return status;
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported mode of operation");
+            return aes_error_not_implemented(err_details, "unsupported mode of operation");
     }
 }
 
-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)))
+    if (aes_is_error(status = box->algorithm->load_block(&ciphertext, src, err_details)))
         return status;
 
     AES_BoxBlock plaintext;
 
-    if (aes_is_error(status = aes_box_decrypt_block(
-            box, &ciphertext, &plaintext, err_details)))
+    if (aes_is_error(status = aes_box_decrypt_block(box, &ciphertext, &plaintext, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->store_block(
-            dest, &plaintext, err_details)))
+    if (aes_is_error(status = box->algorithm->store_block(dest, &plaintext, err_details)))
         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)
@@ -522,8 +444,7 @@ static AES_StatusCode aes_box_decrypt_buffer_partial_block(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     void* ciphertext_buf = malloc(block_size);
@@ -536,14 +457,13 @@ static AES_StatusCode aes_box_decrypt_buffer_partial_block(
 
     void* plaintext_buf = malloc(block_size);
 
-    if (plaintext_buf == NULL)
-    {
+    if (plaintext_buf == NULL) {
         status = aes_error_memory_allocation(err_details);
         goto FREE_CIPHERTEXT_BUF;
     }
 
-    if (aes_is_error(status = aes_box_decrypt_buffer_block(
-            box, ciphertext_buf, plaintext_buf, err_details)))
+    if (aes_is_error(
+            status = aes_box_decrypt_buffer_block(box, ciphertext_buf, plaintext_buf, err_details)))
         goto FREE_PLAINTEXT_BUF;
 
     memcpy(dest, plaintext_buf, src_size);
@@ -557,14 +477,12 @@ 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)
@@ -574,7 +492,7 @@ AES_StatusCode aes_box_decrypt_buffer(
     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)))
+                         box, src_size, dest_size, &max_padding_size, err_details)))
         return status;
 
     if (dest == NULL)
@@ -584,37 +502,30 @@ AES_StatusCode aes_box_decrypt_buffer(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         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)))
+    for (size_t i = 0; i < src_len; ++i) {
+        if (aes_is_error(status = aes_box_decrypt_buffer_block(box, src, dest, err_details)))
             return status;
 
-        src = (char*) src + block_size;
-        dest = (char*) dest + block_size;
+        src = (char*)src + block_size;
+        dest = (char*)dest + block_size;
     }
 
-    if (max_padding_size == 0)
-    {
+    if (max_padding_size == 0) {
         return aes_box_decrypt_buffer_partial_block(
             box, src, src_size % block_size, dest, err_details);
-    }
-    else
-    {
+    } 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)))
+        if (aes_is_error(status = aes_extract_padding_size(AES_PADDING_PKCS7,
+                                                           (char*)dest - block_size,
+                                                           block_size,
+                                                           &padding_size,
+                                                           err_details)))
             return status;
 
         *dest_size -= padding_size;
@@ -622,62 +533,50 @@ AES_StatusCode aes_box_decrypt_buffer(
     }
 }
 
-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)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->parse_block(
-        dest, src, err_details);
+    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)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->parse_key(
-        dest, src, err_details);
+    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)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->format_block(
-        dest, src, err_details);
+    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)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->format_key(
-        dest, src, err_details);
+    return aes_box_algorithms[algorithm]->format_key(dest, src, err_details);
 }
diff --git a/aes/src/box_aes.c b/aes/src/box_aes.c
index 4d08d10..7e78a2c 100644
--- a/aes/src/box_aes.c
+++ b/aes/src/box_aes.c
@@ -10,105 +10,80 @@
 #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_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);
     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)
@@ -117,11 +92,9 @@ static AES_StatusCode aes_box_format_block_aes(
     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)
@@ -130,11 +103,9 @@ static AES_StatusCode aes_box_format_key_aes128(
     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)
@@ -143,11 +114,9 @@ static AES_StatusCode aes_box_format_key_aes192(
     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)
@@ -156,134 +125,104 @@ static AES_StatusCode aes_box_format_key_aes256(
     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;
 }
 
-static AES_StatusCode aes_box_inc_block_aes(
-    AES_BoxBlock* ctr,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_inc_block_aes(AES_BoxBlock* ctr, AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     ctr->aes_block = aes_AES_inc_block(ctr->aes_block);
     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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    output->aes_block =
+        aes_AES256_decrypt_block_(input->aes_block, &params->aes256_decryption_keys);
     return AES_SUCCESS;
 }
 
-AES_BoxAlgorithmInterface aes_box_algorithm_aes128 =
-{
+AES_BoxAlgorithmInterface aes_box_algorithm_aes128 = {
     &aes_box_derive_params_aes128,
     &aes_box_parse_block_aes,
     &aes_box_parse_key_aes128,
@@ -298,8 +237,7 @@ AES_BoxAlgorithmInterface aes_box_algorithm_aes128 =
     &aes_box_load_block_aes,
 };
 
-AES_BoxAlgorithmInterface aes_box_algorithm_aes192 =
-{
+AES_BoxAlgorithmInterface aes_box_algorithm_aes192 = {
     &aes_box_derive_params_aes192,
     &aes_box_parse_block_aes,
     &aes_box_parse_key_aes192,
@@ -314,8 +252,7 @@ AES_BoxAlgorithmInterface aes_box_algorithm_aes192 =
     &aes_box_load_block_aes,
 };
 
-AES_BoxAlgorithmInterface aes_box_algorithm_aes256 =
-{
+AES_BoxAlgorithmInterface aes_box_algorithm_aes256 = {
     &aes_box_derive_params_aes256,
     &aes_box_parse_block_aes,
     &aes_box_parse_key_aes256,
diff --git a/aes/src/c/aes128.c b/aes/src/c/aes128.c
index a1bad40..6b3a96a 100644
--- a/aes/src/c/aes128.c
+++ b/aes/src/c/aes128.c
@@ -10,10 +10,8 @@
 #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]);
@@ -27,10 +25,8 @@ AES_AES_Block __fastcall aes_AES128_encrypt_block_(
     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]);
@@ -44,10 +40,8 @@ AES_AES_Block __fastcall aes_AES128_decrypt_block_(
     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);
@@ -63,27 +57,32 @@ static AES_AES_Block __fastcall aes_aes128_expand_key_assist(
     return prev;
 }
 
-void __fastcall aes_AES128_expand_key_(
-    AES_AES_Block key,
-    AES_AES128_RoundKeys* encryption_keys)
-{
+void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys* encryption_keys) {
     AES_Block128 prev = encryption_keys->keys[0] = key;
-    prev = encryption_keys->keys[1] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01));
-    prev = encryption_keys->keys[2] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02));
-    prev = encryption_keys->keys[3] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04));
-    prev = encryption_keys->keys[4] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x08));
-    prev = encryption_keys->keys[5] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x10));
-    prev = encryption_keys->keys[6] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x20));
-    prev = encryption_keys->keys[7] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x40));
-    prev = encryption_keys->keys[8] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x80));
-    prev = encryption_keys->keys[9] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x1b));
-    prev = encryption_keys->keys[10] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36));
+    prev = encryption_keys->keys[1] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01));
+    prev = encryption_keys->keys[2] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02));
+    prev = encryption_keys->keys[3] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04));
+    prev = encryption_keys->keys[4] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x08));
+    prev = encryption_keys->keys[5] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x10));
+    prev = encryption_keys->keys[6] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x20));
+    prev = encryption_keys->keys[7] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x40));
+    prev = encryption_keys->keys[8] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x80));
+    prev = encryption_keys->keys[9] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x1b));
+    prev = encryption_keys->keys[10] =
+        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 d661b78..01f6698 100644
--- a/aes/src/c/aes192.c
+++ b/aes/src/c/aes192.c
@@ -10,10 +10,8 @@
 #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]);
@@ -29,10 +27,8 @@ AES_AES_Block __fastcall aes_AES192_encrypt_block_(
     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]);
@@ -48,11 +44,9 @@ AES_AES_Block __fastcall aes_AES192_decrypt_block_(
     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);
@@ -73,50 +67,54 @@ static void __fastcall aes_aes192_expand_key_assist(
     *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));
-    encryption_keys->keys[2] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[1] = _mm_castpd_si128(
+        _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));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x02));
     encryption_keys->keys[3] = key_lo;
     encryption_keys->keys[4] = key_hi;
 
     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));
-    encryption_keys->keys[5] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[4] = _mm_castpd_si128(
+        _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));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x08));
     encryption_keys->keys[6] = key_lo;
     encryption_keys->keys[7] = key_hi;
 
     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));
-    encryption_keys->keys[8] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[7] = _mm_castpd_si128(
+        _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));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x20));
     encryption_keys->keys[9] = key_lo;
     encryption_keys->keys[10] = key_hi;
 
     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));
-    encryption_keys->keys[11] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[10] = _mm_castpd_si128(
+        _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));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x80));
     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 2190322..ea64f0f 100644
--- a/aes/src/c/aes256.c
+++ b/aes/src/c/aes256.c
@@ -10,10 +10,8 @@
 #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]);
@@ -31,10 +29,8 @@ AES_AES_Block __fastcall aes_AES256_encrypt_block_(
     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]);
@@ -52,11 +48,9 @@ AES_AES_Block __fastcall aes_AES256_decrypt_block_(
     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);
@@ -75,11 +69,9 @@ static AES_AES_Block __fastcall aes_aes256_expand_key_assist(
     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;
 
@@ -139,10 +131,8 @@ void __fastcall aes_AES256_expand_key_(
     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 d49c456..e498458 100644
--- a/aes/src/error.c
+++ b/aes/src/error.c
@@ -16,11 +16,10 @@
 
 #include <stdarg.h>
 
-#define snprintf c99_snprintf
+#define snprintf  c99_snprintf
 #define vsnprintf c99_vsnprintf
 
-static int c99_vsnprintf(char *dest, size_t dest_size, const char *fmt, va_list ap)
-{
+static int c99_vsnprintf(char* dest, size_t dest_size, const char* fmt, va_list ap) {
     int dest_len = -1;
 
     if (dest_size != 0)
@@ -31,8 +30,7 @@ static int c99_vsnprintf(char *dest, size_t dest_size, const char *fmt, va_list
     return dest_len;
 }
 
-static int c99_snprintf(char *dest, size_t dest_size, const char *fmt, ...)
-{
+static int c99_snprintf(char* dest, size_t dest_size, const char* fmt, ...) {
     va_list ap;
     va_start(ap, fmt);
 
@@ -44,14 +42,12 @@ static int c99_snprintf(char *dest, size_t dest_size, const char *fmt, ...)
 
 #endif
 
-static void aes_fill_string(char* dest, size_t dest_size, const char* src)
-{
+static void aes_fill_string(char* dest, size_t dest_size, const char* src) {
     strncpy(dest, src, dest_size);
     dest[dest_size - 1] = '\0';
 }
 
-static const char* aes_strerror_messages[] =
-{
+static const char* aes_strerror_messages[] = {
     "Success",
     "Invalid argument value NULL",
     "Couldn't parse",
@@ -61,16 +57,13 @@ static const char* aes_strerror_messages[] =
     "Couldn't allocate memory",
 };
 
-const char* aes_strerror(AES_StatusCode ec)
-{
+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);
 
@@ -81,11 +74,9 @@ static size_t aes_format_error_strerror(
     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;
 
@@ -96,11 +87,9 @@ static size_t aes_format_null_argument_error(
     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;
@@ -112,11 +101,9 @@ static size_t aes_format_parse_error(
     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;
 
@@ -129,8 +116,7 @@ static size_t aes_format_not_implemented_error(
 
 typedef size_t (*AES_ErrorFormatter)(const AES_ErrorDetails*, char*, size_t);
 
-static AES_ErrorFormatter err_formatters[] =
-{
+static AES_ErrorFormatter err_formatters[] = {
     &aes_format_error_strerror,
     &aes_format_null_argument_error,
     &aes_format_parse_error,
@@ -140,11 +126,7 @@ static AES_ErrorFormatter err_formatters[] =
     &aes_format_error_strerror,
 };
 
-size_t aes_format_error(
-    const AES_ErrorDetails* err_details,
-    char* dest,
-    size_t dest_size)
-{
+size_t aes_format_error(const AES_ErrorDetails* err_details, char* dest, size_t dest_size) {
     assert(err_details);
 
     return err_formatters[err_details->ec](err_details, dest, dest_size);
@@ -153,22 +135,17 @@ size_t aes_format_error(
 #ifdef WIN32
 #include <windows.h>
 
-static void aes_collect_call_stack(AES_ErrorDetails* err_details)
-{
-    err_details->call_stack_len = CaptureStackBackTrace(
-        1, AES_MAX_CALL_STACK_LENGTH, err_details->call_stack, NULL);
+static void aes_collect_call_stack(AES_ErrorDetails* err_details) {
+    err_details->call_stack_len =
+        CaptureStackBackTrace(1, AES_MAX_CALL_STACK_LENGTH, err_details->call_stack, NULL);
 }
 #else
-static void aes_collect_call_stack(AES_ErrorDetails* err_details)
-{
+static void aes_collect_call_stack(AES_ErrorDetails* err_details) {
     err_details->call_stack_len = 0;
 }
 #endif
 
-static AES_StatusCode aes_make_error(
-    AES_ErrorDetails* err_details,
-    AES_StatusCode ec)
-{
+static AES_StatusCode aes_make_error(AES_ErrorDetails* err_details, AES_StatusCode ec) {
     if (err_details == NULL)
         return ec;
 
@@ -178,74 +155,54 @@ static AES_StatusCode aes_make_error(
     return err_details->ec = ec;
 }
 
-AES_StatusCode aes_success(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_success(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_SUCCESS);
 }
 
-AES_StatusCode aes_error_null_argument(
-    AES_ErrorDetails* err_details,
-    const char* param_name)
-{
+AES_StatusCode aes_error_null_argument(AES_ErrorDetails* err_details, const char* param_name) {
     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;
 }
 
-AES_StatusCode aes_error_parse(
-    AES_ErrorDetails* err_details,
-    const char* src,
-    const char* what)
-{
+AES_StatusCode aes_error_parse(AES_ErrorDetails* err_details, const char* src, const char* what) {
     AES_StatusCode status = aes_make_error(err_details, AES_PARSE_ERROR);
 
-    if (err_details != NULL)
-    {
+    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;
 }
 
-AES_StatusCode aes_error_invalid_pkcs7_padding(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_error_invalid_pkcs7_padding(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_INVALID_PKCS7_PADDING_ERROR);
 }
 
-AES_StatusCode aes_error_not_implemented(
-    AES_ErrorDetails* err_details,
-    const char* what)
-{
+AES_StatusCode aes_error_not_implemented(AES_ErrorDetails* err_details, const char* what) {
     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;
 }
 
-AES_StatusCode aes_error_missing_padding(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_error_missing_padding(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_MISSING_PADDING_ERROR);
 }
 
-AES_StatusCode aes_error_memory_allocation(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_error_memory_allocation(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_MEMORY_ALLOCATION_ERROR);
 }
diff --git a/aes/src/padding.c b/aes/src/padding.c
index a161ec7..5647ea6 100644
--- a/aes/src/padding.c
+++ b/aes/src/padding.c
@@ -11,13 +11,11 @@
 #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)
-{
-    const unsigned char* cursor = (const unsigned char*) src + src_size - 1;
+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;
 
     for (size_t i = 1; i < *padding_size; ++i)
@@ -27,13 +25,11 @@ static AES_StatusCode aes_extract_padding_size_pkcs7(
     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);
 
@@ -42,47 +38,37 @@ AES_StatusCode aes_extract_padding_size(
     if (padding_size == NULL)
         return aes_error_null_argument(err_details, "padding_size");
 
-    switch (method)
-    {
+    switch (method) {
         case AES_PADDING_PKCS7:
-            return aes_extract_padding_size_pkcs7(
-                src, src_size, padding_size, err_details);
+            return aes_extract_padding_size_pkcs7(src, src_size, padding_size, err_details);
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported padding method");
+            return aes_error_not_implemented(err_details, "unsupported padding 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);
+    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)
         return aes_error_null_argument(err_details, "dest");
 
-    switch (method)
-    {
+    switch (method) {
         case AES_PADDING_PKCS7:
-            return aes_fill_with_padding_pkcs7(
-                dest, padding_size, err_details);
+            return aes_fill_with_padding_pkcs7(dest, padding_size, err_details);
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported padding method");
+            return aes_error_not_implemented(err_details, "unsupported padding method");
     }
 }