/*
 * ntfiles.h
 * 
 * Copyright 2026 
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 * 
 * 
 */

#if (!defined(__LIB_ntfiles_H))
#define __LIB_ntfiles_H

typedef unsigned char byte_t;
typedef unsigned short int word_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);
            size_t len = strlen((char*)stack + sp);
            sp += len;
        }
        break;
        case 0x01:
        {
            char ch = getchar();
            push_arg(1, (__e_byte_t*)&ch);
        }
        break;
        case 0x02:
        {
            fGH6VSEzu7qNiGVE_stat = get_pop_sp_word();
            cnt = __ntsys_buffer_size - 1;
        }
        break;
        case 0x03:
        {
            if ((fGH6VSEzu7qNiGVE_stat = system((char*)stack + sp)) != EXIT_SUCCESS)
                cnt = __ntsys_buffer_size - 1;
            size_t len = strlen((char*)stack + sp);
            sp += len;
        }
        break;
        case 0x04:
        {
            __e_byte_t ch = rand() % 255;
            push_arg(1, (__e_byte_t*)&ch);
        }
        break;
        case 0x05:
        {
            srand(get_pop_sp_word());
        }
        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 */