diff --git a/Hash/MeowHash.h b/Hash/MeowHash.h
index 7177acc..bbb9504 100644
--- a/Hash/MeowHash.h
+++ b/Hash/MeowHash.h
@@ -117,56 +117,53 @@
 
 namespace Hash {
     namespace Meow {
-        #if !defined(MEOW_HASH_X64_AESNI_H)
-
         #define MEOW_HASH_VERSION 5
         #define MEOW_HASH_VERSION_NAME "0.5/calico"
 
         #if !defined(meow_u8)
+            #if _MSC_VER
+                #if !defined(__clang__)
+                    #define INSTRUCTION_REORDER_BARRIER _ReadWriteBarrier()
+                #else
+                #endif
 
-        #if _MSC_VER
-        #if !defined(__clang__)
-        #define INSTRUCTION_REORDER_BARRIER _ReadWriteBarrier()
-        #else
-        #endif
-        #include <intrin.h>
-        #else
-        #include <x86intrin.h>
-        #endif
+                #include <intrin.h>
+            #else
+                #include <x86intrin.h>
+            #endif
 
-        #define meow_u8 char unsigned
-        #define meow_u64 long long unsigned
-        #define meow_u128 __m128i
+            #define meow_u8 char unsigned
+            #define meow_u64 long long unsigned
+            #define meow_u128 __m128i
 
-        #if __x86_64__ || _M_AMD64
-        #define meow_umm long long unsigned
-        #define MeowU64From(A, I) (_mm_extract_epi64((A), (I)))
-        #elif __i386__  || _M_IX86
-        #define meow_umm int unsigned
-        #define MeowU64From(A, I) (*(meow_u64 *)&(A))
-        #else
-        #error Cannot determine architecture to use!
-        #endif
+            #if __x86_64__ || _M_AMD64
+                #define meow_umm long long unsigned
+                #define MeowU64From(A, I) (_mm_extract_epi64((A), (I)))
+            #elif __i386__  || _M_IX86
+                #define meow_umm int unsigned
+                #define MeowU64From(A, I) (*(meow_u64 *)&(A))
+            #else
+                #error Cannot determine architecture to use!
+            #endif
 
-        #define MeowU32From(A, I) (_mm_extract_epi32((A), (I)))
-        #define MeowHashesAreEqual(A, B) (_mm_movemask_epi8(_mm_cmpeq_epi8((A), (B))) == 0xFFFF)
+            #define MeowU32From(A, I) (_mm_extract_epi32((A), (I)))
+            #define MeowHashesAreEqual(A, B) (_mm_movemask_epi8(_mm_cmpeq_epi8((A), (B))) == 0xFFFF)
 
-        #if !defined INSTRUCTION_REORDER_BARRIER
-        #define INSTRUCTION_REORDER_BARRIER
-        #endif
+            #if !defined INSTRUCTION_REORDER_BARRIER
+                #define INSTRUCTION_REORDER_BARRIER
+            #endif
 
-        #if !defined MEOW_PAGESIZE
-        #define MEOW_PAGESIZE 4096
-        #endif
+            #if !defined MEOW_PAGESIZE
+                #define MEOW_PAGESIZE 4096
+            #endif
 
-        #if !defined MEOW_PREFETCH
-        #define MEOW_PREFETCH 4096
-        #endif
-
-        #if !defined MEOW_PREFETCH_LIMIT
-        #define MEOW_PREFETCH_LIMIT 0x3ff
-        #endif
+            #if !defined MEOW_PREFETCH
+                #define MEOW_PREFETCH 4096
+            #endif
 
+            #if !defined MEOW_PREFETCH_LIMIT
+                #define MEOW_PREFETCH_LIMIT 0x3ff
+            #endif
         #endif
 
         #define prefetcht0(A) _mm_prefetch((char *)(A), _MM_HINT_T0)
@@ -182,52 +179,52 @@ namespace Hash {
         #define pxor_clear(A, B)    A = _mm_setzero_si128(); // NOTE(casey): pxor_clear is a nonsense thing that is only here because compilers don't detect xor(a, a) is clearing a :(
 
         #define MEOW_MIX_REG(r1, r2, r3, r4, r5,  i1, i2, i3, i4) \
-        aesdec(r1, r2); \
-        INSTRUCTION_REORDER_BARRIER; \
-        paddq(r3, i1); \
-        pxor(r2, i2); \
-        aesdec(r2, r4); \
-        INSTRUCTION_REORDER_BARRIER; \
-        paddq(r5, i3); \
-        pxor(r4, i4);
+            aesdec(r1, r2); \
+            INSTRUCTION_REORDER_BARRIER; \
+            paddq(r3, i1); \
+            pxor(r2, i2); \
+            aesdec(r2, r4); \
+            INSTRUCTION_REORDER_BARRIER; \
+            paddq(r5, i3); \
+            pxor(r4, i4);
 
         #define MEOW_MIX(r1, r2, r3, r4, r5,  ptr) \
-        MEOW_MIX_REG(r1, r2, r3, r4, r5, _mm_loadu_si128( (__m128i *) ((ptr) + 15) ), _mm_loadu_si128( (__m128i *) ((ptr) + 0)  ), _mm_loadu_si128( (__m128i *) ((ptr) + 1)  ), _mm_loadu_si128( (__m128i *) ((ptr) + 16) ))
+            MEOW_MIX_REG(r1, r2, r3, r4, r5, _mm_loadu_si128( (__m128i *) ((ptr) + 15) ), _mm_loadu_si128( (__m128i *) ((ptr) + 0)  ), _mm_loadu_si128( (__m128i *) ((ptr) + 1)  ), _mm_loadu_si128( (__m128i *) ((ptr) + 16) ))
 
         #define MEOW_SHUFFLE(r1, r2, r3, r4, r5, r6) \
-        aesdec(r1, r4); \
-        paddq(r2, r5); \
-        pxor(r4, r6); \
-        aesdec(r4, r2); \
-        paddq(r5, r6); \
-        pxor(r2, r3)
+            aesdec(r1, r4); \
+            paddq(r2, r5); \
+            pxor(r4, r6); \
+            aesdec(r4, r2); \
+            paddq(r5, r6); \
+            pxor(r2, r3)
 
         #if MEOW_DUMP
-        struct meow_dump
-        {
-            meow_u128 xmm[8];
-            void *Ptr;
-            char const *Title;
-        };
-        extern "C" meow_dump *MeowDumpTo;
-        meow_dump *MeowDumpTo;
-        #define MEOW_DUMP_STATE(T, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, ptr) \
-        if(MeowDumpTo) \
-        { \
-            MeowDumpTo->xmm[0] = xmm0; \
-            MeowDumpTo->xmm[1] = xmm1; \
-            MeowDumpTo->xmm[2] = xmm2; \
-            MeowDumpTo->xmm[3] = xmm3; \
-            MeowDumpTo->xmm[4] = xmm4; \
-            MeowDumpTo->xmm[5] = xmm5; \
-            MeowDumpTo->xmm[6] = xmm6; \
-            MeowDumpTo->xmm[7] = xmm7; \
-            MeowDumpTo->Ptr = ptr; \
-            MeowDumpTo->Title = T; \
-            ++MeowDumpTo; \
-        }
+            struct meow_dump
+            {
+                meow_u128 xmm[8];
+                void *Ptr;
+                char const *Title;
+            };
+            extern "C" meow_dump *MeowDumpTo;
+            meow_dump *MeowDumpTo;
+            #define MEOW_DUMP_STATE(T, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, ptr) \
+            if(MeowDumpTo) \
+            { \
+                MeowDumpTo->xmm[0] = xmm0; \
+                MeowDumpTo->xmm[1] = xmm1; \
+                MeowDumpTo->xmm[2] = xmm2; \
+                MeowDumpTo->xmm[3] = xmm3; \
+                MeowDumpTo->xmm[4] = xmm4; \
+                MeowDumpTo->xmm[5] = xmm5; \
+                MeowDumpTo->xmm[6] = xmm6; \
+                MeowDumpTo->xmm[7] = xmm7; \
+                MeowDumpTo->Ptr = ptr; \
+                MeowDumpTo->Title = T; \
+                ++MeowDumpTo; \
+            }
         #else
-        #define MEOW_DUMP_STATE(...)
+            #define MEOW_DUMP_STATE(...)
         #endif
 
         static meow_u8 MeowShiftAdjust[32] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
@@ -742,9 +739,6 @@ namespace Hash {
             }
             MeowEnd(&State, SeedResult);
         }
-
-        #define MEOW_HASH_X64_AESNI_H
-        #endif
     }
 }
 #endif
