diff --git a/ChaCha20-Poly1305.cpp b/ChaCha20-Poly1305.cpp
index ef5c5c3..f48a6bc 100644
--- a/ChaCha20-Poly1305.cpp
+++ b/ChaCha20-Poly1305.cpp
@@ -6,38 +6,38 @@
 #include "extended-precision-integers/include/epi/epi.hpp"
 
 #ifdef _MAKE_LIB
-#include "ChaCha20-Poly1305.hpp"
+    #include "ChaCha20-Poly1305.hpp"
 #endif
 
 #define DEVMODE
 #ifdef DEVMODE
-#include "ChaCha20-Poly1305.hpp"
+    #include "ChaCha20-Poly1305.hpp"
 #endif
 
-namespace chacha20
-{
+namespace chacha20 {
     inline unsigned int bit_left_roll(unsigned int num, size_t n) {
 
         unsigned int msb = (num << n);
-        unsigned int lsb = (num >> (32-n));
+        unsigned int lsb = (num >> (32 - n));
 
         return msb | lsb;
     }
 
     void QUARTERROUND(unsigned int *state, size_t x, size_t y, size_t z, size_t w) {
-        
-        state[x] += state[y]; state[w] ^= state[x]; state[w] = bit_left_roll(state[w],16);
-        state[z] += state[w]; state[y] ^= state[z]; state[y] = bit_left_roll(state[y],12);
-        state[x] += state[y]; state[w] ^= state[x]; state[w] = bit_left_roll(state[w],8);
-        state[z] += state[w]; state[y] ^= state[z]; state[y] = bit_left_roll(state[y],7);
+
+        state[x] += state[y]; state[w] ^= state[x]; state[w] = bit_left_roll(state[w], 16);
+        state[z] += state[w]; state[y] ^= state[z]; state[y] = bit_left_roll(state[y], 12);
+        state[x] += state[y]; state[w] ^= state[x]; state[w] = bit_left_roll(state[w], 8);
+        state[z] += state[w]; state[y] ^= state[z]; state[y] = bit_left_roll(state[y], 7);
     }
 
     void init_state( // function parameters
-        unsigned int *output,
-        const unsigned int *key,
-        unsigned int counter,
-        const unsigned int *nonce) { // function body
-        
+      unsigned int *output,
+      const unsigned int *key,
+      unsigned int counter,
+      const unsigned int *nonce
+    ) { // function body
+
         // indecies 0-3 : constants
         output[0] = 0x61707865;
         output[1] = 0x3320646e;
@@ -64,13 +64,13 @@ namespace chacha20
     }
 
     void apply_20rounds(unsigned int *output, const unsigned int *input) {
-        
+
         // copy initial state to state
-        for(size_t i=0; i<CHACHA20_STATE_DWORDS; ++i)
+        for (size_t i = 0; i < CHACHA20_STATE_DWORDS; ++i)
             output[i] = input[i];
 
         // chacha 20 rounds
-        for(size_t i=0; i<10; ++i) {
+        for (size_t i = 0; i < 10; ++i) {
 
             // column rounds
             QUARTERROUND(output, 0, 4, 8, 12);
@@ -86,62 +86,54 @@ namespace chacha20
         }
 
         // add initialized state to the output state
-        for(size_t i=0; i<CHACHA20_STATE_DWORDS; ++i)
+        for (size_t i = 0; i < CHACHA20_STATE_DWORDS; ++i)
             output[i] += input[i];
     }
 
     unsigned char *encrypt( // function parameters
-        const unsigned char *key,
-        unsigned int         counter,
-        const unsigned char *nonce,
-        const unsigned char *inputText,
-        size_t               textLen
+      const unsigned char *key,
+      unsigned int counter,
+      const unsigned char *nonce,
+      const unsigned char *inputText,
+      size_t textLen
     ) { // function body
         unsigned char *outputCipher = new unsigned char[textLen];
-        encrypt(outputCipher,key,counter,nonce,inputText,textLen);
+        encrypt(outputCipher, key, counter, nonce, inputText, textLen);
 
         return outputCipher;
     }
 
     void encrypt( // function parameters
-        unsigned char       *outputCipher,
-        const unsigned char *key,
-        unsigned int         counter,
-        const unsigned char *nonce,
-        const unsigned char *inputText,
-        size_t               textLen
+      unsigned char *outputCipher,
+      const unsigned char *key,
+      unsigned int counter,
+      const unsigned char *nonce,
+      const unsigned char *inputText,
+      size_t               textLen
     ) { // function body
 
-        unsigned int *plaintext_blocked = (unsigned int*) inputText;
+        unsigned int *plaintext_blocked = (unsigned int *) inputText;
 
-        unsigned int *cipher_blocked = (unsigned int*) outputCipher;
+        unsigned int *cipher_blocked = (unsigned int *) outputCipher;
 
-        size_t blocks = textLen/CHACHA20_BLK_FUNC_OUTPUT_BYTES;
-        size_t lastblock_bytes = (textLen%CHACHA20_BLK_FUNC_OUTPUT_BYTES);
+        size_t blocks = textLen / CHACHA20_BLK_FUNC_OUTPUT_BYTES;
+        size_t lastblock_bytes = (textLen % CHACHA20_BLK_FUNC_OUTPUT_BYTES);
 
         unsigned int chacha_state[CHACHA20_STATE_DWORDS];
         unsigned int key_stream[CHACHA20_STATE_DWORDS];
 
         // initialize ChaCha20 state
-        chacha20::init_state(
-            chacha_state,
-            (unsigned int*)key,
-            counter,
-            (unsigned int*)nonce
-        );
+        chacha20::init_state(chacha_state, (unsigned int *) key, counter, (unsigned int *) nonce);
 
-        for(size_t i=0; i<blocks; ++i) {
+        for (size_t i = 0; i < blocks; ++i) {
 
             // perform ChaCha20 Block Function and get the key_stream output
-            chacha20::apply_20rounds(
-                key_stream,
-                chacha_state
-            );
+            chacha20::apply_20rounds(key_stream, chacha_state);
 
             // increment the chacha state's counter index
             ++chacha_state[CHACHA_STATE_COUNTER_INDEX];
 
-            if(blocks) {
+            if (blocks) {
                 for( // loop condition
                     size_t j=(CHACHA20_BLK_FUNC_OUTPUT_DWORDS*i), k=0;
                     j<((CHACHA20_BLK_FUNC_OUTPUT_DWORDS*i)+CHACHA20_BLK_FUNC_OUTPUT_DWORDS);
@@ -153,18 +145,15 @@ namespace chacha20
         }
 
         // XOR remaining key_stream bytes and plaintext bytes
-        if(lastblock_bytes) {
+        if (lastblock_bytes) {
 
             unsigned char padded_last_bytes[CHACHA20_BLK_FUNC_OUTPUT_BYTES];
-            unsigned int *padded_last_block = (unsigned int*) padded_last_bytes;
-            memcpy(padded_last_bytes,inputText+(CHACHA20_BLK_FUNC_OUTPUT_BYTES*blocks),lastblock_bytes);
+            unsigned int *padded_last_block = (unsigned int *) padded_last_bytes;
+            memcpy(padded_last_bytes, inputText + (CHACHA20_BLK_FUNC_OUTPUT_BYTES * blocks), lastblock_bytes);
 
             // perform ChaCha20 Block Function and get the key_stream output
-            chacha20::apply_20rounds(
-                key_stream,
-                chacha_state
-            );
-            
+            chacha20::apply_20rounds(key_stream, chacha_state);
+
             for( // loop condition
                 size_t j=(CHACHA20_BLK_FUNC_OUTPUT_DWORDS*blocks), k=0;
                 j<((CHACHA20_BLK_FUNC_OUTPUT_DWORDS*blocks)+CHACHA20_BLK_FUNC_OUTPUT_DWORDS);
@@ -173,10 +162,10 @@ namespace chacha20
                 padded_last_block[k] ^= key_stream[k];
             }
 
-            memcpy(outputCipher+(CHACHA20_BLK_FUNC_OUTPUT_BYTES*blocks),padded_last_bytes,lastblock_bytes);
+            memcpy(outputCipher + (CHACHA20_BLK_FUNC_OUTPUT_BYTES * blocks), padded_last_bytes, lastblock_bytes);
         }
     }
-}
+} // namespace chacha20
 
 namespace poly1305 {
 
@@ -191,58 +180,41 @@ namespace poly1305 {
     }
 
     void key_gen(unsigned char *output, const unsigned char *key, const unsigned int *nonce, unsigned int counter) {
-        
+
         unsigned int initial_state[CHACHA20_STATE_DWORDS];
         unsigned int transformed_state[CHACHA20_STATE_DWORDS];
-        
-        chacha20::init_state(initial_state,(unsigned int*)key,counter,nonce);
-        chacha20::apply_20rounds((unsigned int*)transformed_state,initial_state);
-        
+
+        chacha20::init_state(initial_state, (unsigned int *) key, counter, nonce);
+        chacha20::apply_20rounds((unsigned int *) transformed_state, initial_state);
+
         // We take the first 256 bits of the serialized state, and use those as the
         // one-time Poly1305 key:
-        memcpy(output,transformed_state,32);
+        memcpy(output, transformed_state, 32);
     }
 
-    void mac(unsigned char *output, const unsigned char *key, const unsigned char* msg, size_t msg_len) {
-        
+    void mac(unsigned char *output, const unsigned char *key, const unsigned char *msg, size_t msg_len) {
+
         unsigned char unclamped_r[HALF_KEY_BYTES];
-        memcpy(unclamped_r,key,HALF_KEY_BYTES);
+        memcpy(unclamped_r, key, HALF_KEY_BYTES);
         clamp(unclamped_r);
-        
-        epi::uint320_t r, s, a = 0;
+
+        epi::uint320_t           r, s, a = 0;
         constexpr epi::uint320_t p("0x3fffffffffffffffffffffffffffffffb");
 
         memcpy(&r, unclamped_r, HALF_KEY_BYTES);
-        memcpy(&s, key+HALF_KEY_BYTES, HALF_KEY_BYTES);
+        memcpy(&s, key + HALF_KEY_BYTES, HALF_KEY_BYTES);
         memcpy(&r, unclamped_r, HALF_KEY_BYTES);
 
-        std::cout << std::dec << "r = " << std::hex << r << '\n';
-        std::cout << std::dec << "s = " << std::hex << s << '\n';
-        std::cout << std::dec << "a = " << std::hex << a << '\n';
-        std::cout << std::dec << "p = " << std::hex << p << '\n';
-
-        // uint320 r(unclamped_r,HALF_KEY_BYTES),
-        //         s(key+HALF_KEY_BYTES,HALF_KEY_BYTES),
-        //         a(0),
-        //         p(0,0,0x3, 0xffffffffffffffff, 0xfffffffffffffffb);
-
-        size_t blocks = msg_len/HALF_KEY_BYTES;
-        size_t remain = msg_len%HALF_KEY_BYTES;
+        size_t blocks = msg_len / HALF_KEY_BYTES;
+        size_t remain = msg_len % HALF_KEY_BYTES;
 
         // 16 byte blocks
-        for(size_t i=0; i<blocks; ++i) {
+        for (size_t i = 0; i < blocks; ++i) {
 
             epi::uint320_t n;
-            memcpy(&n, msg+(i*HALF_KEY_BYTES), HALF_KEY_BYTES);
-            // uint320 n(msg+(i*HALF_KEY_BYTES),HALF_KEY_BYTES);
-            
-            std::cout << std::dec << "n = " << std::hex << n << '\n';
-            
+            memcpy(&n, msg + (i * HALF_KEY_BYTES), HALF_KEY_BYTES);
             constexpr epi::uint320_t mask_n("0x100000000000000000000000000000000");
             n |= mask_n;
-            // n.limbs[2] |= 0x01;
-
-            std::cout << std::dec << "n | " << std::hex << n << '\n';
 
             a += n;
             a = a * r;
@@ -250,19 +222,15 @@ namespace poly1305 {
         }
 
         // remaining bytes
-        if(remain) {
+        if (remain) {
             unsigned char last_block[HALF_KEY_BYTES];
-            memcpy(last_block,msg+(blocks*HALF_KEY_BYTES),remain);
-            memset(last_block+remain+1,0x00,(HALF_KEY_BYTES-remain)-1);
+            memcpy(last_block, msg + (blocks * HALF_KEY_BYTES), remain);
+            memset(last_block + remain + 1, 0x00, (HALF_KEY_BYTES - remain) - 1);
             last_block[remain] = 0x01;
 
             epi::uint320_t n;
             memcpy(&n, last_block, HALF_KEY_BYTES);
 
-            // uint320 n(last_block,HALF_KEY_BYTES);
-
-            std::cout << std::dec << "n L " << std::hex << n << '\n';
-
             a += n;
             a = a * r;
             a = a % p;
@@ -270,136 +238,134 @@ namespace poly1305 {
 
         a += s;
 
-        memcpy(output,(unsigned char*) &a, 16);
+        memcpy(output, (unsigned char *) &a, 16);
     }
 
     int verify(const unsigned char *tag1, const unsigned char *tag2) {
-        
-        unsigned long *a_hi = (unsigned long*)(tag1);
-        unsigned long *a_lo = (unsigned long*)(tag1+8);
-        unsigned long *b_hi = (unsigned long*)(tag2);
-        unsigned long *b_lo = (unsigned long*)(tag2+8);
+
+        unsigned long *a_hi = (unsigned long *) (tag1);
+        unsigned long *a_lo = (unsigned long *) (tag1 + 8);
+        unsigned long *b_hi = (unsigned long *) (tag2);
+        unsigned long *b_lo = (unsigned long *) (tag2 + 8);
         return (a_hi[0] == b_hi[0]) && (a_lo[0] == b_lo[0]);
     }
-}
+} // namespace poly1305
 
-namespace ChaCha20_Poly1305
-{ 
+namespace ChaCha20_Poly1305 {
     void aead_encrypt(
-        unsigned char       *outputCipher,
-        unsigned char       *outputTag,
-        const unsigned char *inputText,
-        size_t               textLen,
-        const unsigned char *AAD,
-        size_t               AAD_len,
-        const unsigned char *key,
-        const unsigned char *iv,
-        const unsigned char *constant
+      unsigned char *outputCipher,
+      unsigned char *outputTag,
+      const unsigned char *inputText,
+      size_t textLen,
+      const unsigned char *AAD,
+      size_t AAD_len,
+      const unsigned char *key,
+      const unsigned char *iv,
+      const unsigned char *constant
     ) {
-        unsigned int nonce[3];
-        unsigned char *nonce_char = (unsigned char*) nonce;
+        unsigned int   nonce[3];
+        unsigned char *nonce_char = (unsigned char *) nonce;
 
-        memcpy(nonce_char,constant,4);
-        memcpy(nonce_char+4,iv,8);
+        memcpy(nonce_char, constant, 4);
+        memcpy(nonce_char + 4, iv, 8);
 
-        aead_encrypt(outputCipher,outputTag,inputText,textLen,AAD,AAD_len,key,nonce_char);
+        aead_encrypt(outputCipher, outputTag, inputText, textLen, AAD, AAD_len, key, nonce_char);
     }
 
     void aead_decrypt(
-        unsigned char       *outputText,
-        unsigned char       *outputTag,
-        const unsigned char *inputCipher,
-        size_t               cipherLen,
-        const unsigned char *AAD,
-        size_t               AAD_len,
-        const unsigned char *key,
-        const unsigned char *iv,
-        const unsigned char *constant
+      unsigned char *outputText,
+      unsigned char *outputTag,
+      const unsigned char *inputCipher,
+      size_t cipherLen,
+      const unsigned char *AAD,
+      size_t AAD_len,
+      const unsigned char *key,
+      const unsigned char *iv,
+      const unsigned char *constant
     ) {
-        unsigned int nonce[3];
-        unsigned char *nonce_char = (unsigned char*) nonce;
+        unsigned int   nonce[3];
+        unsigned char *nonce_char = (unsigned char *) nonce;
 
-        memcpy(nonce_char,constant,4);
-        memcpy(nonce_char+4,iv,8);
+        memcpy(nonce_char, constant, 4);
+        memcpy(nonce_char + 4, iv, 8);
 
-        aead_decrypt(outputText,outputTag,inputCipher,cipherLen,AAD,AAD_len,key,nonce_char);
+        aead_decrypt(outputText, outputTag, inputCipher, cipherLen, AAD, AAD_len, key, nonce_char);
     }
 
     // nonce version
 
     void aead_encrypt(
-        unsigned char       *outputCipher,
-        unsigned char       *outputTag,
-        const unsigned char *inputText,
-        size_t               textLen,
-        const unsigned char *AAD,
-        size_t               AAD_len,
-        const unsigned char *key,
-        const unsigned char *nonce
+      unsigned char *outputCipher,
+      unsigned char *outputTag,
+      const unsigned char *inputText,
+      size_t textLen,
+      const unsigned char *AAD,
+      size_t AAD_len,
+      const unsigned char *key,
+      const unsigned char *nonce
     ) {
 
         unsigned char poly1305_key[32];
-        poly1305::key_gen(poly1305_key,key,(unsigned int*)nonce);
+        poly1305::key_gen(poly1305_key, key, (unsigned int *) nonce);
 
-        chacha20::encrypt(outputCipher,key,1,(unsigned char*)nonce,inputText,textLen);
+        chacha20::encrypt(outputCipher, key, 1, (unsigned char *) nonce, inputText, textLen);
 
         size_t padding1 = PADDING16(AAD_len);
         size_t padding2 = PADDING16(textLen);
 
-        size_t mac_len = AAD_len+padding1;
-        mac_len += (textLen+padding2);
+        size_t mac_len = AAD_len + padding1;
+        mac_len += (textLen + padding2);
         mac_len += 16;
         unsigned char *mac_data = new unsigned char[mac_len];
 
         size_t curr_pos = 0;
-        memcpy(mac_data,AAD,AAD_len);
-        memset(mac_data+(curr_pos+=AAD_len),0x00,padding1);
-        memcpy(mac_data+(curr_pos+=padding1),outputCipher,textLen);
-        memset(mac_data+(curr_pos+=textLen),0x00,padding2);
-        memcpy(mac_data+(curr_pos+=padding2), &AAD_len,8);
-        memcpy(mac_data+(curr_pos+=8), &textLen,8);
+        memcpy(mac_data, AAD, AAD_len);
+        memset(mac_data + (curr_pos += AAD_len), 0x00, padding1);
+        memcpy(mac_data + (curr_pos += padding1), outputCipher, textLen);
+        memset(mac_data + (curr_pos += textLen), 0x00, padding2);
+        memcpy(mac_data + (curr_pos += padding2), &AAD_len, 8);
+        memcpy(mac_data + (curr_pos += 8), &textLen, 8);
 
-        poly1305::mac(outputTag,poly1305_key,mac_data,mac_len);
+        poly1305::mac(outputTag, poly1305_key, mac_data, mac_len);
 
-        delete [] mac_data;
+        delete[] mac_data;
     }
 
     void aead_decrypt(
-        unsigned char       *outputText,
-        unsigned char       *outputTag,
-        const unsigned char *inputCipher,
-        size_t               cipherLen,
-        const unsigned char *AAD,
-        size_t               AAD_len,
-        const unsigned char *key,
-        const unsigned char *nonce
+      unsigned char *outputText, unsigned char *outputTag,
+      const unsigned char *inputCipher,
+      size_t cipherLen,
+      const unsigned char *AAD,
+      size_t AAD_len,
+      const unsigned char *key,
+      const unsigned char *nonce
     ) {
 
         unsigned char poly1305_key[32];
-        poly1305::key_gen(poly1305_key,key,(unsigned int*)nonce);
+        poly1305::key_gen(poly1305_key, key, (unsigned int *) nonce);
 
-        chacha20::encrypt(outputText,key,1,(unsigned char*)nonce,inputCipher,cipherLen);
+        chacha20::encrypt(outputText, key, 1, (unsigned char *) nonce, inputCipher, cipherLen);
 
         size_t padding1 = PADDING16(AAD_len);
         size_t padding2 = PADDING16(cipherLen);
 
-        size_t mac_len = AAD_len+padding1;
-        mac_len += (cipherLen+padding2);
+        size_t mac_len = AAD_len + padding1;
+        mac_len += (cipherLen + padding2);
         mac_len += 16;
         unsigned char *mac_data = new unsigned char[mac_len];
 
         size_t curr_pos = 0;
-        memcpy(mac_data,AAD,AAD_len);
-        memset(mac_data+(curr_pos+=AAD_len),0x00,padding1);
-        memcpy(mac_data+(curr_pos+=padding1),inputCipher,cipherLen);
-        memset(mac_data+(curr_pos+=cipherLen),0x00,padding2);
-        memcpy(mac_data+(curr_pos+=padding2), &AAD_len,8);
-        memcpy(mac_data+(curr_pos+=8), &cipherLen,8);
+        memcpy(mac_data, AAD, AAD_len);
+        memset(mac_data + (curr_pos += AAD_len), 0x00, padding1);
+        memcpy(mac_data + (curr_pos += padding1), inputCipher, cipherLen);
+        memset(mac_data + (curr_pos += cipherLen), 0x00, padding2);
+        memcpy(mac_data + (curr_pos += padding2), &AAD_len, 8);
+        memcpy(mac_data + (curr_pos += 8), &cipherLen, 8);
 
-        poly1305::mac(outputTag,poly1305_key,mac_data,mac_len);
+        poly1305::mac(outputTag, poly1305_key, mac_data, mac_len);
 
-        delete [] mac_data;
+        delete[] mac_data;
     }
-}
+} // namespace ChaCha20_Poly1305
 
 #endif
\ No newline at end of file
diff --git a/header-build.cpp b/header-build.cpp
index fa64442..462384f 100644
--- a/header-build.cpp
+++ b/header-build.cpp
@@ -5,94 +5,86 @@
 
 #include "Header-Mode-ChaCha20-Poly1305.hpp"
 
-void printChar(const std::string& name, unsigned char* arr, size_t len) {
+void printChar(const std::string &name, unsigned char *arr, size_t len) {
     std::cout << name << " = ";
-    for(size_t i=0; i<len; ++i) {
-        std::cout << (unsigned char)arr[i];
+    for (size_t i = 0; i < len; ++i) {
+        std::cout << (unsigned char) arr[i];
     }
     std::cout << "\n";
 }
 
 int main() {
     std::string lorem =
-        "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
-        "sed do eiusmod tempor incididunt ut labore et dolore mag"
-        "na aliqua. Ut enim ad minim veniam, quis nostrud exercit"
-        "ation ullamco laboris nisi ut aliquip ex ea commodo cons"
-        "equat. Duis aute irure dolor in reprehenderit in volupta"
-        "te velit esse cillum dolore eu fugiat nulla pariatur. Ex"
-        "cepteur sint occaecat cupidatat non proident, sunt in cu"
-        "lpa qui officia deserunt mollit anim id est laborum.";
+      "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
+      "sed do eiusmod tempor incididunt ut labore et dolore mag"
+      "na aliqua. Ut enim ad minim veniam, quis nostrud exercit"
+      "ation ullamco laboris nisi ut aliquip ex ea commodo cons"
+      "equat. Duis aute irure dolor in reprehenderit in volupta"
+      "te velit esse cillum dolore eu fugiat nulla pariatur. Ex"
+      "cepteur sint occaecat cupidatat non proident, sunt in cu"
+      "lpa qui officia deserunt mollit anim id est laborum.";
 
     std::string key = "MyRandomKeyThatShouldBe32char...";
 
-    unsigned char AAD[12] = {
-        0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7
-    };
+    unsigned char AAD[12] = {0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7};
 
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
-    };
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
 
-    unsigned char *iv = nonce+4;
+    unsigned char *iv = nonce + 4;
     unsigned char *constant = nonce;
 
     // encryption (with C++ style casting on parameters).
     unsigned char *cipher_text = new unsigned char[lorem.size()];
     unsigned char *encrypt_mac = new unsigned char[POLY1305_MAC_BYTES];
     ChaCha20_Poly1305::aead_encrypt(
-        cipher_text,encrypt_mac,
-        reinterpret_cast<const unsigned char*>(lorem.data()),lorem.size(),
-        AAD,sizeof(AAD),reinterpret_cast<const unsigned char*>(key.data()),iv,constant
+      cipher_text, encrypt_mac, reinterpret_cast<const unsigned char *>(lorem.data()), lorem.size(), AAD, sizeof(AAD),
+      reinterpret_cast<const unsigned char *>(key.data()), iv, constant
     );
 
     // decryption (with C style casting on parameters).
     unsigned char *recover_text = new unsigned char[lorem.size()];
-    unsigned char *decrypt_mac  = new unsigned char[POLY1305_MAC_BYTES];
+    unsigned char *decrypt_mac = new unsigned char[POLY1305_MAC_BYTES];
     ChaCha20_Poly1305::aead_decrypt(
-        recover_text,decrypt_mac,
-        cipher_text,lorem.size(),
-        AAD,sizeof(AAD),(const unsigned char*)key.data(),iv,constant
+      recover_text, decrypt_mac, cipher_text, lorem.size(), AAD, sizeof(AAD), (const unsigned char *) key.data(), iv,
+      constant
     );
 
     // you can use whatever cast you want C or C++.
-    
+
     // compare plain text and recovered text
     bool correct = true;
-    for(size_t i=0; i<lorem.size(); ++i) {
-        if(recover_text[i]!=(unsigned char)(lorem[i])) {
+    for (size_t i = 0; i < lorem.size(); ++i) {
+        if (recover_text[i] != (unsigned char) (lorem[i])) {
             correct = false;
             break;
         }
     }
 
     bool authentic = true;
-    for(size_t i=0; i<POLY1305_MAC_BYTES; ++i) {
-        if(encrypt_mac[i]!=decrypt_mac[i]) {
+    for (size_t i = 0; i < POLY1305_MAC_BYTES; ++i) {
+        if (encrypt_mac[i] != decrypt_mac[i]) {
             authentic = false;
             break;
         }
     }
-    
-    delete [] cipher_text;
-    delete [] encrypt_mac;
-    delete [] recover_text;
-    delete [] decrypt_mac;
-    
-    if(correct) {
+
+    delete[] cipher_text;
+    delete[] encrypt_mac;
+    delete[] recover_text;
+    delete[] decrypt_mac;
+
+    if (correct) {
         std::cout << "The Decrypted Message is Correct\n";
-    }
-    else {
+    } else {
         std::cout << "The Decrypted Message is Wrong!!!\n";
     }
 
-    if(authentic) {
+    if (authentic) {
         std::cout << "Message is Authentic\n";
-    }
-    else
+    } else
         std::cout << "The Message was Altered\n";
 
-    if(correct && authentic)
+    if (correct && authentic)
         return 0;
     return 1;
 }
diff --git a/static-build.cpp b/static-build.cpp
index 0f994c0..8a654a5 100644
--- a/static-build.cpp
+++ b/static-build.cpp
@@ -7,84 +7,76 @@
 
 int main() {
     std::string lorem =
-        "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
-        "sed do eiusmod tempor incididunt ut labore et dolore mag"
-        "na aliqua. Ut enim ad minim veniam, quis nostrud exercit"
-        "ation ullamco laboris nisi ut aliquip ex ea commodo cons"
-        "equat. Duis aute irure dolor in reprehenderit in volupta"
-        "te velit esse cillum dolore eu fugiat nulla pariatur. Ex"
-        "cepteur sint occaecat cupidatat non proident, sunt in cu"
-        "lpa qui officia deserunt mollit anim id est laborum.";
+      "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
+      "sed do eiusmod tempor incididunt ut labore et dolore mag"
+      "na aliqua. Ut enim ad minim veniam, quis nostrud exercit"
+      "ation ullamco laboris nisi ut aliquip ex ea commodo cons"
+      "equat. Duis aute irure dolor in reprehenderit in volupta"
+      "te velit esse cillum dolore eu fugiat nulla pariatur. Ex"
+      "cepteur sint occaecat cupidatat non proident, sunt in cu"
+      "lpa qui officia deserunt mollit anim id est laborum.";
 
     std::string key = "MyRandomKeyThatShouldBe32char...";
 
-    unsigned char AAD[12] = {
-        0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7
-    };
+    unsigned char AAD[12] = {0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7};
 
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
-    };
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
 
-    unsigned char *iv = nonce+4;
+    unsigned char *iv = nonce + 4;
     unsigned char *constant = nonce;
 
     // encryption (with C++ style casting on parameters).
     unsigned char *cipher_text = new unsigned char[lorem.size()];
     unsigned char *encrypt_mac = new unsigned char[POLY1305_MAC_BYTES];
     ChaCha20_Poly1305::aead_encrypt(
-        cipher_text,encrypt_mac,
-        reinterpret_cast<const unsigned char*>(lorem.data()),lorem.size(),
-        AAD,sizeof(AAD),reinterpret_cast<const unsigned char*>(key.data()),iv,constant
+      cipher_text, encrypt_mac, reinterpret_cast<const unsigned char *>(lorem.data()), lorem.size(), AAD, sizeof(AAD),
+      reinterpret_cast<const unsigned char *>(key.data()), iv, constant
     );
 
     // decryption (with C style casting on parameters).
     unsigned char *recover_text = new unsigned char[lorem.size()];
-    unsigned char *decrypt_mac  = new unsigned char[POLY1305_MAC_BYTES];
+    unsigned char *decrypt_mac = new unsigned char[POLY1305_MAC_BYTES];
     ChaCha20_Poly1305::aead_decrypt(
-        recover_text,decrypt_mac,
-        cipher_text,lorem.size(),
-        AAD,sizeof(AAD),(const unsigned char*)key.data(),iv,constant
+      recover_text, decrypt_mac, cipher_text, lorem.size(), AAD, sizeof(AAD), (const unsigned char *) key.data(), iv,
+      constant
     );
 
     // you can use whatever cast you want C or C++.
-    
+
     // compare plain text and recovered text
     bool correct = true;
-    for(size_t i=0; i<lorem.size(); ++i) {
-        if(recover_text[i]!=(unsigned char)(lorem[i])) {
+    for (size_t i = 0; i < lorem.size(); ++i) {
+        if (recover_text[i] != (unsigned char) (lorem[i])) {
             correct = false;
             break;
         }
     }
 
     bool authentic = true;
-    for(size_t i=0; i<POLY1305_MAC_BYTES; ++i) {
-        if(encrypt_mac[i]!=decrypt_mac[i]) {
+    for (size_t i = 0; i < POLY1305_MAC_BYTES; ++i) {
+        if (encrypt_mac[i] != decrypt_mac[i]) {
             authentic = false;
             break;
         }
     }
 
-    delete [] cipher_text;
-    delete [] encrypt_mac;
-    delete [] recover_text;
-    delete [] decrypt_mac;
-    
-    if(correct) {
+    delete[] cipher_text;
+    delete[] encrypt_mac;
+    delete[] recover_text;
+    delete[] decrypt_mac;
+
+    if (correct) {
         std::cout << "The Decrypted Message is Correct\n";
-    }
-    else {
+    } else {
         std::cout << "The Decrypted Message is Wrong!!!\n";
     }
 
-    if(authentic) {
+    if (authentic) {
         std::cout << "Message is Authentic\n";
-    }
-    else
+    } else
         std::cout << "The Message was Altered\n";
 
-    if(correct && authentic)
+    if (correct && authentic)
         return 0;
     return 1;
 }
diff --git a/tests/BlockFunction_test.cpp b/tests/BlockFunction_test.cpp
index c988bab..617565d 100644
--- a/tests/BlockFunction_test.cpp
+++ b/tests/BlockFunction_test.cpp
@@ -1,73 +1,61 @@
 #include <iostream>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // ChaCha State Comparison
-bool CompareState(unsigned int *A, unsigned int *B){
-    for(size_t i=0; i<16; ++i)
-        if(A[i] != B[i])
+bool CompareState(unsigned int *A, unsigned int *B) {
+    for (size_t i = 0; i < 16; ++i)
+        if (A[i] != B[i])
             return false;
     return true;
 }
 
-int main()
-{
-    unsigned char key[32] = {
-        0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
-        0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
-        0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
-        0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
-    };
+int main() {
+    unsigned char key[32] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+                             0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+                             0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
 
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x09,0x00,0x00,
-        0x00,0x4a,0x00,0x00,0x00,0x00
-    };
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned int correct_output_state[16] = {
-        0xe4e7f110, 0x15593bd1, 0x1fdd0f50, 0xc47120a3,
-        0xc7f4d1c7, 0x0368c033, 0x9aaa2204, 0x4e6cd4c3,
-        0x466482d2, 0x09aa9f07, 0x05d7c214, 0xa2028bd9,
-        0xd19c12b5, 0xb94e16de, 0xe883d0cb, 0x4e3c50a2
-    };
+    unsigned int correct_output_state[16] = {0xe4e7f110, 0x15593bd1, 0x1fdd0f50, 0xc47120a3, 0xc7f4d1c7, 0x0368c033,
+                                             0x9aaa2204, 0x4e6cd4c3, 0x466482d2, 0x09aa9f07, 0x05d7c214, 0xa2028bd9,
+                                             0xd19c12b5, 0xb94e16de, 0xe883d0cb, 0x4e3c50a2};
 
-    unsigned char correct_serial[64] = {
-        0x10, 0xf1, 0xe7, 0xe4, 0xd1, 0x3b, 0x59, 0x15, 0x50, 0x0f, 0xdd, 0x1f, 0xa3, 0x20, 0x71, 0xc4,
-        0xc7, 0xd1, 0xf4, 0xc7, 0x33, 0xc0, 0x68, 0x03, 0x04, 0x22, 0xaa, 0x9a, 0xc3, 0xd4, 0x6c, 0x4e,
-        0xd2, 0x82, 0x64, 0x46, 0x07, 0x9f, 0xaa, 0x09, 0x14, 0xc2, 0xd7, 0x05, 0xd9, 0x8b, 0x02, 0xa2,
-        0xb5, 0x12, 0x9c, 0xd1, 0xde, 0x16, 0x4e, 0xb9, 0xcb, 0xd0, 0x83, 0xe8, 0xa2, 0x50, 0x3c, 0x4e
-    };
+    unsigned char correct_serial[64] = {0x10, 0xf1, 0xe7, 0xe4, 0xd1, 0x3b, 0x59, 0x15, 0x50, 0x0f, 0xdd, 0x1f, 0xa3,
+                                        0x20, 0x71, 0xc4, 0xc7, 0xd1, 0xf4, 0xc7, 0x33, 0xc0, 0x68, 0x03, 0x04, 0x22,
+                                        0xaa, 0x9a, 0xc3, 0xd4, 0x6c, 0x4e, 0xd2, 0x82, 0x64, 0x46, 0x07, 0x9f, 0xaa,
+                                        0x09, 0x14, 0xc2, 0xd7, 0x05, 0xd9, 0x8b, 0x02, 0xa2, 0xb5, 0x12, 0x9c, 0xd1,
+                                        0xde, 0x16, 0x4e, 0xb9, 0xcb, 0xd0, 0x83, 0xe8, 0xa2, 0x50, 0x3c, 0x4e};
 
     unsigned int *initial_state = new unsigned int[CHACHA20_STATE_DWORDS];
-    unsigned int* output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+    unsigned int *output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
 
-    chacha20::init_state(initial_state,(unsigned int*)key,1,(unsigned int*)nonce);
-    chacha20::apply_20rounds(output_state,initial_state);
-    
-    unsigned char* serialize = (unsigned char*) output_state;
+    chacha20::init_state(initial_state, (unsigned int *) key, 1, (unsigned int *) nonce);
+    chacha20::apply_20rounds(output_state, initial_state);
+
+    unsigned char *serialize = (unsigned char *) output_state;
 
     bool serial_passed = true;
-    for(size_t i=0; i<CHACHA20_BLK_FUNC_OUTPUT_BYTES; ++i) {
-        if(serialize[i] != correct_serial[i]) {
+    for (size_t i = 0; i < CHACHA20_BLK_FUNC_OUTPUT_BYTES; ++i) {
+        if (serialize[i] != correct_serial[i]) {
             serial_passed = false;
             break;
         }
     }
-    
-    bool passed = CompareState(correct_output_state,output_state);
 
-    delete [] initial_state;
-    delete [] output_state;
+    bool passed = CompareState(correct_output_state, output_state);
+
+    delete[] initial_state;
+    delete[] output_state;
 
-    if(passed && serial_passed) {
+    if (passed && serial_passed) {
         std::cout << "ChaChaBlockFunctionTest : PASSED\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "ChaChaBlockFunctionTest : FAILED\n";
         return 1;
     }
diff --git a/tests/BlockFunction_test1.cpp b/tests/BlockFunction_test1.cpp
index e666c19..a3ec256 100644
--- a/tests/BlockFunction_test1.cpp
+++ b/tests/BlockFunction_test1.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Block Function Additional Test 1 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,100 +28,87 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned int correct_output_state[16] = {
-        0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653,
-        0xb819d2bd, 0x1aed8da0, 0xccef36a8, 0xc70d778b,
-        0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8,
-        0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2
-    };
-
-    unsigned char correct_serial[64] = {
-        0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-        0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
-        0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
-        0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86
-    };
+    unsigned char key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned int correct_output_state[16] = {0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653, 0xb819d2bd, 0x1aed8da0,
+                                             0xccef36a8, 0xc70d778b, 0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8,
+                                             0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2};
+
+    unsigned char correct_serial[64] = {0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53,
+                                        0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36,
+                                        0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48,
+                                        0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37, 0x6a, 0x43, 0xb8, 0xf4,
+                                        0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86};
 
     unsigned int counter = 0;
-   
+
     // ANSWERS
     unsigned int *initial_state = new unsigned int[CHACHA20_STATE_DWORDS];
-    unsigned int* output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
-
-    chacha20::init_state(initial_state,(unsigned int*)key,counter,(unsigned int*)nonce);
-    chacha20::apply_20rounds(output_state,initial_state);
-    
-    unsigned char* serialize = (unsigned char*) output_state;
-
- 
-    // TESTING ANSWER 
-
-    ASSERT_ARRAY<unsigned int>(output_state,correct_output_state,16,"output state",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(serialize,correct_serial,64,"serialized ",TEST_RESULTS);
-    
-    delete [] initial_state;
-    delete [] output_state;
-    
+    unsigned int *output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+
+    chacha20::init_state(initial_state, (unsigned int *) key, counter, (unsigned int *) nonce);
+    chacha20::apply_20rounds(output_state, initial_state);
+
+    unsigned char *serialize = (unsigned char *) output_state;
+
+    // TESTING ANSWER
+
+    ASSERT_ARRAY<unsigned int>(output_state, correct_output_state, 16, "output state", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(serialize, correct_serial, 64, "serialized ", TEST_RESULTS);
+
+    delete[] initial_state;
+    delete[] output_state;
+
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/BlockFunction_test2.cpp b/tests/BlockFunction_test2.cpp
index 4d172a5..c4fdabd 100644
--- a/tests/BlockFunction_test2.cpp
+++ b/tests/BlockFunction_test2.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Block Function Additional Test 2 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,100 +28,87 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned int correct_output_state[16] = {
-        0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73,
-        0xa0290fcb, 0x6965e348, 0x3e53c612, 0xed7aee32,
-        0x7621b729, 0x434ee69c, 0xb03371d5, 0xd539d874,
-        0x281fed31, 0x45fb0a51, 0x1f0ae1ac, 0x6f4d794b
-    };
-
-    unsigned char correct_serial[64] = {
-        0x9f, 0x07, 0xe7, 0xbe, 0x55, 0x51, 0x38, 0x7a, 0x98, 0xba, 0x97, 0x7c, 0x73, 0x2d, 0x08, 0x0d,
-        0xcb, 0x0f, 0x29, 0xa0, 0x48, 0xe3, 0x65, 0x69, 0x12, 0xc6, 0x53, 0x3e, 0x32, 0xee, 0x7a, 0xed,
-        0x29, 0xb7, 0x21, 0x76, 0x9c, 0xe6, 0x4e, 0x43, 0xd5, 0x71, 0x33, 0xb0, 0x74, 0xd8, 0x39, 0xd5,
-        0x31, 0xed, 0x1f, 0x28, 0x51, 0x0a, 0xfb, 0x45, 0xac, 0xe1, 0x0a, 0x1f, 0x4b, 0x79, 0x4d, 0x6f
-    };
+    unsigned char key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned int correct_output_state[16] = {0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73, 0xa0290fcb, 0x6965e348,
+                                             0x3e53c612, 0xed7aee32, 0x7621b729, 0x434ee69c, 0xb03371d5, 0xd539d874,
+                                             0x281fed31, 0x45fb0a51, 0x1f0ae1ac, 0x6f4d794b};
+
+    unsigned char correct_serial[64] = {0x9f, 0x07, 0xe7, 0xbe, 0x55, 0x51, 0x38, 0x7a, 0x98, 0xba, 0x97, 0x7c, 0x73,
+                                        0x2d, 0x08, 0x0d, 0xcb, 0x0f, 0x29, 0xa0, 0x48, 0xe3, 0x65, 0x69, 0x12, 0xc6,
+                                        0x53, 0x3e, 0x32, 0xee, 0x7a, 0xed, 0x29, 0xb7, 0x21, 0x76, 0x9c, 0xe6, 0x4e,
+                                        0x43, 0xd5, 0x71, 0x33, 0xb0, 0x74, 0xd8, 0x39, 0xd5, 0x31, 0xed, 0x1f, 0x28,
+                                        0x51, 0x0a, 0xfb, 0x45, 0xac, 0xe1, 0x0a, 0x1f, 0x4b, 0x79, 0x4d, 0x6f};
 
     unsigned int counter = 1;
-   
+
     // ANSWERS
     unsigned int *initial_state = new unsigned int[CHACHA20_STATE_DWORDS];
-    unsigned int* output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
-
-    chacha20::init_state(initial_state,(unsigned int*)key,counter,(unsigned int*)nonce);
-    chacha20::apply_20rounds(output_state,initial_state);
-    
-    unsigned char* serialize = (unsigned char*) output_state;
-
- 
-    // TESTING ANSWER 
-
-    ASSERT_ARRAY<unsigned int>(output_state,correct_output_state,16,"output state",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(serialize,correct_serial,64,"serialized ",TEST_RESULTS);
-    
-    delete [] initial_state;
-    delete [] output_state;
-    
+    unsigned int *output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+
+    chacha20::init_state(initial_state, (unsigned int *) key, counter, (unsigned int *) nonce);
+    chacha20::apply_20rounds(output_state, initial_state);
+
+    unsigned char *serialize = (unsigned char *) output_state;
+
+    // TESTING ANSWER
+
+    ASSERT_ARRAY<unsigned int>(output_state, correct_output_state, 16, "output state", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(serialize, correct_serial, 64, "serialized ", TEST_RESULTS);
+
+    delete[] initial_state;
+    delete[] output_state;
+
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/BlockFunction_test3.cpp b/tests/BlockFunction_test3.cpp
index b2eab8c..4e7c26f 100644
--- a/tests/BlockFunction_test3.cpp
+++ b/tests/BlockFunction_test3.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Block Function Additional Test 3 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,99 +28,87 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
-    };
-
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned int correct_output_state[16] = {
-        0x2452eb3a, 0x9249f8ec, 0x8d829d9b, 0xddd4ceb1,
-        0xe8252083, 0x60818b01, 0xf38422b8, 0x5aaa49c9,
-        0xbb00ca8e, 0xda3ba7b4, 0xc4b592d1, 0xfdf2732f,
-        0x4436274e, 0x2561b3c8, 0xebdd4aa6, 0xa0136c00
-    };
-
-    unsigned char correct_serial[64] = {
-        0x3a, 0xeb, 0x52, 0x24, 0xec, 0xf8, 0x49, 0x92, 0x9b, 0x9d, 0x82, 0x8d, 0xb1, 0xce, 0xd4, 0xdd,
-        0x83, 0x20, 0x25, 0xe8, 0x01, 0x8b, 0x81, 0x60, 0xb8, 0x22, 0x84, 0xf3, 0xc9, 0x49, 0xaa, 0x5a,
-        0x8e, 0xca, 0x00, 0xbb, 0xb4, 0xa7, 0x3b, 0xda, 0xd1, 0x92, 0xb5, 0xc4, 0x2f, 0x73, 0xf2, 0xfd,
-        0x4e, 0x27, 0x36, 0x44, 0xc8, 0xb3, 0x61, 0x25, 0xa6, 0x4a, 0xdd, 0xeb, 0x00, 0x6c, 0x13, 0xa0
-    };
+    unsigned char key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
+
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned int correct_output_state[16] = {0x2452eb3a, 0x9249f8ec, 0x8d829d9b, 0xddd4ceb1, 0xe8252083, 0x60818b01,
+                                             0xf38422b8, 0x5aaa49c9, 0xbb00ca8e, 0xda3ba7b4, 0xc4b592d1, 0xfdf2732f,
+                                             0x4436274e, 0x2561b3c8, 0xebdd4aa6, 0xa0136c00};
+
+    unsigned char correct_serial[64] = {0x3a, 0xeb, 0x52, 0x24, 0xec, 0xf8, 0x49, 0x92, 0x9b, 0x9d, 0x82, 0x8d, 0xb1,
+                                        0xce, 0xd4, 0xdd, 0x83, 0x20, 0x25, 0xe8, 0x01, 0x8b, 0x81, 0x60, 0xb8, 0x22,
+                                        0x84, 0xf3, 0xc9, 0x49, 0xaa, 0x5a, 0x8e, 0xca, 0x00, 0xbb, 0xb4, 0xa7, 0x3b,
+                                        0xda, 0xd1, 0x92, 0xb5, 0xc4, 0x2f, 0x73, 0xf2, 0xfd, 0x4e, 0x27, 0x36, 0x44,
+                                        0xc8, 0xb3, 0x61, 0x25, 0xa6, 0x4a, 0xdd, 0xeb, 0x00, 0x6c, 0x13, 0xa0};
 
     unsigned int counter = 1;
-   
+
     // ANSWERS
     unsigned int *initial_state = new unsigned int[CHACHA20_STATE_DWORDS];
-    unsigned int* output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+    unsigned int *output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+
+    chacha20::init_state(initial_state, (unsigned int *) key, counter, (unsigned int *) nonce);
+    chacha20::apply_20rounds(output_state, initial_state);
+
+    unsigned char *serialize = (unsigned char *) output_state;
 
-    chacha20::init_state(initial_state,(unsigned int*)key,counter,(unsigned int*)nonce);
-    chacha20::apply_20rounds(output_state,initial_state);
-    
-    unsigned char* serialize = (unsigned char*) output_state;
+    // TESTING ANSWER
 
-    // TESTING ANSWER 
+    ASSERT_ARRAY<unsigned int>(output_state, correct_output_state, 16, "output state", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(serialize, correct_serial, 64, "serialized ", TEST_RESULTS);
+
+    delete[] initial_state;
+    delete[] output_state;
 
-    ASSERT_ARRAY<unsigned int>(output_state,correct_output_state,16,"output state",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(serialize,correct_serial,64,"serialized ",TEST_RESULTS);
-    
-    delete [] initial_state;
-    delete [] output_state;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/BlockFunction_test4.cpp b/tests/BlockFunction_test4.cpp
index 1e61351..ec8f053 100644
--- a/tests/BlockFunction_test4.cpp
+++ b/tests/BlockFunction_test4.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Block Function Additional Test 4 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,99 +28,87 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned int correct_output_state[16] = {
-        0xfb4dd572, 0x4bc42ef1, 0xdf922636, 0x327f1394,
-        0xa78dea8f, 0x5e269039, 0xa1bebbc1, 0xcaf09aae,
-        0xa25ab213, 0x48a6b46c, 0x1b9d9bcb, 0x092c5be6,
-        0x546ca624, 0x1bec45d5, 0x87f47473, 0x96f0992e
-    };
-
-    unsigned char correct_serial[64] = {
-        0x72, 0xd5, 0x4d, 0xfb, 0xf1, 0x2e, 0xc4, 0x4b, 0x36, 0x26, 0x92, 0xdf, 0x94, 0x13, 0x7f, 0x32,
-        0x8f, 0xea, 0x8d, 0xa7, 0x39, 0x90, 0x26, 0x5e, 0xc1, 0xbb, 0xbe, 0xa1, 0xae, 0x9a, 0xf0, 0xca,
-        0x13, 0xb2, 0x5a, 0xa2, 0x6c, 0xb4, 0xa6, 0x48, 0xcb, 0x9b, 0x9d, 0x1b, 0xe6, 0x5b, 0x2c, 0x09,
-        0x24, 0xa6, 0x6c, 0x54, 0xd5, 0x45, 0xec, 0x1b, 0x73, 0x74, 0xf4, 0x87, 0x2e, 0x99, 0xf0, 0x96
-    };
+    unsigned char key[32] = {0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned int correct_output_state[16] = {0xfb4dd572, 0x4bc42ef1, 0xdf922636, 0x327f1394, 0xa78dea8f, 0x5e269039,
+                                             0xa1bebbc1, 0xcaf09aae, 0xa25ab213, 0x48a6b46c, 0x1b9d9bcb, 0x092c5be6,
+                                             0x546ca624, 0x1bec45d5, 0x87f47473, 0x96f0992e};
+
+    unsigned char correct_serial[64] = {0x72, 0xd5, 0x4d, 0xfb, 0xf1, 0x2e, 0xc4, 0x4b, 0x36, 0x26, 0x92, 0xdf, 0x94,
+                                        0x13, 0x7f, 0x32, 0x8f, 0xea, 0x8d, 0xa7, 0x39, 0x90, 0x26, 0x5e, 0xc1, 0xbb,
+                                        0xbe, 0xa1, 0xae, 0x9a, 0xf0, 0xca, 0x13, 0xb2, 0x5a, 0xa2, 0x6c, 0xb4, 0xa6,
+                                        0x48, 0xcb, 0x9b, 0x9d, 0x1b, 0xe6, 0x5b, 0x2c, 0x09, 0x24, 0xa6, 0x6c, 0x54,
+                                        0xd5, 0x45, 0xec, 0x1b, 0x73, 0x74, 0xf4, 0x87, 0x2e, 0x99, 0xf0, 0x96};
 
     unsigned int counter = 2;
-   
+
     // ANSWERS
     unsigned int *initial_state = new unsigned int[CHACHA20_STATE_DWORDS];
-    unsigned int* output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+    unsigned int *output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+
+    chacha20::init_state(initial_state, (unsigned int *) key, counter, (unsigned int *) nonce);
+    chacha20::apply_20rounds(output_state, initial_state);
+
+    unsigned char *serialize = (unsigned char *) output_state;
 
-    chacha20::init_state(initial_state,(unsigned int*)key,counter,(unsigned int*)nonce);
-    chacha20::apply_20rounds(output_state,initial_state);
-    
-    unsigned char* serialize = (unsigned char*) output_state;
+    // TESTING ANSWER
 
-    // TESTING ANSWER 
+    ASSERT_ARRAY<unsigned int>(output_state, correct_output_state, 16, "output state", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(serialize, correct_serial, 64, "serialized ", TEST_RESULTS);
+
+    delete[] initial_state;
+    delete[] output_state;
 
-    ASSERT_ARRAY<unsigned int>(output_state,correct_output_state,16,"output state",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(serialize,correct_serial,64,"serialized ",TEST_RESULTS);
-    
-    delete [] initial_state;
-    delete [] output_state;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/BlockFunction_test5.cpp b/tests/BlockFunction_test5.cpp
index f0b0d91..b6bd9d2 100644
--- a/tests/BlockFunction_test5.cpp
+++ b/tests/BlockFunction_test5.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Block Function Additional Test 5 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,99 +28,87 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-    };
-
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x02
-    };
-
-    unsigned int correct_output_state[16] = {
-        0x374dc6c2, 0x3736d58c, 0xb904e24a, 0xcd3f93ef,
-        0x88228b1a, 0x96a4dfb3, 0x5b76ab72, 0xc727ee54,
-        0x0e0e978a, 0xf3145c95, 0x1b748ea8, 0xf786c297,
-        0x99c28f5f, 0x628314e8, 0x398a19fa, 0x6ded1b53
-    };
-
-    unsigned char correct_serial[64] = {
-        0xc2, 0xc6, 0x4d, 0x37, 0x8c, 0xd5, 0x36, 0x37, 0x4a, 0xe2, 0x04, 0xb9, 0xef, 0x93, 0x3f, 0xcd,
-        0x1a, 0x8b, 0x22, 0x88, 0xb3, 0xdf, 0xa4, 0x96, 0x72, 0xab, 0x76, 0x5b, 0x54, 0xee, 0x27, 0xc7,
-        0x8a, 0x97, 0x0e, 0x0e, 0x95, 0x5c, 0x14, 0xf3, 0xa8, 0x8e, 0x74, 0x1b, 0x97, 0xc2, 0x86, 0xf7,
-        0x5f, 0x8f, 0xc2, 0x99, 0xe8, 0x14, 0x83, 0x62, 0xfa, 0x19, 0x8a, 0x39, 0x53, 0x1b, 0xed, 0x6d
-    };
+    unsigned char key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
+
+    unsigned int correct_output_state[16] = {0x374dc6c2, 0x3736d58c, 0xb904e24a, 0xcd3f93ef, 0x88228b1a, 0x96a4dfb3,
+                                             0x5b76ab72, 0xc727ee54, 0x0e0e978a, 0xf3145c95, 0x1b748ea8, 0xf786c297,
+                                             0x99c28f5f, 0x628314e8, 0x398a19fa, 0x6ded1b53};
+
+    unsigned char correct_serial[64] = {0xc2, 0xc6, 0x4d, 0x37, 0x8c, 0xd5, 0x36, 0x37, 0x4a, 0xe2, 0x04, 0xb9, 0xef,
+                                        0x93, 0x3f, 0xcd, 0x1a, 0x8b, 0x22, 0x88, 0xb3, 0xdf, 0xa4, 0x96, 0x72, 0xab,
+                                        0x76, 0x5b, 0x54, 0xee, 0x27, 0xc7, 0x8a, 0x97, 0x0e, 0x0e, 0x95, 0x5c, 0x14,
+                                        0xf3, 0xa8, 0x8e, 0x74, 0x1b, 0x97, 0xc2, 0x86, 0xf7, 0x5f, 0x8f, 0xc2, 0x99,
+                                        0xe8, 0x14, 0x83, 0x62, 0xfa, 0x19, 0x8a, 0x39, 0x53, 0x1b, 0xed, 0x6d};
 
     unsigned int counter = 0;
-   
+
     // ANSWERS
     unsigned int *initial_state = new unsigned int[CHACHA20_STATE_DWORDS];
-    unsigned int* output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+    unsigned int *output_state = new unsigned int[CHACHA20_BLK_FUNC_OUTPUT_DWORDS];
+
+    chacha20::init_state(initial_state, (unsigned int *) key, counter, (unsigned int *) nonce);
+    chacha20::apply_20rounds(output_state, initial_state);
+
+    unsigned char *serialize = (unsigned char *) output_state;
 
-    chacha20::init_state(initial_state,(unsigned int*)key,counter,(unsigned int*)nonce);
-    chacha20::apply_20rounds(output_state,initial_state);
-    
-    unsigned char* serialize = (unsigned char*) output_state;
+    // TESTING ANSWER
 
-    // TESTING ANSWER 
+    ASSERT_ARRAY<unsigned int>(output_state, correct_output_state, 16, "output state", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(serialize, correct_serial, 64, "serialized ", TEST_RESULTS);
+
+    delete[] initial_state;
+    delete[] output_state;
 
-    ASSERT_ARRAY<unsigned int>(output_state,correct_output_state,16,"output state",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(serialize,correct_serial,64,"serialized ",TEST_RESULTS);
-    
-    delete [] initial_state;
-    delete [] output_state;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/ChaCha20Encryption_t1.cpp b/tests/ChaCha20Encryption_t1.cpp
index d0cb86d..db0b97e 100644
--- a/tests/ChaCha20Encryption_t1.cpp
+++ b/tests/ChaCha20Encryption_t1.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "ChaCha20 Encryption Test 1 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,89 +28,82 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-    };
+    unsigned char key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
-    };
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     unsigned int counter = 0;
 
-    unsigned char plain_text[64] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
-
-    unsigned char cipher_text[64] = {
-        0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-        0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
-        0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
-        0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86
-    };
-   
+    unsigned char plain_text[64] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char cipher_text[64] = {0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53,
+                                     0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36,
+                                     0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48,
+                                     0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37, 0x6a, 0x43, 0xb8, 0xf4,
+                                     0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86};
+
     // ANSWERS
 
-    unsigned char *cipher_out = chacha20::encrypt(key,counter,nonce,plain_text,64);
+    unsigned char *cipher_out = chacha20::encrypt(key, counter, nonce, plain_text, 64);
 
     // TESTING ANSWER
     std::cout << "cipher_text size = " << sizeof(cipher_text) << "\n";
-    ASSERT_ARRAY<unsigned char>(cipher_out,cipher_text,sizeof(cipher_text),"ChaCha20 encryption ",TEST_RESULTS);
-    
-    delete [] cipher_out;
-    
+    ASSERT_ARRAY<unsigned char>(cipher_out, cipher_text, sizeof(cipher_text), "ChaCha20 encryption ", TEST_RESULTS);
+
+    delete[] cipher_out;
+
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/ChaCha20Encryption_t2.cpp b/tests/ChaCha20Encryption_t2.cpp
index a38b613..1fc002b 100644
--- a/tests/ChaCha20Encryption_t2.cpp
+++ b/tests/ChaCha20Encryption_t2.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "ChaCha20 Encryption Test 2 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,130 +28,114 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
-    };
+    unsigned char key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02
-    };
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
 
     unsigned int counter = 1;
 
     unsigned char plain_text[] = {
-        0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74,
-        0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e,
-        0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
-        0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69,
-        0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x72,
-        0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
-        0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20,
-        0x6f, 0x72, 0x20, 0x52, 0x46, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73,
-        0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69,
-        0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-        0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x61, 0x63, 0x74, 0x69,
-        0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72,
-        0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74,
-        0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20,
-        0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75,
-        0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e,
-        0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x73, 0x65, 0x73, 0x73, 0x69,
-        0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20,
-        0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
-        0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61,
-        0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e,
-        0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c,
-        0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65,
-        0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f
-    };
+      0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74,
+      0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79,
+      0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x6f,
+      0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c,
+      0x6c, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54,
+      0x46, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20, 0x6f, 0x72,
+      0x20, 0x52, 0x46, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d,
+      0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
+      0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
+      0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64,
+      0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
+      0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20, 0x73, 0x74, 0x61, 0x74,
+      0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c,
+      0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
+      0x20, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20,
+      0x61, 0x73, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
+      0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
+      0x6e, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65,
+      0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72,
+      0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f};
 
     unsigned char cipher_text[] = {
-        0xa3, 0xfb, 0xf0, 0x7d, 0xf3, 0xfa, 0x2f, 0xde, 0x4f, 0x37, 0x6c, 0xa2, 0x3e, 0x82, 0x73, 0x70,
-        0x41, 0x60, 0x5d, 0x9f, 0x4f, 0x4f, 0x57, 0xbd, 0x8c, 0xff, 0x2c, 0x1d, 0x4b, 0x79, 0x55, 0xec,
-        0x2a, 0x97, 0x94, 0x8b, 0xd3, 0x72, 0x29, 0x15, 0xc8, 0xf3, 0xd3, 0x37, 0xf7, 0xd3, 0x70, 0x05,
-        0x0e, 0x9e, 0x96, 0xd6, 0x47, 0xb7, 0xc3, 0x9f, 0x56, 0xe0, 0x31, 0xca, 0x5e, 0xb6, 0x25, 0x0d,
-        0x40, 0x42, 0xe0, 0x27, 0x85, 0xec, 0xec, 0xfa, 0x4b, 0x4b, 0xb5, 0xe8, 0xea, 0xd0, 0x44, 0x0e,
-        0x20, 0xb6, 0xe8, 0xdb, 0x09, 0xd8, 0x81, 0xa7, 0xc6, 0x13, 0x2f, 0x42, 0x0e, 0x52, 0x79, 0x50,
-        0x42, 0xbd, 0xfa, 0x77, 0x73, 0xd8, 0xa9, 0x05, 0x14, 0x47, 0xb3, 0x29, 0x1c, 0xe1, 0x41, 0x1c,
-        0x68, 0x04, 0x65, 0x55, 0x2a, 0xa6, 0xc4, 0x05, 0xb7, 0x76, 0x4d, 0x5e, 0x87, 0xbe, 0xa8, 0x5a,
-        0xd0, 0x0f, 0x84, 0x49, 0xed, 0x8f, 0x72, 0xd0, 0xd6, 0x62, 0xab, 0x05, 0x26, 0x91, 0xca, 0x66,
-        0x42, 0x4b, 0xc8, 0x6d, 0x2d, 0xf8, 0x0e, 0xa4, 0x1f, 0x43, 0xab, 0xf9, 0x37, 0xd3, 0x25, 0x9d,
-        0xc4, 0xb2, 0xd0, 0xdf, 0xb4, 0x8a, 0x6c, 0x91, 0x39, 0xdd, 0xd7, 0xf7, 0x69, 0x66, 0xe9, 0x28,
-        0xe6, 0x35, 0x55, 0x3b, 0xa7, 0x6c, 0x5c, 0x87, 0x9d, 0x7b, 0x35, 0xd4, 0x9e, 0xb2, 0xe6, 0x2b,
-        0x08, 0x71, 0xcd, 0xac, 0x63, 0x89, 0x39, 0xe2, 0x5e, 0x8a, 0x1e, 0x0e, 0xf9, 0xd5, 0x28, 0x0f,
-        0xa8, 0xca, 0x32, 0x8b, 0x35, 0x1c, 0x3c, 0x76, 0x59, 0x89, 0xcb, 0xcf, 0x3d, 0xaa, 0x8b, 0x6c,
-        0xcc, 0x3a, 0xaf, 0x9f, 0x39, 0x79, 0xc9, 0x2b, 0x37, 0x20, 0xfc, 0x88, 0xdc, 0x95, 0xed, 0x84,
-        0xa1, 0xbe, 0x05, 0x9c, 0x64, 0x99, 0xb9, 0xfd, 0xa2, 0x36, 0xe7, 0xe8, 0x18, 0xb0, 0x4b, 0x0b,
-        0xc3, 0x9c, 0x1e, 0x87, 0x6b, 0x19, 0x3b, 0xfe, 0x55, 0x69, 0x75, 0x3f, 0x88, 0x12, 0x8c, 0xc0,
-        0x8a, 0xaa, 0x9b, 0x63, 0xd1, 0xa1, 0x6f, 0x80, 0xef, 0x25, 0x54, 0xd7, 0x18, 0x9c, 0x41, 0x1f,
-        0x58, 0x69, 0xca, 0x52, 0xc5, 0xb8, 0x3f, 0xa3, 0x6f, 0xf2, 0x16, 0xb9, 0xc1, 0xd3, 0x00, 0x62,
-        0xbe, 0xbc, 0xfd, 0x2d, 0xc5, 0xbc, 0xe0, 0x91, 0x19, 0x34, 0xfd, 0xa7, 0x9a, 0x86, 0xf6, 0xe6,
-        0x98, 0xce, 0xd7, 0x59, 0xc3, 0xff, 0x9b, 0x64, 0x77, 0x33, 0x8f, 0x3d, 0xa4, 0xf9, 0xcd, 0x85,
-        0x14, 0xea, 0x99, 0x82, 0xcc, 0xaf, 0xb3, 0x41, 0xb2, 0x38, 0x4d, 0xd9, 0x02, 0xf3, 0xd1, 0xab,
-        0x7a, 0xc6, 0x1d, 0xd2, 0x9c, 0x6f, 0x21, 0xba, 0x5b, 0x86, 0x2f, 0x37, 0x30, 0xe3, 0x7c, 0xfd,
-        0xc4, 0xfd, 0x80, 0x6c, 0x22, 0xf2, 0x21
-    };
-   
+      0xa3, 0xfb, 0xf0, 0x7d, 0xf3, 0xfa, 0x2f, 0xde, 0x4f, 0x37, 0x6c, 0xa2, 0x3e, 0x82, 0x73, 0x70, 0x41, 0x60, 0x5d,
+      0x9f, 0x4f, 0x4f, 0x57, 0xbd, 0x8c, 0xff, 0x2c, 0x1d, 0x4b, 0x79, 0x55, 0xec, 0x2a, 0x97, 0x94, 0x8b, 0xd3, 0x72,
+      0x29, 0x15, 0xc8, 0xf3, 0xd3, 0x37, 0xf7, 0xd3, 0x70, 0x05, 0x0e, 0x9e, 0x96, 0xd6, 0x47, 0xb7, 0xc3, 0x9f, 0x56,
+      0xe0, 0x31, 0xca, 0x5e, 0xb6, 0x25, 0x0d, 0x40, 0x42, 0xe0, 0x27, 0x85, 0xec, 0xec, 0xfa, 0x4b, 0x4b, 0xb5, 0xe8,
+      0xea, 0xd0, 0x44, 0x0e, 0x20, 0xb6, 0xe8, 0xdb, 0x09, 0xd8, 0x81, 0xa7, 0xc6, 0x13, 0x2f, 0x42, 0x0e, 0x52, 0x79,
+      0x50, 0x42, 0xbd, 0xfa, 0x77, 0x73, 0xd8, 0xa9, 0x05, 0x14, 0x47, 0xb3, 0x29, 0x1c, 0xe1, 0x41, 0x1c, 0x68, 0x04,
+      0x65, 0x55, 0x2a, 0xa6, 0xc4, 0x05, 0xb7, 0x76, 0x4d, 0x5e, 0x87, 0xbe, 0xa8, 0x5a, 0xd0, 0x0f, 0x84, 0x49, 0xed,
+      0x8f, 0x72, 0xd0, 0xd6, 0x62, 0xab, 0x05, 0x26, 0x91, 0xca, 0x66, 0x42, 0x4b, 0xc8, 0x6d, 0x2d, 0xf8, 0x0e, 0xa4,
+      0x1f, 0x43, 0xab, 0xf9, 0x37, 0xd3, 0x25, 0x9d, 0xc4, 0xb2, 0xd0, 0xdf, 0xb4, 0x8a, 0x6c, 0x91, 0x39, 0xdd, 0xd7,
+      0xf7, 0x69, 0x66, 0xe9, 0x28, 0xe6, 0x35, 0x55, 0x3b, 0xa7, 0x6c, 0x5c, 0x87, 0x9d, 0x7b, 0x35, 0xd4, 0x9e, 0xb2,
+      0xe6, 0x2b, 0x08, 0x71, 0xcd, 0xac, 0x63, 0x89, 0x39, 0xe2, 0x5e, 0x8a, 0x1e, 0x0e, 0xf9, 0xd5, 0x28, 0x0f, 0xa8,
+      0xca, 0x32, 0x8b, 0x35, 0x1c, 0x3c, 0x76, 0x59, 0x89, 0xcb, 0xcf, 0x3d, 0xaa, 0x8b, 0x6c, 0xcc, 0x3a, 0xaf, 0x9f,
+      0x39, 0x79, 0xc9, 0x2b, 0x37, 0x20, 0xfc, 0x88, 0xdc, 0x95, 0xed, 0x84, 0xa1, 0xbe, 0x05, 0x9c, 0x64, 0x99, 0xb9,
+      0xfd, 0xa2, 0x36, 0xe7, 0xe8, 0x18, 0xb0, 0x4b, 0x0b, 0xc3, 0x9c, 0x1e, 0x87, 0x6b, 0x19, 0x3b, 0xfe, 0x55, 0x69,
+      0x75, 0x3f, 0x88, 0x12, 0x8c, 0xc0, 0x8a, 0xaa, 0x9b, 0x63, 0xd1, 0xa1, 0x6f, 0x80, 0xef, 0x25, 0x54, 0xd7, 0x18,
+      0x9c, 0x41, 0x1f, 0x58, 0x69, 0xca, 0x52, 0xc5, 0xb8, 0x3f, 0xa3, 0x6f, 0xf2, 0x16, 0xb9, 0xc1, 0xd3, 0x00, 0x62,
+      0xbe, 0xbc, 0xfd, 0x2d, 0xc5, 0xbc, 0xe0, 0x91, 0x19, 0x34, 0xfd, 0xa7, 0x9a, 0x86, 0xf6, 0xe6, 0x98, 0xce, 0xd7,
+      0x59, 0xc3, 0xff, 0x9b, 0x64, 0x77, 0x33, 0x8f, 0x3d, 0xa4, 0xf9, 0xcd, 0x85, 0x14, 0xea, 0x99, 0x82, 0xcc, 0xaf,
+      0xb3, 0x41, 0xb2, 0x38, 0x4d, 0xd9, 0x02, 0xf3, 0xd1, 0xab, 0x7a, 0xc6, 0x1d, 0xd2, 0x9c, 0x6f, 0x21, 0xba, 0x5b,
+      0x86, 0x2f, 0x37, 0x30, 0xe3, 0x7c, 0xfd, 0xc4, 0xfd, 0x80, 0x6c, 0x22, 0xf2, 0x21};
+
     // ANSWERS
 
-    unsigned char *cipher_out = chacha20::encrypt(key,counter,nonce,plain_text,sizeof(plain_text));
+    unsigned char *cipher_out = chacha20::encrypt(key, counter, nonce, plain_text, sizeof(plain_text));
 
-    // TESTING ANSWER 
+    // TESTING ANSWER
     std::cout << "cipher_text size = " << sizeof(cipher_text) << "\n";
-    ASSERT_ARRAY<unsigned char>(cipher_out,cipher_text,sizeof(cipher_text),"ChaCha20 encryption ",TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(cipher_out, cipher_text, sizeof(cipher_text), "ChaCha20 encryption ", TEST_RESULTS);
 
-    delete [] cipher_out;
-    
+    delete[] cipher_out;
 
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/ChaCha20Encryption_t3.cpp b/tests/ChaCha20Encryption_t3.cpp
index 257df51..2394d29 100644
--- a/tests/ChaCha20Encryption_t3.cpp
+++ b/tests/ChaCha20Encryption_t3.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "ChaCha20 Encryption Test 3 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,96 +28,87 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
-        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
-    };
+    unsigned char key[32] = {0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88,
+                             0x86, 0x04, 0xf6, 0xb5, 0xf0, 0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b,
+                             0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0};
 
-    unsigned char nonce[12] = {
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02
-    };
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
 
     unsigned int counter = 42;
 
     unsigned char plain_text[] = {
-        0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72, 0x69, 0x6c, 0x6c, 0x69, 0x67, 0x2c, 0x20, 0x61,
-        0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f,
-        0x76, 0x65, 0x73, 0x0a, 0x44, 0x69, 0x64, 0x20, 0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64,
-        0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77,
-        0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c, 0x20, 0x6d, 0x69, 0x6d, 0x73, 0x79, 0x20, 0x77,
-        0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76, 0x65,
-        0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x20,
-        0x72, 0x61, 0x74, 0x68, 0x73, 0x20, 0x6f, 0x75, 0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e
-    };
+      0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72, 0x69, 0x6c, 0x6c, 0x69, 0x67, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20,
+      0x74, 0x68, 0x65, 0x20, 0x73, 0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f, 0x76, 0x65, 0x73, 0x0a, 0x44, 0x69,
+      0x64, 0x20, 0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x69,
+      0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c, 0x20, 0x6d, 0x69, 0x6d,
+      0x73, 0x79, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76,
+      0x65, 0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x20, 0x72, 0x61,
+      0x74, 0x68, 0x73, 0x20, 0x6f, 0x75, 0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e};
 
     unsigned char cipher_text[] = {
-        0x62, 0xe6, 0x34, 0x7f, 0x95, 0xed, 0x87, 0xa4, 0x5f, 0xfa, 0xe7, 0x42, 0x6f, 0x27, 0xa1, 0xdf,
-        0x5f, 0xb6, 0x91, 0x10, 0x04, 0x4c, 0x0d, 0x73, 0x11, 0x8e, 0xff, 0xa9, 0x5b, 0x01, 0xe5, 0xcf,
-        0x16, 0x6d, 0x3d, 0xf2, 0xd7, 0x21, 0xca, 0xf9, 0xb2, 0x1e, 0x5f, 0xb1, 0x4c, 0x61, 0x68, 0x71,
-        0xfd, 0x84, 0xc5, 0x4f, 0x9d, 0x65, 0xb2, 0x83, 0x19, 0x6c, 0x7f, 0xe4, 0xf6, 0x05, 0x53, 0xeb,
-        0xf3, 0x9c, 0x64, 0x02, 0xc4, 0x22, 0x34, 0xe3, 0x2a, 0x35, 0x6b, 0x3e, 0x76, 0x43, 0x12, 0xa6,
-        0x1a, 0x55, 0x32, 0x05, 0x57, 0x16, 0xea, 0xd6, 0x96, 0x25, 0x68, 0xf8, 0x7d, 0x3f, 0x3f, 0x77,
-        0x04, 0xc6, 0xa8, 0xd1, 0xbc, 0xd1, 0xbf, 0x4d, 0x50, 0xd6, 0x15, 0x4b, 0x6d, 0xa7, 0x31, 0xb1,
-        0x87, 0xb5, 0x8d, 0xfd, 0x72, 0x8a, 0xfa, 0x36, 0x75, 0x7a, 0x79, 0x7a, 0xc1, 0x88, 0xd1
-    };
-   
+      0x62, 0xe6, 0x34, 0x7f, 0x95, 0xed, 0x87, 0xa4, 0x5f, 0xfa, 0xe7, 0x42, 0x6f, 0x27, 0xa1, 0xdf, 0x5f, 0xb6, 0x91,
+      0x10, 0x04, 0x4c, 0x0d, 0x73, 0x11, 0x8e, 0xff, 0xa9, 0x5b, 0x01, 0xe5, 0xcf, 0x16, 0x6d, 0x3d, 0xf2, 0xd7, 0x21,
+      0xca, 0xf9, 0xb2, 0x1e, 0x5f, 0xb1, 0x4c, 0x61, 0x68, 0x71, 0xfd, 0x84, 0xc5, 0x4f, 0x9d, 0x65, 0xb2, 0x83, 0x19,
+      0x6c, 0x7f, 0xe4, 0xf6, 0x05, 0x53, 0xeb, 0xf3, 0x9c, 0x64, 0x02, 0xc4, 0x22, 0x34, 0xe3, 0x2a, 0x35, 0x6b, 0x3e,
+      0x76, 0x43, 0x12, 0xa6, 0x1a, 0x55, 0x32, 0x05, 0x57, 0x16, 0xea, 0xd6, 0x96, 0x25, 0x68, 0xf8, 0x7d, 0x3f, 0x3f,
+      0x77, 0x04, 0xc6, 0xa8, 0xd1, 0xbc, 0xd1, 0xbf, 0x4d, 0x50, 0xd6, 0x15, 0x4b, 0x6d, 0xa7, 0x31, 0xb1, 0x87, 0xb5,
+      0x8d, 0xfd, 0x72, 0x8a, 0xfa, 0x36, 0x75, 0x7a, 0x79, 0x7a, 0xc1, 0x88, 0xd1};
+
     // ANSWERS
 
-    unsigned char *cipher_out = chacha20::encrypt(key,counter,nonce,plain_text,sizeof(plain_text));
+    unsigned char *cipher_out = chacha20::encrypt(key, counter, nonce, plain_text, sizeof(plain_text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(cipher_out, cipher_text, sizeof(cipher_text), "ChaCha20 encryption ", TEST_RESULTS);
+
+    delete[] cipher_out;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(cipher_out,cipher_text,sizeof(cipher_text),"ChaCha20 encryption ",TEST_RESULTS);
-    
-    delete [] cipher_out;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/ChaCha20Poly1305_decrypt.cpp b/tests/ChaCha20Poly1305_decrypt.cpp
index 91c06d7..832b7a9 100644
--- a/tests/ChaCha20Poly1305_decrypt.cpp
+++ b/tests/ChaCha20Poly1305_decrypt.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "ChaCha20-Poly1305 decrypt, authenticate ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,125 +28,109 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char chacha20key[32] = {
-        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
-        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
-    };
+    unsigned char chacha20key[32] = {0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88,
+                                     0x86, 0x04, 0xf6, 0xb5, 0xf0, 0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b,
+                                     0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0};
 
     unsigned char cipherText[] = {
-        0x64, 0xa0, 0x86, 0x15, 0x75, 0x86, 0x1a, 0xf4, 0x60, 0xf0, 0x62, 0xc7, 0x9b, 0xe6, 0x43, 0xbd,
-        0x5e, 0x80, 0x5c, 0xfd, 0x34, 0x5c, 0xf3, 0x89, 0xf1, 0x08, 0x67, 0x0a, 0xc7, 0x6c, 0x8c, 0xb2,
-        0x4c, 0x6c, 0xfc, 0x18, 0x75, 0x5d, 0x43, 0xee, 0xa0, 0x9e, 0xe9, 0x4e, 0x38, 0x2d, 0x26, 0xb0,
-        0xbd, 0xb7, 0xb7, 0x3c, 0x32, 0x1b, 0x01, 0x00, 0xd4, 0xf0, 0x3b, 0x7f, 0x35, 0x58, 0x94, 0xcf,
-        0x33, 0x2f, 0x83, 0x0e, 0x71, 0x0b, 0x97, 0xce, 0x98, 0xc8, 0xa8, 0x4a, 0xbd, 0x0b, 0x94, 0x81,
-        0x14, 0xad, 0x17, 0x6e, 0x00, 0x8d, 0x33, 0xbd, 0x60, 0xf9, 0x82, 0xb1, 0xff, 0x37, 0xc8, 0x55,
-        0x97, 0x97, 0xa0, 0x6e, 0xf4, 0xf0, 0xef, 0x61, 0xc1, 0x86, 0x32, 0x4e, 0x2b, 0x35, 0x06, 0x38,
-        0x36, 0x06, 0x90, 0x7b, 0x6a, 0x7c, 0x02, 0xb0, 0xf9, 0xf6, 0x15, 0x7b, 0x53, 0xc8, 0x67, 0xe4,
-        0xb9, 0x16, 0x6c, 0x76, 0x7b, 0x80, 0x4d, 0x46, 0xa5, 0x9b, 0x52, 0x16, 0xcd, 0xe7, 0xa4, 0xe9,
-        0x90, 0x40, 0xc5, 0xa4, 0x04, 0x33, 0x22, 0x5e, 0xe2, 0x82, 0xa1, 0xb0, 0xa0, 0x6c, 0x52, 0x3e,
-        0xaf, 0x45, 0x34, 0xd7, 0xf8, 0x3f, 0xa1, 0x15, 0x5b, 0x00, 0x47, 0x71, 0x8c, 0xbc, 0x54, 0x6a,
-        0x0d, 0x07, 0x2b, 0x04, 0xb3, 0x56, 0x4e, 0xea, 0x1b, 0x42, 0x22, 0x73, 0xf5, 0x48, 0x27, 0x1a,
-        0x0b, 0xb2, 0x31, 0x60, 0x53, 0xfa, 0x76, 0x99, 0x19, 0x55, 0xeb, 0xd6, 0x31, 0x59, 0x43, 0x4e,
-        0xce, 0xbb, 0x4e, 0x46, 0x6d, 0xae, 0x5a, 0x10, 0x73, 0xa6, 0x72, 0x76, 0x27, 0x09, 0x7a, 0x10,
-        0x49, 0xe6, 0x17, 0xd9, 0x1d, 0x36, 0x10, 0x94, 0xfa, 0x68, 0xf0, 0xff, 0x77, 0x98, 0x71, 0x30,
-        0x30, 0x5b, 0xea, 0xba, 0x2e, 0xda, 0x04, 0xdf, 0x99, 0x7b, 0x71, 0x4d, 0x6c, 0x6f, 0x2c, 0x29,
-        0xa6, 0xad, 0x5c, 0xb4, 0x02, 0x2b, 0x02, 0x70, 0x9b
-    };
+      0x64, 0xa0, 0x86, 0x15, 0x75, 0x86, 0x1a, 0xf4, 0x60, 0xf0, 0x62, 0xc7, 0x9b, 0xe6, 0x43, 0xbd, 0x5e, 0x80, 0x5c,
+      0xfd, 0x34, 0x5c, 0xf3, 0x89, 0xf1, 0x08, 0x67, 0x0a, 0xc7, 0x6c, 0x8c, 0xb2, 0x4c, 0x6c, 0xfc, 0x18, 0x75, 0x5d,
+      0x43, 0xee, 0xa0, 0x9e, 0xe9, 0x4e, 0x38, 0x2d, 0x26, 0xb0, 0xbd, 0xb7, 0xb7, 0x3c, 0x32, 0x1b, 0x01, 0x00, 0xd4,
+      0xf0, 0x3b, 0x7f, 0x35, 0x58, 0x94, 0xcf, 0x33, 0x2f, 0x83, 0x0e, 0x71, 0x0b, 0x97, 0xce, 0x98, 0xc8, 0xa8, 0x4a,
+      0xbd, 0x0b, 0x94, 0x81, 0x14, 0xad, 0x17, 0x6e, 0x00, 0x8d, 0x33, 0xbd, 0x60, 0xf9, 0x82, 0xb1, 0xff, 0x37, 0xc8,
+      0x55, 0x97, 0x97, 0xa0, 0x6e, 0xf4, 0xf0, 0xef, 0x61, 0xc1, 0x86, 0x32, 0x4e, 0x2b, 0x35, 0x06, 0x38, 0x36, 0x06,
+      0x90, 0x7b, 0x6a, 0x7c, 0x02, 0xb0, 0xf9, 0xf6, 0x15, 0x7b, 0x53, 0xc8, 0x67, 0xe4, 0xb9, 0x16, 0x6c, 0x76, 0x7b,
+      0x80, 0x4d, 0x46, 0xa5, 0x9b, 0x52, 0x16, 0xcd, 0xe7, 0xa4, 0xe9, 0x90, 0x40, 0xc5, 0xa4, 0x04, 0x33, 0x22, 0x5e,
+      0xe2, 0x82, 0xa1, 0xb0, 0xa0, 0x6c, 0x52, 0x3e, 0xaf, 0x45, 0x34, 0xd7, 0xf8, 0x3f, 0xa1, 0x15, 0x5b, 0x00, 0x47,
+      0x71, 0x8c, 0xbc, 0x54, 0x6a, 0x0d, 0x07, 0x2b, 0x04, 0xb3, 0x56, 0x4e, 0xea, 0x1b, 0x42, 0x22, 0x73, 0xf5, 0x48,
+      0x27, 0x1a, 0x0b, 0xb2, 0x31, 0x60, 0x53, 0xfa, 0x76, 0x99, 0x19, 0x55, 0xeb, 0xd6, 0x31, 0x59, 0x43, 0x4e, 0xce,
+      0xbb, 0x4e, 0x46, 0x6d, 0xae, 0x5a, 0x10, 0x73, 0xa6, 0x72, 0x76, 0x27, 0x09, 0x7a, 0x10, 0x49, 0xe6, 0x17, 0xd9,
+      0x1d, 0x36, 0x10, 0x94, 0xfa, 0x68, 0xf0, 0xff, 0x77, 0x98, 0x71, 0x30, 0x30, 0x5b, 0xea, 0xba, 0x2e, 0xda, 0x04,
+      0xdf, 0x99, 0x7b, 0x71, 0x4d, 0x6c, 0x6f, 0x2c, 0x29, 0xa6, 0xad, 0x5c, 0xb4, 0x02, 0x2b, 0x02, 0x70, 0x9b};
 
     unsigned char plainText[] = {
-        0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20,
-        0x61, 0x72, 0x65, 0x20, 0x64, 0x72, 0x61, 0x66, 0x74, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65,
-        0x6e, 0x74, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20,
-        0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x69, 0x78, 0x20, 0x6d,
-        0x6f, 0x6e, 0x74, 0x68, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65,
-        0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63,
-        0x65, 0x64, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x64,
-        0x20, 0x62, 0x79, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65,
-        0x6e, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e,
-        0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72,
-        0x69, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x49, 0x6e, 0x74, 0x65,
-        0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20, 0x61, 0x73, 0x20, 0x72,
-        0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61,
-        0x6c, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65,
-        0x6d, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x73, 0x20,
-        0x2f, 0xe2, 0x80, 0x9c, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x67,
-        0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80, 0x9d
-    };
-
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
-    };
-
-    unsigned char AAD[] = {
-        0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x91
-    };
-    
-    unsigned char receiveTag[] = {
-        0xee, 0xad, 0x9d, 0x67, 0x89, 0x0c, 0xbb, 0x22, 0x39, 0x23, 0x36, 0xfe, 0xa1, 0x85, 0x1f, 0x38
-    };
+      0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65,
+      0x20, 0x64, 0x72, 0x61, 0x66, 0x74, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x76, 0x61,
+      0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6f,
+      0x66, 0x20, 0x73, 0x69, 0x78, 0x20, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61,
+      0x79, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61,
+      0x63, 0x65, 0x64, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x62,
+      0x79, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61,
+      0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69,
+      0x6e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65,
+      0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20, 0x61, 0x73,
+      0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c,
+      0x20, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x6f, 0x74,
+      0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x2f, 0xe2, 0x80, 0x9c, 0x77, 0x6f, 0x72,
+      0x6b, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80, 0x9d};
+
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
+
+    unsigned char AAD[] = {0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x91};
+
+    unsigned char receiveTag[] = {0xee, 0xad, 0x9d, 0x67, 0x89, 0x0c, 0xbb, 0x22,
+                                  0x39, 0x23, 0x36, 0xfe, 0xa1, 0x85, 0x1f, 0x38};
 
     // ANSWERS
     unsigned char *recover_tag = new unsigned char[sizeof(receiveTag)];
     unsigned char *recovered_text = new unsigned char[sizeof(cipherText)];
 
     ChaCha20_Poly1305::aead_decrypt(
-        recovered_text,recover_tag,cipherText,sizeof(cipherText),
-        AAD,sizeof(AAD),chacha20key,nonce+4,nonce
+      recovered_text, recover_tag, cipherText, sizeof(cipherText), AAD, sizeof(AAD), chacha20key, nonce + 4, nonce
     );
 
-    ASSERT_ARRAY<unsigned char>(recover_tag,receiveTag,sizeof(receiveTag), "Poly1305 mac/tag ",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(recovered_text,plainText,sizeof(plainText),"ChaCha20 decrypt ",TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(recover_tag, receiveTag, sizeof(receiveTag), "Poly1305 mac/tag ", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(recovered_text, plainText, sizeof(plainText), "ChaCha20 decrypt ", TEST_RESULTS);
+
+    delete[] recover_tag;
+    delete[] recovered_text;
 
-    delete [] recover_tag;
-    delete [] recovered_text;
-  
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/ChaCha20Poly1305_decrypt_nonceV.cpp b/tests/ChaCha20Poly1305_decrypt_nonceV.cpp
index 4ef5f08..9d09d2a 100644
--- a/tests/ChaCha20Poly1305_decrypt_nonceV.cpp
+++ b/tests/ChaCha20Poly1305_decrypt_nonceV.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "ChaCha20-Poly1305 nonce version decrypt, authenticate ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,125 +28,109 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char chacha20key[32] = {
-        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
-        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
-    };
+    unsigned char chacha20key[32] = {0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88,
+                                     0x86, 0x04, 0xf6, 0xb5, 0xf0, 0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b,
+                                     0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0};
 
     unsigned char cipherText[] = {
-        0x64, 0xa0, 0x86, 0x15, 0x75, 0x86, 0x1a, 0xf4, 0x60, 0xf0, 0x62, 0xc7, 0x9b, 0xe6, 0x43, 0xbd,
-        0x5e, 0x80, 0x5c, 0xfd, 0x34, 0x5c, 0xf3, 0x89, 0xf1, 0x08, 0x67, 0x0a, 0xc7, 0x6c, 0x8c, 0xb2,
-        0x4c, 0x6c, 0xfc, 0x18, 0x75, 0x5d, 0x43, 0xee, 0xa0, 0x9e, 0xe9, 0x4e, 0x38, 0x2d, 0x26, 0xb0,
-        0xbd, 0xb7, 0xb7, 0x3c, 0x32, 0x1b, 0x01, 0x00, 0xd4, 0xf0, 0x3b, 0x7f, 0x35, 0x58, 0x94, 0xcf,
-        0x33, 0x2f, 0x83, 0x0e, 0x71, 0x0b, 0x97, 0xce, 0x98, 0xc8, 0xa8, 0x4a, 0xbd, 0x0b, 0x94, 0x81,
-        0x14, 0xad, 0x17, 0x6e, 0x00, 0x8d, 0x33, 0xbd, 0x60, 0xf9, 0x82, 0xb1, 0xff, 0x37, 0xc8, 0x55,
-        0x97, 0x97, 0xa0, 0x6e, 0xf4, 0xf0, 0xef, 0x61, 0xc1, 0x86, 0x32, 0x4e, 0x2b, 0x35, 0x06, 0x38,
-        0x36, 0x06, 0x90, 0x7b, 0x6a, 0x7c, 0x02, 0xb0, 0xf9, 0xf6, 0x15, 0x7b, 0x53, 0xc8, 0x67, 0xe4,
-        0xb9, 0x16, 0x6c, 0x76, 0x7b, 0x80, 0x4d, 0x46, 0xa5, 0x9b, 0x52, 0x16, 0xcd, 0xe7, 0xa4, 0xe9,
-        0x90, 0x40, 0xc5, 0xa4, 0x04, 0x33, 0x22, 0x5e, 0xe2, 0x82, 0xa1, 0xb0, 0xa0, 0x6c, 0x52, 0x3e,
-        0xaf, 0x45, 0x34, 0xd7, 0xf8, 0x3f, 0xa1, 0x15, 0x5b, 0x00, 0x47, 0x71, 0x8c, 0xbc, 0x54, 0x6a,
-        0x0d, 0x07, 0x2b, 0x04, 0xb3, 0x56, 0x4e, 0xea, 0x1b, 0x42, 0x22, 0x73, 0xf5, 0x48, 0x27, 0x1a,
-        0x0b, 0xb2, 0x31, 0x60, 0x53, 0xfa, 0x76, 0x99, 0x19, 0x55, 0xeb, 0xd6, 0x31, 0x59, 0x43, 0x4e,
-        0xce, 0xbb, 0x4e, 0x46, 0x6d, 0xae, 0x5a, 0x10, 0x73, 0xa6, 0x72, 0x76, 0x27, 0x09, 0x7a, 0x10,
-        0x49, 0xe6, 0x17, 0xd9, 0x1d, 0x36, 0x10, 0x94, 0xfa, 0x68, 0xf0, 0xff, 0x77, 0x98, 0x71, 0x30,
-        0x30, 0x5b, 0xea, 0xba, 0x2e, 0xda, 0x04, 0xdf, 0x99, 0x7b, 0x71, 0x4d, 0x6c, 0x6f, 0x2c, 0x29,
-        0xa6, 0xad, 0x5c, 0xb4, 0x02, 0x2b, 0x02, 0x70, 0x9b
-    };
+      0x64, 0xa0, 0x86, 0x15, 0x75, 0x86, 0x1a, 0xf4, 0x60, 0xf0, 0x62, 0xc7, 0x9b, 0xe6, 0x43, 0xbd, 0x5e, 0x80, 0x5c,
+      0xfd, 0x34, 0x5c, 0xf3, 0x89, 0xf1, 0x08, 0x67, 0x0a, 0xc7, 0x6c, 0x8c, 0xb2, 0x4c, 0x6c, 0xfc, 0x18, 0x75, 0x5d,
+      0x43, 0xee, 0xa0, 0x9e, 0xe9, 0x4e, 0x38, 0x2d, 0x26, 0xb0, 0xbd, 0xb7, 0xb7, 0x3c, 0x32, 0x1b, 0x01, 0x00, 0xd4,
+      0xf0, 0x3b, 0x7f, 0x35, 0x58, 0x94, 0xcf, 0x33, 0x2f, 0x83, 0x0e, 0x71, 0x0b, 0x97, 0xce, 0x98, 0xc8, 0xa8, 0x4a,
+      0xbd, 0x0b, 0x94, 0x81, 0x14, 0xad, 0x17, 0x6e, 0x00, 0x8d, 0x33, 0xbd, 0x60, 0xf9, 0x82, 0xb1, 0xff, 0x37, 0xc8,
+      0x55, 0x97, 0x97, 0xa0, 0x6e, 0xf4, 0xf0, 0xef, 0x61, 0xc1, 0x86, 0x32, 0x4e, 0x2b, 0x35, 0x06, 0x38, 0x36, 0x06,
+      0x90, 0x7b, 0x6a, 0x7c, 0x02, 0xb0, 0xf9, 0xf6, 0x15, 0x7b, 0x53, 0xc8, 0x67, 0xe4, 0xb9, 0x16, 0x6c, 0x76, 0x7b,
+      0x80, 0x4d, 0x46, 0xa5, 0x9b, 0x52, 0x16, 0xcd, 0xe7, 0xa4, 0xe9, 0x90, 0x40, 0xc5, 0xa4, 0x04, 0x33, 0x22, 0x5e,
+      0xe2, 0x82, 0xa1, 0xb0, 0xa0, 0x6c, 0x52, 0x3e, 0xaf, 0x45, 0x34, 0xd7, 0xf8, 0x3f, 0xa1, 0x15, 0x5b, 0x00, 0x47,
+      0x71, 0x8c, 0xbc, 0x54, 0x6a, 0x0d, 0x07, 0x2b, 0x04, 0xb3, 0x56, 0x4e, 0xea, 0x1b, 0x42, 0x22, 0x73, 0xf5, 0x48,
+      0x27, 0x1a, 0x0b, 0xb2, 0x31, 0x60, 0x53, 0xfa, 0x76, 0x99, 0x19, 0x55, 0xeb, 0xd6, 0x31, 0x59, 0x43, 0x4e, 0xce,
+      0xbb, 0x4e, 0x46, 0x6d, 0xae, 0x5a, 0x10, 0x73, 0xa6, 0x72, 0x76, 0x27, 0x09, 0x7a, 0x10, 0x49, 0xe6, 0x17, 0xd9,
+      0x1d, 0x36, 0x10, 0x94, 0xfa, 0x68, 0xf0, 0xff, 0x77, 0x98, 0x71, 0x30, 0x30, 0x5b, 0xea, 0xba, 0x2e, 0xda, 0x04,
+      0xdf, 0x99, 0x7b, 0x71, 0x4d, 0x6c, 0x6f, 0x2c, 0x29, 0xa6, 0xad, 0x5c, 0xb4, 0x02, 0x2b, 0x02, 0x70, 0x9b};
 
     unsigned char plainText[] = {
-        0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20,
-        0x61, 0x72, 0x65, 0x20, 0x64, 0x72, 0x61, 0x66, 0x74, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65,
-        0x6e, 0x74, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20,
-        0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x69, 0x78, 0x20, 0x6d,
-        0x6f, 0x6e, 0x74, 0x68, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65,
-        0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63,
-        0x65, 0x64, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x64,
-        0x20, 0x62, 0x79, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65,
-        0x6e, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e,
-        0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72,
-        0x69, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x49, 0x6e, 0x74, 0x65,
-        0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20, 0x61, 0x73, 0x20, 0x72,
-        0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61,
-        0x6c, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65,
-        0x6d, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x73, 0x20,
-        0x2f, 0xe2, 0x80, 0x9c, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x67,
-        0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80, 0x9d
-    };
-
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
-    };
-
-    unsigned char AAD[] = {
-        0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x91
-    };
-    
-    unsigned char receiveTag[] = {
-        0xee, 0xad, 0x9d, 0x67, 0x89, 0x0c, 0xbb, 0x22, 0x39, 0x23, 0x36, 0xfe, 0xa1, 0x85, 0x1f, 0x38
-    };
+      0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65,
+      0x20, 0x64, 0x72, 0x61, 0x66, 0x74, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x76, 0x61,
+      0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6f,
+      0x66, 0x20, 0x73, 0x69, 0x78, 0x20, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61,
+      0x79, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61,
+      0x63, 0x65, 0x64, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x62,
+      0x79, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61,
+      0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x69,
+      0x6e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65,
+      0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x73, 0x20, 0x61, 0x73,
+      0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c,
+      0x20, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x6f, 0x74,
+      0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x2f, 0xe2, 0x80, 0x9c, 0x77, 0x6f, 0x72,
+      0x6b, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x2f, 0xe2, 0x80, 0x9d};
+
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
+
+    unsigned char AAD[] = {0xf3, 0x33, 0x88, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x91};
+
+    unsigned char receiveTag[] = {0xee, 0xad, 0x9d, 0x67, 0x89, 0x0c, 0xbb, 0x22,
+                                  0x39, 0x23, 0x36, 0xfe, 0xa1, 0x85, 0x1f, 0x38};
 
     // ANSWERS
     unsigned char *recover_tag = new unsigned char[sizeof(receiveTag)];
     unsigned char *recovered_text = new unsigned char[sizeof(cipherText)];
 
     ChaCha20_Poly1305::aead_decrypt(
-        recovered_text,recover_tag,cipherText,sizeof(cipherText),
-        AAD,sizeof(AAD),chacha20key,nonce
+      recovered_text, recover_tag, cipherText, sizeof(cipherText), AAD, sizeof(AAD), chacha20key, nonce
     );
 
-    ASSERT_ARRAY<unsigned char>(recover_tag,receiveTag,sizeof(receiveTag), "Poly1305 mac/tag ",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(recovered_text,plainText,sizeof(plainText),"ChaCha20 decrypt ",TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(recover_tag, receiveTag, sizeof(receiveTag), "Poly1305 mac/tag ", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(recovered_text, plainText, sizeof(plainText), "ChaCha20 decrypt ", TEST_RESULTS);
+
+    delete[] recover_tag;
+    delete[] recovered_text;
 
-    delete [] recover_tag;
-    delete [] recovered_text;
-  
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/Encryption_test.cpp b/tests/Encryption_test.cpp
index b560180..de25f56 100644
--- a/tests/Encryption_test.cpp
+++ b/tests/Encryption_test.cpp
@@ -1,72 +1,59 @@
 #include <iostream>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
 }
 
-int main()
-{
-    unsigned char key[32] = {
-        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
-    };
+int main() {
+    unsigned char key[32] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+                             0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+                             0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
 
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x00};
 
     unsigned int initial_counter = 1;
 
     unsigned char plaintext[114] = {
-       0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c,
-       0x65, 0x6d, 0x65, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73,
-       0x73, 0x20, 0x6f, 0x66, 0x20, 0x27, 0x39, 0x39, 0x3a, 0x20, 0x49, 0x66, 0x20, 0x49, 0x20, 0x63,
-       0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6f,
-       0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x74, 0x69, 0x70, 0x20, 0x66, 0x6f, 0x72, 0x20,
-       0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x6e, 0x73,
-       0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69,
-       0x74, 0x2e
-    };
+      0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c, 0x65, 0x6d, 0x65,
+      0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x27,
+      0x39, 0x39, 0x3a, 0x20, 0x49, 0x66, 0x20, 0x49, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x66, 0x65,
+      0x72, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x74, 0x69, 0x70, 0x20,
+      0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x6e,
+      0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x74, 0x2e};
 
     unsigned char correct_ciphertext[114] = {
-        0x6e, 0x2e, 0x35, 0x9a, 0x25, 0x68, 0xf9, 0x80, 0x41, 0xba, 0x07, 0x28, 0xdd, 0x0d, 0x69, 0x81,
-        0xe9, 0x7e, 0x7a, 0xec, 0x1d, 0x43, 0x60, 0xc2, 0x0a, 0x27, 0xaf, 0xcc, 0xfd, 0x9f, 0xae, 0x0b,
-        0xf9, 0x1b, 0x65, 0xc5, 0x52, 0x47, 0x33, 0xab, 0x8f, 0x59, 0x3d, 0xab, 0xcd, 0x62, 0xb3, 0x57,
-        0x16, 0x39, 0xd6, 0x24, 0xe6, 0x51, 0x52, 0xab, 0x8f, 0x53, 0x0c, 0x35, 0x9f, 0x08, 0x61, 0xd8,
-        0x07, 0xca, 0x0d, 0xbf, 0x50, 0x0d, 0x6a, 0x61, 0x56, 0xa3, 0x8e, 0x08, 0x8a, 0x22, 0xb6, 0x5e,
-        0x52, 0xbc, 0x51, 0x4d, 0x16, 0xcc, 0xf8, 0x06, 0x81, 0x8c, 0xe9, 0x1a, 0xb7, 0x79, 0x37, 0x36,
-        0x5a, 0xf9, 0x0b, 0xbf, 0x74, 0xa3, 0x5b, 0xe6, 0xb4, 0x0b, 0x8e, 0xed, 0xf2, 0x78, 0x5e, 0x42,
-        0x87, 0x4d
-    };
+      0x6e, 0x2e, 0x35, 0x9a, 0x25, 0x68, 0xf9, 0x80, 0x41, 0xba, 0x07, 0x28, 0xdd, 0x0d, 0x69, 0x81, 0xe9, 0x7e, 0x7a,
+      0xec, 0x1d, 0x43, 0x60, 0xc2, 0x0a, 0x27, 0xaf, 0xcc, 0xfd, 0x9f, 0xae, 0x0b, 0xf9, 0x1b, 0x65, 0xc5, 0x52, 0x47,
+      0x33, 0xab, 0x8f, 0x59, 0x3d, 0xab, 0xcd, 0x62, 0xb3, 0x57, 0x16, 0x39, 0xd6, 0x24, 0xe6, 0x51, 0x52, 0xab, 0x8f,
+      0x53, 0x0c, 0x35, 0x9f, 0x08, 0x61, 0xd8, 0x07, 0xca, 0x0d, 0xbf, 0x50, 0x0d, 0x6a, 0x61, 0x56, 0xa3, 0x8e, 0x08,
+      0x8a, 0x22, 0xb6, 0x5e, 0x52, 0xbc, 0x51, 0x4d, 0x16, 0xcc, 0xf8, 0x06, 0x81, 0x8c, 0xe9, 0x1a, 0xb7, 0x79, 0x37,
+      0x36, 0x5a, 0xf9, 0x0b, 0xbf, 0x74, 0xa3, 0x5b, 0xe6, 0xb4, 0x0b, 0x8e, 0xed, 0xf2, 0x78, 0x5e, 0x42, 0x87, 0x4d};
 
-    unsigned char *cipher = chacha20::encrypt(key,initial_counter,nonce,plaintext,114);
+    unsigned char *cipher = chacha20::encrypt(key, initial_counter, nonce, plaintext, 114);
 
     bool passed = true;
-    for(size_t i=0; i<114; ++i) {
-        if(cipher[i] != correct_ciphertext[i]) {
+    for (size_t i = 0; i < 114; ++i) {
+        if (cipher[i] != correct_ciphertext[i]) {
             passed = false;
             break;
         }
     }
 
-    delete [] cipher;
+    delete[] cipher;
 
-    if(passed) {
+    if (passed) {
         std::cout << "ChaChaEncryptionTest : PASSED\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "ChaChaEncryptionTest : FAILED\n";
         return 1;
     }
diff --git a/tests/Poly1305_keygen_t1.cpp b/tests/Poly1305_keygen_t1.cpp
index fdb77ce..6119875 100644
--- a/tests/Poly1305_keygen_t1.cpp
+++ b/tests/Poly1305_keygen_t1.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 keygen using ChaCha20 test 1 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,78 +28,72 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char chacha20key[32] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char chacha20key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char polykey[] = {
-        0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-        0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7
-    };
+    unsigned char polykey[] = {0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a,
+                               0xe5, 0x53, 0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d,
+                               0xed, 0x1a, 0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7};
 
     // ANSWERS
 
     unsigned char *genkey = new unsigned char[32];
-    poly1305::key_gen(genkey,chacha20key,(unsigned int*)nonce);
+    poly1305::key_gen(genkey, chacha20key, (unsigned int *) nonce);
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(genkey, polykey, sizeof(polykey), "Poly1305 key generation test ", TEST_RESULTS);
+
+    delete[] genkey;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(genkey,polykey,sizeof(polykey),"Poly1305 key generation test ",TEST_RESULTS);
-    
-    delete [] genkey;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/Poly1305_keygen_t2.cpp b/tests/Poly1305_keygen_t2.cpp
index 6eacc33..64ea2ee 100644
--- a/tests/Poly1305_keygen_t2.cpp
+++ b/tests/Poly1305_keygen_t2.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 keygen using ChaCha20 test 2 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,78 +28,72 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char chacha20key[32] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
-    };
+    unsigned char chacha20key[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
-    };
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
 
-    unsigned char polykey[] = {
-        0xec, 0xfa, 0x25, 0x4f, 0x84, 0x5f, 0x64, 0x74, 0x73, 0xd3, 0xcb, 0x14, 0x0d, 0xa9, 0xe8, 0x76,
-        0x06, 0xcb, 0x33, 0x06, 0x6c, 0x44, 0x7b, 0x87, 0xbc, 0x26, 0x66, 0xdd, 0xe3, 0xfb, 0xb7, 0x39
-    };
+    unsigned char polykey[] = {0xec, 0xfa, 0x25, 0x4f, 0x84, 0x5f, 0x64, 0x74, 0x73, 0xd3, 0xcb,
+                               0x14, 0x0d, 0xa9, 0xe8, 0x76, 0x06, 0xcb, 0x33, 0x06, 0x6c, 0x44,
+                               0x7b, 0x87, 0xbc, 0x26, 0x66, 0xdd, 0xe3, 0xfb, 0xb7, 0x39};
 
     // ANSWERS
 
     unsigned char *genkey = new unsigned char[32];
-    poly1305::key_gen(genkey,chacha20key,(unsigned int*)nonce);
+    poly1305::key_gen(genkey, chacha20key, (unsigned int *) nonce);
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(genkey, polykey, sizeof(polykey), "Poly1305 key generation test ", TEST_RESULTS);
+
+    delete[] genkey;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(genkey,polykey,sizeof(polykey),"Poly1305 key generation test ",TEST_RESULTS);
-    
-    delete [] genkey;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/Poly1305_keygen_t3.cpp b/tests/Poly1305_keygen_t3.cpp
index 965e10b..b305ab7 100644
--- a/tests/Poly1305_keygen_t3.cpp
+++ b/tests/Poly1305_keygen_t3.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 keygen using ChaCha20 test 3 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,78 +28,72 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char chacha20key[32] = {
-        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
-        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
-    };
+    unsigned char chacha20key[32] = {0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88,
+                                     0x86, 0x04, 0xf6, 0xb5, 0xf0, 0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b,
+                                     0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0};
 
-    unsigned char nonce[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
-    };
+    unsigned char nonce[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
 
-    unsigned char polykey[] = {
-        0x96, 0x5e, 0x3b, 0xc6, 0xf9, 0xec, 0x7e, 0xd9, 0x56, 0x08, 0x08, 0xf4, 0xd2, 0x29, 0xf9, 0x4b,
-        0x13, 0x7f, 0xf2, 0x75, 0xca, 0x9b, 0x3f, 0xcb, 0xdd, 0x59, 0xde, 0xaa, 0xd2, 0x33, 0x10, 0xae
-    };
+    unsigned char polykey[] = {0x96, 0x5e, 0x3b, 0xc6, 0xf9, 0xec, 0x7e, 0xd9, 0x56, 0x08, 0x08,
+                               0xf4, 0xd2, 0x29, 0xf9, 0x4b, 0x13, 0x7f, 0xf2, 0x75, 0xca, 0x9b,
+                               0x3f, 0xcb, 0xdd, 0x59, 0xde, 0xaa, 0xd2, 0x33, 0x10, 0xae};
 
     // ANSWERS
 
     unsigned char *genkey = new unsigned char[32];
-    poly1305::key_gen(genkey,chacha20key,(unsigned int*)nonce);
+    poly1305::key_gen(genkey, chacha20key, (unsigned int *) nonce);
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(genkey, polykey, sizeof(polykey), "Poly1305 key generation test ", TEST_RESULTS);
+
+    delete[] genkey;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(genkey,polykey,sizeof(polykey),"Poly1305 key generation test ",TEST_RESULTS);
-    
-    delete [] genkey;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/Poly1305_mac_t1.cpp b/tests/Poly1305_mac_t1.cpp
index 735f5ae..3082001 100644
--- a/tests/Poly1305_mac_t1.cpp
+++ b/tests/Poly1305_mac_t1.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 1 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,81 +28,76 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
-
-    unsigned char text[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
-
-    unsigned char tag[16] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char text[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char tag[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t10.cpp b/tests/Poly1305_mac_t10.cpp
index 313e5a0..74ef072 100644
--- a/tests/Poly1305_mac_t10.cpp
+++ b/tests/Poly1305_mac_t10.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 10 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,81 +28,76 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
-
-    unsigned char text[] = {
-        0xE3, 0x35, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x33, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0x79, 0xCD, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
-
-    unsigned char tag[16] = {
-        0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char text[] = {0xE3, 0x35, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x33, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0x79, 0xCD, 0x01, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    unsigned char tag[16] = {0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t11.cpp b/tests/Poly1305_mac_t11.cpp
index bcf724a..df67f2e 100644
--- a/tests/Poly1305_mac_t11.cpp
+++ b/tests/Poly1305_mac_t11.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 11 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,80 +28,75 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char text[] = {
-        0xE3, 0x35, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x33, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0x79, 0xCD, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char text[] = {0xE3, 0x35, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0xB9, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x33, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0x79, 0xCD,
+                            0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char tag[16] = {
-        0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char tag[16] = {0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t2.cpp b/tests/Poly1305_mac_t2.cpp
index 5903da0..4fdcff8 100644
--- a/tests/Poly1305_mac_t2.cpp
+++ b/tests/Poly1305_mac_t2.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 2 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,101 +28,92 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70, 0xf0, 0xef, 0xca, 0x96, 0x22, 0x7a, 0x86, 0x3e
-    };
+    unsigned char polykey[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0,
+                                 0x60, 0x70, 0xf0, 0xef, 0xca, 0x96, 0x22, 0x7a, 0x86, 0x3e};
 
     unsigned char text[] = {
-        0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74,
-        0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e,
-        0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
-        0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69,
-        0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x72,
-        0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
-        0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20,
-        0x6f, 0x72, 0x20, 0x52, 0x46, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73,
-        0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69,
-        0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-        0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x61, 0x63, 0x74, 0x69,
-        0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72,
-        0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74,
-        0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20,
-        0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75,
-        0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e,
-        0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x73, 0x65, 0x73, 0x73, 0x69,
-        0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20,
-        0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
-        0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61,
-        0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e,
-        0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c,
-        0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65,
-        0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f
-    };
-
-    unsigned char tag[16] = {
-        0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70, 0xf0, 0xef, 0xca, 0x96, 0x22, 0x7a, 0x86, 0x3e
-    };
+      0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74,
+      0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79,
+      0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x6f,
+      0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c,
+      0x6c, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54,
+      0x46, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20, 0x6f, 0x72,
+      0x20, 0x52, 0x46, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d,
+      0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
+      0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
+      0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64,
+      0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
+      0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20, 0x73, 0x74, 0x61, 0x74,
+      0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c,
+      0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
+      0x20, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20,
+      0x61, 0x73, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
+      0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
+      0x6e, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65,
+      0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72,
+      0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f};
+
+    unsigned char tag[16] = {0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70,
+                             0xf0, 0xef, 0xca, 0x96, 0x22, 0x7a, 0x86, 0x3e};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t3.cpp b/tests/Poly1305_mac_t3.cpp
index a49f241..6d1287e 100644
--- a/tests/Poly1305_mac_t3.cpp
+++ b/tests/Poly1305_mac_t3.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 3 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,101 +28,92 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70, 0xf0, 0xef, 0xca, 0x96, 0x22, 0x7a, 0x86, 0x3e,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70, 0xf0, 0xef, 0xca,
+                                 0x96, 0x22, 0x7a, 0x86, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     unsigned char text[375] = {
-        0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74,
-        0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e,
-        0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
-        0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69,
-        0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x72,
-        0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
-        0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20,
-        0x6f, 0x72, 0x20, 0x52, 0x46, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73,
-        0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69,
-        0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-        0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x61, 0x63, 0x74, 0x69,
-        0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72,
-        0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74,
-        0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20,
-        0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75,
-        0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e,
-        0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x73, 0x65, 0x73, 0x73, 0x69,
-        0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20,
-        0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
-        0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61,
-        0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e,
-        0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c,
-        0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65,
-        0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f
-    };
-
-    unsigned char tag[16] = {
-        0xf3, 0x47, 0x7e, 0x7c, 0xd9, 0x54, 0x17, 0xaf, 0x89, 0xa6, 0xb8, 0x79, 0x4c, 0x31, 0x0c, 0xf0
-    };
+      0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74,
+      0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79,
+      0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x6f,
+      0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c,
+      0x6c, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54,
+      0x46, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20, 0x6f, 0x72,
+      0x20, 0x52, 0x46, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d,
+      0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
+      0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
+      0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64,
+      0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
+      0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20, 0x73, 0x74, 0x61, 0x74,
+      0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c,
+      0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
+      0x20, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20,
+      0x61, 0x73, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
+      0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
+      0x6e, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65,
+      0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72,
+      0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f};
+
+    unsigned char tag[16] = {0xf3, 0x47, 0x7e, 0x7c, 0xd9, 0x54, 0x17, 0xaf,
+                             0x89, 0xa6, 0xb8, 0x79, 0x4c, 0x31, 0x0c, 0xf0};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t4.cpp b/tests/Poly1305_mac_t4.cpp
index ac0e31c..798a791 100644
--- a/tests/Poly1305_mac_t4.cpp
+++ b/tests/Poly1305_mac_t4.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 4 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,85 +28,79 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
-        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
-    };
+    unsigned char polykey[32] = {0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88,
+                                 0x86, 0x04, 0xf6, 0xb5, 0xf0, 0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b,
+                                 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0};
 
     unsigned char text[] = {
-        0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72, 0x69, 0x6c, 0x6c, 0x69, 0x67, 0x2c, 0x20, 0x61,
-        0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f,
-        0x76, 0x65, 0x73, 0x0a, 0x44, 0x69, 0x64, 0x20, 0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64,
-        0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77,
-        0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c, 0x20, 0x6d, 0x69, 0x6d, 0x73, 0x79, 0x20, 0x77,
-        0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76, 0x65,
-        0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x20,
-        0x72, 0x61, 0x74, 0x68, 0x73, 0x20, 0x6f, 0x75, 0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e
-    };
-
-    unsigned char tag[16] = {
-        0x45, 0x41, 0x66, 0x9a, 0x7e, 0xaa, 0xee, 0x61, 0xe7, 0x08, 0xdc, 0x7c, 0xbc, 0xc5, 0xeb, 0x62
-    };
+      0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72, 0x69, 0x6c, 0x6c, 0x69, 0x67, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20,
+      0x74, 0x68, 0x65, 0x20, 0x73, 0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f, 0x76, 0x65, 0x73, 0x0a, 0x44, 0x69,
+      0x64, 0x20, 0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x69,
+      0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c, 0x20, 0x6d, 0x69, 0x6d,
+      0x73, 0x79, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76,
+      0x65, 0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x20, 0x72, 0x61,
+      0x74, 0x68, 0x73, 0x20, 0x6f, 0x75, 0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e};
+
+    unsigned char tag[16] = {0x45, 0x41, 0x66, 0x9a, 0x7e, 0xaa, 0xee, 0x61,
+                             0xe7, 0x08, 0xdc, 0x7c, 0xbc, 0xc5, 0xeb, 0x62};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t5.cpp b/tests/Poly1305_mac_t5.cpp
index 3fd1cdb..6d89b87 100644
--- a/tests/Poly1305_mac_t5.cpp
+++ b/tests/Poly1305_mac_t5.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 5 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,78 +28,73 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char text[] = {
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-    };
+    unsigned char text[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
-    unsigned char tag[16] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char tag[16] = {0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t6.cpp b/tests/Poly1305_mac_t6.cpp
index 86dd52a..efc8c34 100644
--- a/tests/Poly1305_mac_t6.cpp
+++ b/tests/Poly1305_mac_t6.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 6 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,78 +28,73 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-    };
+    unsigned char polykey[32] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
-    unsigned char text[] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char text[] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char tag[16] = {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char tag[16] = {0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t7.cpp b/tests/Poly1305_mac_t7.cpp
index 657b0f8..96f1f9e 100644
--- a/tests/Poly1305_mac_t7.cpp
+++ b/tests/Poly1305_mac_t7.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 7 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,80 +28,75 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char text[] = {
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char text[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                            0xff, 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x11, 0x00, 0x00, 0x00,
+                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char tag[16] = {
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char tag[16] = {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t8.cpp b/tests/Poly1305_mac_t8.cpp
index 97a6451..d707898 100644
--- a/tests/Poly1305_mac_t8.cpp
+++ b/tests/Poly1305_mac_t8.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 8 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,80 +28,75 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char text[] = {
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0xFB, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
-    };
+    unsigned char text[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                            0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+                            0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0x01, 0x01, 0x01, 0x01,
+                            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
 
-    unsigned char tag[16] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char tag[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/Poly1305_mac_t9.cpp b/tests/Poly1305_mac_t9.cpp
index e1fbb08..803f9e2 100644
--- a/tests/Poly1305_mac_t9.cpp
+++ b/tests/Poly1305_mac_t9.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Poly1305 mac test 9 ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -28,78 +28,73 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char polykey[32] = {
-        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    unsigned char polykey[32] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    unsigned char text[] = {
-        0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-    };
+    unsigned char text[] = {0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
-    unsigned char tag[16] = {
-        0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-    };
+    unsigned char tag[16] = {0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
     // ANSWERS
 
     unsigned char *out_tag = new unsigned char[16];
-    poly1305::mac(out_tag,polykey,text,sizeof(text));
+    poly1305::mac(out_tag, polykey, text, sizeof(text));
+
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(out_tag, tag, 16, "Poly1305 tag/mac test ", TEST_RESULTS);
+
+    delete[] out_tag;
 
-    // TESTING ANSWER 
-    ASSERT_ARRAY<unsigned char>(out_tag,tag,16,"Poly1305 tag/mac test ",TEST_RESULTS);
-    
-    delete [] out_tag;
-    
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file
diff --git a/tests/QuarterRound_test.cpp b/tests/QuarterRound_test.cpp
index 1ced902..03b4964 100644
--- a/tests/QuarterRound_test.cpp
+++ b/tests/QuarterRound_test.cpp
@@ -2,54 +2,48 @@
 #include <cstring>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 using namespace std;
 
 // ChaCha State Comparison
-bool CompareState(unsigned int *A, unsigned int *B){
-    for(size_t i=0; i<16; ++i)
-        if(A[i] != B[i])
+bool CompareState(unsigned int *A, unsigned int *B) {
+    for (size_t i = 0; i < 16; ++i)
+        if (A[i] != B[i])
             return false;
     return true;
 }
 
-int main(){
+int main() {
 
-    unsigned int stack_state[4*4] = {
-        0x879531e0, 0xc5ecf37d, 0x516461b1, 0xc9a62f8a,
-        0x44c20ef3, 0x3390af7f, 0xd9fc690b, 0x2a5f714c,
-        0x53372767, 0xb00a5631, 0x974c541a, 0x359e9963,
-        0x5c971061, 0x3d631689, 0x2098d9d6, 0x91dbd320,
+    unsigned int stack_state[4 * 4] = {
+      0x879531e0, 0xc5ecf37d, 0x516461b1, 0xc9a62f8a, 0x44c20ef3, 0x3390af7f, 0xd9fc690b, 0x2a5f714c,
+      0x53372767, 0xb00a5631, 0x974c541a, 0x359e9963, 0x5c971061, 0x3d631689, 0x2098d9d6, 0x91dbd320,
     };
 
     unsigned int *heap_state = new unsigned int[16];
 
-    for(size_t i=0; i<(4*4); ++i)
+    for (size_t i = 0; i < (4 * 4); ++i)
         heap_state[i] = stack_state[i];
 
-    unsigned int correct_state[4*4] = {
-        0x879531e0, 0xc5ecf37d, 0xbdb886dc, 0xc9a62f8a,
-        0x44c20ef3, 0x3390af7f, 0xd9fc690b, 0xcfacafd2,
-        0xe46bea80, 0xb00a5631, 0x974c541a, 0x359e9963,
-        0x5c971061, 0xccc07c79, 0x2098d9d6, 0x91dbd320
-    };
+    unsigned int correct_state[4 * 4] = {0x879531e0, 0xc5ecf37d, 0xbdb886dc, 0xc9a62f8a, 0x44c20ef3, 0x3390af7f,
+                                         0xd9fc690b, 0xcfacafd2, 0xe46bea80, 0xb00a5631, 0x974c541a, 0x359e9963,
+                                         0x5c971061, 0xccc07c79, 0x2098d9d6, 0x91dbd320};
 
     chacha20::QUARTERROUND(stack_state, 2, 7, 8, 13);
     chacha20::QUARTERROUND(heap_state, 2, 7, 8, 13);
 
-    bool passed = CompareState(stack_state,correct_state) && CompareState(heap_state,correct_state);
+    bool passed = CompareState(stack_state, correct_state) && CompareState(heap_state, correct_state);
 
-    delete [] heap_state;
+    delete[] heap_state;
 
-    if(passed) {
+    if (passed) {
         std::cout << "ChaChaQuarterRoundTest : PASSED\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "ChaChaQuarterRoundTest : FAILED\n";
         return 1;
     }
diff --git a/tests/chacha20_aead_enc_dec.cpp b/tests/chacha20_aead_enc_dec.cpp
index 8062c1a..79c0ad4 100644
--- a/tests/chacha20_aead_enc_dec.cpp
+++ b/tests/chacha20_aead_enc_dec.cpp
@@ -3,21 +3,21 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "Initial ChaCha20Poly1305 encrypt, decrypt, authenticate test ";
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE);
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE);
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -29,115 +29,101 @@ int main() {
 
     // TEST VARIABLES
     unsigned char plaintext[114] = {
-        0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c,
-        0x65, 0x6d, 0x65, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73,
-        0x73, 0x20, 0x6f, 0x66, 0x20, 0x27, 0x39, 0x39, 0x3a, 0x20, 0x49, 0x66, 0x20, 0x49, 0x20, 0x63,
-        0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6f,
-        0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x74, 0x69, 0x70, 0x20, 0x66, 0x6f, 0x72, 0x20,
-        0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x6e, 0x73,
-        0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69,
-        0x74, 0x2e
-    };
-
-    unsigned char AAD[12] = {
-        0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7
-    };
-
-    unsigned char key[32] = {
-        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f
-    };      
-
-    unsigned char iv[8] = { 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47 };
-   
-    unsigned char constant[4] = { 0x07, 0x00, 0x00, 0x00 };
-   
+      0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c, 0x65, 0x6d, 0x65,
+      0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x27,
+      0x39, 0x39, 0x3a, 0x20, 0x49, 0x66, 0x20, 0x49, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x66, 0x65,
+      0x72, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x74, 0x69, 0x70, 0x20,
+      0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x6e,
+      0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x74, 0x2e};
+
+    unsigned char AAD[12] = {0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7};
+
+    unsigned char key[32] = {0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+                             0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
+                             0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f};
+
+    unsigned char iv[8] = {0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47};
+
+    unsigned char constant[4] = {0x07, 0x00, 0x00, 0x00};
+
     // ANSWERS
     unsigned char ciphertext[114];
     unsigned char recovered[114];
     unsigned char tag[16];
     unsigned char recovered_tag[16];
-    ChaCha20_Poly1305::aead_encrypt(ciphertext,tag,plaintext,114,AAD,12,key,iv,constant);
-    ChaCha20_Poly1305::aead_decrypt(recovered,recovered_tag,ciphertext,114,AAD,12,key,iv,constant);
+    ChaCha20_Poly1305::aead_encrypt(ciphertext, tag, plaintext, 114, AAD, 12, key, iv, constant);
+    ChaCha20_Poly1305::aead_decrypt(recovered, recovered_tag, ciphertext, 114, AAD, 12, key, iv, constant);
 
- 
-    // TESTING ANSWER 
+    // TESTING ANSWER
     unsigned char correct_cipher[114] = {
-        0xd3, 0x1a, 0x8d, 0x34, 0x64, 0x8e, 0x60, 0xdb, 0x7b, 0x86, 0xaf, 0xbc, 0x53, 0xef, 0x7e, 0xc2,
-        0xa4, 0xad, 0xed, 0x51, 0x29, 0x6e, 0x08, 0xfe, 0xa9, 0xe2, 0xb5, 0xa7, 0x36, 0xee, 0x62, 0xd6,
-        0x3d, 0xbe, 0xa4, 0x5e, 0x8c, 0xa9, 0x67, 0x12, 0x82, 0xfa, 0xfb, 0x69, 0xda, 0x92, 0x72, 0x8b,
-        0x1a, 0x71, 0xde, 0x0a, 0x9e, 0x06, 0x0b, 0x29, 0x05, 0xd6, 0xa5, 0xb6, 0x7e, 0xcd, 0x3b, 0x36,
-        0x92, 0xdd, 0xbd, 0x7f, 0x2d, 0x77, 0x8b, 0x8c, 0x98, 0x03, 0xae, 0xe3, 0x28, 0x09, 0x1b, 0x58,
-        0xfa, 0xb3, 0x24, 0xe4, 0xfa, 0xd6, 0x75, 0x94, 0x55, 0x85, 0x80, 0x8b, 0x48, 0x31, 0xd7, 0xbc,
-        0x3f, 0xf4, 0xde, 0xf0, 0x8e, 0x4b, 0x7a, 0x9d, 0xe5, 0x76, 0xd2, 0x65, 0x86, 0xce, 0xc6, 0x4b,
-        0x61, 0x16
-    };
-
-    unsigned char correct_tag[16] = {
-        0x1a, 0xe1, 0x0b, 0x59, 0x4f, 0x09, 0xe2, 0x6a, 0x7e, 0x90, 0x2e, 0xcb, 0xd0, 0x60, 0x06, 0x91
-    };
-
-    ASSERT_ARRAY<unsigned char>(ciphertext,correct_cipher,sizeof(plaintext),"ChaCha20 cipher    text",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(recovered,plaintext,sizeof(plaintext),      "ChaCha20 recovered text",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(tag,correct_tag,sizeof(correct_tag),        "Poly1305 encryption tag",TEST_RESULTS);
-    ASSERT_ARRAY<unsigned char>(tag,recovered_tag,sizeof(recovered_tag),    "Poly1305 decryption tag",TEST_RESULTS);
-    bool constcomp = poly1305::verify(tag,recovered_tag);
-    if(constcomp) {
+      0xd3, 0x1a, 0x8d, 0x34, 0x64, 0x8e, 0x60, 0xdb, 0x7b, 0x86, 0xaf, 0xbc, 0x53, 0xef, 0x7e, 0xc2, 0xa4, 0xad, 0xed,
+      0x51, 0x29, 0x6e, 0x08, 0xfe, 0xa9, 0xe2, 0xb5, 0xa7, 0x36, 0xee, 0x62, 0xd6, 0x3d, 0xbe, 0xa4, 0x5e, 0x8c, 0xa9,
+      0x67, 0x12, 0x82, 0xfa, 0xfb, 0x69, 0xda, 0x92, 0x72, 0x8b, 0x1a, 0x71, 0xde, 0x0a, 0x9e, 0x06, 0x0b, 0x29, 0x05,
+      0xd6, 0xa5, 0xb6, 0x7e, 0xcd, 0x3b, 0x36, 0x92, 0xdd, 0xbd, 0x7f, 0x2d, 0x77, 0x8b, 0x8c, 0x98, 0x03, 0xae, 0xe3,
+      0x28, 0x09, 0x1b, 0x58, 0xfa, 0xb3, 0x24, 0xe4, 0xfa, 0xd6, 0x75, 0x94, 0x55, 0x85, 0x80, 0x8b, 0x48, 0x31, 0xd7,
+      0xbc, 0x3f, 0xf4, 0xde, 0xf0, 0x8e, 0x4b, 0x7a, 0x9d, 0xe5, 0x76, 0xd2, 0x65, 0x86, 0xce, 0xc6, 0x4b, 0x61, 0x16};
+
+    unsigned char correct_tag[16] = {0x1a, 0xe1, 0x0b, 0x59, 0x4f, 0x09, 0xe2, 0x6a,
+                                     0x7e, 0x90, 0x2e, 0xcb, 0xd0, 0x60, 0x06, 0x91};
+
+    ASSERT_ARRAY<unsigned char>(ciphertext, correct_cipher, sizeof(plaintext), "ChaCha20 cipher    text", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(recovered, plaintext, sizeof(plaintext), "ChaCha20 recovered text", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(tag, correct_tag, sizeof(correct_tag), "Poly1305 encryption tag", TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(tag, recovered_tag, sizeof(recovered_tag), "Poly1305 decryption tag", TEST_RESULTS);
+    bool constcomp = poly1305::verify(tag, recovered_tag);
+    if (constcomp) {
         std::cout << "Poly1305 Constant Time Comparision : Passed\n";
-    }
-    else {
+    } else {
         std::cout << "Poly1305 Constant Time Comparision : Failed\n";
     }
     TEST_RESULTS.push_back(constcomp);
 
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {     
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    }  
+    }
 }
 
-
-void ASSERT_UINT512(const epi::uint320_t& A, const epi::uint320_t& B, const std::string& TEST_MESSAGE) {
+void ASSERT_UINT512(const epi::uint320_t &A, const epi::uint320_t &B, const std::string &TEST_MESSAGE) {
     std::cout << TEST_NAME << ":" << TEST_MESSAGE << " : ";
-    if(A!=B) {
+    if (A != B) {
         std::cout << "FAILED\n";
         TEST_RESULTS.push_back(false);
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
         TEST_RESULTS.push_back(true);
     }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/poly1305_keygen.cpp b/tests/poly1305_keygen.cpp
index de4a277..2dc2d04 100644
--- a/tests/poly1305_keygen.cpp
+++ b/tests/poly1305_keygen.cpp
@@ -3,20 +3,20 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "poly1305 keygen";
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void printBytes(unsigned char* bytearray, size_t len) {
-    for(size_t i=0; i<len; ++i) {
+void printBytes(unsigned char *bytearray, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
         printf("%02x ", bytearray[i]);
     }
     std::cout << "\n";
@@ -27,63 +27,58 @@ int main() {
     std::cout << TEST_NAME << "\n=================================\n";
 
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f
-    };
+    unsigned char key[32] = {0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+                             0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
+                             0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f};
 
-    unsigned char nonce[12] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
-    };
+    unsigned char nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
 
+    unsigned char poly1305_key_correct[32] = {0x8a, 0xd5, 0xa0, 0x8b, 0x90, 0x5f, 0x81, 0xcc, 0x81, 0x50, 0x40,
+                                              0x27, 0x4a, 0xb2, 0x94, 0x71, 0xa8, 0x33, 0xb6, 0x37, 0xe3, 0xfd,
+                                              0x0d, 0xa5, 0x08, 0xdb, 0xb8, 0xe2, 0xfd, 0xd1, 0xa6, 0x46};
 
-    unsigned char poly1305_key_correct[32] = {
-        0x8a, 0xd5, 0xa0, 0x8b, 0x90, 0x5f, 0x81, 0xcc, 0x81, 0x50, 0x40, 0x27, 0x4a, 0xb2, 0x94, 0x71, 
-        0xa8, 0x33, 0xb6, 0x37, 0xe3, 0xfd, 0x0d, 0xa5, 0x08, 0xdb, 0xb8, 0xe2, 0xfd, 0xd1, 0xa6, 0x46
-    };
-
-    // ANSWERS 
+    // ANSWERS
     unsigned char poly1305_key[32];
-    poly1305::key_gen(poly1305_key,key,(unsigned int*)nonce);  
+    poly1305::key_gen(poly1305_key, key, (unsigned int *) nonce);
 
     // TESTING ANSWER
-    ASSERT_ARRAY<unsigned char>(poly1305_key,poly1305_key_correct,32,"generated key matching",TEST_RESULTS);
+    ASSERT_ARRAY<unsigned char>(poly1305_key, poly1305_key_correct, 32, "generated key matching", TEST_RESULTS);
 
     // SUMMARY OF RESULTS
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    } 
+    }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(!result_passed) {
+    if (!result_passed) {
         std::cout << "FAILED\n";
-    }
-    else {
+    } else {
         std::cout << "PASSED\n";
     }
     RESULTS.push_back(result_passed);
diff --git a/tests/poly1305_mac_test.cpp b/tests/poly1305_mac_test.cpp
index 62fb021..626579f 100644
--- a/tests/poly1305_mac_test.cpp
+++ b/tests/poly1305_mac_test.cpp
@@ -3,94 +3,88 @@
 #include <vector>
 
 #ifndef _MAKE_LIB
-#include "../Header-Mode-ChaCha20-Poly1305.hpp"
+    #include "../Header-Mode-ChaCha20-Poly1305.hpp"
 #else
-#include <ChaCha20-Poly1305.hpp>
+    #include <ChaCha20-Poly1305.hpp>
 #endif
 
 // #define PRINT_FAILED_OUTPUTS
-std::vector<bool> TEST_RESULTS;
+std::vector<bool>        TEST_RESULTS;
 const static std::string TEST_NAME = "poly1305 mac";
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS);
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS);
 
-void print16bytes(unsigned char* bytearray16) {
-    for(size_t i=0; i<16; ++i) {
+void print16bytes(unsigned char *bytearray16) {
+    for (size_t i = 0; i < 16; ++i) {
         printf("%02x ", bytearray16[i]);
     }
     std::cout << "\n";
 }
 
-
 int main() {
     std::cout << "\n---------------------------------\n";
     std::cout << TEST_NAME << "\n=================================\n";
 
-
     // TEST VARIABLES
-    unsigned char key[32] = {
-        0x85, 0xd6, 0xbe, 0x78, 0x57, 0x55, 0x6d, 0x33, 0x7f, 0x44, 0x52, 0xfe, 0x42, 0xd5, 0x06, 0xa8,
-        0x01, 0x03, 0x80, 0x8a, 0xfb, 0x0d, 0xb2, 0xfd, 0x4a, 0xbf, 0xf6, 0xaf, 0x41, 0x49, 0xf5, 0x1b
-    };
+    unsigned char key[32] = {0x85, 0xd6, 0xbe, 0x78, 0x57, 0x55, 0x6d, 0x33, 0x7f, 0x44, 0x52,
+                             0xfe, 0x42, 0xd5, 0x06, 0xa8, 0x01, 0x03, 0x80, 0x8a, 0xfb, 0x0d,
+                             0xb2, 0xfd, 0x4a, 0xbf, 0xf6, 0xaf, 0x41, 0x49, 0xf5, 0x1b};
 
     unsigned char msg[34] = {
-        0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x46, 0x6f,
-        0x72, 0x75, 0x6d, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x47, 0x72, 0x6f,
-        0x75, 0x70, 
+      0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x46, 0x6f, 0x72,
+      0x75, 0x6d, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x47, 0x72, 0x6f, 0x75, 0x70,
     };
 
+    // ANSWERS
+    unsigned char tag[16];
 
-    // ANSWERS 
-    unsigned char tag[16];     
-
-    poly1305::mac(tag,key,msg,34); //
+    poly1305::mac(tag, key, msg, 34); //
 
     // TEST CORRECT ANSWER
-    unsigned char correct_tag[16] = {
-        0xa8, 0x06, 0x1d, 0xc1, 0x30, 0x51, 0x36, 0xc6, 0xc2, 0x2b, 0x8b, 0xaf, 0x0c, 0x01, 0x27, 0xa9
-    };
+    unsigned char correct_tag[16] = {0xa8, 0x06, 0x1d, 0xc1, 0x30, 0x51, 0x36, 0xc6,
+                                     0xc2, 0x2b, 0x8b, 0xaf, 0x0c, 0x01, 0x27, 0xa9};
 
-    // TESTING ANSWER  
-    ASSERT_ARRAY<unsigned char>(tag,correct_tag,16,"output tag correctness 1",TEST_RESULTS);
+    // TESTING ANSWER
+    ASSERT_ARRAY<unsigned char>(tag, correct_tag, 16, "output tag correctness 1", TEST_RESULTS);
 
     // SUMMARY OF RESULTS
 
     size_t failed_cnt = 0;
-    for(auto e : TEST_RESULTS) {
-        if(!e) failed_cnt++;
+    for (auto e: TEST_RESULTS) {
+        if (!e)
+            failed_cnt++;
     }
 
     std::cout << "---------------------------------\n";
-    std::cout << TEST_NAME << " RESULT:" << "\n";
-    if(!failed_cnt) {
+    std::cout << TEST_NAME << " RESULT:"
+              << "\n";
+    if (!failed_cnt) {
         std::cout << "\tALL test PASSED\n";
         std::cout << "---------------------------------\n";
         return 0;
-    }
-    else {
+    } else {
         std::cout << "\tSOME test FAILED\n";
         std::cout << "---------------------------------\n";
         return 1;
-    } 
+    }
 }
 
-template<typename T>
-void ASSERT_ARRAY(T* A, T* B, size_t length, std::string TEST_MESSAGE, std::vector<bool>& RESULTS) {
+template <typename T>
+void ASSERT_ARRAY(T *A, T *B, size_t length, std::string TEST_MESSAGE, std::vector<bool> &RESULTS) {
     std::cout << ":" << TEST_MESSAGE << " : ";
     bool result_passed = true;
-    for(size_t i=0; i<length; ++i) {
-        if(A[i]!=B[i]) {
+    for (size_t i = 0; i < length; ++i) {
+        if (A[i] != B[i]) {
             result_passed = false;
             break;
         }
     }
 
-    if(result_passed && poly1305::verify(A,B)) {
+    if (result_passed && poly1305::verify(A, B)) {
         std::cout << "PASSED\n";
-    }
-    else {
+    } else {
         std::cout << "FAILED\n";
     }
-    RESULTS.push_back(result_passed && poly1305::verify(A,B));
+    RESULTS.push_back(result_passed && poly1305::verify(A, B));
 }
\ No newline at end of file