LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGotoIfNot
void genGotoIfNot(CodeGen *gen, int dest)
{
    genUpdateLastJump(gen, gen->ip);
    genUpdateLastJump(gen, dest);

    const Instruction instr = {.opcode = OP_GOTO_IF_NOT, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.intVal = dest};
    genAddInstr(gen, &instr);
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl %eax, 0x1a4(%rdi)
jge 0x18bec
movl %eax, 0x1a4(%rdi)
cmpl %esi, 0x1a4(%rdi)
jge 0x18bfa
movl %esi, 0x1a4(%rdi)
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x20, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x17e12
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoFromTo
void genGoFromTo(CodeGen *gen, int start, int dest)
{
    int next = gen->ip;
    gen->ip = start;
    genGoto(gen, dest);
    gen->ip = next;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl %esi, 0x8(%rdi)
movl %edx, %esi
callq 0x18b3b
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoFromToIf
void genGoFromToIf(CodeGen *gen, int start, int dest)
{
    int next = gen->ip;
    gen->ip = start;
    genGotoIf(gen, dest);
    gen->ip = next;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl %esi, 0x8(%rdi)
movl %edx, %esi
callq 0x18b8b
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoFromToIfNot
void genGoFromToIfNot(CodeGen *gen, int start, int dest)
{
    int next = gen->ip;
    gen->ip = start;
    genGotoIfNot(gen, dest);
    gen->ip = next;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl %esi, 0x8(%rdi)
movl %edx, %esi
callq 0x18bdb
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCaseConstantCheck
void genCaseConstantCheck(CodeGen *gen, const Type *type, Const *constant)
{
    genPushReg(gen, REG_SWITCH_EXPR);                       // Compare switch expression to case constant
    genPushIntConst(gen, constant->intVal);
    genBinary(gen, TOK_EQEQ, type);
    genSavePos(gen);
    genNop(gen);                                            // Goto "case" block start (stub)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x3, %esi
callq 0x180b4
movq (%r14), %rax
movaps 0x5ee16(%rip), %xmm0    # 0x77f30
movq %rsp, %rsi
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x17e12
movq %rbx, %rdi
movl $0x2e, %esi
movq %r15, %rdx
callq 0x187fc
movl 0x8(%rbx), %eax
cmpl %eax, 0x1a4(%rbx)
jge 0x19155
movl %eax, 0x1a4(%rbx)
movslq 0x1a0(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x1a0(%rbx)
movl %eax, 0x14(%rbx,%rcx,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x17e12
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCaseBlockProlog
void genCaseBlockProlog(CodeGen *gen, int numCaseConstants)
{
    for (int i = 0; i < numCaseConstants; i++)
        genGoFromToIf(gen, genRestorePos(gen), gen->ip + 1); // Goto "case" block start (fixup)

    genSavePos(gen);
    genNop(gen);                                            // Goto next "case" or "default" (stub)
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x191c9
movl %esi, %ebp
movslq 0x1a0(%rbx), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rbx)
movl 0x10(%rbx,%rax,4), %eax
movl 0x8(%rbx), %r14d
leal 0x1(%r14), %esi
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x18b8b
movl %r14d, 0x8(%rbx)
decl %ebp
jne 0x1919a
movl 0x8(%rbx), %eax
cmpl %eax, 0x1a4(%rbx)
jge 0x191da
movl %eax, 0x1a4(%rbx)
movslq 0x1a0(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x1a0(%rbx)
movl %eax, 0x14(%rbx,%rcx,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x17e12
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genForPostStmtEpilog
void genForPostStmtEpilog(CodeGen *gen)
{
    int condEpilog = genRestorePos(gen);
    int condProlog = genRestorePos(gen);

    genGoto(gen, condProlog);                               // Goto condition
    genGoFromToIf(gen, condEpilog, gen->ip);                // Goto post-statement end (fixup)

    gen->stack[++gen->top] = condEpilog;                    // Place to stack again
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x1a0(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0x1a0(%rdi)
movl 0x10(%rdi,%rax,4), %r14d
leal -0x2(%rax), %ecx
movl %ecx, 0x1a0(%rdi)
movl 0xc(%rdi,%rax,4), %esi
callq 0x18b3b
movl 0x8(%rbx), %ebp
movl %r14d, 0x8(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x18b8b
movl %ebp, 0x8(%rbx)
movslq 0x1a0(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x1a0(%rbx)
movl %r14d, 0x14(%rbx,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genShortCircuitProlog
void genShortCircuitProlog(CodeGen *gen)
{
    genDup(gen);
    genSavePos(gen);
    genNop(gen);                                            // Goto expression end (stub)
    genPop(gen);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x5ebe1(%rip), %rsi     # 0x78060
callq 0x17e12
movl 0x8(%rbx), %eax
cmpl %eax, 0x1a4(%rbx)
jge 0x19495
movl %eax, 0x1a4(%rbx)
movslq 0x1a0(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x1a0(%rbx)
movl %eax, 0x14(%rbx,%rcx,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x17e12
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x181b1
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genShortCircuitEpilog
void genShortCircuitEpilog(CodeGen *gen, TokenKind op)
{
    if (op == TOK_ANDAND)
        genGoFromToIfNot(gen, genRestorePos(gen), gen->ip); // Goto expression end (fixup)
    else
        genGoFromToIf(gen, genRestorePos(gen), gen->ip);    // Goto expression end (fixup)
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1a0(%rdi), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rdi)
movl 0x10(%rdi,%rax,4), %eax
movl 0x8(%rdi), %ebp
movl %eax, 0x8(%rdi)
cmpl $0x2a, %esi
jne 0x194fa
movl %ebp, %esi
callq 0x18bdb
jmp 0x19501
movl %ebp, %esi
callq 0x18b8b
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genLeaveFrameFixup
void genLeaveFrameFixup(CodeGen *gen, const ParamAndLocalVarLayout *layout)
{
    // Fixup enter stub
    int next = gen->ip;
    gen->ip = genRestorePos(gen);

    genEnterFrame(gen, layout);
    gen->ip = next;

    genLeaveFrame(gen);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movslq 0x1a0(%rdi), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rdi)
movl 0x10(%rdi,%rax,4), %eax
movl %eax, 0x8(%rdi)
leaq 0x8(%rsp), %rax
movl $0x26, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movl $0x0, 0x14(%rax)
movq %rsi, 0x18(%rax)
movq %rax, %rsi
callq 0x17e12
movl %ebp, 0x8(%rbx)
leaq 0x5eb62(%rip), %rsi     # 0x78100
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x17e12
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genTryRemoveImmediateEntryPoint
int genTryRemoveImmediateEntryPoint(CodeGen *gen)
{
    Instruction *prev = getPrevInstr(gen, 1);
    if (prev && prev->opcode == OP_PUSH && prev->inlineOpcode == OP_NOP)
    {
        int entry = prev->operand.intVal;
        genRemoveInstr(gen);
        return entry;
    }
    return -1;
}

// Assembly:
movslq 0x8(%rdi), %rcx
cmpl 0x1a4(%rdi), %ecx
jle 0x195e8
movq (%rdi), %rax
movq %rcx, %rdx
shlq $0x5, %rdx
addq %rax, %rdx
addq $-0x20, %rdx
jmp 0x195ea
xorl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x195ff
cmpl $0x1, (%rdx)
jne 0x195ff
cmpl $0x0, 0x4(%rdx)
je 0x19600
retq
movl 0x18(%rdx), %eax
decl %ecx
movl %ecx, 0x8(%rdi)
movl $0x0, 0x1d8(%rdi)
movl %ecx, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGotosAddStub
void genGotosAddStub(CodeGen *gen, Gotos *gotos)
{
    if (gotos->numGotos >= MAX_GOTOS)
        gen->error->handler(gen->error->context, "To many break/continue/return statements");

    gotos->start[gotos->numGotos++] = gen->ip;
    genNop(gen);                                            // Goto block/function end (stub)
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x64, 0x190(%rsi)
jl 0x19656
movq 0x1e0(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5eaee(%rip), %rsi     # 0x78140
xorl %eax, %eax
callq *(%rcx)
movl 0x8(%rbx), %eax
movslq 0x190(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x190(%r14)
movl %eax, (%r14,%rcx,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x17e12
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCopyResultToTempVar
void genCopyResultToTempVar(CodeGen *gen, const Type *type, int offset)
{
    genDup(gen);
    genPushLocalPtr(gen, offset);
    genSwapAssign(gen, type->kind, type->size);

    genNotify(gen, GEN_NOTIFICATION_COPY_RESULT_TO_TEMP_VAR);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5e974(%rip), %rsi     # 0x78060
callq 0x17e12
movq %r15, %rdi
movl %ebx, %esi
callq 0x17f78
movl (%r14), %esi
movl 0xc0(%r14), %edx
movq %r15, %rdi
callq 0x183d5
movl $0x1, 0x1d8(%r15)
movl 0x8(%r15), %eax
movl %eax, 0x1dc(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genTryRemoveCopyResultToTempVar
int genTryRemoveCopyResultToTempVar(CodeGen *gen)
{
    if (!genJustNotified(gen, GEN_NOTIFICATION_COPY_RESULT_TO_TEMP_VAR))
        return 0;

    Instruction *prev = getPrevInstr(gen, 1), *prev2 = getPrevInstr(gen, 2), *prev3 = getPrevInstr(gen, 3);

    if (prev3 && prev3->opcode == OP_DUP            && prev3->inlineOpcode == OP_NOP &&
        prev2 && prev2->opcode == OP_PUSH_LOCAL_PTR && prev2->inlineOpcode == OP_NOP &&
        prev  && prev->opcode  == OP_ASSIGN         && prev->inlineOpcode  == OP_SWAP)
    {
        int tempVarOffset = prev2->operand.intVal;
        genRemoveInstr(gen);
        genRemoveInstr(gen);
        genRemoveInstr(gen);
        return tempVarOffset;
    }

    return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $0x1, 0x1d8(%rdi)
jne 0x197e2
movl 0x1dc(%rdi), %ecx
cmpl 0x8(%rdi), %ecx
jne 0x197e2
movslq 0x8(%rdi), %rcx
movl 0x1a4(%rdi), %r8d
cmpl %r8d, %ecx
jle 0x1976a
movq (%rdi), %rax
movq %rcx, %rdx
shlq $0x5, %rdx
addq %rax, %rdx
addq $-0x20, %rdx
jmp 0x1976c
xorl %edx, %edx
leaq -0x2(%rcx), %rsi
cmpl %r8d, %esi
jge 0x19779
xorl %esi, %esi
jmp 0x19780
shlq $0x5, %rsi
addq (%rdi), %rsi
leaq -0x3(%rcx), %r9
xorl %eax, %eax
cmpl %r8d, %r9d
jge 0x19790
xorl %r9d, %r9d
jmp 0x19797
shlq $0x5, %r9
addq (%rdi), %r9
testq %r9, %r9
je 0x197e2
cmpl $0xa, (%r9)
jne 0x197e2
cmpl $0x0, 0x4(%r9)
jne 0x197e2
testq %rsi, %rsi
je 0x197e2
cmpl $0x3, (%rsi)
jne 0x197e2
cmpl $0x0, 0x4(%rsi)
jne 0x197e2
testq %rdx, %rdx
je 0x197e2
cmpl $0xe, (%rdx)
jne 0x197e2
cmpl $0xb, 0x4(%rdx)
jne 0x197e2
movl 0x18(%rsi), %eax
movl $0x0, 0x1d8(%rdi)
addl $-0x3, %ecx
movl %ecx, 0x8(%rdi)
movl %ecx, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identFree
void identFree(Idents *idents, int block)
{
    while (idents->first && idents->first->block == block)
    {
        Ident *next = idents->first->next;

        if (idents->first->globallyAllocated)
            storageRemove(idents->storage, idents->first->ptr);

        storageRemove(idents->storage, idents->first);
        idents->first = next;
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x19a9c
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl %ebx, 0x114(%rax)
jne 0x19a97
movq 0x140(%rax), %r15
cmpb $0x1, 0x119(%rax)
jne 0x19a80
movq 0x18(%r14), %rdi
movq 0x120(%rax), %rsi
callq 0xcde8
movq (%r14), %rsi
movq 0x18(%r14), %rdi
callq 0xcde8
movq %r15, (%r14)
movq %r15, %rax
testq %r15, %r15
jne 0x19a58
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAssertFind
const Ident *identAssertFind(const Idents *idents, const Modules *modules, const Blocks *blocks, int module, const char *name, const Type *rcvType)
{
    const Ident *res = identFind(idents, modules, blocks, module, name, rcvType, true);
    if (!res)
        idents->error->handler(idents->error->context, "Unknown identifier %s", name);
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
pushq $0x0
pushq $0x1
callq 0x19ab1
addq $0x10, %rsp
movq %rax, %r15
testq %rax, %rax
jne 0x19d01
movq 0x28(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5e4ad(%rip), %rsi     # 0x781a7
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAssertFindModule
const Ident *identAssertFindModule(const Idents *idents, const Modules *modules, const Blocks *blocks, int module, const char *name)
{
    const Ident *res = identFindModule(idents, modules, blocks, module, name, true);
    if (!res)
        idents->error->handler(idents->error->context, "Unknown module %s", name);
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
movl $0x1, %eax
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0x19ab1
addq $0x10, %rsp
movq %rax, %r15
testq %rax, %rax
jne 0x19d5b
movq 0x28(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5e469(%rip), %rsi     # 0x781bd
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identIsOuterLocalVar
bool identIsOuterLocalVar(const Blocks *blocks, const Ident *ident)
{
    if (!ident || ident->kind != IDENT_VAR || ident->block == 0)
        return false;

    bool curFnBlockFound = false;
    for (int i = blocks->top; i >= 0; i--)
    {
        if (blocks->item[i].block == ident->block && curFnBlockFound)
            return true;

        if (blocks->item[i].fn)
            curFnBlockFound = true;
    }

    return false;
}

// Assembly:
testq %rsi, %rsi
je 0x19dc9
cmpl $0x1, (%rsi)
jne 0x19dc9
movl 0x114(%rsi), %ecx
testl %ecx, %ecx
je 0x19dc9
movslq 0x964(%rdi), %rdx
testq %rdx, %rdx
setns %al
js 0x19dc8
leaq (%rdx,%rdx,2), %rax
incq %rdx
leaq (%rdi,%rax,8), %rsi
addq $0x8, %rsi
xorl %edi, %edi
movl $0x1, %r8d
cmpl %ecx, -0x8(%rsi)
jne 0x19da9
testb $0x1, %dil
jne 0x19dcc
cmpq $0x0, (%rsi)
movzbl %dil, %edi
cmovnel %r8d, %edi
addq $-0x18, %rsi
leaq -0x1(%rdx), %rax
testq %rax, %rax
setg %al
decq %rdx
jg 0x19d9e
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAddTempConst
Ident *identAddTempConst(Idents *idents, const Modules *modules, const Blocks *blocks, const Type *type, Const constant)
{
    IdentName tempName;
    identTempName(idents, tempName);

    Ident *ident = identAddConst(idents, modules, blocks, tempName, type, false, constant);
    ident->temporary = true;
    return ident;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl 0x10(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rdi)
leaq 0x5e138(%rip), %rdx     # 0x782e1
leaq 0x10(%rsp), %rbp
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3170
movl $0x0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
movq %r14, %r9
callq 0x19dfa
movq %rbx, 0x120(%rax)
movb $0x1, 0x11b(%rax)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAddGlobalVar
Ident *identAddGlobalVar(Idents *idents, const Modules *modules, const Blocks *blocks, const char *name, const Type *type, bool exported, void *ptr)
{
    Ident *ident = identAdd(idents, modules, blocks, IDENT_VAR, name, type, exported);
    ident->ptr = ptr;
    ident->globallyAllocated = true;
    return ident;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %r8, %rax
movq %rcx, %r8
movq 0x20(%rsp), %rbx
movl %r9d, (%rsp)
movl $0x1, %ecx
movq %rax, %r9
callq 0x19dfa
movq %rbx, 0x120(%rax)
movb $0x1, 0x119(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocStack
int identAllocStack(Idents *idents, const Types *types, Blocks *blocks, const Type *type)
{
    int *localVarSize = NULL;
    for (int i = blocks->top; i >= 1; i--)
        if (blocks->item[i].fn)
        {
            localVarSize = &blocks->item[i].localVarSize;
            break;
        }
    if (!localVarSize)
        idents->error->handler(idents->error->context, "Stack frame is not found");

    *localVarSize = align(*localVarSize + typeSize(types, type), typeAlignment(types, type));
    return -2 * sizeof(Slot) - (*localVarSize);  // 2 extra slots for the stack frame ref count and parameter layout table
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movl 0x964(%rdx), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0x1a30f
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
cmpq $0x0, 0x8(%rdx,%rcx,8)
jne 0x1a307
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
movl %ecx, %eax
jge 0x1a2ed
jmp 0x1a30f
leaq (%rdx,%rcx,8), %r15
addq $0x10, %r15
testq %r15, %r15
jne 0x1a327
movq 0x28(%rdi), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5deac(%rip), %rsi     # 0x781cf
xorl %eax, %eax
callq *(%rcx)
movslq (%r15), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ede7
movslq %eax, %r13
addq %r12, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ee50
movslq %eax, %rsi
leaq (%rsi,%r13), %rcx
decq %rcx
movq %rcx, %rax
cqto
idivq %rsi
subl %edx, %ecx
movl %ecx, (%r15)
movl $0xfffffff0, %eax       # imm = 0xFFFFFFF0
subl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocVar
Ident *identAllocVar(Idents *idents, const Types *types, const Modules *modules, Blocks *blocks, const char *name, const Type *type, bool exported)
{
    Ident *ident;
    if (blocks->top == 0)       // Global
    {
        void *ptr = storageAdd(idents->storage, typeSize(types, type));
        ident = identAddGlobalVar(idents, modules, blocks, name, type, exported, ptr);
    }
    else                        // Local
    {
        const int offset = identAllocStack(idents, types, blocks, type);
        ident = identAddLocalVar(idents, modules, blocks, name, type, exported, offset);
    }
    return ident;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
cmpl $0x0, 0x964(%rcx)
je 0x1a3ce
movq %r13, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1a2d1
movl %eax, %ebp
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x19dfa
movslq %ebp, %rcx
movq %rcx, 0x120(%rax)
jmp 0x1a41a
movq 0x18(%r13), %rbp
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x1ede7
movslq %eax, %rsi
movq %rbp, %rdi
callq 0xcca8
movq %rax, %rbp
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x19dfa
movq %rbp, 0x120(%rax)
movb $0x1, 0x119(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocTempVar
Ident *identAllocTempVar(Idents *idents, const Types *types, const Modules *modules, Blocks *blocks, const Type *type, bool isFuncResult)
{
    IdentName tempName;
    identTempName(idents, tempName);

    Ident *ident = identAllocVar(idents, types, modules, blocks, tempName, type, false);
    ident->temporary = true;

    if (isFuncResult)
    {
        if (blocks->top == 0)
            idents->error->handler(idents->error->context, "Temporary variable must be local");
        idents->lastTempVarForResult = ident;
    }

    return ident;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %r9d, 0xc(%rsp)
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rdi)
leaq 0x5de83(%rip), %rdx     # 0x782e1
leaq 0x10(%rsp), %rbp
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3170
movl $0x0, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x1a36e
movq %rax, %r15
movb $0x1, 0x11b(%rax)
cmpl $0x0, 0xc(%rsp)
je 0x1a4c2
cmpl $0x0, 0x964(%r14)
jne 0x1a4be
movq 0x28(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5dd2e(%rip), %rsi     # 0x781e8
xorl %eax, %eax
callq *(%rcx)
movq %r15, 0x8(%rbx)
movq %r15, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocParam
Ident *identAllocParam(Idents *idents, const Types *types, const Modules *modules, const Blocks *blocks, const Signature *sig, int index)
{
    const int offset = typeParamOffset(types, sig, index);
    Ident *ident = identAddLocalVar(idents, modules, blocks, sig->param[index]->name, sig->param[index]->type, false, offset);
    identSetUsed(ident);                                                     // Do not warn about unused parameters
    return ident;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq %rsi, %rdi
movq %r8, %rsi
movl %r9d, %edx
callq 0x1fd38
movl %eax, %ebp
movslq %ebx, %rax
movq 0x10(%r14,%rax,8), %r8
movq 0x108(%r8), %r9
movl $0x0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x19dfa
movslq %ebp, %rcx
movq %rcx, 0x120(%rax)
movb $0x1, 0x11a(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identMethodNameWithRcv
const char *identMethodNameWithRcv(const Idents *idents, const Ident *method)
{
    char typeBuf[DEFAULT_STR_LEN + 1];
    typeSpelling(method->type->sig.param[0]->type, typeBuf);

    char *buf = storageAdd(idents->storage, 2 * DEFAULT_STR_LEN + 2 + 1);
    snprintf(buf, 2 * DEFAULT_STR_LEN + 2 + 1, "(%s)%s", typeBuf, method->name);

    return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movq 0x108(%rsi), %rax
movq 0x38(%rax), %rax
movq 0x108(%rax), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x1ee46
movq 0x18(%r14), %rdi
movl $0x201, %esi            # imm = 0x201
callq 0xcca8
movq %rax, %r14
addq $0x4, %rbx
leaq 0x5dc74(%rip), %rdx     # 0x78209
movl $0x201, %esi            # imm = 0x201
movq %rax, %rdi
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3170
movq %r14, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexFree
void lexFree(Lexer *lex)
{
    if (lex->buf)
    {
        storageRemove(lex->storage, lex->buf);
        lex->fileName = NULL;
        lex->buf = NULL;
    }
}

// Assembly:
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x1a983
pushq %rbx
movq %rdi, %rbx
movq 0x258(%rdi), %rdi
callq 0xcde8
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexNext
void lexNext(Lexer *lex)
{
    do
    {
        lexNextWithEOLN(lex);

        // Replace end of line with implicit semicolon
        if (lex->tok.kind == TOK_EOLN)
            if (lex->prevTok.kind == TOK_BREAK       ||
                lex->prevTok.kind == TOK_CONTINUE    ||
                lex->prevTok.kind == TOK_RETURN      ||
                lex->prevTok.kind == TOK_STR         ||
                lex->prevTok.kind == TOK_PLUSPLUS    ||
                lex->prevTok.kind == TOK_MINUSMINUS  ||
                lex->prevTok.kind == TOK_RPAR        ||
                lex->prevTok.kind == TOK_RBRACKET    ||
                lex->prevTok.kind == TOK_RBRACE      ||
                lex->prevTok.kind == TOK_CARET       ||
                lex->prevTok.kind == TOK_IDENT       ||
                lex->prevTok.kind == TOK_INTNUMBER   ||
                lex->prevTok.kind == TOK_REALNUMBER  ||
                lex->prevTok.kind == TOK_CHARLITERAL ||
                lex->prevTok.kind == TOK_STRLITERAL)
            {
               lex->tok.kind = TOK_IMPLICIT_SEMICOLON;
            }

        lex->prevTok = lex->tok;
    } while (lex->tok.kind == TOK_EOLN);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
leaq 0x140(%rdi), %r15
movabsq $0x6a00300000018012, %r12 # imm = 0x6A00300000018012
movq %rbx, %rdi
callq 0x1a9f5
cmpl $0x4b, 0x28(%rbx)
jne 0x1a9d3
movl 0x140(%rbx), %eax
cmpq $0x3e, %rax
ja 0x1a9c4
btq %rax, %r12
jb 0x1a9cc
addl $-0x45, %eax
cmpl $0x5, %eax
jae 0x1a9d3
movl $0x4a, (%r14)
movl $0x118, %edx            # imm = 0x118
movq %r15, %rdi
movq %r14, %rsi
callq 0x3260
cmpl $0x4b, (%r14)
je 0x1a9a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexNextForcedSemicolon
void lexNextForcedSemicolon(Lexer *lex)
{
    lexNextWithEOLN(lex);

    // Replace end of line with implicit semicolon
    if (lex->tok.kind == TOK_EOLN)
        lex->tok.kind = TOK_IMPLICIT_SEMICOLON;

    lex->prevTok = lex->tok;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a9f5
leaq 0x28(%rbx), %rsi
cmpl $0x4b, 0x28(%rbx)
jne 0x1b3b3
movl $0x4a, (%rsi)
addq $0x140, %rbx            # imm = 0x140
movl $0x118, %edx            # imm = 0x118
movq %rbx, %rdi
popq %rbx
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexCheck
bool lexCheck(Lexer *lex, TokenKind kind)
{
    bool res = lex->tok.kind == kind || (lex->tok.kind == TOK_IMPLICIT_SEMICOLON && kind == TOK_SEMICOLON);
    if (!res)
        lex->error->handler(lex->error->context, "%s expected but %s found", lexSpelling(kind), lexSpelling(lex->tok.kind));
    return res;
}

// Assembly:
pushq %rbx
movl 0x28(%rdi), %eax
movb $0x1, %bl
cmpl %esi, %eax
je 0x1b3e1
movl %eax, %ecx
xorl $0x4a, %ecx
movl %esi, %edx
xorl $0x40, %edx
orl %ecx, %edx
sete %bl
testb %bl, %bl
jne 0x1b40d
movq 0x268(%rdi), %r8
movq 0x20(%r8), %rdi
movl %esi, %ecx
leaq 0x734b7(%rip), %rsi     # 0x8e8b0
movq (%rsi,%rcx,8), %rdx
movq (%rsi,%rax,8), %rcx
leaq 0x5cfd3(%rip), %rsi     # 0x783db
xorl %eax, %eax
callq *(%r8)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexChar
static char lexChar(Lexer *lex)
{
    char ch = lex->buf[lex->bufPos];
    if (ch)
    {
        lex->bufPos++;
        lex->pos++;
        if (ch == '\n')
        {
            lex->line++;
            lex->pos = 1;
        }
    }
    return lex->buf[lex->bufPos];
}

// Assembly:
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rdx
movb (%rax,%rdx), %cl
testb %cl, %cl
je 0x1b47b
incl %edx
movl %edx, 0x18(%rdi)
incl 0x20(%rdi)
cmpb $0xa, %cl
jne 0x1b47b
incl 0x1c(%rdi)
movl $0x1, 0x20(%rdi)
movslq 0x18(%rdi), %rcx
movb (%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexCharDigit
static int lexCharDigit(char c, int base)
{
    switch (base)
    {
        case 10: return c >= '0' && c <= '9' ? c - '0' : -1;
        case 16: return c >= '0' && c <= '9' ? c - '0' :
                        c >= 'a' && c <= 'f' ? c - 'a' + 10 :
                        c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
    }
    return -1;
}

// Assembly:
cmpl $0x10, %esi
je 0x1b4aa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xa, %esi
jne 0x1b4a9
movsbl %dil, %ecx
addb $-0x30, %dil
addl $-0x30, %ecx
cmpb $0xa, %dil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbl %ecx, %eax
retq
movsbl %dil, %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x1b4ba
addl $-0x30, %eax
retq
leal -0x61(%rdi), %ecx
cmpb $0x5, %cl
ja 0x1b4c6
addl $-0x57, %eax
retq
addb $-0x41, %dil
addl $-0x37, %eax
cmpb $0x6, %dil
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovbl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexDigitSeq
static uint64_t lexDigitSeq(Lexer *lex, int base, int *len, bool isFrac)
{
    uint64_t result = 0;
    *len = 0;

    if (lexCharDigit(lex->buf[lex->bufPos], base) == -1)
        lex->error->handler(lex->error->context, "Invalid number");

    bool skipDigits = false;

    while (lexCharDigit(lex->buf[lex->bufPos], base) != -1)
    {
        uint64_t newResult = result * base + lexCharDigit(lex->buf[lex->bufPos], base);
        if ((result * base) / base != result || newResult < result)
        {
            if (isFrac)
                skipDigits = true;
            else
                lex->error->handler(lex->error->context, "Number is too large");
        }

        if (!skipDigits)
        {
            result = newResult;
            (*len)++;
        }

        lexChar(lex);

        if (lex->buf[lex->bufPos] == '_')
        {
            if (lexCharDigit(lex->buf[lex->bufPos + 1], base) != -1)
                lexChar(lex);
            else
                lex->error->handler(lex->error->context, "_ must be placed between digits");
        }
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, 0x10(%rsp)
movl $0x0, (%rdx)
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1b483
cmpl $-0x1, %eax
jne 0x1b52a
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5cffb(%rip), %rsi     # 0x78521
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
movsbl (%rax,%rcx), %edi
movl %ebp, %esi
callq 0x1b483
cmpl $-0x1, %eax
je 0x1b615
movl %eax, %ecx
movl %ebp, %r12d
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r12, %rax
mulq %rbx
seto %dl
movslq %ecx, %rcx
leaq (%rax,%rcx), %r13
cmpq %rbx, %r13
setb %cl
orb %dl, %cl
movl %ecx, %edx
xorb $0x1, %dl
orb 0xc(%rsp), %dl
movzbl %r14b, %eax
testb %cl, %cl
movl $0x1, %ecx
cmovnel %ecx, %eax
testb %dl, %dl
je 0x1b588
movl %eax, %r14d
jmp 0x1b59e
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5cf73(%rip), %rsi     # 0x7850d
xorl %eax, %eax
callq *(%rcx)
testb $0x1, %r14b
jne 0x1b5ae
movq 0x10(%rsp), %rax
incl (%rax)
movq %r13, %rbx
movq %r15, %rdi
callq 0x1b455
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
cmpb $0x5f, (%rax,%rcx)
jne 0x1b5f5
movsbl 0x1(%rax,%rcx), %edi
movl %ebp, %esi
callq 0x1b483
cmpl $-0x1, %eax
je 0x1b5df
movq %r15, %rdi
callq 0x1b455
jmp 0x1b5f5
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5cf3f(%rip), %rsi     # 0x78530
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
movsbl (%rax,%rcx), %edi
movl %ebp, %esi
callq 0x1b483
movl %eax, %ecx
cmpl $-0x1, %eax
jne 0x1b550
jmp 0x1b617
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexEscChar
static char lexEscChar(Lexer *lex, bool *escaped)
{
    if (escaped) *escaped = false;
    char ch = lexChar(lex);

    if (ch == '\\')
    {
        if (escaped) *escaped = true;
        ch = lexChar(lex);

        switch (ch)
        {
            case '0': return '\0';
            case 'a': return '\a';
            case 'b': return '\b';
            case 'f': return '\f';
            case 'n': return '\n';
            case 'r': return '\r';
            case 't': return '\t';
            case 'v': return '\v';
            case 'x':
            {
                lexChar(lex);

                unsigned int hex = 0;
                int len = 0;
                const int items = sscanf(lex->buf + lex->bufPos, "%x%n", &hex, &len);

                if (items < 1 || hex > 0xFF)
                {
                    lex->error->handler(lex->error->context, "Illegal character code");
                    lex->tok.kind = TOK_NONE;
                    return 0;
                }

                lex->bufPos += len - 1;
                lex->pos += len - 1;
                return (char)hex;
            }
            default: return ch;
        }
    }
    return ch;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1b640
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x1b455
movl %eax, %ebp
cmpb $0x5c, %al
jne 0x1b751
testq %r14, %r14
je 0x1b65b
movb $0x1, (%r14)
movq %rbx, %rdi
callq 0x1b455
movl %eax, %ebp
movzbl %al, %eax
cmpl $0x65, %eax
jle 0x1b68d
leal -0x6e(%rax), %ecx
cmpl $0xa, %ecx
ja 0x1b6b7
leaq 0x5cd08(%rip), %rax     # 0x78384
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0xa, %bpl
jmp 0x1b751
cmpl $0x30, %eax
je 0x1b6a8
cmpl $0x61, %eax
je 0x1b6af
cmpl $0x62, %eax
jne 0x1b751
movb $0x8, %bpl
jmp 0x1b751
xorl %ebp, %ebp
jmp 0x1b751
movb $0x7, %bpl
jmp 0x1b751
cmpl $0x66, %eax
jne 0x1b751
movb $0xc, %bpl
jmp 0x1b751
movb $0x9, %bpl
jmp 0x1b751
movb $0xd, %bpl
jmp 0x1b751
movq %rbx, %rdi
callq 0x1b455
xorl %eax, %eax
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movslq 0x18(%rbx), %rdi
addq 0x10(%rbx), %rdi
leaq 0x5ce6d(%rip), %rsi     # 0x7856a
movq %r14, %rdx
xorl %eax, %eax
callq 0x32b0
testl %eax, %eax
setle %al
movl (%r14), %ebp
cmpl $0x100, %ebp            # imm = 0x100
setae %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1b745
movq 0x268(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5ce3e(%rip), %rsi     # 0x7856f
xorl %ebp, %ebp
xorl %eax, %eax
callq *(%rcx)
movl $0x0, 0x28(%rbx)
jmp 0x1b751
movb $0xb, %bpl
jmp 0x1b751
movl 0x8(%rsp), %eax
decl %eax
addl %eax, 0x18(%rbx)
addl %eax, 0x20(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexStrLiteralAndGetSize
static int lexStrLiteralAndGetSize(Lexer *lex)
{
    lex->tok.kind = TOK_STRLITERAL;

    int size = 0;
    bool escaped = false;
    char ch = lexEscChar(lex, &escaped);

    while (ch != '\"' || escaped)
    {
        if (ch == 0 || (ch == '\n' && !escaped))
        {
            lex->error->handler(lex->error->context, "Unterminated string");
            lex->tok.kind = TOK_NONE;
            return 0;
        }

        if (lex->tok.strVal)
            lex->tok.strVal[size] = ch;
        size++;
        ch = lexEscChar(lex, &escaped);
    }

    if (lex->tok.strVal)
        lex->tok.strVal[size] = 0;
    size++;
    lexChar(lex);

    return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x49, 0x28(%rdi)
leaq 0xf(%rsp), %r14
movb $0x0, (%r14)
movq %r14, %rsi
callq 0x1b629
cmpb $0x22, %al
setne %dl
movb (%r14), %cl
orb %cl, %dl
xorl %r14d, %r14d
testb $0x1, %dl
je 0x1b7d7
xorl %r14d, %r14d
leaq 0xf(%rsp), %r15
cmpb $0xa, %al
je 0x1b7a7
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x1b7ac
jmp 0x1b7f4
testb $0x1, %cl
je 0x1b7f4
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
je 0x1b7b9
movb %al, (%rcx,%r14)
incq %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b629
cmpb $0x22, %al
setne %dl
movb 0xf(%rsp), %cl
orb %cl, %dl
testb $0x1, %dl
jne 0x1b79a
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x1b7e7
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
incl %r14d
movq %rbx, %rdi
callq 0x1b455
jmp 0x1b814
movq 0x268(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5cd80(%rip), %rsi     # 0x78586
xorl %r14d, %r14d
xorl %eax, %eax
callq *(%rcx)
movl $0x0, 0x28(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlmemcpy
void rtlmemcpy(UmkaStackSlot *params, UmkaStackSlot *result)
{
    void *dest = umkaGetParam(params, 0)->ptrVal;
    const void *src = umkaGetParam(params, 1)->ptrVal;
    const int count = umkaGetParam(params, 2)->intVal;

    memcpy(dest, src, count);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0xcb64
movq (%rax), %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xcb64
movq (%rax), %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0xcb64
movslq (%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlfopen
void rtlfopen(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const char *name = umkaGetParam(params, 0)->ptrVal;
    const char *mode = umkaGetParam(params, 1)->ptrVal;

    FILE *file = fopen(name, mode);
    umkaGetResult(params, result)->ptrVal = file;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movq (%rax), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0xcb64
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3320
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq %r15, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlfread
void rtlfread(UmkaStackSlot *params, UmkaStackSlot *result)
{
    void *buf = umkaGetParam(params, 0)->ptrVal;
    const int size = umkaGetParam(params, 1)->intVal;
    const int cnt = umkaGetParam(params, 2)->intVal;
    FILE *file = umkaGetParam(params, 3)->ptrVal;

    umkaGetResult(params, result)->intVal = fread(buf, size, cnt, file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movq (%rax), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0xcb64
movslq (%rax), %r12
movq %r14, %rdi
movl $0x2, %esi
callq 0xcb64
movslq (%rax), %r13
movq %r14, %rdi
movl $0x3, %esi
callq 0xcb64
movq (%rax), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x30d0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq %r15, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlfseek
void rtlfseek(UmkaStackSlot *params, UmkaStackSlot *result)
{
    FILE *file = umkaGetParam(params, 0)->ptrVal;
    const int offset = umkaGetParam(params, 1)->intVal;
    const int origin = umkaGetParam(params, 2)->intVal;

    int originC = 0;
    if      (origin == 0) originC = SEEK_SET;
    else if (origin == 1) originC = SEEK_CUR;
    else if (origin == 2) originC = SEEK_END;

    umkaGetResult(params, result)->intVal = fseek(file, offset, originC);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movq (%rax), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0xcb64
movslq (%rax), %r12
movq %r14, %rdi
movl $0x2, %esi
callq 0xcb64
movl (%rax), %eax
xorl %edx, %edx
cmpl $0x1, %eax
sete %dl
cmpl $0x2, %eax
cmovel %eax, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x32f0
movslq %eax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq %r15, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtllocaltime
void rtllocaltime(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const time_t curTime = umkaGetParam(params, 0)->intVal;
    RTLDateTime *rtlDateTime = umkaGetResult(params, result)->ptrVal;

    const struct tm *dateTime = localtime(&curTime);
    convToRTLDateTime(rtlDateTime, dateTime);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movq (%rax), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq (%rax), %rbx
movq %r15, %rdi
callq 0x3050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1bc76
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: convToRTLDateTime
static void convToRTLDateTime(RTLDateTime *dest, const struct tm *src)
{
    dest->second    = src->tm_sec;
    dest->minute    = src->tm_min;
    dest->hour      = src->tm_hour;
    dest->day       = src->tm_mday;
    dest->month     = src->tm_mon + 1;
    dest->year      = src->tm_year + 1900;
    dest->dayOfWeek = src->tm_wday + 1;
    dest->dayOfYear = src->tm_yday + 1;
    dest->isDST     = src->tm_isdst != 0;
}

// Assembly:
movslq (%rsi), %rax
movq %rax, (%rdi)
movslq 0x4(%rsi), %rax
movq %rax, 0x8(%rdi)
movslq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
movslq 0xc(%rsi), %rax
movq %rax, 0x18(%rdi)
movslq 0x10(%rsi), %rax
incq %rax
movq %rax, 0x20(%rdi)
movslq 0x14(%rsi), %rax
addq $0x76c, %rax            # imm = 0x76C
movq %rax, 0x28(%rdi)
movslq 0x18(%rsi), %rax
incq %rax
movq %rax, 0x30(%rdi)
movslq 0x1c(%rsi), %rax
incq %rax
movq %rax, 0x38(%rdi)
cmpl $0x0, 0x20(%rsi)
setne 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlmktime
void rtlmktime(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const RTLDateTime *rtlDateTime = umkaGetParam(params, 0)->ptrVal;

    struct tm dateTime;
    convFromRTLDateTime(&dateTime, rtlDateTime);

    umkaGetResult(params, result)->intVal = mktime(&dateTime);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movq (%rax), %rax
movl (%rax), %ecx
leaq 0x8(%rsp), %rdi
movl %ecx, (%rdi)
movl 0x8(%rax), %ecx
movl %ecx, 0x4(%rdi)
movl 0x10(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl 0x18(%rax), %ecx
movl %ecx, 0xc(%rdi)
movl 0x20(%rax), %ecx
decl %ecx
movl %ecx, 0x10(%rdi)
movl $0xfffff894, %ecx       # imm = 0xFFFFF894
addl 0x28(%rax), %ecx
movl %ecx, 0x14(%rdi)
movl 0x30(%rax), %ecx
decl %ecx
movl %ecx, 0x18(%rdi)
movl 0x38(%rax), %ecx
decl %ecx
movl %ecx, 0x1c(%rdi)
movzbl 0x40(%rax), %eax
movl %eax, 0x20(%rdi)
callq 0x32d0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq %r15, (%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlgetenv
void rtlgetenv(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const char *name = (const char *)umkaGetParam(params, 0)->ptrVal;
    void *umka = umkaGetInstance(result);

    const char *env = getenv(name);
    umkaGetResult(params, result)->ptrVal = umkaMakeStr(umka, env);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movq (%rax), %rdi
movq (%rbx), %r15
callq 0x3030
movq %r15, %rdi
movq %rax, %rsi
callq 0xcb09
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq %r15, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtltrace
void rtltrace(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const int depth = umkaGetParam(params, 0)->intVal;
    RTLErrPos *pos = umkaGetParam(params, 1)->ptrVal;

    void *umka = umkaGetInstance(result);

    char fileName[DEFAULT_STR_LEN + 1], fnName[DEFAULT_STR_LEN + 1];
    int line;

    if (umkaGetCallStack(umka, depth, DEFAULT_STR_LEN + 1, NULL, fileName, fnName, &line))
    {
        umkaDecRef(umka, pos->fileName);
        umkaDecRef(umka, pos->fnName);

        pos->fileName = umkaMakeStr(umka, fileName);
        pos->fnName   = umkaMakeStr(umka, fnName);
        pos->line     = line;

        umkaGetResult(params, result)->intVal = 0;
    }
    else
        umkaGetResult(params, result)->intVal = -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xcb64
movl (%rax), %ebp
movq %r14, %rdi
movl $0x1, %esi
callq 0xcb64
movq (%rax), %r12
movq (%rbx), %r15
leaq 0xc(%rsp), %rax
movq %rax, (%rsp)
leaq 0x110(%rsp), %r8
leaq 0x10(%rsp), %r9
movq %r15, %rdi
movl %ebp, %esi
movl $0x100, %edx            # imm = 0x100
xorl %ecx, %ecx
callq 0xc9b2
movq $-0x1, %r13
testb %al, %al
je 0x1bed5
movq (%r12), %rsi
movq %r15, %rdi
callq 0xcaea
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0xcaea
leaq 0x110(%rsp), %rsi
movq %r15, %rdi
callq 0xcb09
movq %rax, (%r12)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xcb09
movq %rax, 0x8(%r12)
movslq 0xc(%rsp), %rax
movq %rax, 0x10(%r12)
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb97
movq %r13, (%rax)
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)