\ No newline at end of file
diff --git a/Utils/ArrayUtils.h b/Utils/ArrayUtils.h
index e8f21cf..2104366 100644
--- a/Utils/ArrayUtils.h
+++ b/Utils/ArrayUtils.h
@@ -17,38 +17,34 @@
 #include "StringUtils.h"
 
 namespace Utils {
-    class ArrayUtils {
-        private:
-
-        public:
-            static inline
-            char* get_arg(const char *id, char **argv, int length)
-            {
-                if (Utils::StringUtils::is_number(id)) {
-                    return argv[atoi(id)];
-                }
-
-                for (int i = 0; i < length - 1; ++i) {
-                    if (strcmp(id, argv[i]) == 0) {
-                        return argv[i + 1];
-                    }
-                }
-
-                return NULL;
+    namespace ArrayUtils {
+        inline
+        char* get_arg(const char *id, char **argv, int length)
+        {
+            if (Utils::StringUtils::is_number(id)) {
+                return argv[atoi(id)];
             }
 
-            static inline
-            bool has_arg(const char *id, char **argv, int length)
-            {
-                for (int i = 0; i < length; ++i) {
-                    if (strcmp(id, argv[i]) == 0) {
-                        return true;
-                    }
+            for (int i = 0; i < length - 1; ++i) {
+                if (strcmp(id, argv[i]) == 0) {
+                    return argv[i + 1];
                 }
-
-                return false;
             }
-    };
+
+            return NULL;
+        }
+
+        inline
+        bool has_arg(const char *id, char **argv, int length)
+        {
+            for (int i = 0; i < length; ++i) {
+                if (strcmp(id, argv[i]) == 0) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
 }
 
 #endif
\ No newline at end of file
diff --git a/Utils/FileUtils.h b/Utils/FileUtils.h
index a9e4823..38a4011 100644
--- a/Utils/FileUtils.h
+++ b/Utils/FileUtils.h
@@ -28,95 +28,91 @@
 #endif
 
 namespace Utils {
-    class FileUtils {
-        private:
-
-        public:
-            static inline
-            bool file_exists (char *filename)
-            {
-                #ifdef _WIN32
-                    #ifdef _MSC_VER
-                        return _access_s(filename, 0) == 0;
-                    #else
-                        return access(filename, 0) == 0;
-                    #endif
-                #elif defined __linux__
-                    struct stat buffer;
-                    return stat(filename, &buffer) == 0;
+    namespace FileUtils {
+        inline
+        bool file_exists (char *filename)
+        {
+            #ifdef _WIN32
+                #ifdef _MSC_VER
+                    return _access_s(filename, 0) == 0;
+                #else
+                    return access(filename, 0) == 0;
                 #endif
-            }
+            #elif defined __linux__
+                struct stat buffer;
+                return stat(filename, &buffer) == 0;
+            #endif
+        }
 
-            static inline
-            time_t last_modification (char *filename)
-            {
-                #ifdef _WIN32
-                    FILETIME modtime;
-                    HANDLE h;
+        inline
+        time_t last_modification (char *filename)
+        {
+            #ifdef _WIN32
+                FILETIME modtime;
+                HANDLE h;
 
-                    h = CreateFileW(filename, GENERIC_READ | FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 0, NULL);
-                    if (h == INVALID_HANDLE_VALUE) {
-                        return (time_t) 0;
-                    }
-
-                    if (GetFileTime(h, NULL, NULL, &modtime) == 0) {
-                        return (time_t) 0;
-                    }
-
-                    unsinged long long seconds = modtime.dwHighDateTime << 32;
-                    seconds |= modtime.dwLowDateTime;
-
-                    return (seconds - 116444736000000000) / 10000000;
-                #elif defined __linux__
-                    struct stat buffer;
-                    stat(filename, &buffer);
-
-                    (time_t) buffer.st_mtim.tv_sec;
-                #endif
-            }
-
-            char* file_extension (char *filename)
-            {
-                char *dot = strrchr(filename, '.');
-
-                if (!dot || dot == filename) {
-                    return "";
+                h = CreateFileW(filename, GENERIC_READ | FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 0, NULL);
+                if (h == INVALID_HANDLE_VALUE) {
+                    return (time_t) 0;
                 }
 
-                return dot + 1;
-            }
-
-            typedef struct {
-                char *content;
-                int size;
-            } file_body;
-
-            static inline
-            file_body read_file (char *filename)
-            {
-                file_body file = {0};
-
-                FILE *fp = fopen(filename, "rb");
-                if (!fp) {
-                    return NULL;
+                if (GetFileTime(h, NULL, NULL, &modtime) == 0) {
+                    return (time_t) 0;
                 }
 
-                fseek(fp, 0, SEEK_END);
-                file.size = ftell(fp);
-                fseek(fp, 0, SEEK_SET);
+                unsinged long long seconds = modtime.dwHighDateTime << 32;
+                seconds |= modtime.dwLowDateTime;
 
-                file.content = malloc(file.size);
-                if (!file.content) {
-                    fprintf(stderr, "CRITICAL: malloc failed");
-                }
+                return (seconds - 116444736000000000) / 10000000;
+            #elif defined __linux__
+                struct stat buffer;
+                stat(filename, &buffer);
 
-                fread(file.content, file.size, 1, fp);
+                (time_t) buffer.st_mtim.tv_sec;
+            #endif
+        }
 
-                fclose(fp);
+        char* file_extension (char *filename)
+        {
+            char *dot = strrchr(filename, '.');
 
-                return file;
+            if (!dot || dot == filename) {
+                return "";
             }
-    };
+
+            return dot + 1;
+        }
+
+        typedef struct {
+            char *content;
+            int size;
+        } file_body;
+
+        inline
+        file_body read_file (char *filename)
+        {
+            file_body file = {0};
+
+            FILE *fp = fopen(filename, "rb");
+            if (!fp) {
+                return NULL;
+            }
+
+            fseek(fp, 0, SEEK_END);
+            file.size = ftell(fp);
+            fseek(fp, 0, SEEK_SET);
+
+            file.content = malloc(file.size);
+            if (!file.content) {
+                fprintf(stderr, "CRITICAL: malloc failed");
+            }
+
+            fread(file.content, file.size, 1, fp);
+
+            fclose(fp);
+
+            return file;
+        }
 }
 
 #endif
\ No newline at end of file
diff --git a/Utils/StringUtils.h b/Utils/StringUtils.h
index 768cd6d..2fed42d 100644
--- a/Utils/StringUtils.h
+++ b/Utils/StringUtils.h
@@ -17,130 +17,125 @@
 #include "ArraySort.h"
 
 namespace Utils {
-    class StringUtils {
-        private:
-
-        public:
-            static inline
-            bool is_number(const char *s)
-            {
-                while (*s != '\0') {
-                    if (!isdigit(*s)) {
-                        return false;
-                    }
-
-                    ++s;
+    namespace StringUtils {
+        inline
+        bool is_number(const char *s)
+        {
+            while (*s != '\0') {
+                if (!isdigit(*s)) {
+                    return false;
                 }
 
-                return true;
+                ++s;
             }
 
-            typedef struct {
-                char **values;
-                int *masks;
-                int size;
-            } text_diff;
+            return true;
+        }
 
-            static
-            text_diff computeLCSDiff (char **from, int fromSize, char **to, int toSize)
-            {
-                char **diffValues = malloc(fromSize * toSize * sizeof(char *));
-                int *diffMasks    = calloc(fromSize * toSize,  sizeof(int));
+        typedef struct {
+            char **values;
+            int *masks;
+            int size;
+        } text_diff;
 
-                int *dm = calloc((fromSize + 1) * (toSize + 1), sizeof(int));
+        text_diff computeLCSDiff (char **from, int fromSize, char **to, int toSize)
+        {
+            char **diffValues = malloc(fromSize * toSize * sizeof(char *));
+            int *diffMasks    = calloc(fromSize * toSize,  sizeof(int));
 
-                if (!diffValues || !diffMasks || !dm) {
-                    fprintf(stderr, "CRITICAL: malloc failed");
+            int *dm = calloc((fromSize + 1) * (toSize + 1), sizeof(int));
+
+            if (!diffValues || !diffMasks || !dm) {
+                fprintf(stderr, "CRITICAL: malloc failed");
+            }
+
+            int i = 0;
+            int j = 0;
+
+            /* Handled with calloc
+            for (j = 0; j <= toSize; ++j) {
+                dm[0 + j] = 0;
+            }
+
+            for (i = 1; i <= fromSize; ++i) {
+                dm[i * fromSize + 0] = 0;
+            }
+            */
+
+            for (i = 1; i <= fromSize; ++i) {
+                for (j = 1; j <= toSize; ++j) {
+                    dm[i * fromSize + j] = strcmp(from[i - 1], to[j - 1]) == 0
+                        ? dm[(i - 1) * fromSize + (j - 1)] + 1
+                        : oms_max(dm[(i - 1) * fromSize + j], dm[i * fromSize + (j - 1)]);
                 }
+            }
 
-                int i = 0;
-                int j = 0;
+            int diffIndex = 0;
 
-                /* Handled with calloc
-                for (j = 0; j <= toSize; ++j) {
-                    dm[0 + j] = 0;
-                }
+            i = fromSize;
+            j = toSize;
 
-                for (i = 1; i <= fromSize; ++i) {
-                    dm[i * fromSize + 0] = 0;
-                }
-                */
-
-                for (i = 1; i <= fromSize; ++i) {
-                    for (j = 1; j <= toSize; ++j) {
-                        dm[i * fromSize + j] = strcmp(from[i - 1], to[j - 1]) == 0
-                            ? dm[(i - 1) * fromSize + (j - 1)] + 1
-                            : oms_max(dm[(i - 1) * fromSize + j], dm[i * fromSize + (j - 1)]);
-                    }
-                }
-
-                int diffIndex = 0;
-
-                i = fromSize;
-                j = toSize;
-
-                while (i > 0 || j > 0) {
-                    if (j > 0 && dm[i * fromSize + (j - 1)] == dm[i * fromSize + j]) {
-                        diffValues[diffIndex] = malloc((strlen(to[j - 1]) + 1) * sizeof(char));
-                        if (!diffValues[diffIndex]) {
-                            fprintf(stderr, "CRITICAL: malloc failed");
-                        }
-
-                        strcpy(diffValues[diffIndex], to[j - 1]);
-                        diffMasks[diffIndex] = 1;
-
-                        --j;
-                        ++diffIndex;
-
-                        continue;
+            while (i > 0 || j > 0) {
+                if (j > 0 && dm[i * fromSize + (j - 1)] == dm[i * fromSize + j]) {
+                    diffValues[diffIndex] = malloc((strlen(to[j - 1]) + 1) * sizeof(char));
+                    if (!diffValues[diffIndex]) {
+                        fprintf(stderr, "CRITICAL: malloc failed");
                     }
 
-                    if (i > 0 && dm[(i - 1) * fromSize + j] == dm[i * fromSize + j]) {
-                        diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char));
-                        if (!diffValues[diffIndex]) {
-                            fprintf(stderr, "CRITICAL: malloc failed");
-                        }
+                    strcpy(diffValues[diffIndex], to[j - 1]);
+                    diffMasks[diffIndex] = 1;
 
-                        strcpy(diffValues[diffIndex], from[i - 1]);
-                        diffMasks[diffIndex] = -1;
+                    --j;
+                    ++diffIndex;
 
-                        --i;
-                        ++diffIndex;
-
-                        continue
-                    }
+                    continue;
+                }
 
+                if (i > 0 && dm[(i - 1) * fromSize + j] == dm[i * fromSize + j]) {
                     diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char));
                     if (!diffValues[diffIndex]) {
                         fprintf(stderr, "CRITICAL: malloc failed");
                     }
 
                     strcpy(diffValues[diffIndex], from[i - 1]);
-
-                    /* Handled with calloc
-                    diffMasks[diffIndex] = 0;
-                    */
+                    diffMasks[diffIndex] = -1;
 
                     --i;
-                    --j;
                     ++diffIndex;
+
+                    continue
                 }
 
-                free(dm);
-
-                diffValues = realloc(diffValues, diffIndex * sizeof(char *));
-                diffMasks  = realloc(diffMasks, diffIndex * sizeof(int));
-
-                if (!diffValues || !diffMasks) {
+                diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char));
+                if (!diffValues[diffIndex]) {
                     fprintf(stderr, "CRITICAL: malloc failed");
                 }
 
-                ArraySort::reverse_char(diffValues, diffIndex);
-                ArraySort::reverse_int(diffMasks, diffIndex);
+                strcpy(diffValues[diffIndex], from[i - 1]);
 
-                return text_diff { diffValues, diffMasks, diffIndex  };
+                /* Handled with calloc
+                diffMasks[diffIndex] = 0;
+                */
+
+                --i;
+                --j;
+                ++diffIndex;
             }
-    };
+
+            free(dm);
+
+            diffValues = realloc(diffValues, diffIndex * sizeof(char *));
+            diffMasks  = realloc(diffMasks, diffIndex * sizeof(int));
+
+            if (!diffValues || !diffMasks) {
+                fprintf(stderr, "CRITICAL: malloc failed");
+            }
+
+            ArraySort::reverse_char(diffValues, diffIndex);
+            ArraySort::reverse_int(diffMasks, diffIndex);
+
+            return text_diff { diffValues, diffMasks, diffIndex  };
+        }
 }
 
 #endif
\ No newline at end of file