add .clang-format

22 files changed, 1225 insertions, 1647 deletions

diff --git a/aesxx/include/aesxx/aes.hpp b/aesxx/include/aesxx/aes.hpp
index efac790..c3457c8 100644
--- a/aesxx/include/aesxx/aes.hpp
+++ b/aesxx/include/aesxx/aes.hpp
@@ -13,263 +13,226 @@
 #include <aes/all.h>
 
 #include <cstddef>
-
 #include <string>
 
-namespace aes
-{
-    namespace aes128
-    {
-        typedef AES_AES128_Block Block;
-        typedef AES_AES128_RoundKeys RoundKeys;
-        typedef AES_AES128_Key Key;
-    }
+namespace aes {
+namespace aes128 {
 
-    template <>
-    struct Types<AES_AES128>
-    {
-        typedef aes128::Block Block;
-        typedef aes128::RoundKeys RoundKeys;
-        typedef aes128::Key Key;
-    };
+typedef AES_AES128_Block Block;
+typedef AES_AES128_RoundKeys RoundKeys;
+typedef AES_AES128_Key Key;
 
-    template <>
-    inline std::size_t get_number_of_rounds<AES_AES128>()
-    {
-        return 11;
-    }
+} // namespace aes128
 
-    template <>
-    inline void from_string<AES_AES128>(aes128::Block& dest, const char* src)
-    {
-        aes_AES128_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
-    }
+template <>
+struct Types<AES_AES128> {
+    typedef aes128::Block Block;
+    typedef aes128::RoundKeys RoundKeys;
+    typedef aes128::Key Key;
+};
 
-    template <>
-    inline std::string to_string<AES_AES128>(const aes128::Block& src)
-    {
-        AES_AES128_BlockString str;
-        aes_AES128_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+template <>
+inline std::size_t get_number_of_rounds<AES_AES128>() {
+    return 11;
+}
 
-    template <>
-    inline std::string to_matrix_string<AES_AES128>(const aes128::Block& src)
-    {
-        AES_AES128_BlockMatrixString str;
-        aes_AES128_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+template <>
+inline void from_string<AES_AES128>(aes128::Block& dest, const char* src) {
+    aes_AES128_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
+}
 
-    template <>
-    inline void from_string<AES_AES128>(aes128::Key& dest, const char* src)
-    {
-        aes_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
-    }
+template <>
+inline std::string to_string<AES_AES128>(const aes128::Block& src) {
+    AES_AES128_BlockString str;
+    aes_AES128_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    template <>
-    inline std::string to_string<AES_AES128>(const aes128::Key& src)
-    {
-        AES_AES128_KeyString str;
-        aes_AES128_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+template <>
+inline std::string to_matrix_string<AES_AES128>(const aes128::Block& src) {
+    AES_AES128_BlockMatrixString str;
+    aes_AES128_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    template <>
-    inline void expand_key<AES_AES128>(
-        const aes128::Key& key,
-        aes128::RoundKeys& encryption_keys)
-    {
-        aes_AES128_expand_key(&key, &encryption_keys);
-    }
+template <>
+inline void from_string<AES_AES128>(aes128::Key& dest, const char* src) {
+    aes_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
+}
 
-    template <>
-    inline void derive_decryption_keys<AES_AES128>(
-        const aes128::RoundKeys& encryption_keys,
-        aes128::RoundKeys& decryption_keys)
-    {
-        aes_AES128_derive_decryption_keys(
-            &encryption_keys, &decryption_keys);
-    }
+template <>
+inline std::string to_string<AES_AES128>(const aes128::Key& src) {
+    AES_AES128_KeyString str;
+    aes_AES128_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    AESXX_ENCRYPT_BLOCK_ECB(AES128);
-    AESXX_DECRYPT_BLOCK_ECB(AES128);
-    AESXX_ENCRYPT_BLOCK_CBC(AES128);
-    AESXX_DECRYPT_BLOCK_CBC(AES128);
-    AESXX_ENCRYPT_BLOCK_CFB(AES128);
-    AESXX_DECRYPT_BLOCK_CFB(AES128);
-    AESXX_ENCRYPT_BLOCK_OFB(AES128);
-    AESXX_DECRYPT_BLOCK_OFB(AES128);
-    AESXX_ENCRYPT_BLOCK_CTR(AES128);
-    AESXX_DECRYPT_BLOCK_CTR(AES128);
+template <>
+inline void expand_key<AES_AES128>(const aes128::Key& key, aes128::RoundKeys& encryption_keys) {
+    aes_AES128_expand_key(&key, &encryption_keys);
+}
 
-    namespace aes192
-    {
-        typedef AES_AES192_Block Block;
-        typedef AES_AES192_RoundKeys RoundKeys;
-        typedef AES_AES192_Key Key;
-    }
+template <>
+inline void derive_decryption_keys<AES_AES128>(const aes128::RoundKeys& encryption_keys,
+                                               aes128::RoundKeys& decryption_keys) {
+    aes_AES128_derive_decryption_keys(&encryption_keys, &decryption_keys);
+}
 
-    template <>
-    struct Types<AES_AES192>
-    {
-        typedef aes192::Block Block;
-        typedef aes192::RoundKeys RoundKeys;
-        typedef aes192::Key Key;
-    };
+AESXX_ENCRYPT_BLOCK_ECB(AES128);
+AESXX_DECRYPT_BLOCK_ECB(AES128);
+AESXX_ENCRYPT_BLOCK_CBC(AES128);
+AESXX_DECRYPT_BLOCK_CBC(AES128);
+AESXX_ENCRYPT_BLOCK_CFB(AES128);
+AESXX_DECRYPT_BLOCK_CFB(AES128);
+AESXX_ENCRYPT_BLOCK_OFB(AES128);
+AESXX_DECRYPT_BLOCK_OFB(AES128);
+AESXX_ENCRYPT_BLOCK_CTR(AES128);
+AESXX_DECRYPT_BLOCK_CTR(AES128);
 
-    template <>
-    inline std::size_t get_number_of_rounds<AES_AES192>()
-    {
-        return 13;
-    }
+namespace aes192 {
 
-    template <>
-    inline void from_string<AES_AES192>(aes192::Block& dest, const char* src)
-    {
-        aes_AES192_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
-    }
+typedef AES_AES192_Block Block;
+typedef AES_AES192_RoundKeys RoundKeys;
+typedef AES_AES192_Key Key;
 
-    template <>
-    inline std::string to_string<AES_AES192>(const aes192::Block& src)
-    {
-        AES_AES192_BlockString str;
-        aes_AES192_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+} // namespace aes192
 
-    template <>
-    inline std::string to_matrix_string<AES_AES192>(const aes192::Block& src)
-    {
-        AES_AES192_BlockMatrixString str;
-        aes_AES192_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+template <>
+struct Types<AES_AES192> {
+    typedef aes192::Block Block;
+    typedef aes192::RoundKeys RoundKeys;
+    typedef aes192::Key Key;
+};
 
-    template <>
-    inline void from_string<AES_AES192>(aes192::Key& dest, const char* src)
-    {
-        aes_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
-    }
+template <>
+inline std::size_t get_number_of_rounds<AES_AES192>() {
+    return 13;
+}
 
-    template <>
-    inline std::string to_string<AES_AES192>(const aes192::Key& src)
-    {
-        AES_AES192_KeyString str;
-        aes_AES192_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+template <>
+inline void from_string<AES_AES192>(aes192::Block& dest, const char* src) {
+    aes_AES192_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
+}
 
-    template <>
-    inline void expand_key<AES_AES192>(
-        const aes192::Key& key,
-        aes192::RoundKeys& encryption_keys)
-    {
-        aes_AES192_expand_key(&key, &encryption_keys);
-    }
+template <>
+inline std::string to_string<AES_AES192>(const aes192::Block& src) {
+    AES_AES192_BlockString str;
+    aes_AES192_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    template <>
-    inline void derive_decryption_keys<AES_AES192>(
-        const aes192::RoundKeys& encryption_keys,
-        aes192::RoundKeys& decryption_keys)
-    {
-        aes_AES192_derive_decryption_keys(
-            &encryption_keys, &decryption_keys);
-    }
+template <>
+inline std::string to_matrix_string<AES_AES192>(const aes192::Block& src) {
+    AES_AES192_BlockMatrixString str;
+    aes_AES192_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    AESXX_ENCRYPT_BLOCK_ECB(AES192);
-    AESXX_DECRYPT_BLOCK_ECB(AES192);
-    AESXX_ENCRYPT_BLOCK_CBC(AES192);
-    AESXX_DECRYPT_BLOCK_CBC(AES192);
-    AESXX_ENCRYPT_BLOCK_CFB(AES192);
-    AESXX_DECRYPT_BLOCK_CFB(AES192);
-    AESXX_ENCRYPT_BLOCK_OFB(AES192);
-    AESXX_DECRYPT_BLOCK_OFB(AES192);
-    AESXX_ENCRYPT_BLOCK_CTR(AES192);
-    AESXX_DECRYPT_BLOCK_CTR(AES192);
+template <>
+inline void from_string<AES_AES192>(aes192::Key& dest, const char* src) {
+    aes_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
+}
 
-    namespace aes256
-    {
-        typedef AES_AES256_Block Block;
-        typedef AES_AES256_RoundKeys RoundKeys;
-        typedef AES_AES256_Key Key;
-    }
+template <>
+inline std::string to_string<AES_AES192>(const aes192::Key& src) {
+    AES_AES192_KeyString str;
+    aes_AES192_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    template <>
-    struct Types<AES_AES256>
-    {
-        typedef aes256::Block Block;
-        typedef aes256::RoundKeys RoundKeys;
-        typedef aes256::Key Key;
-    };
+template <>
+inline void expand_key<AES_AES192>(const aes192::Key& key, aes192::RoundKeys& encryption_keys) {
+    aes_AES192_expand_key(&key, &encryption_keys);
+}
 
-    template <>
-    inline std::size_t get_number_of_rounds<AES_AES256>()
-    {
-        return 15;
-    }
+template <>
+inline void derive_decryption_keys<AES_AES192>(const aes192::RoundKeys& encryption_keys,
+                                               aes192::RoundKeys& decryption_keys) {
+    aes_AES192_derive_decryption_keys(&encryption_keys, &decryption_keys);
+}
+
+AESXX_ENCRYPT_BLOCK_ECB(AES192);
+AESXX_DECRYPT_BLOCK_ECB(AES192);
+AESXX_ENCRYPT_BLOCK_CBC(AES192);
+AESXX_DECRYPT_BLOCK_CBC(AES192);
+AESXX_ENCRYPT_BLOCK_CFB(AES192);
+AESXX_DECRYPT_BLOCK_CFB(AES192);
+AESXX_ENCRYPT_BLOCK_OFB(AES192);
+AESXX_DECRYPT_BLOCK_OFB(AES192);
+AESXX_ENCRYPT_BLOCK_CTR(AES192);
+AESXX_DECRYPT_BLOCK_CTR(AES192);
 
-    template <>
-    inline void from_string<AES_AES256>(aes256::Block& dest, const char* src)
-    {
-        aes_AES256_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
-    }
+namespace aes256 {
 
-    template <>
-    inline std::string to_string<AES_AES256>(const aes256::Block& src)
-    {
-        AES_AES256_BlockString str;
-        aes_AES256_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+typedef AES_AES256_Block Block;
+typedef AES_AES256_RoundKeys RoundKeys;
+typedef AES_AES256_Key Key;
 
-    template <>
-    inline std::string to_matrix_string<AES_AES256>(const aes256::Block& src)
-    {
-        AES_AES256_BlockMatrixString str;
-        aes_AES256_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+} // namespace aes256
 
-    template <>
-    inline void from_string<AES_AES256>(aes256::Key& dest, const char* src)
-    {
-        aes_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
-    }
+template <>
+struct Types<AES_AES256> {
+    typedef aes256::Block Block;
+    typedef aes256::RoundKeys RoundKeys;
+    typedef aes256::Key Key;
+};
+
+template <>
+inline std::size_t get_number_of_rounds<AES_AES256>() {
+    return 15;
+}
 
-    template <>
-    inline std::string to_string<AES_AES256>(const aes256::Key& src)
-    {
-        AES_AES256_KeyString str;
-        aes_AES256_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
-        return {str.str};
-    }
+template <>
+inline void from_string<AES_AES256>(aes256::Block& dest, const char* src) {
+    aes_AES256_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
+}
 
-    template <>
-    inline void expand_key<AES_AES256>(
-        const aes256::Key& key,
-        aes256::RoundKeys& encryption_keys)
-    {
-        aes_AES256_expand_key(&key, &encryption_keys);
-    }
+template <>
+inline std::string to_string<AES_AES256>(const aes256::Block& src) {
+    AES_AES256_BlockString str;
+    aes_AES256_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    template <>
-    inline void derive_decryption_keys<AES_AES256>(
-        const aes256::RoundKeys& encryption_keys,
-        aes256::RoundKeys& decryption_keys)
-    {
-        aes_AES256_derive_decryption_keys(
-            &encryption_keys, &decryption_keys);
-    }
+template <>
+inline std::string to_matrix_string<AES_AES256>(const aes256::Block& src) {
+    AES_AES256_BlockMatrixString str;
+    aes_AES256_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
 
-    AESXX_ENCRYPT_BLOCK_ECB(AES256);
-    AESXX_DECRYPT_BLOCK_ECB(AES256);
-    AESXX_ENCRYPT_BLOCK_CBC(AES256);
-    AESXX_DECRYPT_BLOCK_CBC(AES256);
-    AESXX_ENCRYPT_BLOCK_CFB(AES256);
-    AESXX_DECRYPT_BLOCK_CFB(AES256);
-    AESXX_ENCRYPT_BLOCK_OFB(AES256);
-    AESXX_DECRYPT_BLOCK_OFB(AES256);
-    AESXX_ENCRYPT_BLOCK_CTR(AES256);
-    AESXX_DECRYPT_BLOCK_CTR(AES256);
+template <>
+inline void from_string<AES_AES256>(aes256::Key& dest, const char* src) {
+    aes_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
 }
+
+template <>
+inline std::string to_string<AES_AES256>(const aes256::Key& src) {
+    AES_AES256_KeyString str;
+    aes_AES256_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
+    return {str.str};
+}
+
+template <>
+inline void expand_key<AES_AES256>(const aes256::Key& key, aes256::RoundKeys& encryption_keys) {
+    aes_AES256_expand_key(&key, &encryption_keys);
+}
+
+template <>
+inline void derive_decryption_keys<AES_AES256>(const aes256::RoundKeys& encryption_keys,
+                                               aes256::RoundKeys& decryption_keys) {
+    aes_AES256_derive_decryption_keys(&encryption_keys, &decryption_keys);
+}
+
+AESXX_ENCRYPT_BLOCK_ECB(AES256);
+AESXX_DECRYPT_BLOCK_ECB(AES256);
+AESXX_ENCRYPT_BLOCK_CBC(AES256);
+AESXX_DECRYPT_BLOCK_CBC(AES256);
+AESXX_ENCRYPT_BLOCK_CFB(AES256);
+AESXX_DECRYPT_BLOCK_CFB(AES256);
+AESXX_ENCRYPT_BLOCK_OFB(AES256);
+AESXX_DECRYPT_BLOCK_OFB(AES256);
+AESXX_ENCRYPT_BLOCK_CTR(AES256);
+AESXX_DECRYPT_BLOCK_CTR(AES256);
+
+} // namespace aes
diff --git a/aesxx/include/aesxx/algorithm.hpp b/aesxx/include/aesxx/algorithm.hpp
index 823e57f..933cd5a 100644
--- a/aesxx/include/aesxx/algorithm.hpp
+++ b/aesxx/include/aesxx/algorithm.hpp
@@ -7,7 +7,8 @@
 
 #include <aes/all.h>
 
-namespace aes
-{
-    typedef AES_Algorithm Algorithm;
+namespace aes {
+
+typedef AES_Algorithm Algorithm;
+
 }
diff --git a/aesxx/include/aesxx/api.hpp b/aesxx/include/aesxx/api.hpp
index 68112bf..759ff0c 100644
--- a/aesxx/include/aesxx/api.hpp
+++ b/aesxx/include/aesxx/api.hpp
@@ -9,166 +9,139 @@
 #include "mode.hpp"
 
 #include <cstddef>
-
 #include <string>
 #include <type_traits>
 
-namespace aes
-{
-    template <Algorithm algorithm>
-    struct Types;
+namespace aes {
 
-    template <Algorithm algorithm>
-    std::size_t get_number_of_rounds();
+template <Algorithm algorithm>
+struct Types;
 
-    template <Algorithm algorithm>
-    void from_string(
-        typename Types<algorithm>::Block&,
-        const char*);
+template <Algorithm algorithm>
+std::size_t get_number_of_rounds();
 
-    template <Algorithm algorithm>
-    void from_string(
-        typename Types<algorithm>::Block& dest,
-        const std::string& src)
-    {
-        from_string<algorithm>(dest, src.c_str());
-    }
+template <Algorithm algorithm>
+void from_string(typename Types<algorithm>::Block&, const char*);
 
-    template <Algorithm algorithm>
-    std::string to_string(const typename Types<algorithm>::Block&);
+template <Algorithm algorithm>
+void from_string(typename Types<algorithm>::Block& dest, const std::string& src) {
+    from_string<algorithm>(dest, src.c_str());
+}
 
-    template <Algorithm algorithm>
-    std::string to_matrix_string(const typename Types<algorithm>::Block&);
+template <Algorithm algorithm>
+std::string to_string(const typename Types<algorithm>::Block&);
 
-    template <Algorithm algorithm>
-    void from_string(
-        typename Types<algorithm>::Key&,
-        const char*);
+template <Algorithm algorithm>
+std::string to_matrix_string(const typename Types<algorithm>::Block&);
 
-    template <Algorithm algorithm>
-    void from_string(
-        typename Types<algorithm>::Key& dest,
-        const std::string& src)
-    {
-        from_string<algorithm>(dest, src.c_str());
-    }
+template <Algorithm algorithm>
+void from_string(typename Types<algorithm>::Key&, const char*);
+
+template <Algorithm algorithm>
+void from_string(typename Types<algorithm>::Key& dest, const std::string& src) {
+    from_string<algorithm>(dest, src.c_str());
+}
 
-    template <Algorithm algorithm>
-    std::string to_string(const typename Types<algorithm>::Key&);
+template <Algorithm algorithm>
+std::string to_string(const typename Types<algorithm>::Key&);
 
-    template <Algorithm algorithm>
-    void expand_key(
-        const typename Types<algorithm>::Key& key,
-        typename Types<algorithm>::RoundKeys& encryption_keys);
+template <Algorithm algorithm>
+void expand_key(const typename Types<algorithm>::Key& key,
+                typename Types<algorithm>::RoundKeys& encryption_keys);
 
-    template <Algorithm algorithm>
-    void derive_decryption_keys(
-        const typename Types<algorithm>::RoundKeys& encryption_keys,
-        typename Types<algorithm>::RoundKeys& decryption_keys);
+template <Algorithm algorithm>
+void derive_decryption_keys(const typename Types<algorithm>::RoundKeys& encryption_keys,
+                            typename Types<algorithm>::RoundKeys& decryption_keys);
 
-    template <Algorithm algorithm, Mode mode,
-              typename std::enable_if<ModeRequiresInitVector<mode>::value>::type* = nullptr>
-    void encrypt_block(
-        const typename Types<algorithm>::Block& plaintext,
-        const typename Types<algorithm>::RoundKeys& round_keys,
-        typename Types<algorithm>::Block& iv,
-        typename Types<algorithm>::Block& ciphertext);
+template <Algorithm algorithm,
+          Mode mode,
+          typename std::enable_if<ModeRequiresInitVector<mode>::value>::type* = nullptr>
+void encrypt_block(const typename Types<algorithm>::Block& plaintext,
+                   const typename Types<algorithm>::RoundKeys& round_keys,
+                   typename Types<algorithm>::Block& iv,
+                   typename Types<algorithm>::Block& ciphertext);
 
-    template <Algorithm algorithm, Mode mode,
-              typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
-    void encrypt_block(
-        const typename Types<algorithm>::Block& plaintext,
-        const typename Types<algorithm>::RoundKeys& round_keys,
-        typename Types<algorithm>::Block& ciphertext);
+template <Algorithm algorithm,
+          Mode mode,
+          typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
+void encrypt_block(const typename Types<algorithm>::Block& plaintext,
+                   const typename Types<algorithm>::RoundKeys& round_keys,
+                   typename Types<algorithm>::Block& ciphertext);
 
-    template <Algorithm algorithm, Mode mode,
-              typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
-    void encrypt_block(
-        const typename Types<algorithm>::Block& plaintext,
-        const typename Types<algorithm>::RoundKeys& round_keys,
-        typename Types<algorithm>::Block&,
-        typename Types<algorithm>::Block& ciphertext)
-    {
-        encrypt_block<algorithm, mode>(plaintext, round_keys, ciphertext);
-    }
+template <Algorithm algorithm,
+          Mode mode,
+          typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
+void encrypt_block(const typename Types<algorithm>::Block& plaintext,
+                   const typename Types<algorithm>::RoundKeys& round_keys,
+                   typename Types<algorithm>::Block&,
+                   typename Types<algorithm>::Block& ciphertext) {
+    encrypt_block<algorithm, mode>(plaintext, round_keys, ciphertext);
+}
 
-    template <Algorithm algorithm, Mode mode,
-              typename std::enable_if<ModeRequiresInitVector<mode>::value>::type* = nullptr>
-    void decrypt_block(
-        const typename Types<algorithm>::Block& ciphertext,
-        const typename Types<algorithm>::RoundKeys& round_keys,
-        typename Types<algorithm>::Block& iv,
-        typename Types<algorithm>::Block& plaintext);
+template <Algorithm algorithm,
+          Mode mode,
+          typename std::enable_if<ModeRequiresInitVector<mode>::value>::type* = nullptr>
+void decrypt_block(const typename Types<algorithm>::Block& ciphertext,
+                   const typename Types<algorithm>::RoundKeys& round_keys,
+                   typename Types<algorithm>::Block& iv,
+                   typename Types<algorithm>::Block& plaintext);
 
-    template <Algorithm algorithm, Mode mode,
-              typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
-    void decrypt_block(
-        const typename Types<algorithm>::Block& ciphertext,
-        const typename Types<algorithm>::RoundKeys& round_keys,
-        typename Types<algorithm>::Block& plaintext);
+template <Algorithm algorithm,
+          Mode mode,
+          typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
+void decrypt_block(const typename Types<algorithm>::Block& ciphertext,
+                   const typename Types<algorithm>::RoundKeys& round_keys,
+                   typename Types<algorithm>::Block& plaintext);
+
+template <Algorithm algorithm,
+          Mode mode,
+          typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
+void decrypt_block(const typename Types<algorithm>::Block& ciphertext,
+                   const typename Types<algorithm>::RoundKeys& round_keys,
+                   typename Types<algorithm>::Block&,
+                   typename Types<algorithm>::Block& plaintext) {
+    decrypt_block<algorithm, mode>(ciphertext, round_keys, plaintext);
+}
 
-    template <Algorithm algorithm, Mode mode,
-              typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr>
-    void decrypt_block(
-        const typename Types<algorithm>::Block& ciphertext,
-        const typename Types<algorithm>::RoundKeys& round_keys,
-        typename Types<algorithm>::Block&,
-        typename Types<algorithm>::Block& plaintext)
-    {
-        decrypt_block<algorithm, mode>(ciphertext, round_keys, plaintext);
+template <Algorithm algorithm, Mode mode>
+struct EncryptWrapper {
+    EncryptWrapper(const typename Types<algorithm>::Key& key,
+                   const typename Types<algorithm>::Block& iv)
+        : iv{iv} {
+        expand_key<algorithm>(key, encryption_keys);
     }
 
-    template <Algorithm algorithm, Mode mode>
-    struct EncryptWrapper
-    {
-        EncryptWrapper(
-            const typename Types<algorithm>::Key& key,
-            const typename Types<algorithm>::Block& iv) : iv{iv}
-        {
-            expand_key<algorithm>(key, encryption_keys);
-        }
+    void encrypt_block(const typename Types<algorithm>::Block& plaintext,
+                       typename Types<algorithm>::Block& ciphertext) {
+        aes::encrypt_block<algorithm, mode>(plaintext, encryption_keys, iv, ciphertext);
+    }
 
-        void encrypt_block(
-            const typename Types<algorithm>::Block& plaintext,
-            typename Types<algorithm>::Block& ciphertext)
-        {
-            aes::encrypt_block<algorithm, mode>(
-                plaintext, encryption_keys, iv, ciphertext);
-        }
+    typename Types<algorithm>::Block iv;
+    typename Types<algorithm>::RoundKeys encryption_keys;
+};
 
-        typename Types<algorithm>::Block iv;
+template <Algorithm algorithm, Mode mode>
+struct DecryptWrapper {
+    DecryptWrapper(const typename Types<algorithm>::Key& key,
+                   const typename Types<algorithm>::Block& iv)
+        : iv{iv} {
         typename Types<algorithm>::RoundKeys encryption_keys;
-    };
+        expand_key<algorithm>(key, encryption_keys);
 
-    template <Algorithm algorithm, Mode mode>
-    struct DecryptWrapper
-    {
-        DecryptWrapper(
-            const typename Types<algorithm>::Key& key,
-            const typename Types<algorithm>::Block& iv) : iv{iv}
-        {
-            typename Types<algorithm>::RoundKeys encryption_keys;
-            expand_key<algorithm>(key, encryption_keys);
-
-            if (ModeUsesEncryptionKeysOnly<mode>::value)
-            {
-                decryption_keys = encryption_keys;
-            }
-            else
-            {
-                derive_decryption_keys<algorithm>(encryption_keys, decryption_keys);
-            }
+        if (ModeUsesEncryptionKeysOnly<mode>::value) {
+            decryption_keys = encryption_keys;
+        } else {
+            derive_decryption_keys<algorithm>(encryption_keys, decryption_keys);
         }
+    }
 
-        void decrypt_block(
-            const typename Types<algorithm>::Block& ciphertext,
-            typename Types<algorithm>::Block& plaintext)
-        {
-            aes::decrypt_block<algorithm, mode>(
-                ciphertext, decryption_keys, iv, plaintext);
-        }
+    void decrypt_block(const typename Types<algorithm>::Block& ciphertext,
+                       typename Types<algorithm>::Block& plaintext) {
+        aes::decrypt_block<algorithm, mode>(ciphertext, decryption_keys, iv, plaintext);
+    }
 
-        typename Types<algorithm>::Block iv;
-        typename Types<algorithm>::RoundKeys decryption_keys;
-    };
-}
+    typename Types<algorithm>::Block iv;
+    typename Types<algorithm>::RoundKeys decryption_keys;
+};
+
+} // namespace aes
diff --git a/aesxx/include/aesxx/box.hpp b/aesxx/include/aesxx/box.hpp
index 076407c..540688b 100644
--- a/aesxx/include/aesxx/box.hpp
+++ b/aesxx/include/aesxx/box.hpp
@@ -12,196 +12,140 @@
 #include <aes/all.h>
 
 #include <cstddef>
-
 #include <string>
 #include <vector>
 
-namespace aes
-{
-    class Box
-    {
-    public:
-        typedef AES_BoxBlock Block;
-        typedef AES_BoxKey Key;
+namespace aes {
+
+class Box {
+public:
+    typedef AES_BoxBlock Block;
+    typedef AES_BoxKey Key;
+
+    static std::string format_key(const Key& src, Algorithm algorithm) {
+        AES_BoxKeyString str;
+        aes_box_format_key(&str, algorithm, &src, ErrorDetailsThrowsInDestructor{});
+        return reinterpret_cast<const char*>(&str);
+    }
 
-        static std::string format_key(const Key& src, Algorithm algorithm)
-        {
-            AES_BoxKeyString str;
-            aes_box_format_key(
-                &str, algorithm, &src, ErrorDetailsThrowsInDestructor{});
-            return reinterpret_cast<const char*>(&str);
-        }
+    static std::string format_block(const Block& src, Algorithm algorithm) {
+        AES_BoxBlockString str;
+        aes_box_format_block(&str, algorithm, &src, ErrorDetailsThrowsInDestructor{});
+        return reinterpret_cast<const char*>(&str);
+    }
 
-        static std::string format_block(const Block& src, Algorithm algorithm)
-        {
-            AES_BoxBlockString str;
-            aes_box_format_block(
-                &str, algorithm, &src, ErrorDetailsThrowsInDestructor{});
-            return reinterpret_cast<const char*>(&str);
-        }
+    static void parse_block(Block& dest, Algorithm algorithm, const char* src) {
+        aes_box_parse_block(&dest, algorithm, src, ErrorDetailsThrowsInDestructor{});
+    }
 
-        static void parse_block(
-            Block& dest,
-            Algorithm algorithm,
-            const char* src)
-        {
-            aes_box_parse_block(&dest, algorithm, src,
-                ErrorDetailsThrowsInDestructor{});
-        }
+    static void parse_block(Block& dest, Algorithm algorithm, const std::string& src) {
+        parse_block(dest, algorithm, src.c_str());
+    }
 
-        static void parse_block(
-            Block& dest,
-            Algorithm algorithm,
-            const std::string& src)
-        {
-            parse_block(dest, algorithm, src.c_str());
-        }
+    static void parse_key(Key& dest, Algorithm algorithm, const char* src) {
+        aes_box_parse_key(&dest, algorithm, src, ErrorDetailsThrowsInDestructor{});
+    }
 
-        static void parse_key(
-            Key& dest,
-            Algorithm algorithm,
-            const char* src)
-        {
-            aes_box_parse_key(&dest, algorithm, src,
-                ErrorDetailsThrowsInDestructor{});
-        }
+    static void parse_key(Key& dest, Algorithm algorithm, const std::string& src) {
+        parse_key(dest, algorithm, src.c_str());
+    }
 
-        static void parse_key(
-            Key& dest,
-            Algorithm algorithm,
-            const std::string& src)
-        {
-            parse_key(dest, algorithm, src.c_str());
-        }
+    Box(Algorithm algorithm, const Key& key) : algorithm{algorithm}, mode{AES_ECB} {
+        aes_box_init(&impl, algorithm, &key, mode, nullptr, ErrorDetailsThrowsInDestructor{});
+    }
 
-        Box(Algorithm algorithm, const Key& key)
-            : algorithm{algorithm}
-            , mode{AES_ECB}
-        {
-            aes_box_init(&impl, algorithm, &key, mode, nullptr,
-                ErrorDetailsThrowsInDestructor{});
-        }
+    Box(Algorithm algorithm, const Key& key, Mode mode, const Block& iv)
+        : algorithm{algorithm}, mode{mode} {
+        aes_box_init(&impl, algorithm, &key, mode, &iv, ErrorDetailsThrowsInDestructor{});
+    }
 
-        Box(Algorithm algorithm, const Key& key, Mode mode, const Block& iv)
-            : algorithm{algorithm}
-            , mode{mode}
-        {
-            aes_box_init(&impl, algorithm, &key, mode, &iv,
-                ErrorDetailsThrowsInDestructor{});
-        }
+    void encrypt_block(const Block& plaintext, Block& ciphertext) {
+        aes_box_encrypt_block(&impl, &plaintext, &ciphertext, ErrorDetailsThrowsInDestructor{});
+    }
 
-        void encrypt_block(const Block& plaintext, Block& ciphertext)
-        {
-            aes_box_encrypt_block(
-                &impl, &plaintext, &ciphertext,
-                ErrorDetailsThrowsInDestructor{});
-        }
+    void decrypt_block(const Block& ciphertext, Block& plaintext) {
+        aes_box_decrypt_block(&impl, &ciphertext, &plaintext, ErrorDetailsThrowsInDestructor{});
+    }
 
-        void decrypt_block(const Block& ciphertext, Block& plaintext)
-        {
-            aes_box_decrypt_block(
-                &impl, &ciphertext, &plaintext,
-                ErrorDetailsThrowsInDestructor{});
-        }
+    std::vector<unsigned char> encrypt_buffer(const void* src_buf, std::size_t src_size) {
+        std::size_t dest_size = 0;
 
-        std::vector<unsigned char> encrypt_buffer(
-            const void* src_buf,
-            std::size_t src_size)
-        {
-            std::size_t dest_size = 0;
+        aes_box_encrypt_buffer(
+            &impl, src_buf, src_size, nullptr, &dest_size, aes::ErrorDetailsThrowsInDestructor{});
 
-            aes_box_encrypt_buffer(
-                &impl,
-                src_buf,
-                src_size,
-                nullptr,
-                &dest_size,
-                aes::ErrorDetailsThrowsInDestructor{});
+        std::vector<unsigned char> dest_buf;
+        dest_buf.resize(dest_size);
 
-            std::vector<unsigned char> dest_buf;
-            dest_buf.resize(dest_size);
+        aes_box_encrypt_buffer(&impl,
+                               src_buf,
+                               src_size,
+                               dest_buf.data(),
+                               &dest_size,
+                               aes::ErrorDetailsThrowsInDestructor{});
 
-            aes_box_encrypt_buffer(
-                &impl,
-                src_buf,
-                src_size,
-                dest_buf.data(),
-                &dest_size,
-                aes::ErrorDetailsThrowsInDestructor{});
+        dest_buf.resize(dest_size);
+        return dest_buf;
+    }
 
-            dest_buf.resize(dest_size);
-            return dest_buf;
-        }
+    std::vector<unsigned char> decrypt_buffer(const void* src_buf, std::size_t src_size) {
+        std::size_t dest_size = 0;
 
-        std::vector<unsigned char> decrypt_buffer(
-            const void* src_buf,
-            std::size_t src_size)
-        {
-            std::size_t dest_size = 0;
+        aes_box_decrypt_buffer(
+            &impl, src_buf, src_size, nullptr, &dest_size, aes::ErrorDetailsThrowsInDestructor{});
 
-            aes_box_decrypt_buffer(
-                &impl,
-                src_buf,
-                src_size,
-                nullptr,
-                &dest_size,
-                aes::ErrorDetailsThrowsInDestructor{});
+        std::vector<unsigned char> dest_buf;
+        dest_buf.resize(dest_size);
 
-            std::vector<unsigned char> dest_buf;
-            dest_buf.resize(dest_size);
+        aes_box_decrypt_buffer(&impl,
+                               src_buf,
+                               src_size,
+                               dest_buf.data(),
+                               &dest_size,
+                               aes::ErrorDetailsThrowsInDestructor{});
 
-            aes_box_decrypt_buffer(
-                &impl,
-                src_buf,
-                src_size,
-                dest_buf.data(),
-                &dest_size,
-                aes::ErrorDetailsThrowsInDestructor{});
+        dest_buf.resize(dest_size);
+        return dest_buf;
+    }
 
-            dest_buf.resize(dest_size);
-            return dest_buf;
-        }
+    std::string format_block(const Block& src) {
+        return format_block(src, get_algorithm());
+    }
 
-        std::string format_block(const Block& src)
-        {
-            return format_block(src, get_algorithm());
-        }
+    std::string format_key(const Key& src) {
+        return format_key(src, get_algorithm());
+    }
 
-        std::string format_key(const Key& src)
-        {
-            return format_key(src, get_algorithm());
-        }
+    void parse_block(Block& dest, const char* src) {
+        parse_block(dest, get_algorithm(), src);
+    }
 
-        void parse_block(Block& dest, const char* src)
-        {
-            parse_block(dest, get_algorithm(), src);
-        }
+    void parse_block(Block& dest, const std::string& src) {
+        parse_block(dest, src.c_str());
+    }
 
-        void parse_block(Block& dest, const std::string& src)
-        {
-            parse_block(dest, src.c_str());
-        }
+    void parse_key(Key& dest, const char* src) {
+        parse_key(dest, get_algorithm(), src);
+    }
 
-        void parse_key(Key& dest, const char* src)
-        {
-            parse_key(dest, get_algorithm(), src);
-        }
+    void parse_key(Key& dest, const std::string& src) {
+        parse_key(dest, src.c_str());
+    }
 
-        void parse_key(Key& dest, const std::string& src)
-        {
-            parse_key(dest, src.c_str());
-        }
+    Algorithm get_algorithm() const {
+        return algorithm;
+    }
 
-        Algorithm get_algorithm() const { return algorithm; }
+    Mode get_mode() const {
+        return mode;
+    }
 
-        Mode get_mode() const { return mode; }
+private:
+    Key key;
 
-    private:
-        Key key;
+    Algorithm algorithm;
+    Mode mode;
 
-        Algorithm algorithm;
-        Mode mode;
+    AES_Box impl;
+};
 
-        AES_Box impl;
-    };
-}
+} // namespace aes
diff --git a/aesxx/include/aesxx/data.hpp b/aesxx/include/aesxx/data.hpp
index f36df5e..e381995 100644
--- a/aesxx/include/aesxx/data.hpp
+++ b/aesxx/include/aesxx/data.hpp
@@ -9,47 +9,40 @@
 
 #include <aes/all.h>
 
-namespace aes
-{
-    typedef AES_Block128 Block128;
+namespace aes {
 
-    inline void make_block(Block128& dest, int hi3, int hi2, int lo1, int lo0)
-    {
-        dest = aes_make_block128(hi3, hi2, lo1, lo0);
-    }
+typedef AES_Block128 Block128;
 
-    inline void load_block(Block128& dest, const void* src)
-    {
-        dest = aes_load_block128(src);
-    }
+inline void make_block(Block128& dest, int hi3, int hi2, int lo1, int lo0) {
+    dest = aes_make_block128(hi3, hi2, lo1, lo0);
+}
 
-    inline void load_block_aligned(Block128& dest, const void* src)
-    {
-        dest = aes_load_block128_aligned(src);
-    }
+inline void load_block(Block128& dest, const void* src) {
+    dest = aes_load_block128(src);
+}
 
-    inline void store_block(void* dest, Block128& src)
-    {
-        aes_store_block128(dest, src);
-    }
+inline void load_block_aligned(Block128& dest, const void* src) {
+    dest = aes_load_block128_aligned(src);
+}
 
-    inline void store_block_aligned(void* dest, Block128& src)
-    {
-        aes_store_block128_aligned(dest, src);
-    }
+inline void store_block(void* dest, Block128& src) {
+    aes_store_block128(dest, src);
+}
 
-    inline Block128 xor_blocks(Block128& a, Block128& b)
-    {
-        return aes_xor_block128(a, b);
-    }
+inline void store_block_aligned(void* dest, Block128& src) {
+    aes_store_block128_aligned(dest, src);
+}
 
-    inline Block128 reverse_byte_order(Block128& block)
-    {
-        return aes_reverse_byte_order_block128(block);
-    }
+inline Block128 xor_blocks(Block128& a, Block128& b) {
+    return aes_xor_block128(a, b);
+}
+
+inline Block128 reverse_byte_order(Block128& block) {
+    return aes_reverse_byte_order_block128(block);
+}
 
-    inline Block128 inc_block(Block128& block)
-    {
-        return aes_inc_block128(block);
-    }
+inline Block128 inc_block(Block128& block) {
+    return aes_inc_block128(block);
 }
+
+} // namespace aes
diff --git a/aesxx/include/aesxx/debug.hpp b/aesxx/include/aesxx/debug.hpp
index d7d5d15..d54605d 100644
--- a/aesxx/include/aesxx/debug.hpp
+++ b/aesxx/include/aesxx/debug.hpp
@@ -7,168 +7,134 @@
 
 #ifdef WIN32
 #include <windows.h>
+
 #include <dbghelp.h>
 #pragma comment(lib, "dbghelp.lib")
 #endif
 
 #include <cstddef>
-
 #include <sstream>
 #include <string>
 
-namespace aes
-{
-    namespace aux
-    {
-        class CallStackFormatter
-        {
-        public:
-            CallStackFormatter() = default;
+namespace aes {
+namespace aux {
 
-            std::string format_address(const void* addr) const
-            {
-                #ifdef WIN32
-                return format_address_win32(addr);
-                #else
-                return format_address_fallback(addr);
-                #endif
-            }
+class CallStackFormatter {
+public:
+    CallStackFormatter() = default;
 
-        private:
-            template <typename T>
-            static std::string put_between_brackets(const T& x)
-            {
-                std::ostringstream oss;
-                oss << "[" << x << "]";
-                return oss.str();
-            }
+    std::string format_address(const void* addr) const {
+#ifdef WIN32
+        return format_address_win32(addr);
+#else
+        return format_address_fallback(addr);
+#endif
+    }
 
-            template <typename T>
-            static std::string stringify(const T& x)
-            {
-                std::ostringstream oss;
-                oss << x;
-                return oss.str();
-            }
+private:
+    template <typename T>
+    static std::string put_between_brackets(const T& x) {
+        std::ostringstream oss;
+        oss << "[" << x << "]";
+        return oss.str();
+    }
 
-            static std::string format_address_fallback(const void* addr)
-            {
-                return put_between_brackets(addr);
-            }
+    template <typename T>
+    static std::string stringify(const T& x) {
+        std::ostringstream oss;
+        oss << x;
+        return oss.str();
+    }
 
-            static std::string format_module(
-                const std::string& module_name,
-                const void* offset = nullptr)
-            {
-                if (offset == nullptr)
-                    return put_between_brackets(module_name);
-                else
-                    return put_between_brackets(module_name + "+" + stringify(offset));
-            }
+    static std::string format_address_fallback(const void* addr) {
+        return put_between_brackets(addr);
+    }
 
-            static std::string format_symbol(
-                const std::string& symbol_name,
-                const void* offset = nullptr)
-            {
-                return format_module(symbol_name, offset);
-            }
+    static std::string format_module(const std::string& module_name, const void* offset = nullptr) {
+        if (offset == nullptr)
+            return put_between_brackets(module_name);
+        else
+            return put_between_brackets(module_name + "+" + stringify(offset));
+    }
 
-            static std::string format_symbol(
-                const std::string& module_name,
-                const std::string& symbol_name,
-                const void* offset = nullptr)
-            {
-                return format_symbol(module_name + "!" + symbol_name, offset);
-            }
+    static std::string format_symbol(const std::string& symbol_name, const void* offset = nullptr) {
+        return format_module(symbol_name, offset);
+    }
+
+    static std::string format_symbol(const std::string& module_name,
+                                     const std::string& symbol_name,
+                                     const void* offset = nullptr) {
+        return format_symbol(module_name + "!" + symbol_name, offset);
+    }
 
-            #ifdef WIN32
-            class DbgHelp
-            {
-            public:
-                DbgHelp()
-                {
-                    initialized_flag = SymInitialize(GetCurrentProcess(), NULL, TRUE) != FALSE;
-                }
+#ifdef WIN32
+    class DbgHelp {
+    public:
+        DbgHelp() {
+            initialized_flag = SymInitialize(GetCurrentProcess(), NULL, TRUE) != FALSE;
+        }
 
-                bool initialized() const
-                {
-                    return initialized_flag;
-                }
+        bool initialized() const {
+            return initialized_flag;
+        }
 
-                ~DbgHelp()
-                {
-                    if (initialized_flag)
-                        SymCleanup(GetCurrentProcess());
-                }
+        ~DbgHelp() {
+            if (initialized_flag)
+                SymCleanup(GetCurrentProcess());
+        }
 
-            private:
-                bool initialized_flag = false;
+    private:
+        bool initialized_flag = false;
 
-                DbgHelp(const DbgHelp&) = delete;
-                DbgHelp& operator=(const DbgHelp&) = delete;
-            };
+        DbgHelp(const DbgHelp&) = delete;
+        DbgHelp& operator=(const DbgHelp&) = delete;
+    };
 
-            DbgHelp dbghelp;
+    DbgHelp dbghelp;
 
-            std::string format_address_win32(const void* addr) const
-            {
-                if (!dbghelp.initialized())
-                    return format_address_fallback(addr);
+    std::string format_address_win32(const void* addr) const {
+        if (!dbghelp.initialized())
+            return format_address_fallback(addr);
 
-                DWORD64 symbol_info_buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
-                const auto symbol_info = reinterpret_cast<SYMBOL_INFO*>(symbol_info_buf);
-                symbol_info->SizeOfStruct = sizeof(SYMBOL_INFO);
-                symbol_info->MaxNameLen = MAX_SYM_NAME;
+        DWORD64 symbol_info_buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
+        const auto symbol_info = reinterpret_cast<SYMBOL_INFO*>(symbol_info_buf);
+        symbol_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+        symbol_info->MaxNameLen = MAX_SYM_NAME;
 
-                IMAGEHLP_MODULE64 module_info;
-                module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+        IMAGEHLP_MODULE64 module_info;
+        module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
 
-                DWORD64 symbol_offset;
+        DWORD64 symbol_offset;
 
-                const auto symbol_resolved = SymFromAddr(
-                    GetCurrentProcess(),
-                    reinterpret_cast<DWORD64>(addr),
-                    &symbol_offset,
-                    symbol_info);
+        const auto symbol_resolved = SymFromAddr(
+            GetCurrentProcess(), reinterpret_cast<DWORD64>(addr), &symbol_offset, symbol_info);
 
-                if (symbol_resolved)
-                {
-                    const auto module_resolved = SymGetModuleInfo64(
-                        GetCurrentProcess(),
-                        symbol_info->ModBase,
-                        &module_info);
+        if (symbol_resolved) {
+            const auto module_resolved =
+                SymGetModuleInfo64(GetCurrentProcess(), symbol_info->ModBase, &module_info);
 
-                    if (module_resolved)
-                    {
-                        return format_symbol(
-                            module_info.ModuleName,
-                            symbol_info->Name,
-                            reinterpret_cast<const void*>(symbol_offset));
-                    }
-                    else
-                    {
-                        return format_symbol(symbol_info->Name, addr);
-                    }
-                }
-                else
-                {
-                    const auto module_resolved = SymGetModuleInfo64(
-                        GetCurrentProcess(),
-                        reinterpret_cast<DWORD64>(addr),
-                        &module_info);
+            if (module_resolved) {
+                return format_symbol(module_info.ModuleName,
+                                     symbol_info->Name,
+                                     reinterpret_cast<const void*>(symbol_offset));
+            } else {
+                return format_symbol(symbol_info->Name, addr);
+            }
+        } else {
+            const auto module_resolved = SymGetModuleInfo64(
+                GetCurrentProcess(), reinterpret_cast<DWORD64>(addr), &module_info);
 
-                    if (module_resolved)
-                    {
-                        const auto module_offset = reinterpret_cast<const char*>(addr) - module_info.BaseOfImage;
-                        return format_module(module_info.ModuleName, module_offset);
-                    }
-                    else
-                    {
-                        return format_address_fallback(addr);
-                    }
-                }
+            if (module_resolved) {
+                const auto module_offset =
+                    reinterpret_cast<const char*>(addr) - module_info.BaseOfImage;
+                return format_module(module_info.ModuleName, module_offset);
+            } else {
+                return format_address_fallback(addr);
             }
-            #endif
-        };
+        }
     }
-}
+#endif
+};
+
+} // namespace aux
+} // namespace aes
diff --git a/aesxx/include/aesxx/error.hpp b/aesxx/include/aesxx/error.hpp
index 4d2c783..e5c5803 100644
--- a/aesxx/include/aesxx/error.hpp
+++ b/aesxx/include/aesxx/error.hpp
@@ -11,94 +11,84 @@
 
 #include <boost/config.hpp>
 
+#include <algorithm>
 #include <cstdlib>
 #include <cstring>
-
-#include <algorithm>
 #include <functional>
 #include <ostream>
 #include <stdexcept>
 #include <string>
 #include <vector>
 
-namespace aes
-{
-    class Error : public std::runtime_error
-    {
-    public:
-        Error(const AES_ErrorDetails& err_details)
-            : std::runtime_error{format_error_message(err_details)}
-        {
-            fill_call_stack(err_details);
-        }
+namespace aes {
 
-        void for_each_addr(
-            const std::function<void (const void*, const std::string&)>& callback) const
-        {
-            aux::CallStackFormatter formatter;
+class Error : public std::runtime_error {
+public:
+    Error(const AES_ErrorDetails& err_details)
+        : std::runtime_error{format_error_message(err_details)} {
+        fill_call_stack(err_details);
+    }
 
-            std::for_each(
-                call_stack,
-                call_stack + call_stack_len,
-                [&formatter, &callback] (const void* addr)
-            {
+    void for_each_addr(const std::function<void(const void*, const std::string&)>& callback) const {
+        aux::CallStackFormatter formatter;
+
+        std::for_each(
+            call_stack, call_stack + call_stack_len, [&formatter, &callback](const void* addr) {
                 callback(addr, formatter.format_address(addr));
             });
-        }
+    }
+
+private:
+    static std::string format_error_message(const AES_ErrorDetails& err_details) {
+        std::vector<char> buf;
+        buf.resize(aes_format_error(&err_details, NULL, 0));
+        aes_format_error(&err_details, buf.data(), buf.size());
+        return {buf.begin(), buf.end()};
+    }
 
-    private:
-        static std::string format_error_message(const AES_ErrorDetails& err_details)
-        {
-            std::vector<char> buf;
-            buf.resize(aes_format_error(&err_details, NULL, 0));
-            aes_format_error(&err_details, buf.data(), buf.size());
-            return {buf.begin(), buf.end()};
-        }
+    void fill_call_stack(const AES_ErrorDetails& err_details) {
+        call_stack_len = err_details.call_stack_len;
 
-        void fill_call_stack(const AES_ErrorDetails& err_details)
-        {
-            call_stack_len = err_details.call_stack_len;
+        if (call_stack_len > AES_MAX_CALL_STACK_LENGTH)
+            call_stack_len = AES_MAX_CALL_STACK_LENGTH;
 
-            if (call_stack_len > AES_MAX_CALL_STACK_LENGTH)
-                call_stack_len = AES_MAX_CALL_STACK_LENGTH;
+        std::memcpy(call_stack, err_details.call_stack, call_stack_len * sizeof(const void*));
+    }
 
-            std::memcpy(call_stack, err_details.call_stack, call_stack_len * sizeof(const void*));
-        }
+    std::size_t call_stack_len = 0;
+    const void* call_stack[AES_MAX_CALL_STACK_LENGTH] = {nullptr};
+};
 
-        std::size_t call_stack_len = 0;
-        const void* call_stack[AES_MAX_CALL_STACK_LENGTH] = {nullptr};
-    };
+inline std::ostream& operator<<(std::ostream& os, const Error& error) {
+    os << "AES error: " << error.what() << '\n';
+    os << "Call stack:\n";
+    error.for_each_addr([&os](const void* addr, const std::string& name) {
+        os << '\t' << addr << ' ' << name << '\n';
+    });
+    return os;
+}
 
-    inline std::ostream& operator<<(std::ostream& os, const Error& error)
-    {
-        os << "AES error: " << error.what() << '\n';
-        os << "Call stack:\n";
-        error.for_each_addr([&os] (const void* addr, const std::string& name)
-        {
-            os << '\t' << addr << ' ' << name << '\n';
-        });
-        return os;
+class ErrorDetailsThrowsInDestructor {
+public:
+    ErrorDetailsThrowsInDestructor() {
+        aes_success(get());
     }
 
-    class ErrorDetailsThrowsInDestructor
-    {
-    public:
-        ErrorDetailsThrowsInDestructor()
-        {
-            aes_success(get());
-        }
+    ~ErrorDetailsThrowsInDestructor() BOOST_NOEXCEPT_IF(false) {
+        if (aes_is_error(aes_get_error_code(get())))
+            throw Error(impl);
+    }
 
-        ~ErrorDetailsThrowsInDestructor() BOOST_NOEXCEPT_IF(false)
-        {
-            if (aes_is_error(aes_get_error_code(get())))
-                throw Error(impl);
-        }
+    AES_ErrorDetails* get() {
+        return &impl;
+    }
 
-        AES_ErrorDetails* get() { return &impl; }
+    operator AES_ErrorDetails*() {
+        return get();
+    }
 
-        operator AES_ErrorDetails*() { return get(); }
+private:
+    AES_ErrorDetails impl;
+};
 
-    private:
-        AES_ErrorDetails impl;
-    };
-}
+} // namespace aes
diff --git a/aesxx/include/aesxx/mode.hpp b/aesxx/include/aesxx/mode.hpp
index 1c6c4cf..999db3a 100644
--- a/aesxx/include/aesxx/mode.hpp
+++ b/aesxx/include/aesxx/mode.hpp
@@ -9,145 +9,129 @@
 
 #include <type_traits>
 
-namespace aes
-{
-    typedef AES_Mode Mode;
+namespace aes {
 
-    template <Mode mode>
-    struct ModeRequiresInitVector : public std::true_type
-    { };
+typedef AES_Mode Mode;
 
-    template <>
-    struct ModeRequiresInitVector<AES_ECB> : public std::false_type
-    { };
+template <Mode mode>
+struct ModeRequiresInitVector : public std::true_type {};
 
-    template <Mode mode>
-    struct ModeUsesEncryptionKeysOnly : public std::true_type
-    { };
+template <>
+struct ModeRequiresInitVector<AES_ECB> : public std::false_type {};
 
-    inline bool mode_requires_init_vector(Mode mode)
-    {
-        return mode != AES_ECB;
-    }
+template <Mode mode>
+struct ModeUsesEncryptionKeysOnly : public std::true_type {};
 
-    template <>
-    struct ModeUsesEncryptionKeysOnly<AES_ECB> : public std::false_type
-    { };
+inline bool mode_requires_init_vector(Mode mode) {
+    return mode != AES_ECB;
+}
 
-    template <>
-    struct ModeUsesEncryptionKeysOnly<AES_CBC> : public std::false_type
-    { };
+template <>
+struct ModeUsesEncryptionKeysOnly<AES_ECB> : public std::false_type {};
 
-    inline bool mode_uses_encryption_keys_only(Mode mode)
-    {
-        return mode != AES_ECB && mode != AES_CBC;
-    }
+template <>
+struct ModeUsesEncryptionKeysOnly<AES_CBC> : public std::false_type {};
 
-#define AESXX_ENCRYPT_BLOCK_ECB(prefix) \
-    template <> \
-    inline void encrypt_block<AES_## prefix, AES_ECB>( \
-        const typename Types<AES_## prefix>::Block& plaintext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& ciphertext) \
-    { \
-        ciphertext = aes_## prefix ##_encrypt_block_ECB(plaintext, &encryption_keys); \
+inline bool mode_uses_encryption_keys_only(Mode mode) {
+    return mode != AES_ECB && mode != AES_CBC;
+}
+
+#define AESXX_ENCRYPT_BLOCK_ECB(prefix)                                             \
+    template <>                                                                     \
+    inline void encrypt_block<AES_##prefix, AES_ECB>(                               \
+        const typename Types<AES_##prefix>::Block& plaintext,                       \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,             \
+        typename Types<AES_##prefix>::Block& ciphertext) {                          \
+        ciphertext = aes_##prefix##_encrypt_block_ECB(plaintext, &encryption_keys); \
     }
 
-#define AESXX_DECRYPT_BLOCK_ECB(prefix) \
-    template <> \
-    inline void decrypt_block<AES_## prefix, AES_ECB>( \
-        const typename Types<AES_## prefix>::Block& ciphertext, \
-        const typename Types<AES_## prefix>::RoundKeys& decryption_keys, \
-        typename Types<AES_## prefix>::Block& plaintext) \
-    { \
-        plaintext = aes_## prefix ##_decrypt_block_ECB(ciphertext, &decryption_keys); \
+#define AESXX_DECRYPT_BLOCK_ECB(prefix)                                             \
+    template <>                                                                     \
+    inline void decrypt_block<AES_##prefix, AES_ECB>(                               \
+        const typename Types<AES_##prefix>::Block& ciphertext,                      \
+        const typename Types<AES_##prefix>::RoundKeys& decryption_keys,             \
+        typename Types<AES_##prefix>::Block& plaintext) {                           \
+        plaintext = aes_##prefix##_decrypt_block_ECB(ciphertext, &decryption_keys); \
     }
 
-#define AESXX_ENCRYPT_BLOCK_CBC(prefix) \
-    template <> \
-    inline void encrypt_block<AES_## prefix, AES_CBC>( \
-        const typename Types<AES_## prefix>::Block& plaintext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& ciphertext) \
-    { \
-        ciphertext = aes_## prefix ##_encrypt_block_CBC(plaintext, &encryption_keys, iv, &iv); \
+#define AESXX_ENCRYPT_BLOCK_CBC(prefix)                                                      \
+    template <>                                                                              \
+    inline void encrypt_block<AES_##prefix, AES_CBC>(                                        \
+        const typename Types<AES_##prefix>::Block& plaintext,                                \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& ciphertext) {                                   \
+        ciphertext = aes_##prefix##_encrypt_block_CBC(plaintext, &encryption_keys, iv, &iv); \
     }
 
-#define AESXX_DECRYPT_BLOCK_CBC(prefix) \
-    template <> \
-    inline void decrypt_block<AES_## prefix, AES_CBC>( \
-        const typename Types<AES_## prefix>::Block& ciphertext, \
-        const typename Types<AES_## prefix>::RoundKeys& decryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& plaintext) \
-    { \
-        plaintext = aes_## prefix ##_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &iv); \
+#define AESXX_DECRYPT_BLOCK_CBC(prefix)                                                      \
+    template <>                                                                              \
+    inline void decrypt_block<AES_##prefix, AES_CBC>(                                        \
+        const typename Types<AES_##prefix>::Block& ciphertext,                               \
+        const typename Types<AES_##prefix>::RoundKeys& decryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& plaintext) {                                    \
+        plaintext = aes_##prefix##_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &iv); \
     }
 
-#define AESXX_ENCRYPT_BLOCK_CFB(prefix) \
-    template <> \
-    inline void encrypt_block<AES_## prefix, AES_CFB>( \
-        const typename Types<AES_## prefix>::Block& plaintext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& ciphertext) \
-    { \
-        ciphertext = aes_## prefix ##_encrypt_block_CFB(plaintext, &encryption_keys, iv, &iv); \
+#define AESXX_ENCRYPT_BLOCK_CFB(prefix)                                                      \
+    template <>                                                                              \
+    inline void encrypt_block<AES_##prefix, AES_CFB>(                                        \
+        const typename Types<AES_##prefix>::Block& plaintext,                                \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& ciphertext) {                                   \
+        ciphertext = aes_##prefix##_encrypt_block_CFB(plaintext, &encryption_keys, iv, &iv); \
     }
 
-#define AESXX_DECRYPT_BLOCK_CFB(prefix) \
-    template <> \
-    inline void decrypt_block<AES_## prefix, AES_CFB>( \
-        const typename Types<AES_## prefix>::Block& ciphertext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& plaintext) \
-    { \
-        plaintext = aes_## prefix ##_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &iv); \
+#define AESXX_DECRYPT_BLOCK_CFB(prefix)                                                      \
+    template <>                                                                              \
+    inline void decrypt_block<AES_##prefix, AES_CFB>(                                        \
+        const typename Types<AES_##prefix>::Block& ciphertext,                               \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& plaintext) {                                    \
+        plaintext = aes_##prefix##_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &iv); \
     }
 
-#define AESXX_ENCRYPT_BLOCK_OFB(prefix) \
-    template <> \
-    inline void encrypt_block<AES_## prefix, AES_OFB>( \
-        const typename Types<AES_## prefix>::Block& plaintext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& ciphertext) \
-    { \
-        ciphertext = aes_## prefix ##_encrypt_block_OFB(plaintext, &encryption_keys, iv, &iv); \
+#define AESXX_ENCRYPT_BLOCK_OFB(prefix)                                                      \
+    template <>                                                                              \
+    inline void encrypt_block<AES_##prefix, AES_OFB>(                                        \
+        const typename Types<AES_##prefix>::Block& plaintext,                                \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& ciphertext) {                                   \
+        ciphertext = aes_##prefix##_encrypt_block_OFB(plaintext, &encryption_keys, iv, &iv); \
     }
 
-#define AESXX_DECRYPT_BLOCK_OFB(prefix) \
-    template <> \
-    inline void decrypt_block<AES_## prefix, AES_OFB>( \
-        const typename Types<AES_## prefix>::Block& ciphertext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& plaintext) \
-    { \
-        plaintext = aes_## prefix ##_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &iv); \
+#define AESXX_DECRYPT_BLOCK_OFB(prefix)                                                      \
+    template <>                                                                              \
+    inline void decrypt_block<AES_##prefix, AES_OFB>(                                        \
+        const typename Types<AES_##prefix>::Block& ciphertext,                               \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& plaintext) {                                    \
+        plaintext = aes_##prefix##_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &iv); \
     }
 
-#define AESXX_ENCRYPT_BLOCK_CTR(prefix) \
-    template <> \
-    inline void encrypt_block<AES_## prefix, AES_CTR>( \
-        const typename Types<AES_## prefix>::Block& plaintext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& ciphertext) \
-    { \
-        ciphertext = aes_## prefix ##_encrypt_block_CTR(plaintext, &encryption_keys, iv, &iv); \
+#define AESXX_ENCRYPT_BLOCK_CTR(prefix)                                                      \
+    template <>                                                                              \
+    inline void encrypt_block<AES_##prefix, AES_CTR>(                                        \
+        const typename Types<AES_##prefix>::Block& plaintext,                                \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& ciphertext) {                                   \
+        ciphertext = aes_##prefix##_encrypt_block_CTR(plaintext, &encryption_keys, iv, &iv); \
     }
 
-#define AESXX_DECRYPT_BLOCK_CTR(prefix) \
-    template <> \
-    inline void decrypt_block<AES_## prefix, AES_CTR>( \
-        const typename Types<AES_## prefix>::Block& ciphertext, \
-        const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \
-        typename Types<AES_## prefix>::Block& iv, \
-        typename Types<AES_## prefix>::Block& plaintext) \
-    { \
-        plaintext = aes_## prefix ##_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &iv); \
+#define AESXX_DECRYPT_BLOCK_CTR(prefix)                                                      \
+    template <>                                                                              \
+    inline void decrypt_block<AES_##prefix, AES_CTR>(                                        \
+        const typename Types<AES_##prefix>::Block& ciphertext,                               \
+        const typename Types<AES_##prefix>::RoundKeys& encryption_keys,                      \
+        typename Types<AES_##prefix>::Block& iv,                                             \
+        typename Types<AES_##prefix>::Block& plaintext) {                                    \
+        plaintext = aes_##prefix##_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &iv); \
     }
-}
+
+} // namespace aes
diff --git a/aesxx/utils/block_cmd_parser.hpp b/aesxx/utils/block_cmd_parser.hpp
index 58f86d8..3ae0eac 100644
--- a/aesxx/utils/block_cmd_parser.hpp
+++ b/aesxx/utils/block_cmd_parser.hpp
@@ -19,8 +19,7 @@
 #include <utility>
 #include <vector>
 
-class BlockSettings : public command_line::SettingsParser
-{
+class BlockSettings : public command_line::SettingsParser {
 public:
     aes::Algorithm algorithm = AES_AES128;
     aes::Mode mode = AES_ECB;
@@ -30,65 +29,52 @@ public:
 
     std::vector<Input> inputs;
 
-    explicit BlockSettings(const std::string& argv0)
-        : SettingsParser{argv0}
-    {
-        visible.add_options()
-            ("verbose,v",
-                boost::program_options::bool_switch(&verbose),
-                "enable verbose output")
-            ("algorithm,a",
-                boost::program_options::value<aes::Algorithm>(&algorithm)
-                    ->required()
-                    ->value_name("NAME"),
-                "set algorithm")
-            ("mode,m",
-                boost::program_options::value<aes::Mode>(&mode)
-                    ->required()
-                    ->value_name("MODE"),
-                "set mode of operation")
-            ("use-boxes,b",
-                boost::program_options::bool_switch(&use_boxes),
-                "use the \"boxes\" interface");
-        hidden.add_options()
-            ("args",
-                boost::program_options::value<std::vector<std::string>>(&args),
-                "shouldn't be visible");
+    explicit BlockSettings(const std::string& argv0) : SettingsParser{argv0} {
+        visible.add_options()(
+            "verbose,v", boost::program_options::bool_switch(&verbose), "enable verbose output");
+        visible.add_options()("algorithm,a",
+                              boost::program_options::value<aes::Algorithm>(&algorithm)
+                                  ->required()
+                                  ->value_name("NAME"),
+                              "set algorithm");
+        visible.add_options()(
+            "mode,m",
+            boost::program_options::value<aes::Mode>(&mode)->required()->value_name("MODE"),
+            "set mode of operation");
+        visible.add_options()("use-boxes,b",
+                              boost::program_options::bool_switch(&use_boxes),
+                              "use the \"boxes\" interface");
+        hidden.add_options()("args",
+                             boost::program_options::value<std::vector<std::string>>(&args),
+                             "shouldn't be visible");
         positional.add("args", -1);
     }
 
-    const char* get_short_description() const override
-    {
+    const char* get_short_description() const override {
         return "[-h|--help] [-v|--verbose] [-a|--algorithm NAME] [-m|--mode MODE]"
                " [-- KEY [IV] [BLOCK]...]...";
     }
 
-    void parse(int argc, char* argv[]) override
-    {
+    void parse(int argc, char* argv[]) override {
         SettingsParser::parse(argc, argv);
-        parse_inputs(std::deque<std::string>{
-            std::make_move_iterator(args.begin()),
-            std::make_move_iterator(args.end())});
+        parse_inputs(std::deque<std::string>{std::make_move_iterator(args.begin()),
+                                             std::make_move_iterator(args.end())});
     }
 
 private:
-    void parse_inputs(std::deque<std::string>&& src)
-    {
+    void parse_inputs(std::deque<std::string>&& src) {
         while (!src.empty())
             inputs.emplace_back(parse_input(src));
     }
 
-    Input parse_input(std::deque<std::string>& src) const
-    {
+    Input parse_input(std::deque<std::string>& src) const {
         std::string key{std::move(src.front())};
         src.pop_front();
 
         std::string iv;
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            if (src.empty())
-            {
+        if (aes::mode_requires_init_vector(mode)) {
+            if (src.empty()) {
                 throw boost::program_options::error{
                     "an initialization vector is required for the selected mode of operation"};
             }
@@ -104,12 +90,10 @@ private:
             return {key, std::move(blocks)};
     }
 
-    static std::vector<std::string> parse_blocks(std::deque<std::string>& src)
-    {
+    static std::vector<std::string> parse_blocks(std::deque<std::string>& src) {
         std::vector<std::string> blocks;
 
-        while (!src.empty())
-        {
+        while (!src.empty()) {
             std::string block{std::move(src.front())};
             src.pop_front();
             if (block == "--")
diff --git a/aesxx/utils/block_dumper.hpp b/aesxx/utils/block_dumper.hpp
index a07d855..226ba20 100644
--- a/aesxx/utils/block_dumper.hpp
+++ b/aesxx/utils/block_dumper.hpp
@@ -8,48 +8,38 @@
 #include <aesxx/all.hpp>
 
 #include <cstdlib>
-
 #include <iostream>
 #include <type_traits>
 
 template <aes::Algorithm algorithm>
-void dump_block(
-    const char* header,
-    const typename aes::Types<algorithm>::Block& block)
-{
+void dump_block(const char* header, const typename aes::Types<algorithm>::Block& block) {
     std::cout << header << ": " << aes::to_string<algorithm>(block) << "\n";
     std::cout << aes::to_matrix_string<algorithm>(block) << "\n";
 }
 
 template <aes::Algorithm algorithm>
-void dump_plaintext(const typename aes::Types<algorithm>::Block& block)
-{
+void dump_plaintext(const typename aes::Types<algorithm>::Block& block) {
     dump_block<algorithm>("Plaintext", block);
 }
 
 template <aes::Algorithm algorithm>
-void dump_key(const typename aes::Types<algorithm>::Key& key)
-{
+void dump_key(const typename aes::Types<algorithm>::Key& key) {
     std::cout << "Key: " << aes::to_string<algorithm>(key) << "\n\n";
 }
 
 template <aes::Algorithm algorithm>
-void dump_ciphertext(const typename aes::Types<algorithm>::Block& ciphertext)
-{
+void dump_ciphertext(const typename aes::Types<algorithm>::Block& ciphertext) {
     dump_block<algorithm>("Ciphertext", ciphertext);
 }
 
 template <aes::Algorithm algorithm>
-void dump_iv(const typename aes::Types<algorithm>::Block& iv)
-{
+void dump_iv(const typename aes::Types<algorithm>::Block& iv) {
     dump_block<algorithm>("Initialization vector", iv);
 }
 
 template <aes::Algorithm algorithm>
-void dump_round_keys(
-    const char* header,
-    const typename aes::Types<algorithm>::RoundKeys& round_keys)
-{
+void dump_round_keys(const char* header,
+                     const typename aes::Types<algorithm>::RoundKeys& round_keys) {
     std::cout << header << ":\n";
     for (std::size_t i = 0; i < aes::get_number_of_rounds<algorithm>(); ++i)
         std::cout << "\t[" << i << "]: " << aes::to_string<algorithm>(round_keys.keys[i]) << "\n";
@@ -57,49 +47,45 @@ void dump_round_keys(
 }
 
 template <aes::Algorithm algorithm>
-void dump_encryption_keys(const typename aes::Types<algorithm>::RoundKeys& round_keys)
-{
+void dump_encryption_keys(const typename aes::Types<algorithm>::RoundKeys& round_keys) {
     dump_round_keys<algorithm>("Encryption round keys", round_keys);
 }
 
 template <aes::Algorithm algorithm>
-void dump_decryption_keys(const typename aes::Types<algorithm>::RoundKeys& round_keys)
-{
+void dump_decryption_keys(const typename aes::Types<algorithm>::RoundKeys& round_keys) {
     dump_round_keys<algorithm>("Decryption round keys", round_keys);
 }
 
 template <aes::Algorithm algorithm, aes::Mode mode>
-void dump_wrapper(const aes::EncryptWrapper<algorithm, mode>& wrapper)
-{
+void dump_wrapper(const aes::EncryptWrapper<algorithm, mode>& wrapper) {
     dump_encryption_keys<algorithm>(wrapper.encryption_keys);
 }
 
 template <aes::Algorithm algorithm, aes::Mode mode>
-void dump_wrapper(const aes::DecryptWrapper<algorithm, mode>& wrapper)
-{
+void dump_wrapper(const aes::DecryptWrapper<algorithm, mode>& wrapper) {
     dump_decryption_keys<algorithm>(wrapper.decryption_keys);
 }
 
-template <aes::Algorithm algorithm, aes::Mode mode,
+template <aes::Algorithm algorithm,
+          aes::Mode mode,
           typename std::enable_if<aes::ModeRequiresInitVector<mode>::value>::type* = nullptr>
-void dump_next_iv(const aes::EncryptWrapper<algorithm, mode>& wrapper)
-{
+void dump_next_iv(const aes::EncryptWrapper<algorithm, mode>& wrapper) {
     dump_block<algorithm>("Next initialization vector", wrapper.iv);
 }
 
-template <aes::Algorithm algorithm, aes::Mode mode,
+template <aes::Algorithm algorithm,
+          aes::Mode mode,
           typename std::enable_if<!aes::ModeRequiresInitVector<mode>::value>::type* = nullptr>
-void dump_next_iv(const aes::EncryptWrapper<algorithm, mode>&)
-{ }
+void dump_next_iv(const aes::EncryptWrapper<algorithm, mode>&) {}
 
-template <aes::Algorithm algorithm, aes::Mode mode,
+template <aes::Algorithm algorithm,
+          aes::Mode mode,
           typename std::enable_if<aes::ModeRequiresInitVector<mode>::value>::type* = nullptr>
-void dump_next_iv(const aes::DecryptWrapper<algorithm, mode>& wrapper)
-{
+void dump_next_iv(const aes::DecryptWrapper<algorithm, mode>& wrapper) {
     dump_block<algorithm>("Next initialization vector", wrapper.iv);
 }
 
-template <aes::Algorithm algorithm, aes::Mode mode,
+template <aes::Algorithm algorithm,
+          aes::Mode mode,
           typename std::enable_if<!aes::ModeRequiresInitVector<mode>::value>::type* = nullptr>
-void dump_next_iv(const aes::DecryptWrapper<algorithm, mode>&)
-{ }
+void dump_next_iv(const aes::DecryptWrapper<algorithm, mode>&) {}
diff --git a/aesxx/utils/block_input.hpp b/aesxx/utils/block_input.hpp
index f629062..1dd3f70 100644
--- a/aesxx/utils/block_input.hpp
+++ b/aesxx/utils/block_input.hpp
@@ -9,19 +9,13 @@
 #include <utility>
 #include <vector>
 
-class Input
-{
+class Input {
 public:
     Input(const std::string& key, const std::string& iv, std::vector<std::string>&& blocks)
-        : key{key}
-        , iv{iv}
-        , blocks{std::move(blocks)}
-    { }
+        : key{key}, iv{iv}, blocks{std::move(blocks)} {}
 
     Input(const std::string& key, std::vector<std::string>&& blocks)
-        : key{key}
-        , blocks{std::move(blocks)}
-    { }
+        : key{key}, blocks{std::move(blocks)} {}
 
     const std::string key;
     const std::string iv;
diff --git a/aesxx/utils/data_parsers.hpp b/aesxx/utils/data_parsers.hpp
index 1207c7c..a08f1bf 100644
--- a/aesxx/utils/data_parsers.hpp
+++ b/aesxx/utils/data_parsers.hpp
@@ -14,13 +14,11 @@
 #include <string>
 #include <unordered_map>
 
-inline std::istream& operator>>(std::istream& is, aes::Mode& dest)
-{
+inline std::istream& operator>>(std::istream& is, aes::Mode& dest) {
     std::string src;
     is >> src;
 
-    static const std::unordered_map<std::string, aes::Mode> lookup_table =
-    {
+    static const std::unordered_map<std::string, aes::Mode> lookup_table = {
         {"ecb", AES_ECB},
         {"cbc", AES_CBC},
         {"cfb", AES_CFB},
@@ -37,13 +35,11 @@ inline std::istream& operator>>(std::istream& is, aes::Mode& dest)
     return is;
 }
 
-inline std::istream& operator>>(std::istream& is, aes::Algorithm& dest)
-{
+inline std::istream& operator>>(std::istream& is, aes::Algorithm& dest) {
     std::string src;
     is >> src;
 
-    static const std::unordered_map<std::string, aes::Algorithm> lookup_table =
-    {
+    static const std::unordered_map<std::string, aes::Algorithm> lookup_table = {
         {"aes128", AES_AES128},
         {"aes192", AES_AES192},
         {"aes256", AES_AES256},
diff --git a/aesxx/utils/decrypt_block.cpp b/aesxx/utils/decrypt_block.cpp
index 02a3033..42e496e 100644
--- a/aesxx/utils/decrypt_block.cpp
+++ b/aesxx/utils/decrypt_block.cpp
@@ -16,198 +16,151 @@
 #include <stdexcept>
 #include <string>
 
-namespace
-{
-    template <aes::Algorithm algorithm, aes::Mode mode>
-    void decrypt_with_mode(
-        const Input& input,
-        bool verbose = false)
-    {
-        typename aes::Types<algorithm>::Block iv;
+namespace {
 
-        if (aes::ModeRequiresInitVector<mode>())
-        {
-            aes::from_string<algorithm>(iv, input.iv);
-            if (verbose)
-                dump_iv<algorithm>(iv);
-        }
+template <aes::Algorithm algorithm, aes::Mode mode>
+void decrypt_with_mode(const Input& input, bool verbose = false) {
+    typename aes::Types<algorithm>::Block iv;
 
-        typename aes::Types<algorithm>::Key key;
-        aes::from_string<algorithm>(key, input.key);
+    if (aes::ModeRequiresInitVector<mode>()) {
+        aes::from_string<algorithm>(iv, input.iv);
         if (verbose)
-            dump_key<algorithm>(key);
+            dump_iv<algorithm>(iv);
+    }
 
-        aes::DecryptWrapper<algorithm, mode> decrypt{key, iv};
-        if (verbose)
-            dump_wrapper<algorithm, mode>(decrypt);
+    typename aes::Types<algorithm>::Key key;
+    aes::from_string<algorithm>(key, input.key);
+    if (verbose)
+        dump_key<algorithm>(key);
 
-        for (const auto& block : input.blocks)
-        {
-            typename aes::Types<algorithm>::Block ciphertext, plaintext;
-            aes::from_string<algorithm>(ciphertext, block);
+    aes::DecryptWrapper<algorithm, mode> decrypt{key, iv};
+    if (verbose)
+        dump_wrapper<algorithm, mode>(decrypt);
 
-            decrypt.decrypt_block(ciphertext, plaintext);
+    for (const auto& block : input.blocks) {
+        typename aes::Types<algorithm>::Block ciphertext, plaintext;
+        aes::from_string<algorithm>(ciphertext, block);
 
-            if (verbose)
-            {
-                dump_ciphertext<algorithm>(ciphertext);
-                dump_plaintext<algorithm>(plaintext);
-                dump_next_iv<algorithm, mode>(decrypt);
-            }
-            else
-            {
-                std::cout << aes::to_string<algorithm>(plaintext) << '\n';
-            }
+        decrypt.decrypt_block(ciphertext, plaintext);
+
+        if (verbose) {
+            dump_ciphertext<algorithm>(ciphertext);
+            dump_plaintext<algorithm>(plaintext);
+            dump_next_iv<algorithm, mode>(decrypt);
+        } else {
+            std::cout << aes::to_string<algorithm>(plaintext) << '\n';
         }
     }
+}
 
-    template <aes::Algorithm algorithm>
-    void decrypt_with_algorithm(
-        aes::Mode mode,
-        const Input& input,
-        bool verbose = false)
-    {
-        switch (mode)
-        {
-            case AES_ECB:
-                decrypt_with_mode<algorithm, AES_ECB>(input, verbose);
-                break;
+template <aes::Algorithm algorithm>
+void decrypt_with_algorithm(aes::Mode mode, const Input& input, bool verbose = false) {
+    switch (mode) {
+        case AES_ECB:
+            decrypt_with_mode<algorithm, AES_ECB>(input, verbose);
+            break;
 
-            case AES_CBC:
-                decrypt_with_mode<algorithm, AES_CBC>(input, verbose);
-                break;
+        case AES_CBC:
+            decrypt_with_mode<algorithm, AES_CBC>(input, verbose);
+            break;
 
-            case AES_CFB:
-                decrypt_with_mode<algorithm, AES_CFB>(input, verbose);
-                break;
+        case AES_CFB:
+            decrypt_with_mode<algorithm, AES_CFB>(input, verbose);
+            break;
 
-            case AES_OFB:
-                decrypt_with_mode<algorithm, AES_OFB>(input, verbose);
-                break;
+        case AES_OFB:
+            decrypt_with_mode<algorithm, AES_OFB>(input, verbose);
+            break;
 
-            case AES_CTR:
-                decrypt_with_mode<algorithm, AES_CTR>(input, verbose);
-                break;
+        case AES_CTR:
+            decrypt_with_mode<algorithm, AES_CTR>(input, verbose);
+            break;
 
-            default:
-                throw std::runtime_error("the selected mode of operation is not implemented");
-                break;
-        }
+        default:
+            throw std::runtime_error("the selected mode of operation is not implemented");
+            break;
     }
+}
 
-    void decrypt_using_cxx_api(
-        aes::Algorithm algorithm,
-        aes::Mode mode,
-        const Input& input,
-        bool verbose = false)
-    {
-        switch (algorithm)
-        {
-            case AES_AES128:
-                decrypt_with_algorithm<AES_AES128>(mode, input, verbose);
-                break;
+void decrypt_using_cxx_api(aes::Algorithm algorithm,
+                           aes::Mode mode,
+                           const Input& input,
+                           bool verbose = false) {
+    switch (algorithm) {
+        case AES_AES128:
+            decrypt_with_algorithm<AES_AES128>(mode, input, verbose);
+            break;
 
-            case AES_AES192:
-                decrypt_with_algorithm<AES_AES192>(mode, input, verbose);
-                break;
+        case AES_AES192:
+            decrypt_with_algorithm<AES_AES192>(mode, input, verbose);
+            break;
 
-            case AES_AES256:
-                decrypt_with_algorithm<AES_AES256>(mode, input, verbose);
-                break;
+        case AES_AES256:
+            decrypt_with_algorithm<AES_AES256>(mode, input, verbose);
+            break;
 
-            default:
-                throw std::runtime_error("the selected algorithm is not implemented");
-                break;
-        }
+        default:
+            throw std::runtime_error("the selected algorithm is not implemented");
+            break;
     }
+}
 
-    void decrypt_using_particular_box(
-        aes::Box& box,
-        const std::vector<std::string>& blocks)
-    {
-        for (const auto& block : blocks)
-        {
-            aes::Box::Block ciphertext;
-            box.parse_block(ciphertext, block);
+void decrypt_using_particular_box(aes::Box& box, const std::vector<std::string>& blocks) {
+    for (const auto& block : blocks) {
+        aes::Box::Block ciphertext;
+        box.parse_block(ciphertext, block);
 
-            aes::Box::Block plaintext;
-            box.decrypt_block(ciphertext, plaintext);
-            std::cout << box.format_block(plaintext) << '\n';
-        }
+        aes::Box::Block plaintext;
+        box.decrypt_block(ciphertext, plaintext);
+        std::cout << box.format_block(plaintext) << '\n';
     }
+}
 
-    void decrypt_using_boxes(
-        aes::Algorithm algorithm,
-        aes::Mode mode,
-        const Input& input)
-    {
-        aes::Box::Key key;
-        aes::Box::parse_key(key, algorithm, input.key);
+void decrypt_using_boxes(aes::Algorithm algorithm, aes::Mode mode, const Input& input) {
+    aes::Box::Key key;
+    aes::Box::parse_key(key, algorithm, input.key);
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            aes::Box::Block iv;
-            aes::Box::parse_block(iv, algorithm, input.iv);
-            aes::Box box{algorithm, key, mode, iv};
+    if (aes::mode_requires_init_vector(mode)) {
+        aes::Box::Block iv;
+        aes::Box::parse_block(iv, algorithm, input.iv);
+        aes::Box box{algorithm, key, mode, iv};
 
-            decrypt_using_particular_box(box, input.blocks);
-        }
-        else
-        {
-            aes::Box box{algorithm, key};
-            decrypt_using_particular_box(box, input.blocks);
-        }
+        decrypt_using_particular_box(box, input.blocks);
+    } else {
+        aes::Box box{algorithm, key};
+        decrypt_using_particular_box(box, input.blocks);
     }
 }
 
-int main(int argc, char** argv)
-{
-    try
-    {
+} // namespace
+
+int main(int argc, char** argv) {
+    try {
         BlockSettings settings{argv[0]};
 
-        try
-        {
+        try {
             settings.parse(argc, argv);
-        }
-        catch (const boost::program_options::error& e)
-        {
+        } catch (const boost::program_options::error& e) {
             settings.usage_error(e);
             return 1;
         }
 
-        if (settings.exit_with_usage)
-        {
+        if (settings.exit_with_usage) {
             settings.usage();
             return 0;
         }
 
-        for (const auto& input : settings.inputs)
-        {
-            if (settings.use_boxes)
-            {
-                decrypt_using_boxes(
-                    settings.algorithm,
-                    settings.mode,
-                    input);
-            }
-            else
-            {
-                decrypt_using_cxx_api(
-                    settings.algorithm,
-                    settings.mode,
-                    input,
-                    settings.verbose);
+        for (const auto& input : settings.inputs) {
+            if (settings.use_boxes) {
+                decrypt_using_boxes(settings.algorithm, settings.mode, input);
+            } else {
+                decrypt_using_cxx_api(settings.algorithm, settings.mode, input, settings.verbose);
             }
         }
-    }
-    catch (const aes::Error& e)
-    {
+    } catch (const aes::Error& e) {
         std::cerr << e;
         return 1;
-    }
-    catch (const std::exception& e)
-    {
+    } catch (const std::exception& e) {
         std::cerr << e.what() << "\n";
         return 1;
     }
diff --git a/aesxx/utils/decrypt_bmp.cpp b/aesxx/utils/decrypt_bmp.cpp
index 9f9cd52..86f6b7d 100644
--- a/aesxx/utils/decrypt_bmp.cpp
+++ b/aesxx/utils/decrypt_bmp.cpp
@@ -9,83 +9,66 @@
 
 #include <aesxx/all.hpp>
 
-#include <windows.h>
-
 #include <boost/program_options.hpp>
 
+#include <windows.h>
+
 #include <exception>
 #include <iostream>
 #include <string>
 
-namespace
-{
-    void decrypt_bmp(
-        aes::Box& box,
-        const std::string& ciphertext_path,
-        const std::string& plaintext_path)
-    {
-        bmp::BmpFile bmp{file::read_file(ciphertext_path)};
-        bmp.replace_pixels(box.decrypt_buffer(
-            bmp.get_pixels(),
-            bmp.get_pixels_size()));
-        file::write_file(plaintext_path, bmp.get_buffer(), bmp.get_size());
-    }
+namespace {
 
-    void decrypt_bmp(const FileSettings& settings)
-    {
-        const auto& algorithm = settings.algorithm;
-        const auto& mode = settings.mode;
+void decrypt_bmp(aes::Box& box,
+                 const std::string& ciphertext_path,
+                 const std::string& plaintext_path) {
+    bmp::BmpFile bmp{file::read_file(ciphertext_path)};
+    bmp.replace_pixels(box.decrypt_buffer(bmp.get_pixels(), bmp.get_pixels_size()));
+    file::write_file(plaintext_path, bmp.get_buffer(), bmp.get_size());
+}
 
-        aes::Box::Key key;
-        aes::Box::parse_key(key, algorithm, settings.key);
+void decrypt_bmp(const FileSettings& settings) {
+    const auto& algorithm = settings.algorithm;
+    const auto& mode = settings.mode;
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            aes::Box::Block iv;
-            aes::Box::parse_block(iv, algorithm, settings.iv);
+    aes::Box::Key key;
+    aes::Box::parse_key(key, algorithm, settings.key);
 
-            aes::Box box{algorithm, key, mode, iv};
-            decrypt_bmp(box, settings.input_path, settings.output_path);
-        }
-        else
-        {
-            aes::Box box{algorithm, key};
-            decrypt_bmp(box, settings.input_path, settings.output_path);
-        }
+    if (aes::mode_requires_init_vector(mode)) {
+        aes::Box::Block iv;
+        aes::Box::parse_block(iv, algorithm, settings.iv);
+
+        aes::Box box{algorithm, key, mode, iv};
+        decrypt_bmp(box, settings.input_path, settings.output_path);
+    } else {
+        aes::Box box{algorithm, key};
+        decrypt_bmp(box, settings.input_path, settings.output_path);
     }
 }
 
-int main(int argc, char** argv)
-{
-    try
-    {
+} // namespace
+
+int main(int argc, char** argv) {
+    try {
         FileSettings settings{argv[0]};
 
-        try
-        {
+        try {
             settings.parse(argc, argv);
-        }
-        catch (const boost::program_options::error& e)
-        {
+        } catch (const boost::program_options::error& e) {
             settings.usage_error(e);
             return 1;
         }
 
-        if (settings.exit_with_usage)
-        {
+        if (settings.exit_with_usage) {
             settings.usage();
             return 0;
         }
 
         decrypt_bmp(settings);
-    }
-    catch (const aes::Error& e)
-    {
+    } catch (const aes::Error& e) {
         std::cerr << e;
         return 1;
-    }
-    catch (const std::exception& e)
-    {
+    } catch (const std::exception& e) {
         std::cerr << e.what() << "\n";
         return 1;
     }
diff --git a/aesxx/utils/decrypt_file.cpp b/aesxx/utils/decrypt_file.cpp
index 6da3d17..727362c 100644
--- a/aesxx/utils/decrypt_file.cpp
+++ b/aesxx/utils/decrypt_file.cpp
@@ -15,75 +15,58 @@
 #include <string>
 #include <vector>
 
-namespace
-{
-    void decrypt_file(
-        aes::Box& box,
-        const std::string& ciphertext_path,
-        const std::string& plaintext_path)
-    {
-        const auto ciphertext_buf = file::read_file(ciphertext_path);
-        const auto plaintext_buf = box.decrypt_buffer(
-            ciphertext_buf.data(),
-            ciphertext_buf.size());
-        file::write_file(plaintext_path, plaintext_buf);
-    }
+namespace {
 
-    void decrypt_file(const FileSettings& settings)
-    {
-        const auto& algorithm = settings.algorithm;
-        const auto& mode = settings.mode;
+void decrypt_file(aes::Box& box,
+                  const std::string& ciphertext_path,
+                  const std::string& plaintext_path) {
+    const auto ciphertext_buf = file::read_file(ciphertext_path);
+    const auto plaintext_buf = box.decrypt_buffer(ciphertext_buf.data(), ciphertext_buf.size());
+    file::write_file(plaintext_path, plaintext_buf);
+}
 
-        aes::Box::Key key;
-        aes::Box::parse_key(key, algorithm, settings.key);
+void decrypt_file(const FileSettings& settings) {
+    const auto& algorithm = settings.algorithm;
+    const auto& mode = settings.mode;
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            aes::Box::Block iv;
-            aes::Box::parse_block(iv, algorithm, settings.iv);
+    aes::Box::Key key;
+    aes::Box::parse_key(key, algorithm, settings.key);
 
-            aes::Box box{algorithm, key, mode, iv};
-            decrypt_file(box, settings.input_path, settings.output_path);
-        }
-        else
-        {
-            aes::Box box{algorithm, key};
-            decrypt_file(box, settings.input_path, settings.output_path);
-        }
+    if (aes::mode_requires_init_vector(mode)) {
+        aes::Box::Block iv;
+        aes::Box::parse_block(iv, algorithm, settings.iv);
+
+        aes::Box box{algorithm, key, mode, iv};
+        decrypt_file(box, settings.input_path, settings.output_path);
+    } else {
+        aes::Box box{algorithm, key};
+        decrypt_file(box, settings.input_path, settings.output_path);
     }
 }
 
-int main(int argc, char** argv)
-{
-    try
-    {
+} // namespace
+
+int main(int argc, char** argv) {
+    try {
         FileSettings settings{argv[0]};
 
-        try
-        {
+        try {
             settings.parse(argc, argv);
-        }
-        catch (const boost::program_options::error& e)
-        {
+        } catch (const boost::program_options::error& e) {
             settings.usage_error(e);
             return 1;
         }
 
-        if (settings.exit_with_usage)
-        {
+        if (settings.exit_with_usage) {
             settings.usage();
             return 0;
         }
 
         decrypt_file(settings);
-    }
-    catch (const aes::Error& e)
-    {
+    } catch (const aes::Error& e) {
         std::cerr << e;
         return 1;
-    }
-    catch (const std::exception& e)
-    {
+    } catch (const std::exception& e) {
         std::cerr << e.what() << "\n";
         return 1;
     }
diff --git a/aesxx/utils/encrypt_block.cpp b/aesxx/utils/encrypt_block.cpp
index 0b87364..b6bdca9 100644
--- a/aesxx/utils/encrypt_block.cpp
+++ b/aesxx/utils/encrypt_block.cpp
@@ -16,198 +16,152 @@
 #include <stdexcept>
 #include <string>
 
-namespace
-{
-    template <aes::Algorithm algorithm, aes::Mode mode>
-    void encrypt_with_mode(
-        const Input& input,
-        bool verbose = false)
-    {
-        typename aes::Types<algorithm>::Block iv;
+namespace {
 
-        if (aes::ModeRequiresInitVector<mode>::value)
-        {
-            aes::from_string<algorithm>(iv, input.iv);
-            if (verbose)
-                dump_iv<algorithm>(iv);
-        }
+template <aes::Algorithm algorithm, aes::Mode mode>
+void encrypt_with_mode(const Input& input, bool verbose = false) {
+    typename aes::Types<algorithm>::Block iv;
 
-        typename aes::Types<algorithm>::Key key;
-        aes::from_string<algorithm>(key, input.key);
+    if (aes::ModeRequiresInitVector<mode>::value) {
+        aes::from_string<algorithm>(iv, input.iv);
         if (verbose)
-            dump_key<algorithm>(key);
+            dump_iv<algorithm>(iv);
+    }
 
-        aes::EncryptWrapper<algorithm, mode> encrypt{key, iv};
-        if (verbose)
-            dump_wrapper<algorithm, mode>(encrypt);
+    typename aes::Types<algorithm>::Key key;
+    aes::from_string<algorithm>(key, input.key);
+    if (verbose)
+        dump_key<algorithm>(key);
 
-        for (const auto& input_block_string : input.blocks)
-        {
-            typename aes::Types<algorithm>::Block plaintext, ciphertext;
-            aes::from_string<algorithm>(plaintext, input_block_string);
+    aes::EncryptWrapper<algorithm, mode> encrypt{key, iv};
+    if (verbose)
+        dump_wrapper<algorithm, mode>(encrypt);
 
-            encrypt.encrypt_block(plaintext, ciphertext);
+    for (const auto& input_block_string : input.blocks) {
+        typename aes::Types<algorithm>::Block plaintext, ciphertext;
+        aes::from_string<algorithm>(plaintext, input_block_string);
 
-            if (verbose)
-            {
-                dump_plaintext<algorithm>(plaintext);
-                dump_ciphertext<algorithm>(ciphertext);
-                dump_next_iv<algorithm, mode>(encrypt);
-            }
-            else
-            {
-                std::cout << aes::to_string<algorithm>(ciphertext) << '\n';
-            }
+        encrypt.encrypt_block(plaintext, ciphertext);
+
+        if (verbose) {
+            dump_plaintext<algorithm>(plaintext);
+            dump_ciphertext<algorithm>(ciphertext);
+            dump_next_iv<algorithm, mode>(encrypt);
+        } else {
+            std::cout << aes::to_string<algorithm>(ciphertext) << '\n';
         }
     }
+}
 
-    template <aes::Algorithm algorithm>
-    void encrypt_with_algorithm(
-        aes::Mode mode,
-        const Input& input,
-        bool verbose = false)
-    {
-        switch (mode)
-        {
-            case AES_ECB:
-                encrypt_with_mode<algorithm, AES_ECB>(input, verbose);
-                break;
+template <aes::Algorithm algorithm>
+void encrypt_with_algorithm(aes::Mode mode, const Input& input, bool verbose = false) {
+    switch (mode) {
+        case AES_ECB:
+            encrypt_with_mode<algorithm, AES_ECB>(input, verbose);
+            break;
 
-            case AES_CBC:
-                encrypt_with_mode<algorithm, AES_CBC>(input, verbose);
-                break;
+        case AES_CBC:
+            encrypt_with_mode<algorithm, AES_CBC>(input, verbose);
+            break;
 
-            case AES_CFB:
-                encrypt_with_mode<algorithm, AES_CFB>(input, verbose);
-                break;
+        case AES_CFB:
+            encrypt_with_mode<algorithm, AES_CFB>(input, verbose);
+            break;
 
-            case AES_OFB:
-                encrypt_with_mode<algorithm, AES_OFB>(input, verbose);
-                break;
+        case AES_OFB:
+            encrypt_with_mode<algorithm, AES_OFB>(input, verbose);
+            break;
 
-            case AES_CTR:
-                encrypt_with_mode<algorithm, AES_CTR>(input, verbose);
-                break;
+        case AES_CTR:
+            encrypt_with_mode<algorithm, AES_CTR>(input, verbose);
+            break;
 
-            default:
-                throw std::runtime_error("the selected mode of operation is not implemented");
-                break;
-        }
+        default:
+            throw std::runtime_error("the selected mode of operation is not implemented");
+            break;
     }
+}
 
-    void encrypt_using_cxx_api(
-        aes::Algorithm algorithm,
-        aes::Mode mode,
-        const Input& input,
-        bool verbose = false)
-    {
-        switch (algorithm)
-        {
-            case AES_AES128:
-                encrypt_with_algorithm<AES_AES128>(mode, input, verbose);
-                break;
+void encrypt_using_cxx_api(aes::Algorithm algorithm,
+                           aes::Mode mode,
+                           const Input& input,
+                           bool verbose = false) {
+    switch (algorithm) {
+        case AES_AES128:
+            encrypt_with_algorithm<AES_AES128>(mode, input, verbose);
+            break;
 
-            case AES_AES192:
-                encrypt_with_algorithm<AES_AES192>(mode, input, verbose);
-                break;
+        case AES_AES192:
+            encrypt_with_algorithm<AES_AES192>(mode, input, verbose);
+            break;
 
-            case AES_AES256:
-                encrypt_with_algorithm<AES_AES256>(mode, input, verbose);
-                break;
+        case AES_AES256:
+            encrypt_with_algorithm<AES_AES256>(mode, input, verbose);
+            break;
 
-            default:
-                throw std::runtime_error("the selected algorithm is not implemented");
-                break;
-        }
+        default:
+            throw std::runtime_error("the selected algorithm is not implemented");
+            break;
     }
+}
 
-    void encrypt_using_particular_box(
-        aes::Box& box,
-        const std::vector<std::string>& input_block_strings)
-    {
-        for (const auto& input_block_string : input_block_strings)
-        {
-            aes::Box::Block plaintext;
-            box.parse_block(plaintext, input_block_string);
+void encrypt_using_particular_box(aes::Box& box,
+                                  const std::vector<std::string>& input_block_strings) {
+    for (const auto& input_block_string : input_block_strings) {
+        aes::Box::Block plaintext;
+        box.parse_block(plaintext, input_block_string);
 
-            aes::Box::Block ciphertext;
-            box.encrypt_block(plaintext, ciphertext);
-            std::cout << box.format_block(ciphertext) << '\n';
-        }
+        aes::Box::Block ciphertext;
+        box.encrypt_block(plaintext, ciphertext);
+        std::cout << box.format_block(ciphertext) << '\n';
     }
+}
 
-    void encrypt_using_boxes(
-        aes::Algorithm algorithm,
-        aes::Mode mode,
-        const Input& input)
-    {
-        aes::Box::Key key;
-        aes::Box::parse_key(key, algorithm, input.key);
+void encrypt_using_boxes(aes::Algorithm algorithm, aes::Mode mode, const Input& input) {
+    aes::Box::Key key;
+    aes::Box::parse_key(key, algorithm, input.key);
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            aes::Box::Block iv;
-            aes::Box::parse_block(iv, algorithm, input.iv);
-            aes::Box box{algorithm, key, mode, iv};
+    if (aes::mode_requires_init_vector(mode)) {
+        aes::Box::Block iv;
+        aes::Box::parse_block(iv, algorithm, input.iv);
+        aes::Box box{algorithm, key, mode, iv};
 
-            encrypt_using_particular_box(box, input.blocks);
-        }
-        else
-        {
-            aes::Box box{algorithm, key};
-            encrypt_using_particular_box(box, input.blocks);
-        }
+        encrypt_using_particular_box(box, input.blocks);
+    } else {
+        aes::Box box{algorithm, key};
+        encrypt_using_particular_box(box, input.blocks);
     }
 }
 
-int main(int argc, char** argv)
-{
-    try
-    {
+} // namespace
+
+int main(int argc, char** argv) {
+    try {
         BlockSettings settings{argv[0]};
 
-        try
-        {
+        try {
             settings.parse(argc, argv);
-        }
-        catch (const boost::program_options::error& e)
-        {
+        } catch (const boost::program_options::error& e) {
             settings.usage_error(e);
             return 1;
         }
 
-        if (settings.exit_with_usage)
-        {
+        if (settings.exit_with_usage) {
             settings.usage();
             return 0;
         }
 
-        for (const auto& input : settings.inputs)
-        {
-            if (settings.use_boxes)
-            {
-                encrypt_using_boxes(
-                    settings.algorithm,
-                    settings.mode,
-                    input);
-            }
-            else
-            {
-                encrypt_using_cxx_api(
-                    settings.algorithm,
-                    settings.mode,
-                    input,
-                    settings.verbose);
+        for (const auto& input : settings.inputs) {
+            if (settings.use_boxes) {
+                encrypt_using_boxes(settings.algorithm, settings.mode, input);
+            } else {
+                encrypt_using_cxx_api(settings.algorithm, settings.mode, input, settings.verbose);
             }
         }
-    }
-    catch (const aes::Error& e)
-    {
+    } catch (const aes::Error& e) {
         std::cerr << e;
         return 1;
-    }
-    catch (const std::exception& e)
-    {
+    } catch (const std::exception& e) {
         std::cerr << e.what() << "\n";
         return 1;
     }
diff --git a/aesxx/utils/encrypt_bmp.cpp b/aesxx/utils/encrypt_bmp.cpp
index 7f1a890..01f3a78 100644
--- a/aesxx/utils/encrypt_bmp.cpp
+++ b/aesxx/utils/encrypt_bmp.cpp
@@ -15,75 +15,58 @@
 #include <iostream>
 #include <string>
 
-namespace
-{
-    void encrypt_bmp(
-        aes::Box& box,
-        const std::string& plaintext_path,
-        const std::string& ciphertext_path)
-    {
-        bmp::BmpFile bmp{file::read_file(plaintext_path)};
-        bmp.replace_pixels(box.encrypt_buffer(
-            bmp.get_pixels(),
-            bmp.get_pixels_size()));
-        file::write_file(ciphertext_path, bmp.get_buffer(), bmp.get_size());
-    }
+namespace {
 
-    void encrypt_bmp(const FileSettings& settings)
-    {
-        const auto& algorithm = settings.algorithm;
-        const auto& mode = settings.mode;
+void encrypt_bmp(aes::Box& box,
+                 const std::string& plaintext_path,
+                 const std::string& ciphertext_path) {
+    bmp::BmpFile bmp{file::read_file(plaintext_path)};
+    bmp.replace_pixels(box.encrypt_buffer(bmp.get_pixels(), bmp.get_pixels_size()));
+    file::write_file(ciphertext_path, bmp.get_buffer(), bmp.get_size());
+}
 
-        aes::Box::Key key;
-        aes::Box::parse_key(key, algorithm, settings.key);
+void encrypt_bmp(const FileSettings& settings) {
+    const auto& algorithm = settings.algorithm;
+    const auto& mode = settings.mode;
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            aes::Box::Block iv;
-            aes::Box::parse_block(iv, algorithm, settings.iv);
+    aes::Box::Key key;
+    aes::Box::parse_key(key, algorithm, settings.key);
 
-            aes::Box box{algorithm, key, mode, iv};
-            encrypt_bmp(box, settings.input_path, settings.output_path);
-        }
-        else
-        {
-            aes::Box box{algorithm, key};
-            encrypt_bmp(box, settings.input_path, settings.output_path);
-        }
+    if (aes::mode_requires_init_vector(mode)) {
+        aes::Box::Block iv;
+        aes::Box::parse_block(iv, algorithm, settings.iv);
+
+        aes::Box box{algorithm, key, mode, iv};
+        encrypt_bmp(box, settings.input_path, settings.output_path);
+    } else {
+        aes::Box box{algorithm, key};
+        encrypt_bmp(box, settings.input_path, settings.output_path);
     }
 }
 
-int main(int argc, char** argv)
-{
-    try
-    {
+} // namespace
+
+int main(int argc, char** argv) {
+    try {
         FileSettings settings{argv[0]};
 
-        try
-        {
+        try {
             settings.parse(argc, argv);
-        }
-        catch (const boost::program_options::error& e)
-        {
+        } catch (const boost::program_options::error& e) {
             settings.usage_error(e);
             return 1;
         }
 
-        if (settings.exit_with_usage)
-        {
+        if (settings.exit_with_usage) {
             settings.usage();
             return 0;
         }
 
         encrypt_bmp(settings);
-    }
-    catch (const aes::Error& e)
-    {
+    } catch (const aes::Error& e) {
         std::cerr << e;
         return 1;
-    }
-    catch (const std::exception& e)
-    {
+    } catch (const std::exception& e) {
         std::cerr << e.what() << "\n";
         return 1;
     }
diff --git a/aesxx/utils/encrypt_file.cpp b/aesxx/utils/encrypt_file.cpp
index 570bc60..4a774fd 100644
--- a/aesxx/utils/encrypt_file.cpp
+++ b/aesxx/utils/encrypt_file.cpp
@@ -15,75 +15,58 @@
 #include <string>
 #include <vector>
 
-namespace
-{
-    void encrypt_file(
-        aes::Box& box,
-        const std::string& plaintext_path,
-        const std::string& ciphertext_path)
-    {
-        const auto plaintext_buf = file::read_file(plaintext_path);
-        const auto ciphertext_buf = box.encrypt_buffer(
-            plaintext_buf.data(),
-            plaintext_buf.size());
-        file::write_file(ciphertext_path, ciphertext_buf);
-    }
+namespace {
 
-    void encrypt_file(const FileSettings& settings)
-    {
-        const auto& algorithm = settings.algorithm;
-        const auto& mode = settings.mode;
+void encrypt_file(aes::Box& box,
+                  const std::string& plaintext_path,
+                  const std::string& ciphertext_path) {
+    const auto plaintext_buf = file::read_file(plaintext_path);
+    const auto ciphertext_buf = box.encrypt_buffer(plaintext_buf.data(), plaintext_buf.size());
+    file::write_file(ciphertext_path, ciphertext_buf);
+}
 
-        aes::Box::Key key;
-        aes::Box::parse_key(key, algorithm, settings.key);
+void encrypt_file(const FileSettings& settings) {
+    const auto& algorithm = settings.algorithm;
+    const auto& mode = settings.mode;
 
-        if (aes::mode_requires_init_vector(mode))
-        {
-            aes::Box::Block iv;
-            aes::Box::parse_block(iv, algorithm, settings.iv);
+    aes::Box::Key key;
+    aes::Box::parse_key(key, algorithm, settings.key);
 
-            aes::Box box{algorithm, key, mode, iv};
-            encrypt_file(box, settings.input_path, settings.output_path);
-        }
-        else
-        {
-            aes::Box box{algorithm, key};
-            encrypt_file(box, settings.input_path, settings.output_path);
-        }
+    if (aes::mode_requires_init_vector(mode)) {
+        aes::Box::Block iv;
+        aes::Box::parse_block(iv, algorithm, settings.iv);
+
+        aes::Box box{algorithm, key, mode, iv};
+        encrypt_file(box, settings.input_path, settings.output_path);
+    } else {
+        aes::Box box{algorithm, key};
+        encrypt_file(box, settings.input_path, settings.output_path);
     }
 }
 
-int main(int argc, char** argv)
-{
-    try
-    {
+} // namespace
+
+int main(int argc, char** argv) {
+    try {
         FileSettings settings{argv[0]};
 
-        try
-        {
+        try {
             settings.parse(argc, argv);
-        }
-        catch (const boost::program_options::error& e)
-        {
+        } catch (const boost::program_options::error& e) {
             settings.usage_error(e);
             return 1;
         }
 
-        if (settings.exit_with_usage)
-        {
+        if (settings.exit_with_usage) {
             settings.usage();
             return 0;
         }
 
         encrypt_file(settings);
-    }
-    catch (const aes::Error& e)
-    {
+    } catch (const aes::Error& e) {
         std::cerr << e;
         return 1;
-    }
-    catch (const std::exception& e)
-    {
+    } catch (const std::exception& e) {
         std::cerr << e.what() << "\n";
         return 1;
     }
diff --git a/aesxx/utils/file_cmd_parser.hpp b/aesxx/utils/file_cmd_parser.hpp
index e199409..4a504c8 100644
--- a/aesxx/utils/file_cmd_parser.hpp
+++ b/aesxx/utils/file_cmd_parser.hpp
@@ -17,8 +17,7 @@
 #include <string>
 #include <utility>
 
-class FileSettings : public command_line::SettingsParser
-{
+class FileSettings : public command_line::SettingsParser {
 public:
     aes::Algorithm algorithm = AES_AES128;
     aes::Mode mode = AES_ECB;
@@ -28,54 +27,44 @@ public:
     std::string key;
     std::string iv;
 
-    explicit FileSettings(const std::string& argv0)
-        : SettingsParser{argv0}
-    {
-        visible.add_options()
-            ("algorithm,a",
-                boost::program_options::value<aes::Algorithm>(&algorithm)
-                    ->required()
-                    ->value_name("NAME"),
-                "set algorithm")
-            ("mode,m",
-                boost::program_options::value<aes::Mode>(&mode)
-                    ->required()
-                    ->value_name("MODE"),
-                "set mode of operation")
-            ("key,k",
-                boost::program_options::value<std::string>(&key)
-                    ->required()
-                    ->value_name("KEY"),
-                "set encryption key")
-            ("iv,v",
-                boost::program_options::value<std::string>(&iv)
-                    ->value_name("BLOCK"),
-                "set initialization vector")
-            ("input,i",
-                boost::program_options::value<std::string>(&input_path)
-                    ->required()
-                    ->value_name("PATH"),
-                "set input file path")
-            ("output,o",
-                boost::program_options::value<std::string>(&output_path)
-                    ->required()
-                    ->value_name("PATH"),
-                "set output file path");
+    explicit FileSettings(const std::string& argv0) : SettingsParser{argv0} {
+        visible.add_options()("algorithm,a",
+                              boost::program_options::value<aes::Algorithm>(&algorithm)
+                                  ->required()
+                                  ->value_name("NAME"),
+                              "set algorithm");
+        visible.add_options()(
+            "mode,m",
+            boost::program_options::value<aes::Mode>(&mode)->required()->value_name("MODE"),
+            "set mode of operation");
+        visible.add_options()(
+            "key,k",
+            boost::program_options::value<std::string>(&key)->required()->value_name("KEY"),
+            "set encryption key");
+        visible.add_options()("iv,v",
+                              boost::program_options::value<std::string>(&iv)->value_name("BLOCK"),
+                              "set initialization vector");
+        visible.add_options()(
+            "input,i",
+            boost::program_options::value<std::string>(&input_path)->required()->value_name("PATH"),
+            "set input file path");
+        visible.add_options()("output,o",
+                              boost::program_options::value<std::string>(&output_path)
+                                  ->required()
+                                  ->value_name("PATH"),
+                              "set output file path");
     }
 
-    const char* get_short_description() const override
-    {
+    const char* get_short_description() const override {
         return "[-h|--help] [-a|--algorithm NAME] [-m|--mode MODE]"
                " [-k|--key KEY] [-v|--iv BLOCK]"
                " [-i|--input PATH] [-o|--output PATH]";
     }
 
-    void parse(int argc, char** argv) override
-    {
+    void parse(int argc, char** argv) override {
         SettingsParser::parse(argc, argv);
 
-        if (aes::mode_requires_init_vector(mode) && iv.empty())
-        {
+        if (aes::mode_requires_init_vector(mode) && iv.empty()) {
             throw boost::program_options::error{
                 "an initialization vector is required for the selected mode of operation"};
         }
diff --git a/aesxx/utils/helpers/bmp.hpp b/aesxx/utils/helpers/bmp.hpp
index b4b283b..c256a7a 100644
--- a/aesxx/utils/helpers/bmp.hpp
+++ b/aesxx/utils/helpers/bmp.hpp
@@ -7,51 +7,50 @@
 
 #include <cstddef>
 #include <cstring>
-
 #include <string>
 #include <utility>
 #include <vector>
 
-namespace bmp
-{
-    class BmpFile
-    {
-    public:
-        BmpFile(std::vector<char>&& buffer)
-            : buffer{std::move(buffer)}
-            , header_size{extract_pixels_offset()}
-        { }
+namespace bmp {
+
+class BmpFile {
+public:
+    BmpFile(std::vector<char>&& buffer)
+        : buffer{std::move(buffer)}, header_size{extract_pixels_offset()} {}
+
+    const void* get_buffer() const {
+        return buffer.data();
+    }
 
-        const void* get_buffer() const { return buffer.data(); }
+    std::size_t get_size() const {
+        return buffer.size();
+    }
 
-        std::size_t get_size() const { return buffer.size(); }
+    std::size_t get_header_size() const {
+        return header_size;
+    }
 
-        std::size_t get_header_size() const { return header_size; }
+    const void* get_pixels() const {
+        return buffer.data() + get_header_size();
+    }
 
-        const void* get_pixels() const
-        {
-            return buffer.data() + get_header_size();
-        }
+    std::size_t get_pixels_size() const {
+        return get_size() - get_header_size();
+    }
 
-        std::size_t get_pixels_size() const
-        {
-            return get_size() - get_header_size();
-        }
+    void replace_pixels(std::vector<unsigned char>&& pixels) {
+        buffer.resize(get_header_size() + pixels.size());
+        std::memcpy(buffer.data() + get_header_size(), pixels.data(), pixels.size());
+    }
 
-        void replace_pixels(std::vector<unsigned char>&& pixels)
-        {
-            buffer.resize(get_header_size() + pixels.size());
-            std::memcpy(buffer.data() + get_header_size(), pixels.data(), pixels.size());
-        }
+private:
+    std::size_t extract_pixels_offset() const {
+        const auto header = reinterpret_cast<const BITMAPFILEHEADER*>(get_buffer());
+        return header->bfOffBits;
+    }
 
-    private:
-        std::size_t extract_pixels_offset() const
-        {
-            const auto header = reinterpret_cast<const BITMAPFILEHEADER*>(get_buffer());
-            return header->bfOffBits;
-        }
+    std::vector<char> buffer;
+    std::size_t header_size;
+};
 
-        std::vector<char> buffer;
-        std::size_t header_size;
-    };
-}
+} // namespace bmp
diff --git a/aesxx/utils/helpers/command_line.hpp b/aesxx/utils/helpers/command_line.hpp
index 2e4d803..9a2da05 100644
--- a/aesxx/utils/helpers/command_line.hpp
+++ b/aesxx/utils/helpers/command_line.hpp
@@ -13,75 +13,64 @@
 #include <ostream>
 #include <string>
 
-namespace command_line
-{
-    class SettingsParser
-    {
-    public:
-        explicit SettingsParser(const std::string& argv0)
-            : prog_name{extract_filename(argv0)}
-        {
-            visible.add_options()
-                ("help,h",
-                    "show this message and exit");
-        }
+namespace command_line {
 
-        virtual ~SettingsParser() = default;
+class SettingsParser {
+public:
+    explicit SettingsParser(const std::string& argv0) : prog_name{extract_filename(argv0)} {
+        visible.add_options()("help,h", "show this message and exit");
+    }
 
-        virtual const char* get_short_description() const
-        {
-            return "[--option VALUE]...";
-        }
+    virtual ~SettingsParser() = default;
 
-        virtual void parse(int argc, char* argv[])
-        {
-            boost::program_options::options_description all;
-            all.add(hidden).add(visible);
-            boost::program_options::variables_map vm;
-            boost::program_options::store(
-                boost::program_options::command_line_parser{argc, argv}
-                    .options(all)
-                    .positional(positional)
-                    .run(),
-                vm);
-            if (vm.count("help"))
-                exit_with_usage = true;
-            else
-                boost::program_options::notify(vm);
-        }
+    virtual const char* get_short_description() const {
+        return "[--option VALUE]...";
+    }
 
-        bool exit_with_usage = false;
+    virtual void parse(int argc, char* argv[]) {
+        boost::program_options::options_description all;
+        all.add(hidden).add(visible);
+        boost::program_options::variables_map vm;
+        boost::program_options::store(boost::program_options::command_line_parser{argc, argv}
+                                          .options(all)
+                                          .positional(positional)
+                                          .run(),
+                                      vm);
+        if (vm.count("help"))
+            exit_with_usage = true;
+        else
+            boost::program_options::notify(vm);
+    }
 
-        void usage() const
-        {
-            std::cout << *this;
-        }
+    bool exit_with_usage = false;
 
-        void usage_error(const std::exception& e) const
-        {
-            std::cerr << "usage error: " << e.what() << '\n';
-            std::cerr << *this;
-        }
+    void usage() const {
+        std::cout << *this;
+    }
 
-    protected:
-        boost::program_options::options_description hidden;
-        boost::program_options::options_description visible;
-        boost::program_options::positional_options_description positional;
+    void usage_error(const std::exception& e) const {
+        std::cerr << "usage error: " << e.what() << '\n';
+        std::cerr << *this;
+    }
 
-    private:
-        static std::string extract_filename(const std::string& path)
-        {
-            return boost::filesystem::path{path}.filename().string();
-        }
+protected:
+    boost::program_options::options_description hidden;
+    boost::program_options::options_description visible;
+    boost::program_options::positional_options_description positional;
 
-        const std::string prog_name;
+private:
+    static std::string extract_filename(const std::string& path) {
+        return boost::filesystem::path{path}.filename().string();
+    }
 
-        friend std::ostream& operator<<(std::ostream& os, const SettingsParser& parser)
-        {
-            const auto short_descr = parser.get_short_description();
-            os << "usage: " << parser.prog_name << ' ' << short_descr << '\n';
-            os << parser.visible;
-            return os;
-        }
-    };
-}
+    const std::string prog_name;
+
+    friend std::ostream& operator<<(std::ostream& os, const SettingsParser& parser) {
+        const auto short_descr = parser.get_short_description();
+        os << "usage: " << parser.prog_name << ' ' << short_descr << '\n';
+        os << parser.visible;
+        return os;
+    }
+};
+
+} // namespace command_line
diff --git a/aesxx/utils/helpers/file.hpp b/aesxx/utils/helpers/file.hpp
index 48e4c51..76e3e96 100644
--- a/aesxx/utils/helpers/file.hpp
+++ b/aesxx/utils/helpers/file.hpp
@@ -4,7 +4,6 @@
 // Distributed under the MIT License.
 
 #include <cstddef>
-
 #include <fstream>
 #include <iterator>
 #include <limits>
@@ -13,57 +12,46 @@
 #include <type_traits>
 #include <vector>
 
-namespace file
-{
-    inline std::size_t cast_to_size_t(std::streamoff size)
-    {
-        if (size < 0)
-            throw std::range_error{"file::cast_to_size_t: something went really wrong"};
-        typedef std::make_unsigned<std::streamoff>::type unsigned_streamoff;
-        if (static_cast<unsigned_streamoff>(size) > std::numeric_limits<std::size_t>::max())
-            throw std::range_error{"file::cast_to_size_t: this file is too large"};
-        return static_cast<std::size_t>(size);
-    }
+namespace file {
 
-    inline std::size_t get_file_size(const std::string& path)
-    {
-        std::ifstream ifs;
-        ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
-        ifs.open(path, std::ifstream::binary | std::ifstream::ate);
-        return cast_to_size_t(ifs.tellg());
-    }
+inline std::size_t cast_to_size_t(std::streamoff size) {
+    if (size < 0)
+        throw std::range_error{"file::cast_to_size_t: something went really wrong"};
+    typedef std::make_unsigned<std::streamoff>::type unsigned_streamoff;
+    if (static_cast<unsigned_streamoff>(size) > std::numeric_limits<std::size_t>::max())
+        throw std::range_error{"file::cast_to_size_t: this file is too large"};
+    return static_cast<std::size_t>(size);
+}
 
-    inline std::vector<char> read_file(const std::string& path)
-    {
-        const auto size = get_file_size(path);
+inline std::size_t get_file_size(const std::string& path) {
+    std::ifstream ifs;
+    ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
+    ifs.open(path, std::ifstream::binary | std::ifstream::ate);
+    return cast_to_size_t(ifs.tellg());
+}
 
-        std::ifstream ifs;
-        ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
-        ifs.open(path, std::ifstream::binary);
+inline std::vector<char> read_file(const std::string& path) {
+    const auto size = get_file_size(path);
 
-        std::vector<char> src_buf;
-        src_buf.reserve(size);
-        src_buf.assign(
-            std::istreambuf_iterator<char>{ifs},
-            std::istreambuf_iterator<char>{});
-        return src_buf;
-    }
+    std::ifstream ifs;
+    ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
+    ifs.open(path, std::ifstream::binary);
 
-    inline void write_file(
-        const std::string& path,
-        const void* buffer,
-        const std::size_t size)
-    {
-        std::ofstream ofs;
-        ofs.exceptions(std::ofstream::badbit | std::ofstream::failbit);
-        ofs.open(path, std::ofstream::binary);
-        ofs.write(reinterpret_cast<const char*>(buffer), size);
-    }
+    std::vector<char> src_buf;
+    src_buf.reserve(size);
+    src_buf.assign(std::istreambuf_iterator<char>{ifs}, std::istreambuf_iterator<char>{});
+    return src_buf;
+}
 
-    inline void write_file(
-        const std::string& path,
-        const std::vector<unsigned char>& src)
-    {
-        write_file(path, src.data(), src.size());
-    }
+inline void write_file(const std::string& path, const void* buffer, const std::size_t size) {
+    std::ofstream ofs;
+    ofs.exceptions(std::ofstream::badbit | std::ofstream::failbit);
+    ofs.open(path, std::ofstream::binary);
+    ofs.write(reinterpret_cast<const char*>(buffer), size);
 }
+
+inline void write_file(const std::string& path, const std::vector<unsigned char>& src) {
+    write_file(path, src.data(), src.size());
+}
+
+} // namespace file