LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aed0
movq -0x8(%rbp), %rax
cmpl $0x4b, 0x28(%rax)
jne 0x1ae97
movq -0x8(%rbp), %rax
cmpl $0x1, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x4, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0xf, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x10, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x2c, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x2d, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x39, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x3b, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x3d, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x3e, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x45, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x46, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x47, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x48, 0x140(%rax)
je 0x1ae8a
movq -0x8(%rbp), %rax
cmpl $0x49, 0x140(%rax)
jne 0x1ae95
movq -0x8(%rbp), %rax
movl $0x4a, 0x28(%rax)
jmp 0x1ae97
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movl $0x118, %edx            # imm = 0x118
callq 0x3270
movq -0x8(%rbp), %rax
cmpl $0x4b, 0x28(%rax)
je 0x1ad9c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexNextWithEOLN
static void lexNextWithEOLN(Lexer *lex)
{
    lexSpacesAndComments(lex);

    lex->tok.kind = TOK_NONE;
    lex->tok.line = lex->debug->line = lex->line;
    lex->tok.pos = lex->pos;

    char ch = lex->buf[lex->bufPos];
    if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch == '_')
        lexKeywordOrIdent(lex);
    else if ((ch >= '0' && ch <= '9') || ch == '.')
        lexNumber(lex);
    else if (ch == '\'')
        lexCharLiteral(lex);
    else if (ch == '"')
        lexStrLiteral(lex);

    if (lex->tok.kind == TOK_NONE)
        lexOperator(lex);

    if (lex->tok.kind == TOK_NONE)
    {
        if (!lex->buf[lex->bufPos])
            lex->tok.kind = TOK_EOF;
        else
            lex->error->handler(lex->error->context, "Unexpected character or end of file");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b240
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x138(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x13c(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x41, %eax
jl 0x1af48
movsbl -0x9(%rbp), %eax
cmpl $0x5a, %eax
jle 0x1af63
movsbl -0x9(%rbp), %eax
cmpl $0x61, %eax
jl 0x1af5a
movsbl -0x9(%rbp), %eax
cmpl $0x7a, %eax
jle 0x1af63
movsbl -0x9(%rbp), %eax
cmpl $0x5f, %eax
jne 0x1af6e
movq -0x8(%rbp), %rdi
callq 0x1b350
jmp 0x1afc0
movsbl -0x9(%rbp), %eax
cmpl $0x30, %eax
jl 0x1af80
movsbl -0x9(%rbp), %eax
cmpl $0x39, %eax
jle 0x1af89
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %eax
jne 0x1af94
movq -0x8(%rbp), %rdi
callq 0x1b500
jmp 0x1afbe
movsbl -0x9(%rbp), %eax
cmpl $0x27, %eax
jne 0x1afa8
movq -0x8(%rbp), %rdi
callq 0x1b8b0
jmp 0x1afbc
movsbl -0x9(%rbp), %eax
cmpl $0x22, %eax
jne 0x1afba
movq -0x8(%rbp), %rdi
callq 0x1b940
jmp 0x1afbc
jmp 0x1afbe
jmp 0x1afc0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x1afd3
movq -0x8(%rbp), %rdi
callq 0x1b9c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x1b02a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1b000
movq -0x8(%rbp), %rax
movl $0x4c, 0x28(%rax)
jmp 0x1b028
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1be746(%rip), %rsi    # 0x1d976a
movb $0x0, %al
callq *%rcx
jmp 0x1b02a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aed0
movq -0x8(%rbp), %rax
cmpl $0x4b, 0x28(%rax)
jne 0x1b05a
movq -0x8(%rbp), %rax
movl $0x4a, 0x28(%rax)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movl $0x118, %edx            # imm = 0x118
callq 0x3270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0xe(%rbp)
je 0x1b0bf
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x4a, 0x28(%rcx)
movb %al, -0xf(%rbp)
jne 0x1b0b9
cmpl $0x40, -0xc(%rbp)
sete %al
movb %al, -0xf(%rbp)
movb -0xf(%rbp), %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x1b125
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x1b130
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x1b130
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %r8
movq %rax, %rcx
leaq 0x1be553(%rip), %rsi    # 0x1d9673
movb $0x0, %al
callq *%r8
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexShortAssignment
TokenKind lexShortAssignment(TokenKind kind)
{
    // Full replacements for short assignment operators
    switch (kind)
    {
        case TOK_PLUSEQ:  return TOK_PLUS;
        case TOK_MINUSEQ: return TOK_MINUS;
        case TOK_MULEQ:   return TOK_MUL;
        case TOK_DIVEQ:   return TOK_DIV;
        case TOK_MODEQ:   return TOK_MOD;
        case TOK_ANDEQ:   return TOK_AND;
        case TOK_OREQ:    return TOK_OR;
        case TOK_XOREQ:   return TOK_XOR;
        case TOK_SHLEQ:   return TOK_SHL;
        case TOK_SHREQ:   return TOK_SHR;
        default:          return TOK_NONE;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x20, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x1b226
movq -0x10(%rbp), %rax
leaq 0x1be159(%rip), %rcx    # 0x1d931c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x16, -0x4(%rbp)
jmp 0x1b22d
movl $0x17, -0x4(%rbp)
jmp 0x1b22d
movl $0x18, -0x4(%rbp)
jmp 0x1b22d
movl $0x19, -0x4(%rbp)
jmp 0x1b22d
movl $0x1a, -0x4(%rbp)
jmp 0x1b22d
movl $0x1b, -0x4(%rbp)
jmp 0x1b22d
movl $0x1c, -0x4(%rbp)
jmp 0x1b22d
movl $0x1d, -0x4(%rbp)
jmp 0x1b22d
movl $0x1e, -0x4(%rbp)
jmp 0x1b22d
movl $0x1f, -0x4(%rbp)
jmp 0x1b22d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexSpacesAndComments
static void lexSpacesAndComments(Lexer *lex)
{
    char ch = lex->buf[lex->bufPos];

    while (ch && (ch == ' ' || ch == '\t' || ch == '\r' || ch == '/'))
    {
        if (ch == '/')
        {
            ch = lexChar(lex);
            if (ch == '/')
                lexSingleLineComment(lex);
            else if (ch == '*')
                lexMultiLineComment(lex);
            else
            {
                // Discard ch
                lex->bufPos--;
                lex->pos--;
                break;
            }

            ch = lex->buf[lex->bufPos];
        }
        else
            ch = lexChar(lex);
    } // while
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa(%rbp)
je 0x1b2ad
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xb(%rbp)
je 0x1b2a7
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0xb(%rbp)
je 0x1b2a7
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0xb(%rbp)
je 0x1b2a7
movsbl -0x9(%rbp), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0x1b2b9
jmp 0x1b33d
movsbl -0x9(%rbp), %eax
cmpl $0x2f, %eax
jne 0x1b32c
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x2f, %eax
jne 0x1b2e2
movq -0x8(%rbp), %rdi
callq 0x1c070
jmp 0x1b314
movsbl -0x9(%rbp), %eax
cmpl $0x2a, %eax
jne 0x1b2f6
movq -0x8(%rbp), %rdi
callq 0x1c0c0
jmp 0x1b312
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x1b33d
jmp 0x1b314
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
jmp 0x1b338
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
jmp 0x1b262
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexCharLiteral
static void lexCharLiteral(Lexer *lex)
{
    lex->tok.kind = TOK_CHARLITERAL;
    lex->tok.intVal = lexEscChar(lex, NULL);

    const char ch = lexChar(lex);
    if (ch != '\'')
    {
        lex->error->handler(lex->error->context, "Invalid character literal");
        lex->tok.kind = TOK_NONE;
    }
    lexChar(lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x48, 0x28(%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c4b0
movsbq %al, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x27, %eax
je 0x1b928
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1bdecf(%rip), %rsi    # 0x1d97e8
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x1bff0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexStrLiteral
static void lexStrLiteral(Lexer *lex)
{
    Lexer lookaheadLex = *lex;
    lookaheadLex.tok.strVal = NULL;
    const int size = lexStrLiteralAndGetSize(&lookaheadLex);

    lex->tok.strVal = storageAddStr(lex->storage, size - 1);
    lexStrLiteralAndGetSize(lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x278(%rbp), %rdi
movl $0x270, %edx            # imm = 0x270
callq 0x3270
movq $0x0, -0x248(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x1c640
movl %eax, -0x27c(%rbp)
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rdi
movl -0x27c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x4c60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x1c640
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
cmpb $0x0, -0x9(%rbp)
je 0x1c051
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x1c04f
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x1c051
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb (%rax,%rcx), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexMultiLineComment
static void lexMultiLineComment(Lexer *lex)
{
    char ch = lexChar(lex);
    bool asteriskFound = false;

    while (ch && !(ch == '/' && asteriskFound))
    {
        asteriskFound = false;

        while (ch && ch != '*')
            ch = lexChar(lex);

        if (ch == '*') asteriskFound = true;
        ch = lexChar(lex);
    }

    ch = lexChar(lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
je 0x1c106
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0xc(%rbp)
jne 0x1c0fe
movb -0xa(%rbp), %al
movb %al, -0xc(%rbp)
movb -0xc(%rbp), %al
xorb $-0x1, %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0x1c10f
jmp 0x1c163
movb $0x0, -0xa(%rbp)
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
je 0x1c12e
movsbl -0x9(%rbp), %eax
cmpl $0x2a, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x1c137
jmp 0x1c145
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
jmp 0x1c113
movsbl -0x9(%rbp), %eax
cmpl $0x2a, %eax
jne 0x1c152
movb $0x1, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
jmp 0x1c0dc
movq -0x8(%rbp), %rdi
callq 0x1bff0
movb %al, -0x9(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexCharIf
static char lexCharIf(Lexer *lex, char ch)
{
    if (lex->buf[lex->bufPos] == ch)
    {
        lexChar(lex);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1c1bd
movq -0x10(%rbp), %rdi
callq 0x1bff0
movb $0x1, -0x1(%rbp)
jmp 0x1c1c1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xa, %eax
je 0x1c1f7
jmp 0x1c1ea
movl -0x10(%rbp), %eax
subl $0x10, %eax
je 0x1c22a
jmp 0x1c2a8
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x1c215
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x1c215
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c21f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x1c21f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c2af
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x1c248
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x1c248
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c2a0
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x1c269
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x1c269
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c29a
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x1c28a
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x1c28a
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x20(%rbp)
jmp 0x1c294
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0x1c294
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c2af
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x49, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x15(%rbp), %rsi
callq 0x1c4b0
movb %al, -0x16(%rbp)
movsbl -0x16(%rbp), %ecx
movb $0x1, %al
cmpl $0x22, %ecx
movb %al, -0x17(%rbp)
jne 0x1c686
movb -0x15(%rbp), %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
testb $0x1, %al
jne 0x1c692
jmp 0x1c721
movsbl -0x16(%rbp), %eax
cmpl $0x0, %eax
je 0x1c6aa
movsbl -0x16(%rbp), %eax
cmpl $0xa, %eax
jne 0x1c6e6
testb $0x1, -0x15(%rbp)
jne 0x1c6e6
movq -0x10(%rbp), %rax
movq 0x268(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x268(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1bd150(%rip), %rsi    # 0x1d981e
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1c754
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1c703
movb -0x16(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x15(%rbp), %rsi
callq 0x1c4b0
movb %al, -0x16(%rbp)
jmp 0x1c672
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1c73c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bff0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x48a0
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3270
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3320
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x48a0
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x48a0
movq (%rax), %rax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movslq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x30c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x48a0
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x48a0
movq (%rax), %rax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x1cbb0
movl $0x0, -0x24(%rbp)
jmp 0x1cbd0
cmpl $0x1, -0x20(%rbp)
jne 0x1cbbf
movl $0x1, -0x24(%rbp)
jmp 0x1cbce
cmpl $0x2, -0x20(%rbp)
jne 0x1cbcc
movl $0x2, -0x24(%rbp)
jmp 0x1cbce
jmp 0x1cbd0
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x32f0
cltq
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3050
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cf00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
setne %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x40(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3330
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cf00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: convFromRTLDateTime
static void convFromRTLDateTime(struct tm *dest, const RTLDateTime *src)
{
    dest->tm_sec    = src->second;
    dest->tm_min    = src->minute;
    dest->tm_hour   = src->hour;
    dest->tm_mday   = src->day;
    dest->tm_mon    = src->month - 1;
    dest->tm_year   = src->year - 1900;
    dest->tm_wday   = src->dayOfWeek - 1;
    dest->tm_yday   = src->dayOfYear - 1;
    dest->tm_isdst  = src->isDST;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x76c, %rax            # imm = 0x76C
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movb 0x40(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d1b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3030
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x46d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48a0
movq (%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x48a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d1b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x130(%rbp), %r8
leaq -0x230(%rbp), %r9
movl $0x100, %edx            # imm = 0x100
xorl %eax, %eax
movl %eax, %ecx
leaq -0x234(%rbp), %rax
movq %rax, (%rsp)
callq 0x4430
testb $0x1, %al
jne 0x1d2fa
jmp 0x1d375
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x4640
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4640
movq -0x28(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x46d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x46d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x234(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq $0x0, (%rax)
jmp 0x1d389
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4940
movq $-0x1, (%rax)
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x4e38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1d576
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1d560
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rdi
callq 0x1ecd0
testb $0x1, %al
jne 0x1d41f
jmp 0x1d560
movq -0x18(%rbp), %rax
movl 0x114(%rax), %eax
movq -0x8(%rbp), %rcx
addq $0x4220, %rcx           # imm = 0x4220
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x1d560
movq -0x18(%rbp), %rax
testb $0x1, 0x11b(%rax)
je 0x1d465
movq -0x18(%rbp), %rax
testb $0x1, 0x11a(%rax)
je 0x1d560
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
leaq 0x1bafdb(%rip), %rsi    # 0x1d844f
callq 0x3220
cmpl $0x0, %eax
je 0x1d560
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
leaq 0x1b6f57(%rip), %rsi    # 0x1d43e8
callq 0x3220
cmpl $0x0, %eax
jne 0x1d4f7
movq -0x8(%rbp), %rax
addq $0x4220, %rax           # imm = 0x4220
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x1d4d8
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1bc56d(%rip), %rsi    # 0x1d9a41
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
addq $0x4220, %rax           # imm = 0x4220
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x15(%rax)
jne 0x1d4f5
jmp 0x1d562
jmp 0x1d4f7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x114(%rax)
jne 0x1d531
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq 0x120(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rcx
movl $0x2d, %esi
callq 0x17390
jmp 0x1d55e
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq 0x120(%rax), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rcx
movl $0x2d, %esi
callq 0x17400
jmp 0x1d560
jmp 0x1d562
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1d3ee
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4b84(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jl 0x1d5d7
movq -0x8(%rbp), %rax
addq $0x4220, %rax           # imm = 0x4220
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1d5c0
jmp 0x1d5d7
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1d3d0
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d59c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x114(%rax)
jne 0x1d634
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0x21fe0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x8680
jmp 0x1d675
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd010
movq -0x8(%rbp), %rax
addq $0x4e70, %rax           # imm = 0x4E70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0x21fe0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x16f50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseStmtList
static void parseStmtList(Compiler *comp)
{
    while (1)
    {
        parseStmt(comp);
        if (comp->lex.tok.kind != TOK_SEMICOLON && comp->lex.tok.kind != TOK_IMPLICIT_SEMICOLON)
            break;
        lexNext(&comp->lex);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ed80
movq -0x8(%rbp), %rax
cmpl $0x40, 0x4bd0(%rax)
je 0x1ec41
movq -0x8(%rbp), %rax
cmpl $0x4a, 0x4bd0(%rax)
je 0x1ec41
jmp 0x1ec53
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
jmp 0x1ec1c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseStmt
static void parseStmt(Compiler *comp)
{
    switch (comp->lex.tok.kind)
    {
        case TOK_TYPE:
        case TOK_CONST:
        case TOK_VAR:       parseDecl(comp);            break;
        case TOK_LBRACE:    parseBlock(comp);           break;
        case TOK_IDENT:
        case TOK_CARET:
        case TOK_WEAK:
        case TOK_LBRACKET:
        case TOK_STR:
        case TOK_STRUCT:
        case TOK_INTERFACE:
        case TOK_MAP:
        case TOK_FN:        parseSimpleStmt(comp);      break;
        case TOK_IF:        parseIfStmt(comp);          break;
        case TOK_SWITCH:    parseSwitchStmt(comp);      break;
        case TOK_FOR:       parseForStmt(comp);         break;
        case TOK_BREAK:     parseBreakStmt(comp);       break;
        case TOK_CONTINUE:  parseContinueStmt(comp);    break;
        case TOK_RETURN:    parseReturnStmt(comp);      break;

        default: break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x44, %eax
ja 0x1ee1a
movq -0x10(%rbp), %rax
leaq 0x1baa92(%rip), %rcx    # 0x1d9840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0xaa80
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1ee30
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1eef0
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1f080
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1f1f0
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1f230
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1f4e0
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1f570
jmp 0x1ee1c
movq -0x8(%rbp), %rdi
callq 0x1f600
jmp 0x1ee1c
jmp 0x1ee1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3c, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x5e60
movq -0x8(%rbp), %rdi
callq 0x1ec10
movq -0x8(%rbp), %rdi
callq 0x1d3a0
movq -0x8(%rbp), %rax
addq $0x4e38, %rax           # imm = 0x4E38
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x6020
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x1a7e0
movq -0x8(%rbp), %rax
addq $0x4e38, %rax           # imm = 0x4E38
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x6020
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x194d0
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x5fa0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3d, %esi
callq 0x1b150
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0xc, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x5e60
movq -0x8(%rbp), %rdi
callq 0x1f910
testb $0x1, %al
jne 0x1f0c0
jmp 0x1f0de
movq -0x8(%rbp), %rdi
callq 0xa8f0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x22870
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x18580
movq -0x8(%rbp), %rdi
callq 0x1ee30
movq -0x8(%rbp), %rax
cmpl $0x6, 0x4bd0(%rax)
jne 0x1f196
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x18670
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rax
cmpl $0xc, 0x4bd0(%rax)
jne 0x1f17b
movq -0x8(%rbp), %rdi
callq 0x1f080
jmp 0x1f184
movq -0x8(%rbp), %rdi
callq 0x1ee30
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x186c0
jmp 0x1f1a6
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x18600
movq -0x8(%rbp), %rdi
callq 0x1d3a0
movq -0x8(%rbp), %rax
addq $0x4e38, %rax           # imm = 0x4E38
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x6020
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x1a7e0
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x5fa0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseBreakStmt
static void parseBreakStmt(Compiler *comp)
{
    lexEat(&comp->lex, TOK_BREAK);

    if (!comp->gen.breaks)
        comp->error.handler(comp->error.context, "No loop to break");

    doGarbageCollectionDownToBlock(comp, comp->gen.breaks->block);
    genGotosAddStub(&comp->gen, comp->gen.breaks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x1, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
cmpq $0x0, 0x5018(%rax)
jne 0x1f530
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ba6c8(%rip), %rsi    # 0x1d9bf4
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x5018(%rax), %rax
movl 0x194(%rax), %esi
callq 0x1d580
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x8(%rbp), %rax
movq 0x5018(%rax), %rsi
callq 0x18ce0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseContinueStmt
static void parseContinueStmt(Compiler *comp)
{
    lexEat(&comp->lex, TOK_CONTINUE);

    if (!comp->gen.continues)
        comp->error.handler(comp->error.context, "No loop to continue");

    doGarbageCollectionDownToBlock(comp, comp->gen.continues->block);
    genGotosAddStub(&comp->gen, comp->gen.continues);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x4, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
cmpq $0x0, 0x5020(%rax)
jne 0x1f5c0
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ba649(%rip), %rsi    # 0x1d9c05
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x5020(%rax), %rax
movl 0x194(%rax), %esi
callq 0x1d580
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x8(%rbp), %rax
movq 0x5020(%rax), %rsi
callq 0x18ce0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)