#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <math.h>
#include <float.h>

#define ALLOC(x) malloc(x)
#define FREE(x) free(x)

typedef unsigned int uint;

char eszycidpyopu(unsigned char value, int high)
{
    char wymiltmlrn[17] = "0123456789ABCDEF";
    unsigned char v;

    if (high)
    {
        v = value & 0xf0;
        v >>= 4;
    }
    else
        v = value & 0x0f;
    return (wymiltmlrn[v]);
}

int mzgdpamntyya(char c)
{
    if (c >= '0' && c <= '9')
        return (1);
    return (0);
}

int woixzhsdkaaa(char c)
{
    if (c == ' ' || c == '\t' || c == ',' || c == '(' || c == ')')
        return (1);
    return (0);
}

char *uramvgnxaqhy(char *src)
{
    while (*src && woixzhsdkaaa(*src))
        src++;
    return (src);
}

char *oprhlhvhyoja(char *src)
{
    while (*src && !woixzhsdkaaa(*src))
        src++;
    return (src);
}

char *nrudfuxjdxkx(char *buf, char *src, uint maxlen)
{
    uint i;

    i = 0;
    if (!src)
        return (NULL);
    src = uramvgnxaqhy(src);
    if (!*src)
        return (NULL);
    while (*src && !woixzhsdkaaa(*src) && *src != '#' && *src != '\n' && *src != '\r')
    {
        *buf = *src;
        src++;
        buf++;
        i++;
        if (i == maxlen)
            break;
    }
    *buf = '\0';
    return (src);
}

void wqnqvgjjspqm(uint **dst, uint size, uint src)
{
    char *hsreltpusc;

    if (!dst)
        return;
    
    hsreltpusc = ALLOC(size + 4);
    if (!hsreltpusc) return;
    if (*dst)
    {
        
        memcpy(hsreltpusc, *dst, size);
        FREE(*dst);
    }
    else
    {
        
        if (size > 0)
            memset(hsreltpusc, 0, size);
    }
    *((uint *)&hsreltpusc[size]) = src;
    *dst = (uint *)hsreltpusc;
}

void sbphxzmnvflr(char **dst, uint size, char src)
{
    char *hsreltpusc;

    if (!dst) return;
    hsreltpusc = ALLOC(size + 1);
    if (!hsreltpusc) return;
    if (*dst)
    {
        memcpy(hsreltpusc, *dst, size);
        FREE(*dst);
    }
    else
    {
        if (size > 0) memset(hsreltpusc, 0, size);
    }
    hsreltpusc[size] = src;
    *dst = hsreltpusc;
}

void wyvxlcovqdyf(char **dst, uint size, short src)
{
    char *hsreltpusc;

    if (!dst) return;
    hsreltpusc = ALLOC(size + 2);
    if (!hsreltpusc) return;
    if (*dst)
    {
        memcpy(hsreltpusc, *dst, size);
        FREE(*dst);
    }
    else
    {
        if (size > 0) memset(hsreltpusc, 0, size);
    }
    *((short *)&hsreltpusc[size]) = src;
    *dst = hsreltpusc;
}

void qmlpxapbjwts(char **dst, uint size, char *src, uint sbvaliuojs)
{
    char *hsreltpusc;

    if (!dst) return;
    hsreltpusc = ALLOC(size + sbvaliuojs);
    if (!hsreltpusc) return;
    if (*dst)
        memcpy(hsreltpusc, *dst, size);
    else if (size > 0)
        memset(hsreltpusc, 0, size);
    memcpy(hsreltpusc + size, src, sbvaliuojs);
    if (*dst) FREE(*dst);
    *dst = hsreltpusc;
}


char* smuffqhaygrr(char* wjsjzcbysq, uint sbvaliuojs, char* key, uint keylen) {
    
    char* result = (char*)ALLOC(sbvaliuojs + 1); 

    if (result == NULL) {
        return NULL; 
    }

    
    for (size_t i = 0; i < sbvaliuojs; i++) {
        result[i] = wjsjzcbysq[i] ^ key[i % keylen]; 
    }
    result[sbvaliuojs] = '\0'; 

    return result;
}

char            *hmqlsloivrtx(char *dst, char *src)
{
    
    
    
    
    size_t aitvwfwkrs, vmfakdadvp;
    char *ihzdbqgkzs;

    if (!src)
        return dst;
    vmfakdadvp = strlen(src);
    if (!dst)
    {
        ihzdbqgkzs = ALLOC(vmfakdadvp + 1);
        if (!ihzdbqgkzs)
            return NULL;
        memcpy(ihzdbqgkzs, src, vmfakdadvp);
        ihzdbqgkzs[vmfakdadvp] = '\0';
        return ihzdbqgkzs;
    }
    aitvwfwkrs = strlen(dst);
    ihzdbqgkzs = ALLOC(aitvwfwkrs + vmfakdadvp + 1);
    if (!ihzdbqgkzs)
        return NULL;
    memcpy(ihzdbqgkzs, dst, aitvwfwkrs);
    memcpy(ihzdbqgkzs + aitvwfwkrs, src, vmfakdadvp);
    ihzdbqgkzs[aitvwfwkrs + vmfakdadvp] = '\0';
    FREE(dst);
    return ihzdbqgkzs;
}

int amzxqzeqyrgn(char c)
{
    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
        return (1);
    return (0);
}

int bplsrgqnplnl(const char *wjsjzcbysq)
{
    int result = 0; 
    int pehymbqcsd = 1;   
    int i = 0;      

    
    while (woixzhsdkaaa(wjsjzcbysq[i]) || amzxqzeqyrgn(wjsjzcbysq[i])) {
        i++;
    }

    
    if (wjsjzcbysq[i] == '-' || wjsjzcbysq[i] == '+') {
        if (wjsjzcbysq[i] == '-') {
            pehymbqcsd = -1; 
        }
        i++; 
    }

    
    while (wjsjzcbysq[i] >= '0' && wjsjzcbysq[i] <= '9') {
        result = result * 10 + (wjsjzcbysq[i] - '0'); 
        i++;
    }

    return pehymbqcsd * result; 
}

char* arrtztkotazh(int value, char* wjsjzcbysq, int tapirhgwpr) {
    int i = 0;
    int olvltwixpa = 0;

    
    if (value == 0) {
        wjsjzcbysq[i++] = '0';
        wjsjzcbysq[i] = '\0';
        return wjsjzcbysq;
    }

    
    if (value < 0 && tapirhgwpr == 10) {
        olvltwixpa = 1;
        value = -value;
    }

    
    while (value != 0) {
        int blupywknwn = value % tapirhgwpr;
        wjsjzcbysq[i++] = (blupywknwn > 9) ? (blupywknwn - 10) + 'a' : blupywknwn + '0';
        value = value / tapirhgwpr;
    }

    
    if (olvltwixpa) {
        wjsjzcbysq[i++] = '-';
    }

    wjsjzcbysq[i] = '\0'; 

    
    for (int j = 0; j < i / 2; j++) {
        char temp = wjsjzcbysq[j];
        wjsjzcbysq[j] = wjsjzcbysq[i - j - 1];
        wjsjzcbysq[i - j - 1] = temp;
    }

    return wjsjzcbysq;
}

int ttl = 10000000;
#define MAX_SYMBOL 2048
#define MEMORY_SIZE 0xffff
int assemble_rotation_enabled = 0;
int instruction_rotation = 0;
char flag[] = "MT{This_is_the_flag_redacted}";
#define NUM_REGISTERS 32
int x[NUM_REGISTERS];
float f[NUM_REGISTERS];
int pc = 0;
char ozfckxugso[MEMORY_SIZE];
char *program_output;
uint program_output_length;


int offset_bootloader;

#define BOOTLOADER_SIZE 32
char bootloader[BOOTLOADER_SIZE] = {
    0x72, 0x65, 0x64, 0x61, 0x63, 0x74, 0x65, 0x64,
    0x72, 0x65, 0x64, 0x61, 0x63, 0x74, 0x65, 0x64,
    0x72, 0x65, 0x64, 0x61, 0x63, 0x74, 0x65, 0x64,
    0x72, 0x65, 0x64, 0x61, 0x63, 0x74, 0x65, 0x64
};

#define OUTPUT_MAX (BOOTLOADER_SIZE * 2)

#define OP_VALUES_COUNT 20
int op_values[OP_VALUES_COUNT] = {
    0b01101, 
    0b00101, 
    0b00100, 
    0b01100, 
    0b00011, 
    0b11100, 
    0b00000, 
    0b01000, 
    0b11011, 
    0b11001, 
    0b11000, 
    0b10000, 
    0b10001, 
    0b10010, 
    0b10011, 
    0b10100, 
    0b00001, 
    0b01001  
};

void ufrsfczrzibv(char byte)
{
    char *tmp;

    if (program_output_length >= OUTPUT_MAX)
        return;
    if (program_output_length == 0 || !program_output)
    {
        
        tmp = ALLOC(2);
        if (!tmp) return;
        tmp[0] = byte;
        tmp[1] = '\0';
        
        if (program_output)
            FREE(program_output);
        program_output = tmp;
        program_output_length = 1;
        return;
    }
    tmp = ALLOC(program_output_length + 2);
    if (!tmp) return;
    memcpy(tmp, program_output, program_output_length);
    tmp[program_output_length] = byte;
    tmp[program_output_length + 1] = '\0';
    FREE(program_output);
    program_output = tmp;
    program_output_length++;
}

int ccaoayyihidz(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    x[tuzrmuzbtn] = (dzhbbzwqgn & 0xfffff000);
    pc += 4;
    return (0);
}

int tfljcffiqfvi(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    x[tuzrmuzbtn] = (dzhbbzwqgn & 0xfffff000) + pc;
    pc += 4;
    return (0);
}

int uwjowkppdajm(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int value;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    value = ((dzhbbzwqgn & 0xfff00000) >> 20);
    int ysvqvpeume = value & 0x800;
    if (ysvqvpeume != 0)
        value += 0xfffff000;
    x[tuzrmuzbtn] = x[oahgriwscz] + value;
    pc += 4;
    return (0);
}

int knzgidixqgtn(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int value;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    value = (dzhbbzwqgn & 0xfff00000) >> 20;
    int ysvqvpeume = value & 0x800;
    if (ysvqvpeume != 0)
        value += 0xfffff000;
    if (x[oahgriwscz] < value)
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int ahamebxfowqv(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    if ((uint)x[oahgriwscz] < (uint)((dzhbbzwqgn & 0xfff00000) >> 20))
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int nrhuzwqohqua(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int value;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    value = (dzhbbzwqgn & 0xfff00000) >> 20;
    int ysvqvpeume = value & 0x800;
    if (ysvqvpeume != 0)
        value += 0xfffff000;
    x[tuzrmuzbtn] = x[oahgriwscz] ^ value;
    pc += 4;
    return (0);
}

int mvszkvunbxje(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int value;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    value = (dzhbbzwqgn & 0xfff00000) >> 20;
    int ysvqvpeume = value & 0x800;
    if (ysvqvpeume != 0)
        value += 0xfffff000;
    x[tuzrmuzbtn] = x[oahgriwscz] | value;
    pc += 4;
    return (0);
}

int gbjccjjxfnsi(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int value;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    value = (dzhbbzwqgn & 0xfff00000) >> 20;
    int ysvqvpeume = value & 0x800;
    if (ysvqvpeume != 0)
        value += 0xfffff000;
    x[tuzrmuzbtn] = x[oahgriwscz] & value;
    pc += 4;
    return (0);
}

int earbsgsofywt(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int dxksrdzswa;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    dxksrdzswa = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] << dxksrdzswa;
    pc += 4;
    return (0);
}

int qbmgldgsvnsg(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int dxksrdzswa;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    dxksrdzswa = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] >> dxksrdzswa;
    pc += 4;
    return (0);
}

