LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xff13
movslq 0x1dc(%rdi), %rsi
cmpl 0x8(%rdi), %esi
jne 0xff13
movl 0x1a4(%rdi), %r8d
cmpl %r8d, %esi
jle 0xfe9e
movq (%rdi), %rax
movq %rsi, %rcx
shlq $0x5, %rcx
addq %rax, %rcx
addq $-0x20, %rcx
jmp 0xfea0
xorl %ecx, %ecx
movq %rsi, %rdx
addq $-0x2, %rdx
xorl %eax, %eax
cmpl %r8d, %edx
jge 0xfeb2
xorl %edx, %edx
jmp 0xfeb9
shlq $0x5, %rdx
addq (%rdi), %rdx
addl $-0x3, %esi
cmpl %r8d, %esi
jl 0xff13
movq (%rdi), %r8
testq %r8, %r8
je 0xff13
movslq %esi, %r9
shlq $0x5, %r9
addq %r9, %r8
cmpl $0xa, (%r8)
jne 0xff13
cmpl $0x0, 0x4(%r8)
jne 0xff13
testq %rdx, %rdx
je 0xff13
cmpl $0x3, (%rdx)
jne 0xff13
cmpl $0x0, 0x4(%rdx)
jne 0xff13
testq %rcx, %rcx
je 0xff13
cmpl $0xe, (%rcx)
jne 0xff13
cmpl $0xb, 0x4(%rcx)
jne 0xff13
movl 0x18(%rdx), %eax
movl %esi, 0x8(%rdi)
andl $0x0, 0x1d8(%rdi)
movl %esi, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x101d9
cmpl %ebx, 0x114(%rsi)
jne 0x101d9
movq 0x140(%rsi), %r15
cmpb $0x1, 0x119(%rsi)
jne 0x101c8
movq 0x18(%r14), %rdi
movq 0x120(%rsi), %rsi
callq 0x4279
movq (%r14), %rsi
movq 0x18(%r14), %rdi
callq 0x4279
movq %r15, (%r14)
movq %r15, %rsi
jmp 0x10198
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x10, %rsp
movq %r8, %rbx
movq %rdi, %r15
movl $0x1, (%rsp)
callq 0x101df
movq %rax, %r14
testq %rax, %rax
jne 0x1041f
movq 0x28(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5ad2f(%rip), %rsi     # 0x6b147
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
pushq $0x1
popq %r9
callq 0x1042c
movq %rax, %r14
testq %rax, %rax
jne 0x10471
movq 0x28(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5acf3(%rip), %rsi     # 0x6b15d
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x104c3
cmpl $0x1, (%rsi)
jne 0x104c3
movl 0x114(%rsi), %ecx
testl %ecx, %ecx
je 0x104c3
movl 0x964(%rdi), %edx
xorl %esi, %esi
testl %edx, %edx
setns %al
js 0x104c5
movl %edx, %r8d
imulq $0x18, %r8, %r8
cmpl %ecx, (%rdi,%r8)
sete %r9b
testb %sil, %r9b
jne 0x104c5
addq %rdi, %r8
cmpq $0x0, 0x8(%r8)
setne %al
orb %al, %sil
decl %edx
jmp 0x10496
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x10(%rsp), %rbp
movq %rbp, %rsi
callq 0x108ad
movq %rbx, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x104c6
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_O2/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)
pushq $0x1
popq %rcx
movq %rax, %r9
callq 0x104f1
movq %rbx, 0x120(%rax)
movb $0x1, 0x119(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdx, %rbx
movq %rsi, %r15
movl 0x964(%rdx), %eax
testl %eax, %eax
jle 0x109cb
movl %eax, %ecx
imulq $0x18, %rcx, %rcx
decl %eax
cmpq $0x0, 0x8(%rbx,%rcx)
je 0x109ae
addq %rcx, %rbx
addq $0x10, %rbx
jmp 0x109e0
movq 0x28(%rdi), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5a795(%rip), %rsi     # 0x6b16f
xorl %ebx, %ebx
xorl %eax, %eax
callq *(%rcx)
movslq (%rbx), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x15124
movslq %eax, %r13
addq %r12, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x15188
movslq %eax, %rsi
leaq (%rsi,%r13), %rcx
decq %rcx
movq %rcx, %rax
cqto
idivq %rsi
subl %edx, %ecx
movl %ecx, (%rbx)
pushq $-0x10
popq %rax
subl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10a74
movq %r13, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x10996
movl %eax, (%rsp)
movzbl 0x40(%rsp), %r9d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x10902
jmp 0x10aac
movq 0x18(%r13), %rbp
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x15124
movslq %eax, %rsi
movq %rbp, %rdi
callq 0x4144
movq %rax, (%rsp)
movzbl 0x40(%rsp), %r9d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x108cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x10(%rsp), %rbp
movq %rbp, %rsi
callq 0x108ad
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x10a24
movq %rax, %r15
movb $0x1, 0x11b(%rax)
cmpl $0x0, 0xc(%rsp)
je 0x10b3a
cmpl $0x0, 0x964(%r14)
jne 0x10b36
movq 0x28(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5a656(%rip), %rsi     # 0x6b188
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_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
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 0x15f2f
movslq %ebx, %rcx
movq 0x10(%r14,%rcx,8), %rcx
movq 0x108(%rcx), %r8
movl %eax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %r9d, %r9d
callq 0x10902
movb $0x1, 0x11a(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15180
movq 0x18(%r14), %rdi
movl $0x201, %esi            # imm = 0x201
callq 0x4144
movq %rax, %r14
addq $0x4, %rbx
leaq 0x5a5ad(%rip), %rdx     # 0x6b1a9
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_O2/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 0x10f6d
pushq %rbx
movq %rdi, %rbx
movq 0x258(%rdi), %rdi
callq 0x4279
andq $0x0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
leaq 0x28(%rdi), %rbx
leaq 0x140(%rdi), %r14
movabsq $0x6a00300000018012, %r12 # imm = 0x6A00300000018012
movq %r15, %rdi
callq 0x10fe7
cmpl $0x4b, 0x28(%r15)
jne 0x10fcc
movl (%r14), %eax
cmpq $0x3e, %rax
ja 0x10fac
btq %rax, %r12
jb 0x10fc6
addl $-0x45, %eax
cmpl $0x5, %eax
jb 0x10fc6
movl $0x118, %edx            # imm = 0x118
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3260
jmp 0x10f8e
movl $0x4a, (%rbx)
movl $0x118, %edx            # imm = 0x118
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O2/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 0x10fe7
leaq 0x28(%rbx), %rsi
cmpl $0x4b, 0x28(%rbx)
jne 0x1186a
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_O2/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 0x118c1
movl %eax, %ecx
xorl $0x4a, %ecx
movl %esi, %edx
xorl $0x40, %edx
orl %ecx, %edx
je 0x118c1
movq 0x268(%rdi), %r8
movq 0x20(%r8), %rdi
movl %esi, %ecx
leaq 0x69005(%rip), %rsi     # 0x7a8b0
movq (%rsi,%rcx,8), %rdx
movq (%rsi,%rax,8), %rcx
leaq 0x59ac1(%rip), %rsi     # 0x6b37b
xorl %ebx, %ebx
xorl %eax, %eax
callq *(%r8)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
movb (%rax,%rcx), %dl
testb %dl, %dl
je 0x1192f
incl %ecx
movl %ecx, 0x18(%rdi)
incl 0x20(%rdi)
cmpb $0xa, %dl
jne 0x1192f
incl 0x1c(%rdi)
movl $0x1, 0x20(%rdi)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11974
cmpl $0xa, %esi
jne 0x11984
movzbl %dil, %ecx
addb $-0x30, %dil
addl $-0x30, %ecx
cmpb $0xa, %dil
pushq $-0x1
popq %rax
cmovbl %ecx, %eax
retq
movsbl %dil, %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x11988
addl $-0x30, %eax
retq
pushq $-0x1
popq %rax
retq
leal -0x61(%rdi), %ecx
cmpb $0x5, %cl
ja 0x11994
addl $-0x57, %eax
retq
addb $-0x41, %dil
addl $-0x37, %eax
cmpb $0x6, %dil
pushq $-0x1
popq %rcx
cmovbl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, 0x10(%rsp)
andl $0x0, (%rdx)
movq %rdi, %r15
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
movsbl (%rax,%rcx), %edi
callq 0x11954
cmpl $-0x1, %eax
jne 0x119f3
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x59ad2(%rip), %rsi     # 0x6b4c1
xorl %eax, %eax
callq *(%rcx)
movl %ebp, %r12d
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
movsbl (%rax,%rcx), %edi
movl %ebp, %esi
callq 0x11954
cmpl $-0x1, %eax
je 0x11ac7
movl %eax, %ecx
movq %r12, %rax
mulq %rbx
seto %dl
movslq %ecx, %rcx
leaq (%rax,%rcx), %r13
cmpq %rbx, %r13
setb %al
orb %dl, %al
movl %eax, %ecx
xorb $0x1, %cl
orb 0xc(%rsp), %cl
je 0x11a48
orb %r14b, %al
movb $0x1, %r14b
testb $0x1, %al
je 0x11a67
jmp 0x11a74
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x59a53(%rip), %rsi     # 0x6b4ad
xorl %eax, %eax
callq *(%rcx)
testb $0x1, %r14b
movb $0x1, %r14b
jne 0x11a74
movq 0x10(%rsp), %rax
incl (%rax)
xorl %r14d, %r14d
movq %r13, %rbx
movq %r15, %rdi
callq 0x11909
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
cmpb $0x5f, (%rax,%rcx)
jne 0x119fb
movsbl 0x1(%rax,%rcx), %edi
movl %ebp, %esi
callq 0x11954
cmpl $-0x1, %eax
je 0x11aac
movq %r15, %rdi
callq 0x11909
jmp 0x119fb
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x59a12(%rip), %rsi     # 0x6b4d0
xorl %eax, %eax
callq *(%rcx)
jmp 0x119fb
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_O2/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 0x11af0
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x11909
movl %eax, %ebp
cmpb $0x5c, %al
jne 0x11bfb
testq %r14, %r14
je 0x11b0b
movb $0x1, (%r14)
movq %rbx, %rdi
callq 0x11909
movl %eax, %ebp
movzbl %al, %eax
leal -0x6e(%rax), %ecx
cmpl $0xa, %ecx
ja 0x11b38
leaq 0x597fd(%rip), %rax     # 0x6b324
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0xa, %bpl
jmp 0x11bfb
cmpl $0x30, %eax
je 0x11beb
cmpl $0x66, %eax
je 0x11be6
cmpl $0x62, %eax
je 0x11be1
cmpl $0x61, %eax
jne 0x11bfb
movb $0x7, %bpl
jmp 0x11bfb
movb $0x9, %bpl
jmp 0x11bfb
movb $0xb, %bpl
jmp 0x11bfb
movq %rbx, %rdi
callq 0x11909
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
leaq 0x8(%rsp), %rcx
andl $0x0, (%rcx)
movslq 0x18(%rbx), %rdi
addq 0x10(%rbx), %rdi
leaq 0x5996e(%rip), %rsi     # 0x6b50a
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 0x11bef
movq 0x268(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5993f(%rip), %rsi     # 0x6b50f
xorl %ebp, %ebp
xorl %eax, %eax
callq *(%rcx)
andl $0x0, 0x28(%rbx)
jmp 0x11bfb
movb $0xd, %bpl
jmp 0x11bfb
movb $0x8, %bpl
jmp 0x11bfb
movb $0xc, %bpl
jmp 0x11bfb
xorl %ebp, %ebp
jmp 0x11bfb
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_O2/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), %r15
movb $0x0, (%r15)
movq %r15, %rsi
callq 0x11ad9
xorl %r14d, %r14d
cmpb $0x22, %al
setne %dl
movb 0xf(%rsp), %cl
orb %cl, %dl
testb $0x1, %dl
je 0x11c6c
cmpb $0xa, %al
je 0x11c4a
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x11c4f
jmp 0x11c89
testb $0x1, %cl
je 0x11c89
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
je 0x11c5c
movb %al, (%rcx,%r14)
incq %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11ad9
jmp 0x11c2d
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x11c7c
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
incl %r14d
movq %rbx, %rdi
callq 0x11909
jmp 0x11ca6
movq 0x268(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5988b(%rip), %rsi     # 0x6b526
xorl %r14d, %r14d
xorl %eax, %eax
callq *(%rcx)
andl $0x0, 0x28(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x4003
movq (%rax), %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x4003
movslq (%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4003
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3320
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq %r15, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4003
movslq (%rax), %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x4003
movslq (%rax), %r13
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x4003
movq (%rax), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x30d0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq %r15, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4003
movslq (%rax), %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x4003
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 0x4036
movq %r15, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq (%rax), %rbx
movq %r15, %rdi
callq 0x3050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x120d8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movdqu (%rsi), %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
pxor %xmm2, %xmm2
pxor %xmm3, %xmm3
pcmpgtd %xmm1, %xmm3
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
pxor %xmm3, %xmm3
pcmpgtd %xmm0, %xmm3
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movdqu %xmm0, (%rdi)
movdqu %xmm1, 0x10(%rdi)
movq 0x10(%rsi), %xmm0
paddd 0x5943d(%rip), %xmm0    # 0x6b550
pxor %xmm1, %xmm1
pcmpgtd %xmm0, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqu %xmm0, 0x20(%rdi)
movq 0x18(%rsi), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
pcmpgtd %xmm0, %xmm2
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movdqu %xmm0, 0x30(%rdi)
cmpl $0x0, 0x20(%rsi)
setne 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtlgmtime
void rtlgmtime(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const time_t curTime = umkaGetParam(params, 0)->intVal;
    RTLDateTime *rtlDateTime = umkaGetResult(params, result)->ptrVal;

    const struct tm *dateTime = gmtime(&curTime);
    convToRTLDateTime(rtlDateTime, dateTime);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x4003
movq (%rax), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq (%rax), %rbx
movq %r15, %rdi
callq 0x3330
movq %rbx, %rdi
movq %rax, %rsi
callq 0x120d8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movups 0x20(%rax), %xmm0
movups 0x30(%rax), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
paddd 0x5938f(%rip), %xmm0    # 0x6b560
movdqa %xmm0, 0x10(%rdi)
movzbl 0x40(%rax), %eax
movl %eax, 0x20(%rdi)
callq 0x32d0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq %r15, (%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4003
movq (%rax), %rdi
movq (%rbx), %r15
callq 0x3030
movq %r15, %rdi
movq %rax, %rsi
callq 0x3fa8
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq %r15, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x4003
movl (%rax), %ebp
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4003
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 0x3e51
testb %al, %al
je 0x1232d
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3f89
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x3f89
leaq 0x110(%rsp), %rsi
movq %r15, %rdi
callq 0x3fa8
movq %rax, (%r12)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x3fa8
movq %rax, 0x8(%r12)
movslq 0xc(%rsp), %rax
movq %rax, 0x10(%r12)
xorl %r15d, %r15d
jmp 0x12331
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4036
movq %r15, (%rax)
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: doGarbageCollectionAt
static void doGarbageCollectionAt(Compiler *comp, int blockStackPos)
{
    for (const Ident *ident = comp->idents.first; ident; ident = ident->next)
        if (ident->kind == IDENT_VAR && typeGarbageCollected(ident->type) && ident->block == comp->blocks.item[blockStackPos].block && !(ident->temporary && !ident->used) && strcmp(ident->name, "#result") != 0)
        {
            // Skip unused upvalues
            if (strcmp(ident->name, "#upvalues") == 0)
            {
                if (!comp->blocks.item[blockStackPos].fn)
                    comp->error.handler(comp->error.context, "Upvalues can only be declared in the function scope");

                if (!comp->blocks.item[blockStackPos].hasUpvalues)
                    continue;
            }

            if (ident->block == 0)
                genChangeRefCntGlobal(&comp->gen, TOK_MINUSMINUS, ident->ptr, ident->type);
            else
                genChangeRefCntLocal(&comp->gen, TOK_MINUSMINUS, ident->offset, ident->type);
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e38(%rdi), %rbp
movslq %esi, %rax
imulq $0x18, %rax, %rax
leaq (%rdi,%rax), %r12
addq $0x4220, %r12           # imm = 0x4220
leaq 0x4e70(%rdi), %r14
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x12475
cmpl $0x1, (%rbp)
jne 0x12469
movq 0x108(%rbp), %rdi
xorl %esi, %esi
callq 0x151e4
testb %al, %al
je 0x12469
movl 0x114(%rbp), %r15d
cmpl (%r12), %r15d
jne 0x12469
cmpb $0x1, 0x11b(%rbp)
jne 0x123da
cmpb $0x1, 0x11a(%rbp)
jne 0x12469
leaq 0x4(%rbp), %r13
movq %r13, %rdi
leaq 0x57fc3(%rip), %rsi     # 0x6a3ab
callq 0x3210
testl %eax, %eax
je 0x12469
movq %r13, %rdi
leaq 0x53fe5(%rip), %rsi     # 0x663e0
callq 0x3210
testl %eax, %eax
jne 0x12431
cmpq $0x0, 0x8(%r12)
jne 0x12422
movq 0x5118(%rbx), %rdi
leaq 0x5928f(%rip), %rsi     # 0x6b6a9
xorl %eax, %eax
callq *0x50f8(%rbx)
cmpb $0x1, 0x15(%r12)
jne 0x12469
movl 0x114(%rbp), %r15d
testl %r15d, %r15d
je 0x12450
movl 0x120(%rbp), %edx
movq 0x108(%rbp), %rcx
movq %r14, %rdi
pushq $0x2d
popq %rsi
callq 0xf076
jmp 0x12469
movq 0x108(%rbp), %rcx
movq 0x120(%rbp), %rdx
movq %r14, %rdi
pushq $0x2d
popq %rsi
callq 0xf027
addq $0x140, %rbp            # imm = 0x140
jmp 0x12386
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: doGarbageCollectionDownToBlock
void doGarbageCollectionDownToBlock(Compiler *comp, int block)
{
    // Collect garbage over all scopes down to the specified block (not inclusive)
    for (int i = comp->blocks.top; i >= 1; i--)
    {
        if (comp->blocks.item[i].block == block)
            break;
        doGarbageCollectionAt(comp, i);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4220(%rdi), %r15
movl 0x4b84(%rdi), %ebp
testl %ebp, %ebp
jle 0x124bb
movl %ebp, %eax
imulq $0x18, %rax, %rax
cmpl %ebx, (%r15,%rax)
je 0x124bb
movq %r14, %rdi
movl %ebp, %esi
callq 0x12358
decl %ebp
jmp 0x1249d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: doZeroVar
void doZeroVar(Compiler *comp, const Ident *ident)
{
    if (ident->block == 0)
        constZero(ident->ptr, typeSize(&comp->types, ident->type));
    else
    {
        doPushVarPtr(comp, ident);
        genZero(&comp->gen, typeSize(&comp->types, ident->type));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
leaq 0x4e18(%rdi), %r14
cmpl $0x0, 0x114(%rsi)
je 0x1250e
movq %rdi, %rbx
movq %r15, %rsi
callq 0x8c92
addq $0x4e70, %rbx           # imm = 0x4E70
movq 0x108(%r15), %rsi
movq %r14, %rdi
callq 0x15124
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xede9
movq 0x108(%r15), %rsi
movq 0x120(%r15), %rbx
movq %r14, %rdi
callq 0x15124
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x6130
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseBlock
static void parseBlock(Compiler *comp)
{
    lexEat(&comp->lex, TOK_LBRACE);
    blocksEnter(&comp->blocks);

    parseStmtList(comp);

    doGarbageCollection(comp);
    identWarnIfUnusedAll(&comp->idents, blocksCurrent(&comp->blocks));
    identFree(&comp->idents, blocksCurrent(&comp->blocks));

    blocksLeave(&comp->blocks);
    lexEat(&comp->lex, TOK_RBRACE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x4ba8(%rdi), %rbx
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0x118d3
leaq 0x4220(%r14), %r15
movq %r15, %rdi
callq 0x4b13
movq %r14, %rdi
callq 0x133c5
movq %r14, %rdi
callq 0x12350
addq $0x4e38, %r14           # imm = 0x4E38
movq %r15, %rdi
callq 0x4bcc
movq %r14, %rdi
movl %eax, %esi
callq 0x10c75
movq %r15, %rdi
callq 0x4bcc
movq %r14, %rdi
movl %eax, %esi
callq 0x1018b
movq %r15, %rdi
callq 0x4b91
pushq $0x3d
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x118d3
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseIfStmt
static void parseIfStmt(Compiler *comp)
{
    lexEat(&comp->lex, TOK_IF);

    // Additional scope embracing shortVarDecl and statement body
    blocksEnter(&comp->blocks);

    // [shortVarDecl ";"]
    if (doShortVarDeclLookahead(comp))
    {
        parseShortVarDecl(comp);
        lexEat(&comp->lex, TOK_SEMICOLON);
    }

    // expr
    const Type *type = comp->boolType;
    parseExpr(comp, &type, NULL);
    typeAssertCompatible(&comp->types, comp->boolType, type);

    genIfCondEpilog(&comp->gen);

    // block
    parseBlock(comp);

    // ["else" (ifStmt | block)]
    if (comp->lex.tok.kind == TOK_ELSE)
    {
        genElseProlog(&comp->gen);
        lexNext(&comp->lex);

        if (comp->lex.tok.kind == TOK_IF)
            parseIfStmt(comp);
        else
            parseBlock(comp);

        genIfElseEpilog(&comp->gen);
    }
    else
    {
        genIfEpilog(&comp->gen);
    }

    // Additional scope embracing shortVarDecl and statement body
    doGarbageCollection(comp);
    identWarnIfUnusedAll(&comp->idents, blocksCurrent(&comp->blocks));
    blocksLeave(&comp->blocks);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4ba8(%rdi), %r15
pushq $0xc
popq %rsi
movq %r15, %rdi
callq 0x118d3
leaq 0x4220(%rbx), %r14
movq %r14, %rdi
callq 0x4b13
movq %rbx, %rdi
callq 0x14cd9
testb %al, %al
je 0x14c15
movq %rbx, %rdi
callq 0x77f1
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x118d3
movq 0x5268(%rbx), %rax
movq %rsp, %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xd3a5
leaq 0x4e18(%rbx), %rdi
movq 0x5268(%rbx), %rsi
movq (%r12), %rdx
callq 0x15600
leaq 0x4e70(%rbx), %r12
movq %r12, %rdi
callq 0xf9ff
movq %rbx, %rdi
callq 0x148a1
cmpl $0x6, 0x4bd0(%rbx)
jne 0x14c8a
movq %r12, %rdi
callq 0xfa54
movq %r15, %rdi
callq 0x10f6e
cmpl $0xc, 0x4bd0(%rbx)
jne 0x14c94
movq %rbx, %rdi
callq 0x14bca
jmp 0x14c9c
movq %r12, %rdi
callq 0xfa38
jmp 0x14ca4
movq %rbx, %rdi
callq 0x148a1
movq %r12, %rdi
callq 0xfa87
movq %rbx, %rdi
callq 0x12350
addq $0x4e38, %rbx           # imm = 0x4E38
movq %r14, %rdi
callq 0x4bcc
movq %rbx, %rdi
movl %eax, %esi
callq 0x10c75
movq %r14, %rdi
callq 0x4b91
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: doShortVarDeclLookahead
static bool doShortVarDeclLookahead(Compiler *comp)
{
    // ident {"," ident} ":="
    Lexer lookaheadLex = comp->lex;
    while (1)
    {
        if (lookaheadLex.tok.kind != TOK_IDENT)
            return false;

        lexNext(&lookaheadLex);
        if (lookaheadLex.tok.kind != TOK_COMMA)
            break;

        lexNext(&lookaheadLex);
    }
    return lookaheadLex.tok.kind == TOK_COLONEQ;
}

// Assembly:
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
leaq 0x4ba8(%rdi), %rsi
movq %rsp, %rbx
movl $0x270, %edx            # imm = 0x270
movq %rbx, %rdi
callq 0x3260
cmpl $0x45, 0x28(%rsp)
jne 0x14d1a
movq %rbx, %rdi
callq 0x10f6e
movl 0x28(%rsp), %eax
cmpl $0x3f, %eax
jne 0x14d1e
movq %rbx, %rdi
callq 0x10f6e
jmp 0x14cf8
xorl %eax, %eax
jmp 0x14d24
cmpl $0x37, %eax
sete %al
addq $0x270, %rsp            # imm = 0x270
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseDefault
static void parseDefault(Compiler *comp)
{
    lexEat(&comp->lex, TOK_DEFAULT);
    lexEat(&comp->lex, TOK_COLON);

    // Additional scope embracing stmtList
    blocksEnter(&comp->blocks);

    parseStmtList(comp);

    // Additional scope embracing stmtList
    doGarbageCollection(comp);
    identWarnIfUnusedAll(&comp->idents, blocksCurrent(&comp->blocks));
    blocksLeave(&comp->blocks);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4ba8(%rdi), %r14
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x118d3
pushq $0x41
popq %rsi
movq %r14, %rdi
callq 0x118d3
leaq 0x4220(%rbx), %r14
movq %r14, %rdi
callq 0x4b13
movq %rbx, %rdi
callq 0x133c5
movq %rbx, %rdi
callq 0x12350
addq $0x4e38, %rbx           # imm = 0x4E38
movq %r14, %rdi
callq 0x4bcc
movq %rbx, %rdi
movl %eax, %esi
callq 0x10c75
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b91
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAdd
Type *typeAdd(Types *types, const Blocks *blocks, TypeKind kind)
{
    Type *type = storageAdd(types->storage, sizeof(Type));

    type->kind  = kind;
    type->block = blocks->item[blocks->top].block;
    type->sameAs = type;
    type->size = typeSizeRecompute(type);
    type->alignment = typeAlignmentRecompute(type);

    type->next = types->first;
    types->first = type;

    return type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl $0xd0, %esi
callq 0x4144
movq %rax, %r12
movl %ebx, (%rax)
movslq 0x964(%r14), %rax
imulq $0x18, %rax, %rax
movl (%r14,%rax), %eax
movl %eax, 0x4(%r12)
movq %r12, 0x20(%r12)
movq %r12, %rdi
callq 0x14e22
movl %eax, 0xc0(%r12)
movq %r12, %rdi
callq 0x14f15
movl %eax, 0xc4(%r12)
movq (%r15), %rax
movq %rax, 0xc8(%r12)
movq %r12, (%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq