diff --git a/dump.bin b/dump.bin
new file mode 100644
index 0000000..0d2b7c6
Binary files /dev/null and b/dump.bin differ
diff --git a/example.exe b/example.exe
index bfad7a8..472b765 100644
Binary files a/example.exe and b/example.exe differ
diff --git a/ntfiles.h b/ntfiles.h
index 9dffbe6..6fea630 100644
--- a/ntfiles.h
+++ b/ntfiles.h
@@ -24,12 +24,616 @@
 #if (!defined(__LIB_ntfiles_H))
 #define __LIB_ntfiles_H
 
-typedef unsigned char __e_byte_t;
+typedef unsigned char byte_t;
+typedef unsigned short int word_t;
 
-typedef struct {
-    __e_byte_t e_magic[3];
-    __e_byte_t e_filesize[4];
-    __e_byte_t e_memorysize[2]; 
-} __e_image_header_t; 
+#if defined(__LP64__) || defined(_M_IA64)
+typedef unsigned int dword_t;
+typedef unsigned long int qword_t;
+#else
+typedef unsigned long int dword_t;
+typedef unsigned long long int qword_t;
+#endif
+
+typedef signed char sbyte_t;
+typedef signed short int sword_t;
+
+#if defined(__LP64__) || defined(_M_IA64)
+typedef signed int sdword_t;
+typedef signed long int sqword_t;
+#else
+typedef signed long int sdword_t;
+typedef signed long long int sqword_t;
+#endif
+
+#define stack __ntsys_stack
+#define sp __ntsys_stack_pointer
+#define buf __ntsys_buffer
+#define cnt __ntsys_buffer_ptr
+#define ip __ntsys_buffer_ptr
+
+static void push(void) {
+    size_t size = buf[cnt];
+    sp -= size;
+    size_t t = 0;
+    while (t < size) {
+        stack[sp + t] = buf[++cnt];
+        t ++;
+    }
+    cnt ++;
+}
+
+static void pop(void) {
+    sp += buf[cnt++];
+}
+
+static void push_str(void) {
+    size_t size = 0;
+    while (buf[cnt] != 0) { 
+        size ++; 
+        cnt ++;
+    } 
+    size ++;
+    cnt -= size;
+    sp -= size;
+    size_t t = 0;
+    while (t < size) {
+        stack[sp + t] = buf[++cnt];
+        t ++;
+    }
+    cnt ++;
+}
+
+__e_byte_t arg1_fGH6VSEzu7qNiGVE[8];
+__e_byte_t arg2_fGH6VSEzu7qNiGVE[8];
+
+#define arg1 arg1_fGH6VSEzu7qNiGVE
+#define arg2 arg2_fGH6VSEzu7qNiGVE
+
+static void pop_arg(size_t size, __e_byte_t* arg) {
+    int __i = 1; 
+    if (!(*((char *)&__i) == 1)) {
+        /* BIG ENDIAN */
+        size_t i = 0;
+        while (i < size) {
+            arg[size - i - 1] = stack[sp + i];
+            i ++;
+        }
+        sp += size;
+    } else {
+        /* LITTLE ENDIAN */
+        size_t i = 0;
+        while (i < size) {
+            arg[i] = stack[sp + i];
+            i ++;
+        }
+        sp += size;
+    }
+}
+
+static void nt_not() {
+    size_t size = buf[cnt++];
+    pop_arg(size, arg1);
+    sp -= size;
+    size_t i = 0;
+    while (i < size) {
+        stack[sp + i] = ~arg1[i];
+        i ++;
+    }
+}
+
+static void operation(__e_byte_t op) {
+    size_t size = buf[cnt++];
+    pop_arg(size & 0x0F, arg1);
+    pop_arg(size & 0x0F, arg2);
+    switch (op) {
+        case 1:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 + *(byte_t*)arg2;
+            break;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 + *(word_t*)arg2;
+            break;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 + *(dword_t*)arg2;
+            break;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 + *(qword_t*)arg2;
+            break;
+            case 0xF1:
+            *(sbyte_t*)arg1 = *(sbyte_t*)arg1 + *(sbyte_t*)arg2;
+            break;
+            case 0xF2:
+            *(sword_t*)arg1 = *(sword_t*)arg1 + *(sword_t*)arg2;
+            break;
+            case 0xF4:
+            *(sdword_t*)arg1 = *(sdword_t*)arg1 + *(sdword_t*)arg2;
+            break;
+            case 0xF8:
+            *(sqword_t*)arg1 = *(sqword_t*)arg1 + *(sqword_t*)arg2;
+            break;
+        }
+        break;
+        case 2:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 - *(byte_t*)arg2;
+            break;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 - *(word_t*)arg2;
+            break;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 - *(dword_t*)arg2;
+            break;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 - *(qword_t*)arg2;
+            break;
+            case 0xF1:
+            *(sbyte_t*)arg1 = *(sbyte_t*)arg1 - *(sbyte_t*)arg2;
+            break;
+            case 0xF2:
+            *(sword_t*)arg1 = *(sword_t*)arg1 - *(sword_t*)arg2;
+            break;
+            case 0xF4:
+            *(sdword_t*)arg1 = *(sdword_t*)arg1 - *(sdword_t*)arg2;
+            break;
+            case 0xF8:
+            *(sqword_t*)arg1 = *(sqword_t*)arg1 - *(sqword_t*)arg2;
+            break;
+        }
+        break;
+        case 3:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0xF1:
+            *(sbyte_t*)arg1 = *(sbyte_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0xF2:
+            *(sword_t*)arg1 = *(sword_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0xF4:
+            *(sdword_t*)arg1 = *(sdword_t*)arg1 * (*(byte_t*)arg2);
+            break;
+            case 0xF8:
+            *(sqword_t*)arg1 = *(sqword_t*)arg1 * (*(byte_t*)arg2);
+            break;
+        }
+        break;
+        case 4:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 / *(byte_t*)arg2;
+            break;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 / *(word_t*)arg2;
+            break;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 / *(dword_t*)arg2;
+            break;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 / *(qword_t*)arg2;
+            break;
+            case 0xF1:
+            *(sbyte_t*)arg1 = *(sbyte_t*)arg1 / *(sbyte_t*)arg2;
+            break;
+            case 0xF2:
+            *(sword_t*)arg1 = *(sword_t*)arg1 / *(sword_t*)arg2;
+            break;
+            case 0xF4:
+            *(sdword_t*)arg1 = *(sdword_t*)arg1 / *(sdword_t*)arg2;
+            break;
+            case 0xF8:
+            *(sqword_t*)arg1 = *(sqword_t*)arg1 / *(sqword_t*)arg2;
+            break;
+        }
+        break;
+    }
+    sp -= size & 0x0F;
+    size_t i = 0;
+    while (i < (size  & 0x0F)) {
+        stack[sp + i] = arg1[i];
+        i ++;
+    }
+}
+
+static void add(void) {
+    operation(1);
+}
+
+static void sub(void) {
+    operation(2);
+}
+
+static void mul(void) {
+    operation(3);
+}
+
+static void div_r(void) {
+    operation(4);
+}
+
+static void logic_operation(__e_byte_t n) {
+    size_t size = buf[cnt++];
+    pop_arg(size, arg1);
+    pop_arg(size, arg2);
+    switch (n) {
+        case 1:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 >> *(byte_t*)arg2;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 >> *(word_t*)arg2;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 >> *(dword_t*)arg2;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 >> *(qword_t*)arg2;
+        }
+        break;
+        case 2:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 << *(byte_t*)arg2;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 << *(word_t*)arg2;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 << *(dword_t*)arg2;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 << *(qword_t*)arg2;
+        }
+        break;
+        case 3:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 | *(byte_t*)arg2;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 | *(word_t*)arg2;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 | *(dword_t*)arg2;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 | *(qword_t*)arg2;
+        }
+        break;
+        case 4:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 & *(byte_t*)arg2;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 & *(word_t*)arg2;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 & *(dword_t*)arg2;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 & *(qword_t*)arg2;
+        }
+        break;
+        case 5:
+        switch (size) {
+            case 0x01:
+            *(byte_t*)arg1 = *(byte_t*)arg1 ^ *(byte_t*)arg2;
+            case 0x02:
+            *(word_t*)arg1 = *(word_t*)arg1 ^ *(word_t*)arg2;
+            case 0x04:
+            *(dword_t*)arg1 = *(dword_t*)arg1 ^ *(dword_t*)arg2;
+            case 0x08:
+            *(qword_t*)arg1 = *(qword_t*)arg1 ^ *(qword_t*)arg2;
+        }
+        break;
+    }
+    sp -= size;
+    size_t i = 0;
+    while (i < size) {
+        stack[sp + i] = arg1[i];
+        i ++;
+    }
+}
+
+static void nt_shr(void) {
+    logic_operation(1);
+}
+
+static void nt_shl(void) {
+    logic_operation(2);
+}
+
+static void nt_or(void) {
+    logic_operation(3);
+}
+
+static void nt_and(void) {
+    logic_operation(4);
+}
+
+static void nt_xor(void) {
+    logic_operation(5);
+}
+
+static void nt_goto(void) {
+    pop_arg(2, arg1);
+    cnt = *(word_t*)arg1;
+}
+
+static void bez_bnez(__e_byte_t mode) {
+    size_t size = buf[cnt++];
+    pop_arg(size & 0x0F, arg1);
+    __e_byte_t res = 0;
+    switch (size) {
+        case 0x01:
+        if (*(byte_t*)arg1 == 0) res = 1;
+        break;
+        case 0x02:
+        if (*(word_t*)arg1 == 0) res = 1;
+        break;
+        case 0x04:
+        if (*(dword_t*)arg1 == 0) res = 1;
+        break;
+        case 0x08:
+        if (*(qword_t*)arg1 == 0) res = 1;
+        break;
+        case 0xF1:
+        if (*(sbyte_t*)arg1 == 0) res = 1;
+        break;
+        case 0xF2:
+        if (*(sword_t*)arg1 == 0) res = 1;
+        break;
+        case 0xF4:
+        if (*(sdword_t*)arg1 == 0) res = 1;
+        break;
+        case 0xF8:
+        if (*(sqword_t*)arg1 == 0) res = 1;
+        break;
+    }
+    if (mode) res = !res;
+    pop_arg(2, arg2);
+    if (res) {
+        cnt = *(word_t*)arg2;
+    }
+}
+
+static void push_arg(size_t size, __e_byte_t* arg) {
+    sp -= size;
+    size_t i = 0;
+    while (i < size) {
+        stack[sp + i] = arg[i];
+        i ++;
+    }
+}
+
+static void n_up_down_eq(__e_byte_t mode) {
+    size_t size = buf[cnt++];
+    pop_arg(size & 0x0F, arg1);
+    pop_arg(size & 0x0F, arg2);
+    __e_byte_t res = 0;
+    switch (mode & 0x0F) {
+        case 0:
+        switch (size) {
+            case 0x01:
+            if (*(byte_t*)arg1 == *(byte_t*)arg2) res = 1;
+            break;
+            case 0x02:
+            if (*(word_t*)arg1 == *(word_t*)arg2) res = 1;
+            break;
+            case 0x04:
+            if (*(dword_t*)arg1 == *(dword_t*)arg2) res = 1;
+            break;
+            case 0x08:
+            if (*(qword_t*)arg1 == *(qword_t*)arg2) res = 1;
+            break;
+            case 0xF1:
+            if (*(qword_t*)arg1 == *(qword_t*)arg2) res = 1;
+            break;
+            case 0xF2:
+            if (*(sword_t*)arg1 == *(sword_t*)arg2) res = 1;
+            break;
+            case 0xF4:
+            if (*(sdword_t*)arg1 == *(sdword_t*)arg2) res = 1;
+            break;
+            case 0xF8:
+            if (*(sqword_t*)arg1 == *(sqword_t*)arg2) res = 1;
+            break;
+        }
+        break;
+        case 1:
+        switch (size) {
+            case 0x01:
+            if (*(byte_t*)arg1 > *(byte_t*)arg2) res = 1;
+            break;
+            case 0x02:
+            if (*(word_t*)arg1 > *(word_t*)arg2) res = 1;
+            break;
+            case 0x04:
+            if (*(dword_t*)arg1 > *(dword_t*)arg2) res = 1;
+            break;
+            case 0x08:
+            if (*(qword_t*)arg1 > *(qword_t*)arg2) res = 1;
+            break;
+            case 0xF1:
+            if (*(qword_t*)arg1 > *(qword_t*)arg2) res = 1;
+            break;
+            case 0xF2:
+            if (*(sword_t*)arg1 > *(sword_t*)arg2) res = 1;
+            break;
+            case 0xF4:
+            if (*(sdword_t*)arg1 > *(sdword_t*)arg2) res = 1;
+            break;
+            case 0xF8:
+            if (*(sqword_t*)arg1 > *(sqword_t*)arg2) res = 1;
+            break;
+        }
+        break;
+        case 2:
+        switch (size) {
+            case 0x01:
+            if (*(byte_t*)arg1 < *(byte_t*)arg2) res = 1;
+            break;
+            case 0x02:
+            if (*(word_t*)arg1 < *(word_t*)arg2) res = 1;
+            break;
+            case 0x04:
+            if (*(dword_t*)arg1 < *(dword_t*)arg2) res = 1;
+            break;
+            case 0x08:
+            if (*(qword_t*)arg1 < *(qword_t*)arg2) res = 1;
+            break;
+            case 0xF1:
+            if (*(qword_t*)arg1 < *(qword_t*)arg2) res = 1;
+            break;
+            case 0xF2:
+            if (*(sword_t*)arg1 < *(sword_t*)arg2) res = 1;
+            break;
+            case 0xF4:
+            if (*(sdword_t*)arg1 < *(sdword_t*)arg2) res = 1;
+            break;
+            case 0xF8:
+            if (*(sqword_t*)arg1 < *(sqword_t*)arg2) res = 1;
+            break;
+        }
+        break;
+    }
+    if ((mode & 0xF0) == 0xF0) res = !res;
+    pop_arg(2, arg2);
+    if (res) {
+        cnt = *(word_t*)arg2;
+    }
+}
+
+static void eq(void) {
+    n_up_down_eq(0x00);
+}
+
+static void neq(void) {
+    n_up_down_eq(0xF0);
+}
+
+static void up(void) {
+    n_up_down_eq(0x01);
+}
+
+static void down(void) {
+    n_up_down_eq(0x02);
+}
+
+static void upne(void) {
+    n_up_down_eq(0xF1);
+}
+
+static void downe(void) {
+    n_up_down_eq(0xF2);
+}
+
+static void bnez(void) {
+    bez_bnez(1);
+}
+
+static void bez(void) {
+    bez_bnez(0);
+}
+
+static void mwrt(void) {
+    size_t size = buf[cnt++];
+    pop_arg(2, arg1);
+    pop_arg(size, arg2);
+    word_t pos = *(word_t*)arg1;
+    size_t i = 0;
+    while (i < size) {
+        stack[i + pos] = arg2[i];
+        i ++;
+    }
+}
+
+static void mrd(void) {
+    size_t size = buf[cnt++];
+    pop_arg(2, arg1);
+    word_t pos = *(word_t*)arg1;
+    sp -= size;
+    size_t i = 0;
+    while (i < size) {
+        stack[sp + i] = stack[pos + i];
+        i ++;
+    }
+}
+
+static void get_sp(void) {
+    push_arg(2, (__e_byte_t*)&sp);
+}
+
+static void set_sp(void) {
+    pop_arg(2, arg1);
+    sp = *(word_t*)arg1;
+}
+
+static word_t get_pop_sp_word(void) {
+    pop_arg(2, arg1);
+    return *(word_t*)arg1;
+}
+
+static byte_t get_pop_sp_byte(void) {
+    pop_arg(1, arg1);
+    return *(byte_t*)arg1;
+}
+
+static void nt_fs_syscall(void) {
+    switch (get_pop_sp_byte()) {
+        case 0x00:
+        {
+            fputs((char*)stack + sp, stdout);
+        }
+        break;
+        case 0x01:
+        {
+            char ch = getchar();
+            pop_arg(1, (__e_byte_t*)&ch);
+        }
+        break;
+        case 0x02:
+        {
+            fGH6VSEzu7qNiGVE_stat = get_pop_sp_word();
+            cnt = __ntsys_buffer_size - 1;
+        }
+        break;
+    }
+}
+
+void (*fn_fGH6VSEzu7qNiGVE[])(void) = {
+    /* Операции со стеком (0 - 2) */
+    push, pop, push_str,
+    /* Арифметические операции (3 - 6) */
+    add, sub, mul, div_r,
+    /* Логические операции (7 - 12) */
+    nt_not, nt_shr, nt_shl, nt_or,
+    nt_and, nt_xor,
+    /* Переход (13) */
+    nt_goto,
+    /* Условия (14 - 21) */
+    bnez, bez,
+    up, down,
+    eq, neq,
+    upne, downe,
+    /* Работа с памятью (22 - 23) */
+    mwrt, mrd,
+    /* Адресация на стеке (24 - 25) */
+    get_sp, set_sp,
+    /* Системные вызовы (26) */
+    nt_fs_syscall
+};
+
+#undef stack
+#undef sp
+#undef buf
+#undef cnt
+#undef ip
+
+#undef arg1
+#undef arg2
 
 #endif /* __LIB_ntfiles_H */