int pdvmjqpaktmj(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int dxksrdzswa;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    dxksrdzswa = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] >> (int)dxksrdzswa;
    pc += 4;
    return (0);
}

int afgkzszekngi(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] + x[nhneaklrzi];
    pc += 4;
    return (0);
}

int vdmrlvrpyrhc(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] - x[nhneaklrzi];
    pc += 4;
    return (0);
}

int xbceffrgiykt(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] << x[nhneaklrzi];
    pc += 4;
    return (0);
}

int qilkkdjhtywp(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (x[oahgriwscz] < (int)x[nhneaklrzi])
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int esrydkbncmze(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (x[oahgriwscz] < (uint)x[nhneaklrzi])
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int ekdtszmcsrhs(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] ^ x[nhneaklrzi];
    pc += 4; 
    return (0);
}

int ciljsrdoidzb(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] >> (uint)(x[nhneaklrzi] & 0x1f);
    pc += 4; 
    return (0);
}

int jatvacndzbgh(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] >> (int)(x[nhneaklrzi] & 0x1f);
    pc += 4;
    return (0);
}

int zsnfdofvhfxd(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] | x[nhneaklrzi];
    pc += 4; 
    return (0);
}

int nmzrjriwpkdg(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] & x[nhneaklrzi];
    pc += 4; 
    return (0);
}

int ukbaazjxtkom(int dzhbbzwqgn) 
{
    int qwhdrxdrbr;
    int usmbyihitq;

    qwhdrxdrbr = (dzhbbzwqgn & 0xf00000) >> 20;
    usmbyihitq = (dzhbbzwqgn & 0x0f000000) >> 24;
    pc += 4;
    return (0);
}

int kmccktodigzt(int dzhbbzwqgn) 
{
    pc += 4;
    return (0);
}

char csr[0x0fff];

int yrwpvlifrgjg(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int mslrsnshkv;
    int t;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    mslrsnshkv = (dzhbbzwqgn & 0xfff00000) >> 20;
    if (tuzrmuzbtn != 0)
    {
        t = csr[mslrsnshkv];
        csr[mslrsnshkv] = x[oahgriwscz];
        x[tuzrmuzbtn] = t;
    }
    else
        csr[mslrsnshkv] = x[oahgriwscz];
    pc += 4; 
    return (0);
}

int hlcicyocusuk(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int mslrsnshkv;
    int t;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    mslrsnshkv = (dzhbbzwqgn & 0xfff00000) >> 20;
    t = csr[mslrsnshkv];
    csr[mslrsnshkv] = t | x[oahgriwscz];
    x[tuzrmuzbtn] = t;
    pc += 4;
    return (0);
}

int hmjbkfkzsjhk(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int mslrsnshkv;
    int t;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    mslrsnshkv = (dzhbbzwqgn & 0xfff00000) >> 20;
    t = csr[mslrsnshkv];
    csr[mslrsnshkv] = t & ~x[oahgriwscz];
    x[tuzrmuzbtn] = t;
    pc += 4;
    return (0);
}

int drtsztchhazh(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int wryjvwntss;
    int mslrsnshkv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    wryjvwntss = (dzhbbzwqgn & 0x0f8000) >> 15;
    mslrsnshkv = (dzhbbzwqgn & 0xfff00000) >> 20;
    x[tuzrmuzbtn] = csr[mslrsnshkv];
    csr[mslrsnshkv] = wryjvwntss;
    pc += 4;
    return (0);
}

int mcircxcauajy(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int wryjvwntss;
    int mslrsnshkv;
    int t;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    wryjvwntss = (dzhbbzwqgn & 0x0f8000) >> 15;
    mslrsnshkv = (dzhbbzwqgn & 0xfff00000) >> 20;
    t = csr[mslrsnshkv];
    csr[mslrsnshkv] = t | wryjvwntss;
    x[tuzrmuzbtn] = t;
    pc += 4;
    return (0);
}

int zlppedqyzkcq(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int mslrsnshkv;
    int t;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    mslrsnshkv = (dzhbbzwqgn & 0xfff00000) >> 20;
    t = csr[mslrsnshkv];
    csr[mslrsnshkv] = t & ~oahgriwscz;
    x[tuzrmuzbtn] = t;
    pc += 4;
    return (0);
}

int vffyeekjdwqt(int dzhbbzwqgn) 
{
    instruction_rotation++;
    pc += 4;
    return (0);
}

int jegerxbyktzv(int dzhbbzwqgn) 
{
    
    ufrsfczrzibv((char)x[10]);
    pc += 4;
    return (0);
}

int rxwgfjnrfbwv(int dzhbbzwqgn) 
{
    pc += 4;
    return (0);
}

int hiycvoznriro(int dzhbbzwqgn) 
{
    pc += 4;
    return (0);
}

int roamkfipazun(int dzhbbzwqgn) 
{
    pc += 4;
    return (0);
}

int sabwlseseeii(int dzhbbzwqgn) 
{
    pc += 4;
    return (0);
}

int msmftchpafqk(int dzhbbzwqgn) 
{
    pc += 4;
    return (0);
}

int quovuxhhkpvp(int dzhbbzwqgn)
{
    int tuzrmuzbtn, oahgriwscz, offset;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = (dzhbbzwqgn & 0xfff00000) >> 20;
    if (offset & 0x800)
        offset |= 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    char igjaipzmgf = ozfckxugso[x[oahgriwscz] + offset];
    x[tuzrmuzbtn] = (int)igjaipzmgf;  
    pc += 4;
    return (0);
}

int hwnkrtxuiuhb(int dzhbbzwqgn)
{
    int tuzrmuzbtn, oahgriwscz, offset;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = (dzhbbzwqgn & 0xfff00000) >> 20;
    if (offset & 0x800)
        offset |= 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    short igjaipzmgf = *(short *)&ozfckxugso[x[oahgriwscz] + offset];
    x[tuzrmuzbtn] = (int)igjaipzmgf;  
    pc += 4;
    return (0);
}

int cyqulfqyzgjj(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int offset;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = (dzhbbzwqgn & 0xfff00000) >> 20;
    int ysvqvpeume = offset & 0x800;
    if (ysvqvpeume != 0)
        offset += 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    x[tuzrmuzbtn] = *((int *)&ozfckxugso[x[oahgriwscz] + offset]);
    pc += 4;
    return (0);
}

int wjrlfwwxotcd(int dzhbbzwqgn)
{
    int tuzrmuzbtn, oahgriwscz, offset;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = (dzhbbzwqgn & 0xfff00000) >> 20;
    if (offset & 0x800)
        offset |= 0xfffff000;  
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    x[tuzrmuzbtn] = (unsigned char)ozfckxugso[x[oahgriwscz] + offset];  
    pc += 4;
    return (0);
}

int tqsmfeingsxy(int dzhbbzwqgn)
{
    int tuzrmuzbtn, oahgriwscz, offset;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = (dzhbbzwqgn & 0xfff00000) >> 20;
    if (offset & 0x800)
        offset |= 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    x[tuzrmuzbtn] = *(unsigned short *)&ozfckxugso[x[oahgriwscz] + offset];  
    pc += 4;
    return (0);
}

int zbpvmwulmqfr(int dzhbbzwqgn)
{
    int oahgriwscz, nhneaklrzi, offset;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    offset = ((dzhbbzwqgn & 0xfe000000) >> 20) | ((dzhbbzwqgn & 0x0f80) >> 7);
    if (offset & 0x800)
        offset |= 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    ozfckxugso[x[oahgriwscz] + offset] = (unsigned char)(x[nhneaklrzi] & 0xFF);  
    pc += 4;
    return (0);
}

int xbqcziudixce(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int jzmdyasvxe;
    int moqmutvrdt;
    int offset;

    jzmdyasvxe = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    moqmutvrdt = (dzhbbzwqgn & 0xfe000000) >> 25;
    offset = (moqmutvrdt << 5) + jzmdyasvxe;
    int ysvqvpeume = offset & 0x800;
    if (ysvqvpeume != 0)
        offset += 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    *((short *)&ozfckxugso[x[oahgriwscz] + offset]) = (short)x[nhneaklrzi];
    pc += 4;
    return (0);
}

int ytvvwcohmznm(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int jzmdyasvxe;
    int moqmutvrdt;
    int offset;

    jzmdyasvxe = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    moqmutvrdt = (dzhbbzwqgn & 0xfe000000) >> 25;
    offset = (moqmutvrdt << 5) + jzmdyasvxe;
    int ysvqvpeume = offset & 0x800;
    if (ysvqvpeume != 0)
        offset += 0xfffff000;
    if (x[oahgriwscz] + offset >= MEMORY_SIZE || x[oahgriwscz] + offset < 0)
        return (1);
    *((int *)&ozfckxugso[x[oahgriwscz] + offset]) = (int)x[nhneaklrzi];
    pc += 4;
    return (0);
}
int fkoetpgdntrn(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int offset;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)   << 20;  
    offset |= ((dzhbbzwqgn >> 21) & 0x3FF) << 1;   
    offset |= ((dzhbbzwqgn >> 20) & 0x1)   << 11;  
    offset |= ((dzhbbzwqgn >> 12) & 0xFF)  << 12;  
    
    
    int ysvqvpeume = offset & 0x100000;
    if (ysvqvpeume != 0)
        offset |= 0xFFE00000;
    
    x[tuzrmuzbtn] = pc + 4;
    pc += offset;
    return (0);
}

int dvjihmxragqo(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int offset;
    int t;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = (dzhbbzwqgn & 0xfff00000) >> 20;
    int ysvqvpeume = offset & 0x0800;
    if (ysvqvpeume != 0)
        offset += 0xfffff000;
    t = pc + 4;
    pc = (x[oahgriwscz] + offset) ;
    x[tuzrmuzbtn] = t;
    return (0);
}
int saauthigfjer(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int offset;

    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)  << 12;  
    offset |= ((dzhbbzwqgn >> 25) & 0x3F) << 5;   
    offset |= ((dzhbbzwqgn >> 8)  & 0xF)  << 1;   
    offset |= ((dzhbbzwqgn >> 7)  & 0x1)  << 11;  
    
    
    int ysvqvpeume = offset & 0x1000;
    if (ysvqvpeume != 0)
        offset |= 0xFFFFE000;
    
    if (x[oahgriwscz] == x[nhneaklrzi])
        pc += offset;
    else
        pc += 4;
    return (0);
}
int gijsyivozzfr(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int offset;

    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)  << 12;
    offset |= ((dzhbbzwqgn >> 25) & 0x3F) << 5;
    offset |= ((dzhbbzwqgn >> 8)  & 0xF)  << 1;
    offset |= ((dzhbbzwqgn >> 7)  & 0x1)  << 11;
    
    int ysvqvpeume = offset & 0x1000;
    if (ysvqvpeume != 0)
        offset |= 0xFFFFE000;
    
    if (x[oahgriwscz] != x[nhneaklrzi])
        pc += offset;
    else
        pc += 4;
    return (0);
}
int lpndygsmgjzd(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int offset;

    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)  << 12;
    offset |= ((dzhbbzwqgn >> 25) & 0x3F) << 5;
    offset |= ((dzhbbzwqgn >> 8)  & 0xF)  << 1;
    offset |= ((dzhbbzwqgn >> 7)  & 0x1)  << 11;
    
    int ysvqvpeume = offset & 0x1000;
    if (ysvqvpeume != 0)
        offset |= 0xFFFFE000;
    
    if (x[oahgriwscz] < x[nhneaklrzi])
        pc += offset;
    else
        pc += 4;
    return (0);
}
int zadsxarjvyxu(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int offset;

    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)  << 12;
    offset |= ((dzhbbzwqgn >> 25) & 0x3F) << 5;
    offset |= ((dzhbbzwqgn >> 8)  & 0xF)  << 1;
    offset |= ((dzhbbzwqgn >> 7)  & 0x1)  << 11;
    
    int ysvqvpeume = offset & 0x1000;
    if (ysvqvpeume != 0)
        offset |= 0xFFFFE000;
    
    if (x[oahgriwscz] >= x[nhneaklrzi])
        pc += offset;
    else
        pc += 4;
    return (0);
}
int ecqlszjnqvly(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int offset;

    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)  << 12;
    offset |= ((dzhbbzwqgn >> 25) & 0x3F) << 5;
    offset |= ((dzhbbzwqgn >> 8)  & 0xF)  << 1;
    offset |= ((dzhbbzwqgn >> 7)  & 0x1)  << 11;
    
    int ysvqvpeume = offset & 0x1000;
    if (ysvqvpeume != 0)
        offset |= 0xFFFFE000;
    
    if ((uint)x[oahgriwscz] < (uint)x[nhneaklrzi])
        pc += offset;
    else
        pc += 4;
    return (0);
}
int qkadowoljrmk(int dzhbbzwqgn) 
{
    int oahgriwscz;
    int nhneaklrzi;
    int offset;

    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    offset = 0;
    offset |= ((dzhbbzwqgn >> 31) & 0x1)  << 12;
    offset |= ((dzhbbzwqgn >> 25) & 0x3F) << 5;
    offset |= ((dzhbbzwqgn >> 8)  & 0xF)  << 1;
    offset |= ((dzhbbzwqgn >> 7)  & 0x1)  << 11;
    
    int ysvqvpeume = offset & 0x1000;
    if (ysvqvpeume != 0)
        offset |= 0xFFFFE000;
    
    if ((uint)x[oahgriwscz] >= (uint)x[nhneaklrzi])
        pc += offset;
    else
        pc += 4;
    return (0);
}


