LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka.c
// Function: help
void help(void)
{
    printf("%s\n", umkaGetVersion());
    printf("(C) Vasiliy Tereshkov, 2020-2025\n");
    printf("Usage: umka [<parameters>] <file.um> [<script-parameters>]\n");
    printf("Parameters:\n");
    printf("    -stack <stack-size>     - Set stack size\n");
    printf("    -asm                    - Write assembly listing\n");
    printf("    -check                  - Compile only\n");
    printf("    -warn                   - Enable warnings\n");
    printf("    -sandbox                - Run in sandbox mode\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4810
movq %rax, %rsi
leaq 0x1d0d00(%rip), %rdi    # 0x1d41f3
movb $0x0, %al
callq 0x3150
leaq 0x1d0b03(%rip), %rdi    # 0x1d4004
movb $0x0, %al
callq 0x3150
leaq 0x1d0b17(%rip), %rdi    # 0x1d4026
movb $0x0, %al
callq 0x3150
leaq 0x1d0b45(%rip), %rdi    # 0x1d4062
movb $0x0, %al
callq 0x3150
leaq 0x1d0b44(%rip), %rdi    # 0x1d406f
movb $0x0, %al
callq 0x3150
leaq 0x1d0b64(%rip), %rdi    # 0x1d409d
movb $0x0, %al
callq 0x3150
leaq 0x1d0b8c(%rip), %rdi    # 0x1d40d3
movb $0x0, %al
callq 0x3150
leaq 0x1d0baa(%rip), %rdi    # 0x1d40ff
movb $0x0, %al
callq 0x3150
leaq 0x1d0bcb(%rip), %rdi    # 0x1d412e
movb $0x0, %al
callq 0x3150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka.c
// Function: writeAsmFile
bool writeAsmFile(void *umka, const char *mainPath)
{
    bool ok = false;

    char *asmFileName = malloc(strlen(mainPath) + 4 + 1);
    if (!asmFileName)
        fprintf(stderr, "Error: Out of memory\n");
    else
    {
        sprintf(asmFileName, "%s.asm", mainPath);
        const char *asmBuf = umkaAsm(umka);
        if (!asmBuf)
            fprintf(stderr, "Error: Cannot output assembly listing\n");
        else
        {
            FILE *asmFile = fopen(asmFileName, "w");
            if (!asmFile)
                fprintf(stderr, "Error: Cannot open file %s\n", asmFileName);
            else
            {
                if (fwrite(asmBuf, strlen(asmBuf), 1, asmFile) != 1)
                    fprintf(stderr, "Error: Cannot write file %s\n", asmFileName);
                else
                    ok = true;
                fclose(asmFile);
            }
        }
        free(asmFileName);
    }

    return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
addq $0x4, %rdi
addq $0x1, %rdi
callq 0x32a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x35c5
movq 0x1e2a49(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
leaq 0x1d0ba8(%rip), %rsi    # 0x1d4161
movb $0x0, %al
callq 0x3230
jmp 0x36a7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1d0ba3(%rip), %rsi    # 0x1d4177
movb $0x0, %al
callq 0x3380
movq -0x8(%rbp), %rdi
callq 0x4340
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x360c
movq 0x1e2a02(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
leaq 0x1d0b7e(%rip), %rsi    # 0x1d417e
movb $0x0, %al
callq 0x3230
jmp 0x369e
movq -0x20(%rbp), %rdi
leaq 0x1d0e86(%rip), %rsi    # 0x1d449d
callq 0x3320
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3645
movq 0x1e29ca(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1d0b69(%rip), %rsi    # 0x1d41a5
movb $0x0, %al
callq 0x3230
jmp 0x369c
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rcx
movl $0x1, %edx
callq 0x3390
cmpq $0x1, %rax
je 0x368f
movq 0x1e2980(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1d0b3b(%rip), %rsi    # 0x1d41c1
movb $0x0, %al
callq 0x3230
jmp 0x3693
movb $0x1, -0x11(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3110
jmp 0x369e
movq -0x20(%rbp), %rdi
callq 0x3040
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka.c
// Function: printRuntimeError
void printRuntimeError(void *umka)
{
    const UmkaError *error = umkaGetError(umka);

    if (error->msg[0])
    {
        fprintf(stderr, "\nRuntime error %s (%d): %s\n", error->fileName, error->line, error->msg);
        fprintf(stderr, "Stack trace:\n");

        for (int depth = 0; depth < MAX_CALL_STACK_DEPTH; depth++)
        {
            char fileName[MAX_STR_LENGTH + 1], fnName[MAX_STR_LENGTH + 1];
            int line;

            if (!umkaGetCallStack(umka, depth, MAX_STR_LENGTH + 1, NULL, fileName, fnName, &line))
                break;

            fprintf(stderr, "    %s: %s (%d)\n", fnName, fileName, line);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpb $0x0, (%rax)
je 0x385e
movq 0x1e2854(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %r8
leaq 0x1d0a4a(%rip), %rsi    # 0x1d420e
movb $0x0, %al
callq 0x3230
movq 0x1e2826(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
leaq 0x1d0a4e(%rip), %rsi    # 0x1d422a
movb $0x0, %al
callq 0x3230
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x385c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x120(%rbp), %r8
leaq -0x230(%rbp), %r9
movl $0x101, %edx            # imm = 0x101
xorl %eax, %eax
movl %eax, %ecx
leaq -0x234(%rbp), %rax
movq %rax, (%rsp)
callq 0x4430
testb $0x1, %al
jne 0x3824
jmp 0x385c
movq 0x1e27cd(%rip), %rax    # 0x1e5ff8
movq (%rax), %rdi
leaq -0x230(%rbp), %rdx
leaq -0x120(%rbp), %rcx
movl -0x234(%rbp), %r8d
leaq 0x1d09ee(%rip), %rsi    # 0x1d4238
movb $0x0, %al
callq 0x3230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x37ea
jmp 0x385e
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaInit
UMKA_API bool umkaInit(void *umka, const char *fileName, const char *sourceString, int stackSize, void *reserved, int argc, char **argv, bool fileSystemEnabled, bool implLibsEnabled, UmkaWarningCallback warningCallback)
{
    Compiler *comp = umka;
    memset(comp, 0, sizeof(Compiler));

    // First set error handlers
    comp->error.handler = compileError;
    comp->error.runtimeHandler = runtimeError;
    comp->error.warningHandler = compileWarning;
    comp->error.warningCallback = (WarningCallback)warningCallback;
    comp->error.context = comp;

    if (setjmp(comp->error.jumper) == 0)
    {
        compilerInit(comp, fileName, sourceString, stackSize, argc, argv, fileSystemEnabled, implLibsEnabled);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %ecx, -0x54(%rbp)
movq %rdx, %rax
movl -0x54(%rbp), %edx
movq %rax, -0x50(%rbp)
movq %rsi, %rax
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq %rdi, %r10
movq -0x48(%rbp), %rdi
movq 0x28(%rbp), %rax
movb 0x20(%rbp), %al
movb 0x18(%rbp), %cl
movq 0x10(%rbp), %r11
movq %r10, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
andb $0x1, %cl
movb %cl, -0x35(%rbp)
andb $0x1, %al
movb %al, -0x36(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x52d8, %edx           # imm = 0x52D8
callq 0x3190
movq -0x40(%rbp), %rax
leaq 0xb6(%rip), %rcx        # 0x3cc0
movq %rcx, 0x50f8(%rax)
movq -0x40(%rbp), %rax
leaq 0x1c4(%rip), %rcx       # 0x3de0
movq %rcx, 0x5100(%rax)
movq -0x40(%rbp), %rax
leaq 0x2f2(%rip), %rcx       # 0x3f20
movq %rcx, 0x5108(%rax)
movq 0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x5110(%rax)
movq -0x40(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x5118(%rax)
movq -0x40(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0x28, %rdi
callq 0x3210
cmpl $0x0, %eax
jne 0x3caa
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x34(%rbp), %r8d
movq 0x10(%rbp), %r9
movb -0x35(%rbp), %r10b
movb -0x36(%rbp), %al
andb $0x1, %r10b
andb $0x1, %al
movzbl %r10b, %r10d
movl %r10d, (%rsp)
movzbl %al, %eax
movl %eax, 0x8(%rsp)
callq 0x61d0
movb $0x1, -0x1(%rbp)
jmp 0x3cae
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: compileError
static void compileError(void *context, const char *format, ...)
{
    va_list args;
    va_start(args, format);

    Compiler *comp = context;
    errorReportInit(&comp->error.report, &comp->storage, comp->lex.fileName, comp->debug.fnName, comp->lex.tok.line, comp->lex.tok.pos, 1, format, args);

    vmKill(&comp->vm);

    va_end(args);
    longjmp(comp->error.jumper, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x3cfb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0xf8, %rdi
movq -0x38(%rbp), %rsi
addq $0xf0, %rsi
movq -0x38(%rbp), %rax
movq 0x4ba8(%rax), %rdx
movq -0x38(%rbp), %rax
movq 0x50e8(%rax), %rcx
movq -0x38(%rbp), %rax
movl 0x4ce0(%rax), %r8d
movq -0x38(%rbp), %rax
movl 0x4ce4(%rax), %r9d
movq -0x10(%rbp), %r10
leaq -0x30(%rbp), %rax
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x49e0
movq -0x38(%rbp), %rdi
addq $0x5058, %rdi           # imm = 0x5058
callq 0xe1590
leaq -0x30(%rbp), %rax
movq -0x38(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3300
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: runtimeError
static void runtimeError(void *context, int code, const char *format, ...)
{
    va_list args;
    va_start(args, format);

    Compiler *comp = context;
    const DebugInfo *debug = &comp->vm.fiber->debugPerInstr[comp->vm.fiber->ip];
    errorReportInit(&comp->error.report, &comp->storage, debug->fileName, debug->fnName, debug->line, 1, code, format, args);

    vmKill(&comp->vm);

    va_end(args);
    longjmp(comp->error.jumper, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x3e1b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x5058(%rax), %rax
movq 0x60(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x5058(%rcx), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0xf8, %rdi
movq -0x38(%rbp), %rsi
addq $0xf0, %rsi
movq -0x40(%rbp), %rax
movq (%rax), %rdx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movl 0x10(%rax), %r8d
movl -0xc(%rbp), %r11d
movq -0x18(%rbp), %r10
leaq -0x30(%rbp), %rax
movl $0x1, %r9d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x49e0
movq -0x38(%rbp), %rdi
addq $0x5058, %rdi           # imm = 0x5058
callq 0xe1590
leaq -0x30(%rbp), %rax
movq -0x38(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3300
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: compileWarning
static void compileWarning(void *context, const DebugInfo *debug, const char *format, ...)
{
    va_list args;
    va_start(args, format);

    Compiler *comp = context;

    ErrorReport report = {0};
    errorReportInit(&report, &comp->storage,
                    debug ? debug->fileName : comp->lex.fileName,
                    debug ? debug->fnName : comp->debug.fnName,
                    debug ? debug->line : comp->lex.tok.line,
                    debug ? 1 : comp->lex.tok.pos,
                    0,
                    format, args);

    if (comp->error.warningCallback)
        ((UmkaWarningCallback)comp->error.warningCallback)((UmkaError *)&report);

    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
testb %al, %al
je 0x3f61
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3190
movq -0x38(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3fe6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x120(%rbp)
jmp 0x3ff8
movq -0x38(%rbp), %rax
movq 0x4ba8(%rax), %rax
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x401e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x130(%rbp)
jmp 0x4030
movq -0x38(%rbp), %rax
movq 0x50e8(%rax), %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
movq %rax, -0x138(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4054
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x13c(%rbp)
jmp 0x4064
movq -0x38(%rbp), %rax
movl 0x4ce0(%rax), %eax
movl %eax, -0x13c(%rbp)
movl -0x13c(%rbp), %eax
movl %eax, -0x140(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4084
movl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x4094
movq -0x38(%rbp), %rax
movl 0x4ce4(%rax), %eax
movl %eax, -0x144(%rbp)
movl -0x140(%rbp), %r8d
movq -0x138(%rbp), %rcx
movq -0x128(%rbp), %rdx
movq -0x118(%rbp), %rsi
movl -0x144(%rbp), %r9d
movq -0x18(%rbp), %r10
leaq -0x30(%rbp), %rax
leaq -0x60(%rbp), %rdi
xorl %r11d, %r11d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x49e0
movq -0x38(%rbp), %rax
cmpq $0x0, 0x5110(%rax)
je 0x40f8
movq -0x38(%rbp), %rax
leaq -0x60(%rbp), %rdi
callq *0x5110(%rax)
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaCompile
UMKA_API bool umkaCompile(void *umka)
{
    Compiler *comp = umka;

    if (setjmp(comp->error.jumper) == 0)
    {
        compilerCompile(comp);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0x28, %rdi
callq 0x3210
cmpl $0x0, %eax
jne 0x414c
movq -0x18(%rbp), %rdi
callq 0x81d0
movb $0x1, -0x1(%rbp)
jmp 0x4150
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaRun
UMKA_API int umkaRun(void *umka)
{
    Compiler *comp = umka;

    if (setjmp(comp->error.jumper) == 0)
    {
        comp->error.jumperNesting++;
        compilerRun(comp);
        comp->error.jumperNesting--;
        return 0;
    }

    return comp->error.report.code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50f8, %rdi           # imm = 0x50F8
addq $0x28, %rdi
callq 0x3210
cmpl $0x0, %eax
jne 0x41c5
movq -0x18(%rbp), %rax
movl 0x51e8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x51e8(%rax)
movq -0x18(%rbp), %rdi
callq 0x8220
movq -0x18(%rbp), %rax
movl 0x51e8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x51e8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x41d2
movq -0x18(%rbp), %rax
movl 0x5208(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaCall
UMKA_API int umkaCall(void *umka, UmkaFuncContext *fn)
{
    Compiler *comp = umka;

    // Nested calls to umkaCall() should not reset the error jumper
    jmp_buf dummyJumper;
    jmp_buf *jumper = comp->error.jumperNesting == 0 ? &comp->error.jumper : &dummyJumper;

    if (setjmp(*jumper) == 0)
    {
        comp->error.jumperNesting++;
        compilerCall(comp, (FuncContext *)fn);
        comp->error.jumperNesting--;
        return 0;
    }

    return comp->error.report.code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x51e8(%rax)
jne 0x421f
movq -0x20(%rbp), %rax
addq $0x50f8, %rax           # imm = 0x50F8
addq $0x28, %rax
movq %rax, -0x100(%rbp)
jmp 0x422f
leaq -0xf0(%rbp), %rax
movq %rax, -0x100(%rbp)
jmp 0x422f
movq -0x100(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x3210
cmpl $0x0, %eax
jne 0x428a
movq -0x20(%rbp), %rax
movl 0x51e8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x51e8(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8250
movq -0x20(%rbp), %rax
movl 0x51e8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x51e8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4297
movq -0x20(%rbp), %rax
movl 0x5208(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaGetCallStack
UMKA_API bool umkaGetCallStack(void *umka, int depth, int nameSize, int *offset, char *fileName, char *fnName, int *line)
{
    Compiler *comp = umka;
    Slot *base = comp->vm.fiber->base;
    int ip = comp->vm.fiber->ip;

    while (depth-- > 0)
        if (!vmUnwindCallStack(&comp->vm, &base, &ip))
            return false;

    if (offset)
        *offset = ip;

    if (fileName)
        snprintf(fileName, nameSize, "%s", comp->vm.fiber->debugPerInstr[ip].fileName);

    if (fnName)
        snprintf(fnName, nameSize, "%s", comp->vm.fiber->debugPerInstr[ip].fnName);

    if (line)
        *line = comp->vm.fiber->debugPerInstr[ip].line;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x5058(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x5058(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x44b5
movq -0x38(%rbp), %rdi
addq $0x5058, %rdi           # imm = 0x5058
leaq -0x40(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0xe1c00
testb $0x1, %al
jne 0x44b3
movb $0x0, -0x1(%rbp)
jmp 0x4568
jmp 0x447e
cmpq $0x0, -0x20(%rbp)
je 0x44c5
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x44ff
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x5058(%rax), %rax
movq 0x60(%rax), %rax
movslq -0x44(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0x1d5aab(%rip), %rdx    # 0x1d9fa3
movb $0x0, %al
callq 0x3170
cmpq $0x0, -0x30(%rbp)
je 0x453a
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x5058(%rax), %rax
movq 0x60(%rax), %rax
movslq -0x44(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq 0x1d5a70(%rip), %rdx    # 0x1d9fa3
movb $0x0, %al
callq 0x3170
cmpq $0x0, 0x10(%rbp)
je 0x4564
movq -0x38(%rbp), %rax
movq 0x5058(%rax), %rax
movq 0x60(%rax), %rax
movslq -0x44(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaGetDynArrayLen
UMKA_API int umkaGetDynArrayLen(const void *array)
{
    const DynArray *dynArray = (const DynArray *)array;
    if (!dynArray->data)
        return 0;
    return getDims(dynArray)->len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x47d8
movl $0x0, -0x4(%rbp)
jmp 0x47e7
movq -0x18(%rbp), %rdi
callq 0x47f0
movq (%rax), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaGetParam
UMKA_API UmkaStackSlot *umkaGetParam(UmkaStackSlot *params, int index)
{
    const ParamLayout *paramLayout = (ParamLayout *)params[-4].ptrVal;      // For -4, see the stack layout diagram in umka_vm.c
    if (index < 0 || index >= paramLayout->numParams - paramLayout->numResultParams - 1)
        return NULL;
    return params + paramLayout->firstSlotIndex[index + 1];                                                 // + 1 to skip upvalues
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x48d9
movslq -0x14(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
subq 0x8(%rdx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jl 0x48e3
movq $0x0, -0x8(%rbp)
jmp 0x4904
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq 0x18(%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_api.c
// Function: umkaGetResult
UMKA_API UmkaStackSlot *umkaGetResult(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const ParamLayout *paramLayout = (ParamLayout *)params[-4].ptrVal;      // For -4, see the stack layout diagram in umka_vm.c
    if (paramLayout->numResultParams == 1)
        result->ptrVal = params[paramLayout->firstSlotIndex[paramLayout->numParams - 1]].ptrVal;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x4986
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
subq $0x1, %rdx
movq 0x18(%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: errorReportInit
void errorReportInit(ErrorReport *report, Storage *storage, const char *fileName, const char *fnName, int line, int pos, int code, const char *format, va_list args)
{
    char *reportFileName = storageAdd(storage, strlen(fileName) + 1);
    strcpy(reportFileName, fileName);
    report->fileName = reportFileName;

    char *reportFnName = storageAdd(storage, strlen(fnName) + 1);
    strcpy(reportFnName, fnName);
    report->fnName = reportFnName;

    report->line = line;
    report->pos = pos;
    report->code = code;

    va_list argsCopy;
    va_copy(argsCopy, args);

    const int msgLen = vsnprintf(NULL, 0, format, args);
    char *reportMsg = storageAdd(storage, msgLen + 1);
    vsnprintf(reportMsg, msgLen + 1, format, argsCopy);
    report->msg = reportMsg;

    va_end(argsCopy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3120
movq -0x70(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x4b20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3120
movq -0x68(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x4b20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x30a0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq -0x50(%rbp), %rax
movq 0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rbp), %rdx
movq 0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x30d0
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movl -0x54(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4b20
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x18(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x30d0
movq -0x60(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: storageAdd
void *storageAdd(Storage *storage, int64_t size)
{
    StorageChunk *chunk = malloc(sizeof(StorageChunk) + size);
    if (!chunk)
        storage->error->handler(storage->error->context, "Out of memory");

    chunk->prev = NULL;
    chunk->next = storage->first;
    chunk->size = size;
    memset(chunk->data, 0, size);

    if (storage->first)
        storage->first->prev = chunk;
    storage->first = chunk;

    return chunk->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x32a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b6a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1cf751(%rip), %rsi    # 0x1d42b7
movb $0x0, %al
callq *%rcx
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x3190
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4bbb
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x18, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: storageFree
void storageFree(Storage *storage)
{
    while (storage->first)
    {
        StorageChunk *next = storage->first->next;
        free(storage->first);
        storage->first = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4c4e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4c1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: storageAddStr
char *storageAddStr(Storage *storage, int64_t len)
{
    StrDimensions dims = {.len = len, .capacity = len + 1};

    char *dimsAndData = storageAdd(storage, sizeof(StrDimensions) + dims.capacity);
    *(StrDimensions *)dimsAndData = dims;

    char *data = dimsAndData + sizeof(StrDimensions);
    data[len] = 0;

    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x4b20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: storageAddDynArray
DynArray *storageAddDynArray(Storage *storage, const struct tagType *type, int64_t len)
{
    DynArray *array = storageAdd(storage, sizeof(DynArray));

    array->type     = type;
    array->itemSize = array->type->base->size;

    DynArrayDimensions dims = {.len = len, .capacity = 2 * (len + 1)};

    char *dimsAndData = storageAdd(storage, sizeof(DynArrayDimensions) + dims.capacity * array->itemSize);
    *(DynArrayDimensions *)dimsAndData = dims;

    array->data = dimsAndData + sizeof(DynArrayDimensions);
    return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x4b20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq 0xc0(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
imulq 0x8(%rax), %rsi
addq $0x10, %rsi
callq 0x4b20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: storageRemove
void storageRemove(Storage *storage, void *data)
{
    StorageChunk *chunk = (StorageChunk *)((char *)data - sizeof(StorageChunk));

    if (chunk == storage->first)
        storage->first = chunk->next;

    if (chunk->prev)
        chunk->prev->next = chunk->next;

    if (chunk->next)
        chunk->next->prev = chunk->prev;

    free(chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x4db8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4dd5
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4df2
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: storageRealloc
void *storageRealloc(Storage *storage, void *data, int64_t size)
{
    const StorageChunk *chunk = (const StorageChunk *)((char *)data - sizeof(StorageChunk));

    void *newData = storageAdd(storage, size);
    memcpy(newData, data, chunk->size);
    storageRemove(storage, data);

    return newData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4b20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x3270
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4d80
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: moduleInit
void moduleInit(Modules *modules, Storage *storage, bool implLibsEnabled, Error *error)
{
    for (int i = 0; i < MAX_MODULES; i++)
    {
        modules->module[i] = NULL;
        modules->moduleSource[i] = NULL;
    }
    modules->numModules = 0;
    modules->numModuleSources = 0;
    modules->implLibsEnabled = implLibsEnabled;
    modules->storage = storage;
    modules->error = error;

    if (!moduleCurFolder(modules->curFolder, DEFAULT_STR_LEN + 1))
        modules->error->handler(modules->error->context, "Cannot get current folder");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x400, -0x24(%rbp)     # imm = 0x400
jge 0x4eca
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, 0x2000(%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4e92
movq -0x8(%rbp), %rax
movl $0x0, 0x4000(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4004(%rax)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4108(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4110(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4118(%rax)
movq -0x8(%rbp), %rdi
addq $0x4008, %rdi           # imm = 0x4008
movl $0x100, %esi            # imm = 0x100
callq 0x4f60
cmpq $0x0, %rax
jne 0x4f57
movq -0x8(%rbp), %rax
movq 0x4118(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x4118(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1cf372(%rip), %rsi    # 0x1d42c5
movb $0x0, %al
callq *%rcx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: moduleCurFolder
char *moduleCurFolder(char *buf, int size)
{
#ifdef _WIN32
    if (GetCurrentDirectory(size, buf) == 0)
        return NULL;
#else
    if (!getcwd(buf, size))
        return NULL;
#endif

    int len = strlen(buf);

    if (len > 0 && (buf[len - 1] == '/' || buf[len - 1] == '\\'))
        return buf;

    if (len > size - 2)
        return NULL;

    buf[len] = '/';
    buf[len + 1] = 0;
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x31a0
cmpq $0x0, %rax
jne 0x4f8f
movq $0x0, -0x8(%rbp)
jmp 0x5013
movq -0x10(%rbp), %rdi
callq 0x3120
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x4fd7
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x4fcd
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x4fd7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5013
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jle 0x4fee
movq $0x0, -0x8(%rbp)
jmp 0x5013
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: moduleFind
int moduleFind(const Modules *modules, const char *path)
{
    const unsigned int pathHash = hash(path);
    for (int i = 0; i < modules->numModules; i++)
        if (modules->module[i]->pathHash == pathHash && strcmp(modules->module[i]->path, path) == 0)
            return i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5330
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4000(%rcx), %eax
jge 0x5318
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x300(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x530b
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x530b
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x531f
jmp 0x530d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x52c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.h
// Function: hash
static inline unsigned int hash(const char *str)
{
    // djb2 hash
    unsigned int hash = 5381;
    char ch;

    while ((ch = *str++))
        hash = ((hash << 5) + hash) + ch;

    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0xc(%rbp)     # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0xd(%rbp)
cmpb $0x0, %al
je 0x536b
movl -0xc(%rbp), %eax
shll $0x5, %eax
addl -0xc(%rbp), %eax
movsbl -0xd(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x533f
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: moduleFindImported
int moduleFindImported(const Modules *modules, const Blocks *blocks, const char *alias)
{
    for (int i = 0; i < modules->numModules; i++)
    {
        const char *importAlias = modules->module[blocks->module]->importAlias[i];
        if (importAlias && strcmp(importAlias, alias) == 0)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4000(%rcx), %eax
jge 0x53eb
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x968(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movq 0x310(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x53de
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x53de
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x53f2
jmp 0x53e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x538b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: modulePathIsAbsolute
bool modulePathIsAbsolute(const char *path)
{
    while (path && (*path == ' ' || *path == '\t'))
        path++;

    if (!path)
        return false;

#ifdef _WIN32
    return isalpha(path[0]) && path[1] == ':';
#else
    return path[0] == '/';
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x581b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x12(%rbp)
je 0x5815
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5824
jmp 0x5832
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x57e8
cmpq $0x0, -0x10(%rbp)
jne 0x583f
movb $0x0, -0x1(%rbp)
jmp 0x5851
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: moduleFindSource
const ModuleSource *moduleFindSource(const Modules *modules, const char *path)
{
    const unsigned int pathHash = hash(path);
    for (int i = 0; i < modules->numModuleSources; i++)
        if (modules->moduleSource[i]->pathHash == pathHash && strcmp(modules->moduleSource[i]->path, path) == 0)
            return modules->moduleSource[i];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5330
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4004(%rcx), %eax
jge 0x58fe
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x2000(%rax,%rcx,8), %rax
movl 0x300(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x58f1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x2000(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x58f1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x2000(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5906
jmp 0x58f3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5893
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: blocksInit
void blocksInit(Blocks *blocks, Error *error)
{
    blocks->numBlocks = 0;
    blocks->top = -1;
    blocks->module = -1;
    blocks->error = error;

    blocksEnter(blocks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x960(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x964(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x968(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x970(%rax)
movq -0x8(%rbp), %rdi
callq 0x5e60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: blocksEnterFn
void blocksEnterFn(Blocks *blocks, const struct tagIdent *fn, bool hasUpvalues)
{
    if (blocks->top >= MAX_BLOCK_NESTING)
        blocks->error->handler(blocks->error->context, "Block nesting is too deep");

    blocks->top++;
    blocks->item[blocks->top].block = blocks->numBlocks++;
    blocks->item[blocks->top].fn = fn;
    blocks->item[blocks->top].localVarSize = 0;
    blocks->item[blocks->top].hasReturn = false;
    blocks->item[blocks->top].hasUpvalues = hasUpvalues;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x64, 0x964(%rax)
jl 0x5edc
movq -0x8(%rbp), %rax
movq 0x970(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x970(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1ce4b1(%rip), %rsi    # 0x1d4389
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
movl 0x964(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x964(%rax)
movq -0x8(%rbp), %rax
movl 0x960(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x960(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq 0x964(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq 0x964(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x964(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x964(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x14(%rax)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq 0x964(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
andb $0x1, %cl
movb %cl, 0x15(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: externalFind
External *externalFind(const Externals *externals, const char *name)
{
    const unsigned int nameHash = hash(name);

    for (External *external = externals->first; external; external = external->next)
        if (external->hash == nameHash && strcmp(external->name, name) == 0)
            return external;

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5330
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60ec
movq -0x28(%rbp), %rax
movl 0x100(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x60d9
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x60d9
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x60f4
jmp 0x60db
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x60a7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_common.c
// Function: externalAdd
External *externalAdd(Externals *externals, const char *name, void *entry, bool resolveInTrusted)
{
    External *external = storageAdd(externals->storage, sizeof(External));

    external->entry = entry;
    external->resolved = false;
    external->resolveInTrusted = resolveInTrusted;

    strncpy(external->name, name, DEFAULT_STR_LEN);
    external->name[DEFAULT_STR_LEN] = 0;

    external->hash = hash(name);

    external->next = externals->first;
    externals->first = external;

    return external;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x4b20
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x110(%rax)
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x111(%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xff, %edx
callq 0x3080
movq -0x28(%rbp), %rax
movb $0x0, 0xff(%rax)
movq -0x10(%rbp), %rdi
callq 0x5330
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x100(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)