\ No newline at end of file
diff --git a/ntsys b/ntsys
index 73d2a05..5d750c5 100755
Binary files a/ntsys and b/ntsys differ
diff --git a/ntsys.h b/ntsys.h
index 6e76e9b..f992757 100644
--- a/ntsys.h
+++ b/ntsys.h
@@ -33,7 +33,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "ntfiles.h"
+
+typedef unsigned char __e_byte_t;
+
+typedef struct {
+    __e_byte_t e_magic[3];
+    __e_byte_t e_filesize[4];
+    __e_byte_t e_memorysize[2]; 
+} __e_image_header_t; 
 
 #if (!defined(EXIT_SUCCESS)) 
 #define EXIT_SUCCESS 0
@@ -43,6 +50,16 @@
 #define EXIT_FAILURE 1
 #endif
 
+__e_byte_t* __ntsys_stack = NULL;
+unsigned int __ntsys_stack_pointer = 0;
+__e_byte_t* __ntsys_buffer = NULL;
+size_t __ntsys_buffer_size = 0;
+unsigned int __ntsys_buffer_ptr = 0;
+int fGH6VSEzu7qNiGVE_stat = EXIT_SUCCESS;
+
+
+#include "ntfiles.h"
+
 static void ntsys_error(char* _err) {
     printf("\033[1mntsys: \033[91m%s\033[0m\n", _err);
 }