int zxvspdummgra(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = (int)x[oahgriwscz] * (int)x[nhneaklrzi];
    pc += 4; 
    return (0);
}

int iutxxxqgotqn(int dzhbbzwqgn) 
{
    int tuzrmuzbtn, oahgriwscz, nhneaklrzi;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    
    long long result = (long long)x[oahgriwscz] * (long long)x[nhneaklrzi];
    x[tuzrmuzbtn] = (int)(result >> 32);  
    
    pc += 4;
    return (0);
}

int xwjwfotvqglq(int dzhbbzwqgn) 
{
    int tuzrmuzbtn, oahgriwscz, nhneaklrzi;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    long long result = (long long)x[oahgriwscz] * 
                       (unsigned long long)(unsigned int)x[nhneaklrzi];
    x[tuzrmuzbtn] = (int)(result >> 32);
    
    pc += 4;
    return (0);
}

int avmsnmktsxwx(int dzhbbzwqgn) 
{
    int tuzrmuzbtn, oahgriwscz, nhneaklrzi;
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    
    unsigned long long result = (unsigned long long)(unsigned int)x[oahgriwscz] * 
                                (unsigned long long)(unsigned int)x[nhneaklrzi];
    x[tuzrmuzbtn] = (int)(result >> 32);
    
    pc += 4;
    return (0);
}

int cpxhuujuanxu(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] / x[nhneaklrzi];
    pc += 4;
    return (0);
}

int euymzifycyta(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] / (uint)x[nhneaklrzi];
    pc += 4;
    return (0);
}

int lizwnvrjeoip(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] % x[nhneaklrzi];
    pc += 4;
    return (0);
}

int foqbiqdxsncl(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    x[tuzrmuzbtn] = x[oahgriwscz] % (uint)x[nhneaklrzi];
    pc += 4;
    return (0);
}

int cvoafqwfwcmu(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = f[oahgriwscz] * f[nhneaklrzi] + f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int witjgqghkicc(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = f[oahgriwscz] * f[nhneaklrzi] - f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int wqvloqrxbfju(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = -f[oahgriwscz] * f[nhneaklrzi] + f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int xwriltxhmrmf(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = -f[oahgriwscz] * f[nhneaklrzi] - f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int pzitkwhitwhv(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] + f[nhneaklrzi];
    pc += 4;
    return (0);
}

int atmknyhzigcu(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] - f[nhneaklrzi];
    pc += 4;
    return (0);
}

int xfsosxetioqf(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] * f[nhneaklrzi];
    pc += 4;
    return (0);
}

int eyewoljymhdw(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] / f[nhneaklrzi];
    pc += 4;
    return (0);
}

int gwvjcdhmkpdf(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    f[tuzrmuzbtn] = sqrt(f[oahgriwscz]);
    pc += 4;
    return (0);
}

int bbztaygvbpwq(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = (float)(((int)f[oahgriwscz] & 0x7fffffff) + ((int)f[nhneaklrzi] & 0x80000000));
    pc += 4;
    return (0);
}

int xtokvidtwfdh(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = (float)(((int)f[oahgriwscz] & 0x7fffffff) + ~((int)f[nhneaklrzi] & 0x80000000));
    pc += 4;
    return (0);
}

int mhpomyfhhjor(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = (float)((((int)f[oahgriwscz] & 0x80000000) ^ ((int)f[nhneaklrzi] & 0x80000000)) + ((int)f[oahgriwscz] & 0x7fffffff));
    pc += 4;
    return (0);
}

int smgowikpsdgc(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] <= f[nhneaklrzi])
        f[tuzrmuzbtn] = f[oahgriwscz];
    else
        f[tuzrmuzbtn] = f[nhneaklrzi];
    pc += 4;
    return (0);
}

int bazapkmsjgmf(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] >= f[nhneaklrzi])
        f[tuzrmuzbtn] = f[oahgriwscz];
    else
        f[tuzrmuzbtn] = f[nhneaklrzi];
    pc += 4;
    return (0);
}

int yuezaamevrbs(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    x[tuzrmuzbtn] = (int)f[oahgriwscz];
    pc += 4;
    return (0);
}

int miecoujabrbq(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    x[tuzrmuzbtn] = (uint)f[oahgriwscz];
    pc += 4;
    return (0);
}

int ebiydncgapue(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    memcpy(&x[tuzrmuzbtn], &f[oahgriwscz], sizeof(int));
    pc += 4;
    return (0);
}

int xivgvomkuiiu(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] == f[nhneaklrzi])
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int uhhbszsflntw(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] < f[nhneaklrzi])
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int ruqblrnrgwrn(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] <= f[nhneaklrzi])
        x[tuzrmuzbtn] = 1;
    else
        x[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int vcwixtxycifd(float f)
{
    if (isinf(f)) {
        if (f < 0) {
            return (0);
        } else {
            return (7);
        }
    } else if (isnan(f)) {
        if (f != f) { 
            return (8);
        } else {
            return (9);
        }
    } else if (f == 0.0f) {
        if (1.0f / f < 0) {
            return (3);
        } else {
            return (4);
        }
    } else if (fabs(f) < FLT_MIN) {
        if (f < 0) {
            return (2);
        } else {
            return (5);
        }
    } else if (f < 0) {
        return (1);
    }
    return (6);
}

int ebgnbbucqpql(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    x[tuzrmuzbtn] = vcwixtxycifd(f[oahgriwscz]);
    pc += 4;
    return (0);
}

int dkberbovemyw(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    f[tuzrmuzbtn] = (float)((int)x[oahgriwscz]);
    pc += 4;
    return (0);
}

int oaxqicizkcjb(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    f[tuzrmuzbtn] = (float)((unsigned int)x[oahgriwscz]);
    pc += 4;
    return (0);
}

int mbxikxeizmzd(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    memcpy(&f[tuzrmuzbtn], &x[oahgriwscz], sizeof(int));
    pc += 4;
    return (0);
}

int vjdnhqrgkkqz(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = f[oahgriwscz] * f[nhneaklrzi] + f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int mspdeuoqrxsw(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = f[oahgriwscz] * f[nhneaklrzi] - f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int qrajxfglmqkd(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = -f[oahgriwscz] * f[nhneaklrzi] + f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int nlescbjzurkn(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;
    int dowdxvqzmv;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    dowdxvqzmv = dzhbbzwqgn >> 27;
    f[tuzrmuzbtn] = -f[oahgriwscz] * f[nhneaklrzi] - f[dowdxvqzmv];
    pc += 4;
    return (0);
}

int jklikxxqqaqd(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] + f[nhneaklrzi];
    pc += 4;
    return (0);
}

int ekxkzkscoipo(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] - f[nhneaklrzi];
    pc += 4;
    return (0);
}

int lxmcszbebqps(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] * f[nhneaklrzi];
    pc += 4;
    return (0);
}

int izhwsxklzulm(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = f[oahgriwscz] / f[nhneaklrzi];
    pc += 4;
    return (0);
}

int jotkrqfaeivh(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    f[tuzrmuzbtn] = sqrt(f[oahgriwscz]);
    pc += 4;
    return (0);
}

int sedfynxtbzdr(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = (float)(((int)f[oahgriwscz] & 0x7fffffff) + ((int)f[nhneaklrzi] & 0x80000000));
    pc += 4;
    return (0);
}

int viwdgicusquc(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = (float)(((int)f[oahgriwscz] & 0x7fffffff) + ~((int)f[nhneaklrzi] & 0x80000000));
    pc += 4;
    return (0);
}

int czgufqnaslpw(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    f[tuzrmuzbtn] = (float)(((int)f[oahgriwscz] & 0x7fffffff) + (((int)f[oahgriwscz] & 0x80000000) ^ ((int)f[nhneaklrzi] & 0x80000000)));
    pc += 4;
    return (0);
}

int zjhgtphnovlr(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] <= f[nhneaklrzi])
        f[tuzrmuzbtn] = f[oahgriwscz];
    else
        f[tuzrmuzbtn] = f[nhneaklrzi];
    pc += 4;
    return (0);
}

int gzpxcingaxry(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] <= f[nhneaklrzi])
        f[tuzrmuzbtn] = f[nhneaklrzi];
    else
        f[tuzrmuzbtn] = f[oahgriwscz];
    pc += 4;
    return (0);
}

int mqpcmtqzssnb(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    f[tuzrmuzbtn] = (float)f[oahgriwscz];
    pc += 4;
    return (0);
}

int loagjwwuardj(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    
    f[tuzrmuzbtn] = (float)f[oahgriwscz];
    pc += 4;
    return (0);
}