@@ -61,15 +78,52 @@ static void __help(void) {
         "    " "--help / -h    - show this help"            "\n"
         "    " "--version / -v - show version"              "\n"
         "    " "--asm / -a     - compile assembler program" "\n"
-        "    " "--out / -o     - set output file name"      "\0"
+        "    " "--out / -o     - set output file name"      "\n"
+        "    " "--debug / -d   - display debugging info"    "\0"
     );
 }
-
-static int __exe_run(__e_byte_t* memory, unsigned int memorysize, unsigned long filesize, FILE* fp) {
+static int __exe_run(__e_byte_t* memory, unsigned int memorysize, unsigned long filesize, FILE* fp, __e_byte_t debug) {
+    __ntsys_stack_pointer = memorysize;
+    __ntsys_stack = memory;
+    __e_byte_t* buff = malloc(filesize - 8);
+    __ntsys_buffer = buff;
+    __ntsys_buffer_size = fread(buff, 1, filesize - 8, fp);
+    __ntsys_buffer_ptr = 0;
+    if (!debug) {
+        while (__ntsys_buffer_ptr < __ntsys_buffer_size) {
+            __e_byte_t cmd = buff[__ntsys_buffer_ptr];
+            __ntsys_buffer_ptr ++;
+            fn_fGH6VSEzu7qNiGVE[cmd]();
+        }
+    } else {
+        putchar('\n');
+        while (__ntsys_buffer_ptr < __ntsys_buffer_size) {
+            __e_byte_t cmd = buff[__ntsys_buffer_ptr];
+            fprintf(stdout, "Command       %d 0x%X\n"
+            "Position      %d 0x%X\n"
+            "Stack point   %d 0x%X\n\n"
+            , cmd, cmd, 
+            __ntsys_buffer_ptr, __ntsys_buffer_ptr,
+            __ntsys_stack_pointer, __ntsys_stack_pointer);
+            __ntsys_buffer_ptr ++;
+            fn_fGH6VSEzu7qNiGVE[cmd]();
+            FILE* df = fopen("dump.bin", "wb");
+            if (df == NULL) {
+                ntsys_error("Cannot open dump file!");
+                return EXIT_FAILURE;
+            }
+            fwrite(__ntsys_stack, 1, memorysize, df);
+            fclose(df);
+            puts("Press any key to continue...");
+            getchar();
+        }
+    }
+    free(buff);
+    if (fGH6VSEzu7qNiGVE_stat != EXIT_SUCCESS) return fGH6VSEzu7qNiGVE_stat;
     return EXIT_SUCCESS;
 }
 
-int ntsys_api_call(char* filename) {
+int ntsys_api_call(char* filename, unsigned char debug) {
 
     /* File data */
 
@@ -78,7 +132,7 @@ int ntsys_api_call(char* filename) {
 
     /* Parser */
 
-    FILE* fp = fopen(filename, "r");
+    FILE* fp = fopen(filename, "rb");
     if (fp == NULL) {
         ntsys_error("Cannot open file!");
         return EXIT_FAILURE;
@@ -89,8 +143,8 @@ int ntsys_api_call(char* filename) {
     head.e_magic[2] = (__e_byte_t)0;
     int __i = 1;  
     size_t i = 0;
-    if (*((char *)&__i) == 1) {
-        /* LITTLE ENDIAN */
+    if (!(*((char *)&__i) == 1)) {
+        /* BIG ENDIAN */
         head.e_memorysize[0] = head_bin[7];
         head.e_memorysize[1] = head_bin[6];
         i = 3;
@@ -100,7 +154,7 @@ int ntsys_api_call(char* filename) {
             i --;
         }
     } else {
-        /* BIG ENDIAN */
+        /* LITTLE ENDIAN */
         head.e_memorysize[0] = head_bin[6];
         head.e_memorysize[1] = head_bin[7];
         while (i != 4) {
@@ -114,15 +168,26 @@ int ntsys_api_call(char* filename) {
         return EXIT_FAILURE;
     }
     unsigned long int filesize = 0;
+    if (sizeof(dword_t) != 4 || sizeof(qword_t) != 8 || sizeof(word_t) != 2) goto __exit_datatype_error;
     switch (4) {
         case sizeof(NAME_OF_64_BITS_TYPE): filesize = *((NAME_OF_64_BITS_TYPE*)head.e_filesize); break;
         case sizeof(NAME_OF_32_BITS_TYPE): filesize = *((NAME_OF_32_BITS_TYPE*)head.e_filesize); break;
         default:
+        __exit_datatype_error:
         ntsys_error("Unknown data type! You must recompile the program and specify a different type.");
         return EXIT_FAILURE;
     }
+    unsigned int mem_size = (unsigned int)*((NAME_OF_16_BITS_TYPE*)head.e_memorysize);
     __e_byte_t* memory = malloc(*((NAME_OF_16_BITS_TYPE*)head.e_memorysize));
-    int stat = __exe_run(memory, (unsigned int)*((NAME_OF_16_BITS_TYPE*)head.e_memorysize), filesize, fp);
+    if (memory == NULL) {
+        ntsys_error("Out of memory!");
+        return EXIT_FAILURE;
+    }
+    if (debug) {
+        printf("File size     %lu 0x%lX\n", filesize, filesize);
+        printf("Memory size   %u 0x%X\n", mem_size, mem_size);
+    }
+    int stat = __exe_run(memory, mem_size, filesize, fp, debug);
     fclose(fp);
     free(memory);
     return stat;
@@ -138,12 +203,16 @@ int _lib_ntsys_main(int argc, char** argv) {
     char* asm_out = "out.exe";
     char mode = 'R';
     unsigned char out = 0;
+    unsigned char debug = 0;
     while (t < argc) {
         char* str = argv[t];
         if (str[0] == '-') {
             unsigned char f = 0;
             if (str[1] == '-') f = 1;
             switch (str[1 + f]) {
+                case 'd':
+                debug = 1;
+                break;
                 case 'h':
                 __help();
                 return EXIT_SUCCESS;
@@ -175,7 +244,7 @@ int _lib_ntsys_main(int argc, char** argv) {
         ntsys_error("Please specify the file name!");
         return EXIT_FAILURE;
     }
-    if (mode == 'R') return ntsys_api_call(filename);
+    if (mode == 'R') return ntsys_api_call(filename, debug);
     return ntsys_compile_asm(filename, asm_out);
 }
 
diff --git a/test/arifmetic_operation_test.exe b/test/arifmetic_operation_test.exe
new file mode 100644
index 0000000..fca6417
Binary files /dev/null and b/test/arifmetic_operation_test.exe differ
diff --git a/test/goto_operator_test.exe b/test/goto_operator_test.exe
new file mode 100644
index 0000000..d2598e0
Binary files /dev/null and b/test/goto_operator_test.exe differ
diff --git a/test/if_goto_operation_test.exe b/test/if_goto_operation_test.exe
new file mode 100644
index 0000000..c737428
Binary files /dev/null and b/test/if_goto_operation_test.exe differ
diff --git a/test/logic_operation_test.exe b/test/logic_operation_test.exe
new file mode 100644
index 0000000..d11c6b6
Binary files /dev/null and b/test/logic_operation_test.exe differ
diff --git a/test/memory_read_write_test.exe b/test/memory_read_write_test.exe
new file mode 100644
index 0000000..11a5e68
Binary files /dev/null and b/test/memory_read_write_test.exe differ
diff --git a/test/syscall_test.exe b/test/syscall_test.exe
new file mode 100644
index 0000000..d84fa40
Binary files /dev/null and b/test/syscall_test.exe differ