int qxkyrusrjqnr(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] == f[nhneaklrzi])
        f[tuzrmuzbtn] = 1;
    else
        f[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int qntusjojeqos(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] < f[nhneaklrzi])
        f[tuzrmuzbtn] = 1;
    else
        f[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int eryfiuanxvsb(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int nhneaklrzi;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    nhneaklrzi = (dzhbbzwqgn & 0x01f00000) >> 20;
    if (f[oahgriwscz] <= f[nhneaklrzi])
        f[tuzrmuzbtn] = 1;
    else
        f[tuzrmuzbtn] = 0;
    pc += 4;
    return (0);
}

int lnmjvyvaccam(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    x[tuzrmuzbtn] = vcwixtxycifd(f[oahgriwscz]);
    pc += 4;
    return (0);
}

int ioizzluxpykm(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    x[tuzrmuzbtn] = (int)f[oahgriwscz];
    pc += 4;
    return (0);
}

int ozdpleneafil(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    x[tuzrmuzbtn] = (int)f[oahgriwscz];
    pc += 4;
    return (0);
}

int eszjniqjxnwi(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    
    f[tuzrmuzbtn] = (float)x[oahgriwscz];
    pc += 4;
    return (0);
}

int nkypgwpmwncc(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    
    f[tuzrmuzbtn] = (float)((unsigned int)x[oahgriwscz]);
    pc += 4;
    return (0);
}

int egehxadiepyd(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int offset;

    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = dzhbbzwqgn >> 20;
    f[tuzrmuzbtn] = *((float *)&ozfckxugso[x[oahgriwscz] + offset]);
    pc += 4;
    return (0);
}

int muxfacntbrgr(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int offset;

    
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = tuzrmuzbtn;
    offset += (dzhbbzwqgn & 0xf8000000);
    *((float *)&ozfckxugso[x[oahgriwscz] + offset]) = (float)f[tuzrmuzbtn];
    pc += 4;
    return (0);
}

int nlbudxrvnvxd(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int offset;

    
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = tuzrmuzbtn;
    offset += (dzhbbzwqgn & 0xf8000000);
    
    f[tuzrmuzbtn] = *((float *)&ozfckxugso[x[oahgriwscz] + offset]);
    pc += 4;
    return (0);
}

int ivifpzzwbzgv(int dzhbbzwqgn) 
{
    int tuzrmuzbtn;
    int oahgriwscz;
    int offset;

    
    tuzrmuzbtn = (dzhbbzwqgn & 0x0f80) >> 7;
    oahgriwscz = (dzhbbzwqgn & 0x0f8000) >> 15;
    offset = tuzrmuzbtn;
    offset += (dzhbbzwqgn & 0xf8000000);
    
    *((double *)&ozfckxugso[x[oahgriwscz] + offset]) = (double)f[tuzrmuzbtn];
    pc += 4;
    return (0);
}



int ucmdvojvqpmd(int dzhbbzwqgn)
{
    int vxqjrkhcsj;
    int cpupclzcne;
    int bmwskriqhb;
    int ajnyndbtty;
    int jacdtrbgnj;

    
    if ((dzhbbzwqgn & 3) != 3)
        return (1);
    vxqjrkhcsj = (dzhbbzwqgn & 0x7c) >> 2;
    cpupclzcne = (dzhbbzwqgn & 0x07000) >> 12;
    ajnyndbtty = (dzhbbzwqgn & 0x01f00000) >> 20;
    bmwskriqhb = (dzhbbzwqgn & 0x06000000) >> 25;
    jacdtrbgnj = (dzhbbzwqgn & 0xf8000000) >> 27;
    
    int mxzsoeldbe;
    mxzsoeldbe = vxqjrkhcsj;
    if (mxzsoeldbe == op_values[(0 + instruction_rotation) % OP_VALUES_COUNT])
        return (ccaoayyihidz(dzhbbzwqgn));
    else if (mxzsoeldbe == op_values[(1 + instruction_rotation) % OP_VALUES_COUNT])
        return (tfljcffiqfvi(dzhbbzwqgn));
    else if (mxzsoeldbe == op_values[(2 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b101 + instruction_rotation) % 8) 
            return (uwjowkppdajm(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
            return (knzgidixqgtn(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b111 + instruction_rotation) % 8) 
            return (ahamebxfowqv(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b110 + instruction_rotation) % 8) 
            return (nrhuzwqohqua(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b100 + instruction_rotation) % 8) 
            return (mvszkvunbxje(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b011 + instruction_rotation) % 8) 
            return (gbjccjjxfnsi(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            return (earbsgsofywt(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
        {
            mxzsoeldbe = jacdtrbgnj;
            if (mxzsoeldbe == 0b00000)
                return (qbmgldgsvnsg(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b01000)
                return (pdvmjqpaktmj(dzhbbzwqgn));
            else
                return (1);
        }
    }
    else if (mxzsoeldbe == op_values[(3 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = bmwskriqhb;
        if (mxzsoeldbe == 0b00)
        { 
            mxzsoeldbe = cpupclzcne;
            if (mxzsoeldbe == (0b111 + instruction_rotation) % 8) 
            {
                switch (jacdtrbgnj)
                {
                    case 0b00000:
                        return (afgkzszekngi(dzhbbzwqgn));
                    case 0b01000:
                        return (vdmrlvrpyrhc(dzhbbzwqgn));
                    default:
                        return (1);
                }
            }
            else if (mxzsoeldbe == (0b110 + instruction_rotation) % 8) 
                return (xbceffrgiykt(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b101 + instruction_rotation) % 8) 
                return (qilkkdjhtywp(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b100 + instruction_rotation) % 8) 
                return (esrydkbncmze(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b011 + instruction_rotation) % 8) 
                return (ekdtszmcsrhs(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            {
                switch (jacdtrbgnj)
                {
                    case 0b00000:
                        return (ciljsrdoidzb(dzhbbzwqgn));
                    case 0b01000:
                        return (jatvacndzbgh(dzhbbzwqgn));
                    default:
                        return (1);
                }
            }
            else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                return (zsnfdofvhfxd(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                return (nmzrjriwpkdg(dzhbbzwqgn));
        }
        else if (mxzsoeldbe == 0b01)
        { 
            mxzsoeldbe = cpupclzcne;
            if (mxzsoeldbe == (0b111 + instruction_rotation) % 8) 
                return (zxvspdummgra(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b110 + instruction_rotation) % 8) 
                return (iutxxxqgotqn(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b101 + instruction_rotation) % 8) 
                return (xwjwfotvqglq(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b100 + instruction_rotation) % 8) 
                return (avmsnmktsxwx(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b011 + instruction_rotation) % 8) 
                return (cpxhuujuanxu(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
                return (euymzifycyta(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                return (lizwnvrjeoip(dzhbbzwqgn));
            else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                return (foqbiqdxsncl(dzhbbzwqgn));
        }
    }
    else if (mxzsoeldbe == op_values[(4 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
            return (ukbaazjxtkom(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
            return (kmccktodigzt(dzhbbzwqgn));
    }
    else if (mxzsoeldbe == op_values[(5 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
            return (yrwpvlifrgjg(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b111 + instruction_rotation) % 8) 
            return (hlcicyocusuk(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b110 + instruction_rotation) % 8) 
            return (hmjbkfkzsjhk(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b101 + instruction_rotation) % 8) 
            return (drtsztchhazh(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b011 + instruction_rotation) % 8) 
            return (mcircxcauajy(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            return (zlppedqyzkcq(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
        {
            if (bmwskriqhb == 0b01 && jacdtrbgnj == 0b00010)
                return (msmftchpafqk(dzhbbzwqgn));
            else
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (vffyeekjdwqt(dzhbbzwqgn));
                else if (mxzsoeldbe == 0b00001)
                    return (jegerxbyktzv(dzhbbzwqgn));
                else if (mxzsoeldbe == 0b00010)
                {
                    mxzsoeldbe = jacdtrbgnj;
                    if (mxzsoeldbe == 0b00000)
                        return (rxwgfjnrfbwv(dzhbbzwqgn));
                    else if (mxzsoeldbe == 0b00010)
                        return (hiycvoznriro(dzhbbzwqgn));
                    else if (mxzsoeldbe == 0b00110)
                        return (roamkfipazun(dzhbbzwqgn));
                    else
                        return (1);
                }
                else if (mxzsoeldbe == 0b00101)
                    return (sabwlseseeii(dzhbbzwqgn));
                else
                    return (1);
            }
        }
        else
            return (1);
    }
    else if (mxzsoeldbe == op_values[(6 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b101 + instruction_rotation) % 8) 
            return (quovuxhhkpvp(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b100 + instruction_rotation) % 8) 
            return (hwnkrtxuiuhb(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            return (cyqulfqyzgjj(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
            return (wjrlfwwxotcd(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
            return (tqsmfeingsxy(dzhbbzwqgn));
        else
            return (1);
    }
    else if (mxzsoeldbe == op_values[(7 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            return (zbpvmwulmqfr(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
            return (xbqcziudixce(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
            return (ytvvwcohmznm(dzhbbzwqgn));
        else
            return (1);
    }
    else if (mxzsoeldbe == op_values[(8 + instruction_rotation) % OP_VALUES_COUNT])
        return (fkoetpgdntrn(dzhbbzwqgn));
    else if (mxzsoeldbe == op_values[(9 + instruction_rotation) % OP_VALUES_COUNT])
        return (dvjihmxragqo(dzhbbzwqgn));
    else if (mxzsoeldbe == op_values[(10 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b111 + instruction_rotation) % 8) 
            return (saauthigfjer(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b110 + instruction_rotation) % 8) 
            return (gijsyivozzfr(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b101 + instruction_rotation) % 8) 
            return (lpndygsmgjzd(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b100 + instruction_rotation) % 8) 
            return (zadsxarjvyxu(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
            return (ecqlszjnqvly(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
            return (qkadowoljrmk(dzhbbzwqgn));
        else
            return (1);
    }
    else if (mxzsoeldbe == op_values[(11 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = bmwskriqhb;
        if (mxzsoeldbe == 0b00)
            return (cvoafqwfwcmu(dzhbbzwqgn));
        else if (mxzsoeldbe == 0b01)
            return (vjdnhqrgkkqz(dzhbbzwqgn));
    }
    else if (mxzsoeldbe == op_values[(12 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = bmwskriqhb;
        if (mxzsoeldbe == 0b00)
            return (witjgqghkicc(dzhbbzwqgn));
        else if (mxzsoeldbe == 0b01)
            return (mspdeuoqrxsw(dzhbbzwqgn));
    }
    else if (mxzsoeldbe == op_values[(13 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = ajnyndbtty;
        if (mxzsoeldbe == 0b00)
            return (wqvloqrxbfju(dzhbbzwqgn));
        else if (mxzsoeldbe == 0b01)
            return (qrajxfglmqkd(dzhbbzwqgn));
    }
    else if (mxzsoeldbe == op_values[(14 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = bmwskriqhb;
        if (mxzsoeldbe == 0b00)
            return (xwriltxhmrmf(dzhbbzwqgn));
        else if (mxzsoeldbe == 0b01)
            return (nlescbjzurkn(dzhbbzwqgn));
    }
    else if (mxzsoeldbe == op_values[(15 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = bmwskriqhb;
        if (mxzsoeldbe == 0b00)
        {
            mxzsoeldbe = jacdtrbgnj;
            if (mxzsoeldbe == 0b00000)
                return (pzitkwhitwhv(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00001)
                return (atmknyhzigcu(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00010)
                return (xfsosxetioqf(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00011)
                return (eyewoljymhdw(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b01011)
                return (gwvjcdhmkpdf(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00100)
            {
                mxzsoeldbe = cpupclzcne;
                if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
                    return (bbztaygvbpwq(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                    return (xtokvidtwfdh(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                    return (mhpomyfhhjor(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b00101)
            {
                mxzsoeldbe = cpupclzcne;
                if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                    return (smgowikpsdgc(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                    return (bazapkmsjgmf(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11000)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (yuezaamevrbs(dzhbbzwqgn));
                else if (mxzsoeldbe == 0b00001)
                    return (miecoujabrbq(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11100)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                {
                    mxzsoeldbe = cpupclzcne;
                    if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                        return (ebiydncgapue(dzhbbzwqgn));
                    else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                        return (ebgnbbucqpql(dzhbbzwqgn));
                }
            }
            else if (mxzsoeldbe == 0b10100)
            {
                mxzsoeldbe = cpupclzcne;
                if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                    return (xivgvomkuiiu(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                    return (uhhbszsflntw(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
                    return (ruqblrnrgwrn(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11010)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (dkberbovemyw(dzhbbzwqgn));
                else if (mxzsoeldbe == 0b00001)
                    return (oaxqicizkcjb(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11110)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                {
                    mxzsoeldbe = cpupclzcne;
                    if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                        return (mbxikxeizmzd(dzhbbzwqgn));
                }
            }
            else if (mxzsoeldbe == 0b01000)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00001)
                    return (mqpcmtqzssnb(dzhbbzwqgn));
            }
        }
        else if (mxzsoeldbe == 0b01)
        {
            mxzsoeldbe = jacdtrbgnj;
            if (mxzsoeldbe == 0b00000)
                return (jklikxxqqaqd(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00001)
                return (ekxkzkscoipo(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00010)
                return (lxmcszbebqps(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b00011)
                return (izhwsxklzulm(dzhbbzwqgn));
            else if (mxzsoeldbe == 0b01011)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (jotkrqfaeivh(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b00100)
            {
                mxzsoeldbe = cpupclzcne;
                if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
                    return (sedfynxtbzdr(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                    return (viwdgicusquc(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                    return (czgufqnaslpw(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b00101)
            {
                mxzsoeldbe = cpupclzcne;
                if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                    return (zjhgtphnovlr(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                    return (gzpxcingaxry(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b01000)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (loagjwwuardj(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b101000)
            {
                mxzsoeldbe = cpupclzcne;
                if (mxzsoeldbe == (0b001 + instruction_rotation) % 8) 
                    return (eryfiuanxvsb(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
                    return (qxkyrusrjqnr(dzhbbzwqgn));
                else if (mxzsoeldbe == (0b000 + instruction_rotation) % 8) 
                    return (qntusjojeqos(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11100)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (lnmjvyvaccam(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11000)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (ioizzluxpykm(dzhbbzwqgn));
                else if (mxzsoeldbe == 0b00001)
                    return (ozdpleneafil(dzhbbzwqgn));
            }
            else if (mxzsoeldbe == 0b11010)
            {
                mxzsoeldbe = ajnyndbtty;
                if (mxzsoeldbe == 0b00000)
                    return (eszjniqjxnwi(dzhbbzwqgn));
                else if (mxzsoeldbe == 0b00001)
                    return (nkypgwpmwncc(dzhbbzwqgn));
            }
        }
    }
    else if (mxzsoeldbe == op_values[(16 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b011 + instruction_rotation) % 8) 
            return (egehxadiepyd(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            return (nlbudxrvnvxd(dzhbbzwqgn));
    }
    else if (mxzsoeldbe == op_values[(17 + instruction_rotation) % OP_VALUES_COUNT])
    {
        mxzsoeldbe = cpupclzcne;
        if (mxzsoeldbe == (0b011 + instruction_rotation) % 8) 
            return (muxfacntbrgr(dzhbbzwqgn));
        else if (mxzsoeldbe == (0b010 + instruction_rotation) % 8) 
            return (ivifpzzwbzgv(dzhbbzwqgn));
    }
    else
        return (1);
    return (0);
}

void tpdemtwgfqin(char *key, uint key_len, uint input_size)
{
    int    offset;
    char   tmp[2] = "}";

    srandom(14949242);
    offset = (random() % 0xff) + (MEMORY_SIZE - 0xff);
    if (offset + strlen(flag) + 1 > MEMORY_SIZE)
        offset -= strlen(flag) + 1;
    memcpy(ozfckxugso + offset, flag, strlen(flag));
    

    offset += strlen(flag);
    if (input_size + (MEMORY_SIZE - offset) >= MEMORY_SIZE)
    {
        offset_bootloader = -1;
        return ;
    }
    offset_bootloader = MEMORY_SIZE - (input_size + (MEMORY_SIZE - offset));
    offset_bootloader = random() % (offset_bootloader - BOOTLOADER_SIZE);
    memcpy(ozfckxugso + offset_bootloader, bootloader, BOOTLOADER_SIZE);
}

#define READ_SIZE	512
char *xrjpuzrgzytk(char *filename, size_t *size)
{
    int sdwugusijd;
    char buf[READ_SIZE];
    char *data;
    char *temp;
    int cmqhnxfnws[2];
    
    sdwugusijd = open(filename, O_RDONLY);
    if (sdwugusijd < 0)
        return (NULL);
    data = malloc(READ_SIZE);
    if (!data)
    {
        close(sdwugusijd);
        return (NULL);
    }
    cmqhnxfnws[1] = 0;
    while ((cmqhnxfnws[0] = read(sdwugusijd, buf, READ_SIZE)) > 0)
    {
        temp = realloc(data, cmqhnxfnws[1] + cmqhnxfnws[0] + 1);
        if (!temp)
        {
            free(data);
            close(sdwugusijd);
            return (NULL);
        }
        data = temp;
        memcpy(data + cmqhnxfnws[1], buf, cmqhnxfnws[0]);
        cmqhnxfnws[1] += cmqhnxfnws[0];
    }
    close(sdwugusijd);
    if (cmqhnxfnws[0] < 0)
    {
        free(data);
        return (NULL);
    }
    data[cmqhnxfnws[1]] = '\0';
    if (size)
        *size = cmqhnxfnws[1];   
    return (data);
}



void pdayxvlwibru(char* wjsjzcbysq, int sbvaliuojs) 
{ 
    int i = 0, j = sbvaliuojs - 1, temp; 
    while (i < j) { 
        temp = wjsjzcbysq[i]; 
        wjsjzcbysq[i] = wjsjzcbysq[j]; 
        wjsjzcbysq[j] = temp; 
        i++; 
        j--; 
    } 
}

typedef struct s_cell
{
    char visited;
    char neighbor[4];
}               t_cell;

typedef struct s_pointer
{
    int x, y;
    int h, w;
    t_cell *c;
}               t_pointer;

t_cell *ojydhqiiwhne(int width, int height)
{
    t_cell *cell;

    if (!(cell = ALLOC(sizeof(struct s_cell) * (width * height))))
        return (NULL);
    memset(cell, 0, sizeof(struct s_cell) * width * height);
    return (cell);
}

struct s_pointer eignrutbrtqe(t_cell *c, int width, int height)
{
    char side;
    int offset;
    struct s_pointer pointer;

    side = random() % 4;
    if (side == 0 || side == 2)
        offset = random() % width;
    else
        offset = random() % height;
    pointer.w = width;
    pointer.h = height;
    if (side == 0)
    {
        pointer.x = offset;
        pointer.y = 0;
        pointer.c = &c[offset];
    }
    if (side == 1)
    {
        pointer.x = width - 1;
        pointer.y = offset;
        pointer.c = &c[offset * width + width - 1];
    }
    if (side == 2)
    {
        pointer.x = offset;
        pointer.y = height - 1;
        pointer.c = &c[(height - 1) * width + offset];
    }
    if (side == 3)
    {
        pointer.x = 0;
        pointer.y = offset;
        pointer.c = &c[offset * width];
    }
    pointer.c->neighbor[side] = 1;
    return (pointer);
}

int niipwjipgplt(int dir)
{
    if (dir == 0)
        return (2);
    if (dir == 1)
        return (3);
    if (dir == 2)
        return (0);
    return (1);
}

char *phkftyfxswor(int counter)
{
    char *face;
    char xavycfysbj[32];

    face = hmqlsloivrtx(NULL, "f ");
    arrtztkotazh(counter, xavycfysbj, 10);
    face = hmqlsloivrtx(face, xavycfysbj);
    face = hmqlsloivrtx(face, " ");

    arrtztkotazh(counter + 1, xavycfysbj, 10);
    face = hmqlsloivrtx(face, xavycfysbj);
    face = hmqlsloivrtx(face, " ");

    arrtztkotazh(counter + 2, xavycfysbj, 10);
    face = hmqlsloivrtx(face, xavycfysbj);
    face = hmqlsloivrtx(face, "\n");

    face = hmqlsloivrtx(face, "f ");
    arrtztkotazh(counter + 1, xavycfysbj, 10);
    face = hmqlsloivrtx(face, xavycfysbj);
    face = hmqlsloivrtx(face, " ");

    arrtztkotazh(counter + 2, xavycfysbj, 10);
    face = hmqlsloivrtx(face, xavycfysbj);
    face = hmqlsloivrtx(face, " ");

    arrtztkotazh(counter + 3, xavycfysbj, 10);
    face = hmqlsloivrtx(face, xavycfysbj);
    face = hmqlsloivrtx(face, "\n");
    return (face);
}

char *ebqkqweuyzgk(int idx, int x, int y)
{
    char xavycfysbj[32];
    char *vert;
    int pkfkclmums, jligkndera, wxmzcsfblo;

    vert = hmqlsloivrtx(NULL, "v ");
    jligkndera = 0;
    if (idx >= 4)
    {
        idx -= 4;
        jligkndera = 1;
    }
    if (idx == 0) 
    {
        pkfkclmums = x;
        wxmzcsfblo = y;
    }
    if (idx == 1) 
    {
        pkfkclmums = x + 1;
        wxmzcsfblo = y;
    }
    if (idx == 2) 
    {
        pkfkclmums = x + 1;
        wxmzcsfblo = y + 1;
    }
    if (idx == 3) 
    {
        pkfkclmums = x;
        wxmzcsfblo = y + 1;
    }
    arrtztkotazh(pkfkclmums, xavycfysbj, 10);
    vert = hmqlsloivrtx(vert, xavycfysbj);
    vert = hmqlsloivrtx(vert, " ");
    arrtztkotazh(jligkndera, xavycfysbj, 10);
    vert = hmqlsloivrtx(vert, xavycfysbj);
    vert = hmqlsloivrtx(vert, " ");
    arrtztkotazh(wxmzcsfblo, xavycfysbj, 10);
    vert = hmqlsloivrtx(vert, xavycfysbj);
    vert = hmqlsloivrtx(vert, "\n");
    return (vert);
}

char *tppkdeewihcu(int dir, int x, int y)
{
    char *tmp;
    char *vert;

    vert = NULL;
    if (dir == 0)
    {
        tmp = ebqkqweuyzgk(4, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(5, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(0, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(1, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
    }
    if (dir == 1)
    {
        tmp = ebqkqweuyzgk(5, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(6, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(1, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(2, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
    }
    if (dir == 2)
    {
        tmp = ebqkqweuyzgk(6, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(7, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(2, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(3, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
    }
    if (dir == 3)
    {
        tmp = ebqkqweuyzgk(7, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(4, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(3, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
        
        tmp = ebqkqweuyzgk(0, x, y);
        vert = hmqlsloivrtx(vert, tmp);
        FREE(tmp);
    }
    return (vert);
}

char *rwbsfvdhsgqs(t_cell *c, int width, int height, int *ret_counter)
{
    char *model;
    int counter;
    char *vert;
    char *face;
    int i;
    int j;
    int k;

    counter = 1;
    face = NULL;
    vert = NULL;
    j = -1;
    while (++j < height)
    {
        i = -1;
        while (++i < width)
        {
            k = -1;
            while (++k < 4)
            {
                if (c[j * width + i].neighbor[k] == 1)
                    continue;
                model = tppkdeewihcu(k, i, j);
                vert = hmqlsloivrtx(vert, model);
                FREE(model);
                model = phkftyfxswor(counter);
                face = hmqlsloivrtx(face, model);
                FREE(model);
                counter += 4;
            }
        }
    }
    model = hmqlsloivrtx(NULL, "o maze\n");
    model = hmqlsloivrtx(model, vert);
    model = hmqlsloivrtx(model, face);
    FREE(vert);
    FREE(face);
    *ret_counter = counter;
    return (model);
}

struct s_pointer vjnkayajthcx(t_cell *cell, struct s_pointer point)
{
    struct s_pointer opposit;

    opposit.h = point.h;
    opposit.w = point.w;
    if (point.x != 0 && point.x != point.w - 1)
    {
        opposit.x = (point.w - 1) - point.x;
        if (point.y == 0)
            opposit.y = point.h - 1;
        else
            opposit.y = 0;
    }
    else
    {
        opposit.y = (point.h - 1) - point.y;
        if (point.x == 0)
            opposit.x = point.w - 1;
        else
            opposit.x = 0;
    }
    opposit.c = &cell[opposit.y * point.w + opposit.x];
    return (opposit);
}

char        *hivukitxqmad(char *wjsjzcbysq)
{
    char ksfchfuhot;
    int i;
    int sbvaliuojs;

    sbvaliuojs = strlen(wjsjzcbysq);
    i = -1;
    while (++i < sbvaliuojs)
    {
        ksfchfuhot = wjsjzcbysq[i];
        wjsjzcbysq[i] = wjsjzcbysq[(sbvaliuojs - 1) - i];
        wjsjzcbysq[(sbvaliuojs - 1) - i] = ksfchfuhot;
    }
    return (wjsjzcbysq);
}

char *klediyevsblc(char *key, uint *length)
{
    uint sbvaliuojs;
    int i;
    char igjaipzmgf;
    char c[2];
    char *wjsjzcbysq;

    sbvaliuojs = 0;
    c[1] = '\0';
    i = 0;
    wjsjzcbysq = NULL;
    while (*key)
    {
        if (i % 4 == 0)
            c[0] = *key - '0';
        if (i % 4 == 1)
            c[0] += (*key - '0') << 2;
        if (i % 4 == 2)
            c[0] += (*key - '0') << 4;
        if (i % 4 == 3)
        {
            sbvaliuojs++;
            c[0] += (*key - '0') << 6;
            wjsjzcbysq = hmqlsloivrtx(wjsjzcbysq, c);
            c[0] = 0;
        }
        i++;
        key++;
    }
    if (c[0] != 0)
    {
        sbvaliuojs++;
        wjsjzcbysq = hmqlsloivrtx(wjsjzcbysq, c);
    }
    if (length)
        *length = sbvaliuojs;
    return (wjsjzcbysq);
}

typedef unsigned int		uint;

typedef struct s_point
{
	float		x;
	float 		y;
	float 		z;
	float 		w;
	int		index;
}		t_point;

#define MAX_FACE_POINT		6
typedef struct s_face
{
	uint		num_points;
	
	t_point		*p[MAX_FACE_POINT];
	uint		pIndex[MAX_FACE_POINT];
}		t_face;

typedef struct s_obj
{
	uint		num_points;
	t_point		*p;
	uint		num_faces;
	t_face		*f;
}		t_obj;

char *cxdjkhiqblac(char *model, struct s_pointer start, struct s_point center, int counter)
{
    char buf[32];
    float vert[24] = {
        -1, -1, 1,
        -1, 1, 1,
        -1, -1, -1,
        -1, 1, -1,
        1, -1, 1,
        1, 1, 1,
        1, -1, -1,
        1, 1, -1
    };
    int face[24] = {
        1, 2, 4, 3,
        3, 4, 8, 7,
        7, 8, 6, 5,
        5, 6, 2, 1,
        3, 7, 5, 1,
        8, 4, 2, 6
    };
    int i;

    i = -1;
    while (++i < 24)
        vert[i] *= 0.5;
    model = hmqlsloivrtx(model, "o start\n");
    i = -1;
    while (++i < 8)
    {
        model = hmqlsloivrtx(model, "v ");
        sprintf(buf, "%f", (vert[i * 3] * 0.5) + start.x + 0.5 + center.x);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        sprintf(buf, "%f", (vert[i * 3 + 1] * 0.5) + 0.5 + center.y);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        sprintf(buf, "%f", (vert[i * 3 + 2] * 0.5) + start.y + 0.5 + center.z);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, "\n");
    }
    counter -= 1;
    i = -1;
    while (++i < 6)
    {
        model = hmqlsloivrtx(model, "f ");
        arrtztkotazh(face[i * 4] + counter, buf, 10);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        arrtztkotazh(face[i * 4 + 1] + counter, buf, 10);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        arrtztkotazh(face[i * 4 + 2] + counter, buf, 10);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        arrtztkotazh(face[i * 4 + 3] + counter, buf, 10);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, "\n");
    }
    return (model);
}

static int		emlxuwhdvkia(char c)
{
	return (c >= '0' && c <= '9' ? 1 : 0);
}

static int		qkdlzzuxetim(char c)
{
	return ((c >= '0' && c <= '9') || c == '.' || c == '-' ? 1 : 0);
}

static uint		cvstxqpsnrmj(char *obj, char verb)
{
	uint		fikzucztls;

	if (!obj)
		return (0);
	fikzucztls = 0;
	while (*obj)
	{
		if (*obj == '\n' || *obj == verb)
		{
			while (*obj && (*obj == ' ' || *obj == '\n'))
				obj++;
			if (obj[0] == verb && obj[1] && (obj[1] == ' ' || obj[1] == '\t'))
				fikzucztls++;
		}
        if (*obj)
		    obj++;
        else
            break;
	}
	return (fikzucztls);
}

int		hujrebtqdfhg(t_obj *obj, char *data)
{
	int		index;

	if (!obj || !data)
		return (1);
	if (obj->p)
	{
        FREE(obj->p);
		obj->p = NULL;
	}
    if ((obj->num_points = cvstxqpsnrmj(data, 'v')))
		if (!(obj->p = ALLOC(sizeof(struct s_point) * obj->num_points)))
			return (1);
    index = 0;
	while (*data)
	{
		if (*data == '\n' || *data == 'v')
		{
			while (*data && (*data == ' ' || *data == '\n'))
				data++;
			if (data[0] == 'v' && data[1] && (data[1] == ' ' || data[1] == '\t'))
			{
				while (*data && !qkdlzzuxetim(*data))
					data++;
                if (!*data)
                    break;
				obj->p[index].x = atof(data++);
				while (*data && qkdlzzuxetim(*data))
					data++;
                if (!*data)
                    break;
				while (*data && !qkdlzzuxetim(*data))
					data++;
                if (!*data)
                    break;
				obj->p[index].y = atof(data++);
				while (*data && qkdlzzuxetim(*data))
					data++;
                if (!*data)
                    break;
				while (*data && !qkdlzzuxetim(*data))
					data++;
				obj->p[index].z = atof(data++);
				obj->p[index].w = 0.0;
				obj->p[index].index = index;
				index++;
			}
		}
        if (*data)
		    data++;
	}
	return (index != obj->num_points ? 1 : 0);
}

static uint	nirairiqipem(char *obj)
{
	uint		pgivnyujnq;

	pgivnyujnq = 0;
	while (*obj && *obj != '\n')
	{
		while (*obj && !emlxuwhdvkia(*obj) && *obj != '\n')
			obj++;
		if (emlxuwhdvkia(*obj))
			pgivnyujnq++;
		while (*obj && *obj != ' ' && *obj != '\n')
			obj++;
	}
	return (pgivnyujnq);
}

static void	wdxlcurlrrzx(t_obj *obj, t_face *f, char *d)
{
	int			index;
	int			bdbcpbwcqq;

	index = -1;
	while (++index < MAX_FACE_POINT)
		f->pIndex[index] = 0;
	index = 0;
	while (*d && *d != '\n')
	{
		if (emlxuwhdvkia(*d))
		{
			if ((bdbcpbwcqq = atoi(d++)) > obj->num_points)
				continue;
			f->p[index] = &obj->p[bdbcpbwcqq];
			f->pIndex[index] = bdbcpbwcqq;
			if (++index >= MAX_FACE_POINT)
				break;
			while (*d && *d != ' ' && *d != '\n')
				d++;
		}
		else
			d++;
	}
}

int		qvsatjoveecs(t_obj *obj, char *data)
{
	int		index;

    if (!obj || !data)
		return (1);
	if (obj->f)
	{
		FREE(obj->f);
		obj->f = NULL;
	}
    if ((obj->num_faces = cvstxqpsnrmj(data, 'f')))
    {
		if (!(obj->f = ALLOC(sizeof(struct s_face) * obj->num_faces)))
			return (1);
    }
	index = 0;
	while (*data)
		if (*(data++) == '\n')
		{
			while (*data && (*data == ' ' || *data == '\n'))
				data++;
			if (data[0] == 'f' && data[1] && (data[1] == ' ' || data[1] == '\t'))
			{
				obj->f[index].num_points = nirairiqipem(++data);
				wdxlcurlrrzx(obj, &obj->f[index], data);
				index++;
			}
		}
	return (index != obj->num_faces ? 1 : 0);
}

void        evgpzykljfez(t_obj *obj)
{
    if (obj->p)
        FREE(obj->p);
    if (obj->f)
        FREE(obj->f);
    FREE(obj);
}

t_obj		*momdteijvvzu(char *obj_data)
{
	t_obj	*obj;

	if (!(obj = ALLOC(sizeof(struct s_obj))))
		return (NULL);
	memset(obj, '\0', sizeof(struct s_obj));
	if (hujrebtqdfhg(obj, obj_data) || qvsatjoveecs(obj, obj_data))
    {
        evgpzykljfez(obj);
		return (NULL);
    }
	return (obj);
}

char		*tarauemxrdoa(char *data, size_t size)
{
    size_t i, j;
    char *rpmuehueqm;
    char c;
    if (!data || size == 0) return NULL;
    rpmuehueqm = ALLOC(size * 8 + 1);
    if (!rpmuehueqm) return NULL;
    memset(rpmuehueqm, 0, size * 8 + 1);
    i = -1;
    j = 0;
    while (++i < size)
    {
        c = data[i];
        rpmuehueqm[j++] = c & 0x80 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x40 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x20 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x10 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x08 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x04 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x02 ? '1' : '0';
        rpmuehueqm[j++] = c & 0x01 ? '1' : '0';
    }
    return (rpmuehueqm);
}

#define EPSILON 	0.001000
#define DECODE_EPSILON	1000

void		yntvnilnmtob(t_obj *obj, char *data, size_t size)
{
	char		*rpmuehueqm;
	int		i;
	int		qnbpkyabye;
	int		length;

	if (!(rpmuehueqm = tarauemxrdoa(data, size)))
		return ;
	length = strlen(rpmuehueqm);
	i = -1;
	qnbpkyabye = -1;
	while (++i < length)
	{
		if (i % 3 == 0)
		{
			if (++qnbpkyabye >= obj->num_points)
				break;
			if ((int)(obj->p[qnbpkyabye].x * DECODE_EPSILON) % 2)
				obj->p[qnbpkyabye].x -= EPSILON;
			obj->p[qnbpkyabye].x += EPSILON * (rpmuehueqm[i] == '1' ? 1 : 0);
		}
		else if (i % 3 == 1)
		{
			if ((int)(obj->p[qnbpkyabye].y * DECODE_EPSILON) % 2)
				obj->p[qnbpkyabye].y -= EPSILON;
			obj->p[qnbpkyabye].y += EPSILON * (rpmuehueqm[i] == '1' ? 1 : 0);
		}
		else if (i % 3 == 2)
		{
			if ((int)(obj->p[qnbpkyabye].z * DECODE_EPSILON) % 2)
				obj->p[qnbpkyabye].z -= EPSILON;
			obj->p[qnbpkyabye].z += EPSILON * (rpmuehueqm[i] == '1' ? 1 : 0);
		}
	}
    FREE(rpmuehueqm);
}

char	*dpybuwwazbds(char *rpmuehueqm)
{
    if (!rpmuehueqm) return NULL;
    int length = (int)strlen(rpmuehueqm);
    int sbapxdfqjh = length / 8;
    if (sbapxdfqjh <= 0) return NULL;
    char *vaqrnbtdke = malloc((size_t)sbapxdfqjh + 1);
    if (!vaqrnbtdke) return NULL;
    memset(vaqrnbtdke, 0, (size_t)sbapxdfqjh + 1);
    for (int i = 0; i < sbapxdfqjh; ++i) {
        unsigned char c = 0;
        for (int b = 0; b < 8; ++b) {
            char yaiptxmwzn = rpmuehueqm[i*8 + b];
            c = (unsigned char)((c << 1) | (yaiptxmwzn == '1' ? 1 : 0));
        }
        vaqrnbtdke[i] = (char)c;
    }
    vaqrnbtdke[sbapxdfqjh] = '\0';
    return vaqrnbtdke;
}

char		*eqqylrizsulz(t_obj *obj, uint *length)
{
    int		i;
    char		*vaqrnbtdke;
    char		*p;

    if (!obj || obj->num_points <= 1) return NULL;
    
    int tiewbkklem = obj->num_points;
    size_t bits_len = (size_t)tiewbkklem * 3;
    vaqrnbtdke = malloc(bits_len + 1);
    if (!vaqrnbtdke) return NULL;
    p = vaqrnbtdke;
    for (i = 0; i < tiewbkklem; ++i)
    {
        *p++ = ((int)(obj->p[i].x * DECODE_EPSILON) % 2) ? '1' : '0';
        *p++ = ((int)(obj->p[i].y * DECODE_EPSILON) % 2) ? '1' : '0';
        *p++ = ((int)(obj->p[i].z * DECODE_EPSILON) % 2) ? '1' : '0';
    }
    vaqrnbtdke[bits_len] = '\0';
    if (length)
        *length = (uint)(bits_len / 8);
    p = dpybuwwazbds(vaqrnbtdke);
    FREE(vaqrnbtdke);
    return (p);
}

struct s_point pwhzthdrlfdy(struct s_point p)
{
    struct s_point inv;

    inv.x = p.x * -1;
    inv.y = p.y * -1;
    inv.z = p.z * -1;
    inv.w = p.w;
    inv.index = p.index;
    return (inv);
}

float bwknxlivuybt(struct s_point a, struct s_point b)
{
    float dot;

    dot = 0;
    dot += a.x * b.x;
    dot += a.y * b.y;
    dot += a.z * b.z;
    return (dot);
}

struct s_point nnmljykozwhu(struct s_point a, struct s_point b)
{
    a.x += b.x;
    a.y += b.y;
    a.z += b.z;
    return (a);
}

void tqebkvdqfruu(t_point *a, struct s_point b)
{
    a->x += b.x;
    a->y += b.y;
    a->z += b.z;
}

struct s_point pkywdsapgmuf(t_obj *obj)
{
    struct s_point center;
    struct s_point min = {INFINITY, INFINITY, INFINITY};
    struct s_point max = {-INFINITY, -INFINITY, -INFINITY};
    
    for (int i = 0; i < obj->num_points; i++) {
        if (obj->p[i].x < min.x) min.x = obj->p[i].x;
        if (obj->p[i].y < min.y) min.y = obj->p[i].y;
        if (obj->p[i].z < min.z) min.z = obj->p[i].z;
        if (obj->p[i].x > max.x) max.x = obj->p[i].x;
        if (obj->p[i].y > max.y) max.y = obj->p[i].y;
        if (obj->p[i].z > max.z) max.z = obj->p[i].z;
    }
    
    center.x = (min.x + max.x) / 2.0f;
    center.y = (min.y + max.y) / 2.0f;
    center.z = (min.z + max.z) / 2.0f;
    
    return center;
}

struct s_point mwhdhkkvhzvo(t_obj *obj)
{
    int i;
    struct s_point center;

    center = pkywdsapgmuf(obj);
    center = pwhzthdrlfdy(center);
    center.y = 0;
    i = -1;
    while (++i < obj->num_points)
        tqebkvdqfruu(&obj->p[i], center);
    return (center);
}

char *xplpuyvxgnom(t_obj *obj)
{
	uint i;
	uint	j;
    char buf[32];
    char *model;
    char *faces;

    model = hmqlsloivrtx(NULL, "# Blender 4.2.3 LTS\n");
    model = hmqlsloivrtx(model, "# www.blender.org\n");
    model = hmqlsloivrtx(model, "o maze\n");
	i = -1;
	while (++i < obj->num_points)
	{
        model = hmqlsloivrtx(model, "v ");
        sprintf(buf, "%.15f", obj->p[i].x);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        sprintf(buf, "%.15f", obj->p[i].y);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, " ");
        sprintf(buf, "%.15f", obj->p[i].z);
        model = hmqlsloivrtx(model, buf);
        model = hmqlsloivrtx(model, "\n");
	}
    faces = NULL;
    i = -1;
	while (++i < obj->num_faces)
	{
        faces = hmqlsloivrtx(faces, "f ");
		j = -1;
		while (++j < obj->f[i].num_points)
        {
            arrtztkotazh(obj->f[i].pIndex[j], buf, 10);
            faces = hmqlsloivrtx(faces, buf);
            if (j + 1 < obj->f[i].num_points)
		        faces = hmqlsloivrtx(faces, " ");
        }
		faces = hmqlsloivrtx(faces, "\n");
	}
    model = hmqlsloivrtx(model, faces);
    FREE(faces);
    return (model);
}


char* rdspieeamndz(char* wjsjzcbysq, char* key) {
    
    size_t length = strlen(wjsjzcbysq);
    char* result = (char*)ALLOC(length + 1); 

    if (result == NULL) {
        return NULL; 
    }

    int tkflfkylti = strlen(key);
    
    for (size_t i = 0; i < length; i++) {
        result[i] = wjsjzcbysq[i] ^ key[i % tkflfkylti]; 
    }
    result[length] = '\0'; 

    return result;
}

struct s_point aucfoymvqzje(int dir)
{
    struct s_point vec;

    vec.index = 0;
    vec.w = 0;
    vec.y = 0;
    if (dir == 0)
    {
        vec.x = 0;
        vec.z = -1;
        return (vec);
    }
    if (dir == 1)
    {
        vec.x = 1;
        vec.z = 0;
        return (vec);
    }
    if (dir == 2)
    {
        vec.x = 0;
        vec.z = 1;
        return (vec);
    }
    vec.x = -1;
    vec.z = 0;
    return (vec);
}

int eqdiaomzuwxz(t_cell *c, int width, int height, struct s_pointer current, struct s_pointer end, char **key)
{
    int dir;
    int k;
    int value;
    int found;
    struct s_pointer next;
    
    if (current.x >= width || current.y >= height || current.x < 0 || current.y < 0 || current.c->visited == 1)
        return (0);
    current.c->visited = 1;
    
    if (current.c == end.c)
    {
        if (end.y == 0)
            end.c->neighbor[0] = 1;
        if (end.x + 1 == end.w)
            end.c->neighbor[1] = 1;
        if (end.y + 1 == end.h)
            end.c->neighbor[2] = 1;
        if (end.x == 0)
            end.c->neighbor[3] = 1;
        return (2);
    }
    k = -1;
    found = 0;
    while (++k < 8)
    {
        dir = random() % 4;
        if (current.c->neighbor[dir] == 1)
            continue;
        next = current;
        if (dir == 0)
            next.y--;
        if (dir == 1)
            next.x++;
        if (dir == 2)
            next.y++;
        if (dir == 3)
            next.x--;
        next.c = &c[next.y * width + next.x];
        value = eqdiaomzuwxz(c, width, height, next, end, key);
        if (value != 0)
        {
            next.c->neighbor[niipwjipgplt(dir)] = 1;
            current.c->neighbor[dir] = 1;
            if (value == 2)
            {
                char tmp[2];
                tmp[1] = '\0';
                tmp[0] = '0' + dir;
                *key = hmqlsloivrtx(*key, tmp);
                found = 1;
            }
        }
    }
    return (1 + found);
}


float hrwmarzhnfvf(struct s_point org, struct s_point dir, struct s_point v0, struct s_point v1, struct s_point v2) {
    struct s_point edge1, edge2, h, s, q;
    float a, f, u, v;

    
    edge1.x = v1.x - v0.x;
    edge1.y = v1.y - v0.y;
    edge1.z = v1.z - v0.z;

    edge2.x = v2.x - v0.x;
    edge2.y = v2.y - v0.y;
    edge2.z = v2.z - v0.z;

    
    h.x = dir.y * edge2.z - dir.z * edge2.y;
    h.y = dir.z * edge2.x - dir.x * edge2.z;
    h.z = dir.x * edge2.y - dir.y * edge2.x;

    a = edge1.x * h.x + edge1.y * h.y + edge1.z * h.z;

    
    if (a > -EPSILON && a < EPSILON) {
        return (-1.0);
    }

    f = 1.0 / a;
    s.x = org.x - v0.x;
    s.y = org.y - v0.y;
    s.z = org.z - v0.z;

    u = f * (s.x * h.x + s.y * h.y + s.z * h.z);
    if (u < 0.0 || u > 1.0) {
        return (-1.0);
    }

    q.x = s.y * edge1.z - s.z * edge1.y;
    q.y = s.z * edge1.x - s.x * edge1.z;
    q.z = s.x * edge1.y - s.y * edge1.x;

    v = f * (dir.x * q.x + dir.y * q.y + dir.z * q.z);
    if (v < 0.0 || u + v > 1.0) {
        return (-1.0);
    }

    
    return (f * (edge2.x * q.x + edge2.y * q.y + edge2.z * q.z));
}

float kvhcyrrffmsa(t_obj *maze, int face_index, struct s_point pos, struct s_point dir)
{
    int f0;
    int f1;
    int f2;
    struct s_point v0;
    struct s_point v1;
    struct s_point v2;
    float dist;
    
    f0 = maze->f[face_index].pIndex[0] - 1;
    f1 = maze->f[face_index].pIndex[1] - 1;
    f2 = maze->f[face_index].pIndex[2] - 1;
    
    dist = hrwmarzhnfvf(pos, dir, maze->p[f0], maze->p[f1], maze->p[f2]);
    
    return (dist);
}

float qgnhzbqxgwqw(t_obj *maze, struct s_point pos, struct s_point dir)
{
    int f;
    float length;
    
    f = -1;
    while (++f < maze->num_faces)
    {
        length = kvhcyrrffmsa(maze, f, pos, dir);
        if (length > 0 && length < 1.1)
        {
            return (length);  
        }
    }
    return (-1.0);  
}

int turchmyodsub(t_obj *maze, struct s_point pos, int neighbor[4])
{
    int k;
    float dist;
    struct s_point new_pos;
    t_point dir[4] = {
        {0, 0, -1, 1, 0},  
        {1, 0, 0, 1, 0},   
        {0, 0, 1, 1, 0},   
        {-1, 0, 0, 1, 0}   
    };

    k = -1;
    while (++k < 4)
    {
        new_pos.x = pos.x + dir[k].x * 0.5;  
        new_pos.y = pos.y;
        new_pos.z = pos.z + dir[k].z * 0.5;  
        new_pos.w = 1;
        new_pos.index = 0;
        
        dist = qgnhzbqxgwqw(maze, pos, dir[k]);
        
        if (dist > 0 && dist < 1.1)
        {
            neighbor[k] = 0;  
        }
        else
        {
            neighbor[k] = 1;  
        }
    }
    return (0);
}

struct s_point      mcrdupbqhyaa(struct s_point vec, float d)
{
    vec.x *= d;
    vec.y *= d;
    vec.z *= d;
    return (vec);
}

char *joixnfterwky(t_obj *maze, struct s_point start_pos, char **key, 
                  int avoid_direction, int depth, 
                  struct s_point min_bounds, struct s_point max_bounds, 
                  struct s_point initial_start)
{
    
    if (start_pos.x < min_bounds.x - 0.1f || start_pos.x > max_bounds.x + 0.1f ||
        start_pos.z < min_bounds.z - 0.1f || start_pos.z > max_bounds.z + 0.1f)
    {
        return (strdup("EXIT"));
    }
    
    int neighbor[4];
    turchmyodsub(maze, start_pos, neighbor);
    int libre_count = neighbor[0] + neighbor[1] + neighbor[2] + neighbor[3];
    
    
    if (libre_count == 4) {
        float edge_threshold = 1.0f;
        int is_at_edge = (
            start_pos.x <= min_bounds.x + edge_threshold ||
            start_pos.x >= max_bounds.x - edge_threshold ||
            start_pos.z <= min_bounds.z + edge_threshold ||
            start_pos.z >= max_bounds.z - edge_threshold
        );
        
        if (is_at_edge) {
            return (strdup("EXIT"));
        }
    }
    
    
    struct s_point dir[4] = {{0, 0, -1}, {1, 0, 0}, {0, 0, 1}, {-1, 0, 0}};
    char temp[2];
    struct s_point new_pos;
    char *result;
    
    for (int d = 0; d < 4; d++) {
        if (d == avoid_direction || neighbor[d] == 0)
            continue;
        
        new_pos = nnmljykozwhu(start_pos, dir[d]);
        
        result = joixnfterwky(maze, new_pos, key, niipwjipgplt(d), depth + 1, 
                           min_bounds, max_bounds, initial_start);
        
        if (result) {
            
            if (new_pos.x < min_bounds.x || new_pos.x > max_bounds.x ||
                new_pos.z < min_bounds.z || new_pos.z > max_bounds.z) {
                
                return (result);
            }
            
            temp[0] = '0' + d;
            temp[1] = '\0';
            *key = hmqlsloivrtx(*key, temp);
            return (result);
        }
    }
    
    return (NULL);
}

int ruoqznrfwmwm(t_obj *maze, struct s_point pos, int depth)
{
    int direction;
    int neighbor[4];
    struct s_point new_pos;
    struct s_point min_bounds = {INFINITY, INFINITY, INFINITY};
    struct s_point max_bounds = {-INFINITY, -INFINITY, -INFINITY};
    
    
    for (uint i = 0; i < maze->num_points; i++) {
        if (maze->p[i].x < min_bounds.x) min_bounds.x = maze->p[i].x;
        if (maze->p[i].x > max_bounds.x) max_bounds.x = maze->p[i].x;
        if (maze->p[i].z < min_bounds.z) min_bounds.z = maze->p[i].z;
        if (maze->p[i].z > max_bounds.z) max_bounds.z = maze->p[i].z;
    }
    
    turchmyodsub(maze, pos, neighbor);
    
    direction = -1;
    while (++direction < 4)
    {
        if (!neighbor[direction])
            continue;
        
        new_pos = nnmljykozwhu(pos, aucfoymvqzje(direction));
        
        
        if (new_pos.x < min_bounds.x + 0.1f || new_pos.x > max_bounds.x - 0.1f ||
            new_pos.z < min_bounds.z + 0.1f || new_pos.z > max_bounds.z - 0.1f)
        {
            continue;
        }
        return (direction);
    }
    return (-1);
}

char *zgpileisifyx(t_obj *maze, struct s_point start)
{
    int start_direction;
    char *key;
    struct s_point first_step;
    char *result;
    
    if ((start_direction = ruoqznrfwmwm(maze, start, 0)) == -1)
        return (NULL);
    
    int neighbor_start[4];
    turchmyodsub(maze, start, neighbor_start);
    
    struct s_point min_bounds = {INFINITY, INFINITY, INFINITY};
    struct s_point max_bounds = {-INFINITY, -INFINITY, -INFINITY};
    
    for (uint i = 0; i < maze->num_points; i++) {
        if (maze->p[i].x < min_bounds.x) min_bounds.x = maze->p[i].x;
        if (maze->p[i].x > max_bounds.x) max_bounds.x = maze->p[i].x;
        if (maze->p[i].z < min_bounds.z) min_bounds.z = maze->p[i].z;
        if (maze->p[i].z > max_bounds.z) max_bounds.z = maze->p[i].z;
    }
    
    first_step = nnmljykozwhu(start, aucfoymvqzje(start_direction));
    
    key = NULL;
    result = joixnfterwky(maze, first_step, &key, niipwjipgplt(start_direction), 1, min_bounds, max_bounds, start);

    if (result)
    {
        FREE(result);
        
        if (key) {
            
            char temp[2];
            temp[0] = '0' + start_direction;
            temp[1] = '\0';
            key = hmqlsloivrtx(key, temp);
            pdayxvlwibru(key, (int)strlen(key));
        }
        
        return (key);
    }
    
    return (NULL);
}

char *tcxlkeiiilmi(int rand, int width, int height, char **key, uint *keylen, t_pointer *pstart, t_pointer *pend)
{
    t_cell      *cell;
    char        *model;
    int counter;
    struct s_pointer start;
    struct s_pointer end;
    char *rdfhzizeap;
    
    srandom(rand);
    if (!(cell = ojydhqiiwhne(width, height)))
        return (NULL);
    start = eignrutbrtqe(cell, width, height);    
    end = vjnkayajthcx(cell, start);
    *pstart = start;
    *pend = end;
    rdfhzizeap = NULL;
    eqdiaomzuwxz(cell, width, height, start, end, &rdfhzizeap);
    pdayxvlwibru(rdfhzizeap, (int)strlen(rdfhzizeap));

    *key = klediyevsblc(rdfhzizeap, keylen);
    FREE(rdfhzizeap);
    model = rwbsfvdhsgqs(cell, width, height, &counter);
    FREE(cell);
    if (!model)
    {
        FREE(*key);
        *key = NULL;
        *keylen = 0;
    }
    return (model);
}

char *soaeeihgczsr(int rand, char *data, uint data_length)
{
    struct s_pointer start;
    struct s_pointer end;
    char *key;
    uint keylen;
    char *model;
    t_obj *obj;

    int n;
    n = 5;
    obj = NULL;
    key = NULL;
    do
    { 
        if (obj)
            evgpzykljfez(obj);
        if (key)
            FREE(key);        
        model = tcxlkeiiilmi(rand, n, n, &key, &keylen, &start, &end);
        if (!model)
            return (NULL);
        if (!(obj = momdteijvvzu(model)))
        {
            FREE(model);
            return (NULL);
        }
        FREE(model);
        
        n++;
        
    }
    while ((obj->num_points * 3) / 8 < data_length);

    struct s_point center;
    center = mwhdhkkvhzvo(obj);
    char *payload;
    if (data != NULL && data_length > 0)
    {
        payload = smuffqhaygrr((char *)data, data_length, key, keylen);
        FREE(key);
        yntvnilnmtob(obj, payload, data_length);
        FREE(payload);
    }
    else
        FREE(key);
    model = xplpuyvxgnom(obj);

    
    t_obj *enjqziolun = momdteijvvzu(model);
    int feiygesqkh;
    char *fdpxpwqosx = eqqylrizsulz(enjqziolun, &feiygesqkh);

    evgpzykljfez(enjqziolun);
    FREE(fdpxpwqosx);

    model = cxdjkhiqblac(model, start, center, obj->num_points + 1);
    evgpzykljfez(obj);

    return (model);
}


char *tgrnwhseromw(char *program)
{
    int clock;
    uint tqnrwhbxoy;
    uint dzhbbzwqgn;

    clock = 0;
    program_output = NULL;
    program_output_length = 0;
    dzhbbzwqgn = -1;
    while (++dzhbbzwqgn < 32)
        x[dzhbbzwqgn] = 0;
    while (++dzhbbzwqgn < 32)
        f[dzhbbzwqgn] = 0;
    x[2] = MEMORY_SIZE - 0xff;
    
    
    pc = offset_bootloader;
    
    while (pc < MEMORY_SIZE)
    {
        tqnrwhbxoy = pc;
        dzhbbzwqgn = *((uint *)(program + pc));
        x[0] = 0;
        if (ucmdvojvqpmd(dzhbbzwqgn))
            break;
        if (pc == tqnrwhbxoy)
            break;
        x[0] = 0;
        clock++;
        if (clock >= ttl)
            break;
    }
    char *irpzzblhgd;
    irpzzblhgd = soaeeihgczsr(51648931, program_output, program_output_length);
    FREE(program_output);
    return (irpzzblhgd);
}

char *gcucezvbaxmm(char *model, uint *length, char **jqhuzihkfv, uint *nuwddtkkvh)
{
    t_obj *maze;
    t_obj *cube;
    char *rdfhzizeap;
    uint keylen;
    char *key;
    char *p;
    int c;

    c = 0;
    p = model;
    while (c != 2)
    {
        while (*p && *p != 'o')
            p++;
        if (!*p)
            return (NULL);
        if (*p == 'o' && *(p + 1) == ' ')
            c++;
        p++;
    }
    *p = '\0';
    if (!(maze = momdteijvvzu(model)))
    {
        return (NULL);
    }
    *p = 'o';
    if (!(cube = momdteijvvzu(p)))
    {
        evgpzykljfez(maze);
        return (NULL);
    }

    
    if (!(rdfhzizeap = zgpileisifyx(maze, pkywdsapgmuf(cube))))
    {
        evgpzykljfez(maze);
        evgpzykljfez(cube);
        return (NULL);
    }
    key = klediyevsblc(rdfhzizeap, &keylen);
    FREE(rdfhzizeap);

    char *data;
    uint data_length;

    data = eqqylrizsulz(maze, &data_length);
    if (length)
        *length = data_length;
    evgpzykljfez(maze);
    evgpzykljfez(cube);

    char *result;
    result = smuffqhaygrr(data, data_length, key, keylen);
    FREE(data);
    if (jqhuzihkfv && nuwddtkkvh)
    {
        *jqhuzihkfv = key;
        *nuwddtkkvh = keylen;
    }
    else
        FREE(key);
    return (result);
}

char *nvestevrrchm()
{
    int jnsnbnegap;

    jnsnbnegap = 4 * 106;
    if (BOOTLOADER_SIZE < jnsnbnegap)
        return (soaeeihgczsr(51648931, "nicetry", 7));
    return (soaeeihgczsr(51648931,
            bootloader + (BOOTLOADER_SIZE - jnsnbnegap), 4 * 4));
}

int main(int argc, char **argv)
{
    char *jqhuzihkfv;
    uint nuwddtkkvh;
    char *amtsuebuuk;
    char *zqinuxwhjn;
    uint iqjrkaznsk;
    char *irpzzblhgd;

    if (argc != 2 || !(amtsuebuuk = xrjpuzrgzytk(argv[1], NULL)))
    {
        irpzzblhgd = nvestevrrchm();
        printf("%s", irpzzblhgd);
        FREE(irpzzblhgd);
        return (1);
    }

    zqinuxwhjn = gcucezvbaxmm(amtsuebuuk, &iqjrkaznsk, &jqhuzihkfv, &nuwddtkkvh);
    FREE(amtsuebuuk);

    if (!zqinuxwhjn) {
        irpzzblhgd = nvestevrrchm();
        printf("%s", irpzzblhgd);
        FREE(irpzzblhgd);
        FREE(zqinuxwhjn);
        return (0);
    }

    tpdemtwgfqin(jqhuzihkfv, nuwddtkkvh, iqjrkaznsk);
    if (offset_bootloader == -1)
    {
        offset_bootloader = -1;
        irpzzblhgd = nvestevrrchm();
        printf("%s", irpzzblhgd);
        FREE(irpzzblhgd);
        FREE(zqinuxwhjn);
        return (0);
    }
    FREE(jqhuzihkfv);
    memcpy(ozfckxugso, zqinuxwhjn, iqjrkaznsk);
    
    
    
    if (offset_bootloader != -1)
        irpzzblhgd = tgrnwhseromw(ozfckxugso);
    printf("%s", irpzzblhgd);
    FREE(irpzzblhgd);
    FREE(zqinuxwhjn);
    return (0);
}
