LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexDigitSeq
static uint64_t lexDigitSeq(Lexer *lex, int base, int *len, bool isFrac)
{
    uint64_t result = 0;
    *len = 0;

    if (lexCharDigit(lex->buf[lex->bufPos], base) == -1)
        lex->error->handler(lex->error->context, "Invalid number");

    bool skipDigits = false;

    while (lexCharDigit(lex->buf[lex->bufPos], base) != -1)
    {
        uint64_t newResult = result * base + lexCharDigit(lex->buf[lex->bufPos], base);
        if ((result * base) / base != result || newResult < result)
        {
            if (isFrac)
                skipDigits = true;
            else
                lex->error->handler(lex->error->context, "Number is too large");
        }

        if (!skipDigits)
        {
            result = newResult;
            (*len)++;
        }

        lexChar(lex);

        if (lex->buf[lex->bufPos] == '_')
        {
            if (lexCharDigit(lex->buf[lex->bufPos + 1], base) != -1)
                lexChar(lex);
            else
                lex->error->handler(lex->error->context, "_ must be placed between digits");
        }
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, 0x10(%rsp)
movl $0x0, (%rdx)
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1641c
movl %eax, %ecx
cmpl $-0x1, %eax
jne 0x164da
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x61060(%rip), %rsi     # 0x77521
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
movsbl (%rax,%rcx), %edi
movl %ebp, %esi
callq 0x1641c
movl %eax, %ecx
cmpl $-0x1, %ecx
je 0x165ad
movl %ebp, %r12d
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r12, %rax
mulq %rbx
seto %dl
movslq %ecx, %rcx
leaq (%rax,%rcx), %r13
cmpq %rbx, %r13
setb %al
orb %dl, %al
movl %eax, %ecx
xorb $0x1, %cl
orb 0xc(%rsp), %cl
je 0x16556
orb %r14b, %al
movb $0x1, %r14b
testb $0x1, %al
jne 0x16525
movq 0x10(%rsp), %rax
incl (%rax)
xorl %r14d, %r14d
movq %r13, %rbx
movq %r15, %rdi
callq 0x163ef
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
cmpb $0x5f, (%rax,%rcx)
jne 0x1658d
movsbl 0x1(%rax,%rcx), %edi
movl %ebp, %esi
callq 0x1641c
cmpl $-0x1, %eax
je 0x16577
movq %r15, %rdi
callq 0x163ef
jmp 0x1658d
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x60fa5(%rip), %rsi     # 0x7750d
xorl %eax, %eax
callq *(%rcx)
testb $0x1, %r14b
movb $0x1, %r14b
je 0x16518
jmp 0x16525
movq 0x268(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x60fa7(%rip), %rsi     # 0x77530
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r15), %rax
movslq 0x18(%r15), %rcx
movsbl (%rax,%rcx), %edi
movl %ebp, %esi
callq 0x1641c
movl %eax, %ecx
cmpl $-0x1, %eax
jne 0x164eb
jmp 0x165af
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x165ea
movq %rsi, %r15
movb $0x0, (%rsi)
movq %r14, %rdi
callq 0x163ef
cmpb $0x5c, %al
jne 0x16624
movb $0x1, (%r15)
jmp 0x165f6
movq %r14, %rdi
callq 0x163ef
cmpb $0x5c, %al
jne 0x16624
movq %r14, %rdi
callq 0x163ef
movl %eax, %ebx
movzbl %al, %eax
cmpl $0x65, %eax
jle 0x16632
leal -0x6e(%rax), %ecx
cmpl $0xa, %ecx
ja 0x1664d
leaq 0x60d6d(%rip), %rax     # 0x77384
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0xa, %bl
jmp 0x16626
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x30, %eax
je 0x16645
cmpl $0x61, %eax
je 0x16649
cmpl $0x62, %eax
jne 0x16626
movb $0x8, %bl
jmp 0x16626
xorl %ebx, %ebx
jmp 0x16626
movb $0x7, %bl
jmp 0x16626
cmpl $0x66, %eax
jne 0x16626
movb $0xc, %bl
jmp 0x16626
movb $0x9, %bl
jmp 0x16626
movb $0xd, %bl
jmp 0x16626
movq %r14, %rdi
callq 0x163ef
xorl %eax, %eax
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movslq 0x18(%r14), %rdi
addq 0x10(%r14), %rdi
leaq 0x60ee5(%rip), %rsi     # 0x7756a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32b0
testl %eax, %eax
setle %al
movl (%rbx), %ebx
cmpl $0x100, %ebx            # imm = 0x100
setae %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x166d2
movq 0x268(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x60eb7(%rip), %rsi     # 0x7756f
xorl %ebx, %ebx
xorl %eax, %eax
callq *(%rcx)
movl $0x0, 0x28(%r14)
jmp 0x16626
movb $0xb, %bl
jmp 0x16626
movl 0x8(%rsp), %eax
decl %eax
addl %eax, 0x18(%r14)
addl %eax, 0x20(%r14)
jmp 0x16626
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexStrLiteralAndGetSize
static int lexStrLiteralAndGetSize(Lexer *lex)
{
    lex->tok.kind = TOK_STRLITERAL;

    int size = 0;
    bool escaped = false;
    char ch = lexEscChar(lex, &escaped);

    while (ch != '\"' || escaped)
    {
        if (ch == 0 || (ch == '\n' && !escaped))
        {
            lex->error->handler(lex->error->context, "Unterminated string");
            lex->tok.kind = TOK_NONE;
            return 0;
        }

        if (lex->tok.strVal)
            lex->tok.strVal[size] = ch;
        size++;
        ch = lexEscChar(lex, &escaped);
    }

    if (lex->tok.strVal)
        lex->tok.strVal[size] = 0;
    size++;
    lexChar(lex);

    return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x49, 0x28(%rdi)
leaq 0xf(%rsp), %r14
movb $0x0, (%r14)
movq %r14, %rsi
callq 0x165c1
cmpb $0x22, %al
setne %dl
movb (%r14), %cl
orb %cl, %dl
xorl %r14d, %r14d
testb $0x1, %dl
je 0x16760
xorl %r14d, %r14d
leaq 0xf(%rsp), %r15
cmpb $0xa, %al
je 0x16730
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x16735
jmp 0x1677d
testb $0x1, %cl
je 0x1677d
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
je 0x16742
movb %al, (%rcx,%r14)
incq %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x165c1
cmpb $0x22, %al
setne %dl
movb 0xf(%rsp), %cl
orb %cl, %dl
testb $0x1, %dl
jne 0x16723
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x16770
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
incl %r14d
movq %rbx, %rdi
callq 0x163ef
jmp 0x1679d
movq 0x268(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x60df7(%rip), %rsi     # 0x77586
xorl %r14d, %r14d
xorl %eax, %eax
callq *(%rcx)
movl $0x0, 0x28(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x792c
movq (%rax), %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x792c
movslq (%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x792c
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3320
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq %r15, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x792c
movslq (%rax), %r12
movq %r14, %rdi
movl $0x2, %esi
callq 0x792c
movslq (%rax), %r13
movq %r14, %rdi
movl $0x3, %esi
callq 0x792c
movq (%rax), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x30d0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq %r15, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x792c
movslq (%rax), %r12
movq %r14, %rdi
movl $0x2, %esi
callq 0x792c
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 0x795f
movq %r15, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq (%rax), %rbx
movq %r15, %rdi
callq 0x3050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16bfe
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq (%rax), %rbx
movq %r15, %rdi
callq 0x3330
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16bfe
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
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 0x608c9(%rip), %xmm0    # 0x775c0
movdqa %xmm0, 0x10(%rdi)
movzbl 0x40(%rax), %eax
movl %eax, 0x20(%rdi)
callq 0x32d0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq %r15, (%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x792c
movq (%rax), %rdi
movq (%rbx), %r15
callq 0x3030
movq %r15, %rdi
movq %rax, %rsi
callq 0x78d1
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq %r15, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_runtime.c
// Function: rtltrace
void rtltrace(UmkaStackSlot *params, UmkaStackSlot *result)
{
    const int depth = umkaGetParam(params, 0)->intVal;
    RTLErrPos *pos = umkaGetParam(params, 1)->ptrVal;

    void *umka = umkaGetInstance(result);

    char fileName[DEFAULT_STR_LEN + 1], fnName[DEFAULT_STR_LEN + 1];
    int line;

    if (umkaGetCallStack(umka, depth, DEFAULT_STR_LEN + 1, NULL, fileName, fnName, &line))
    {
        umkaDecRef(umka, pos->fileName);
        umkaDecRef(umka, pos->fnName);

        pos->fileName = umkaMakeStr(umka, fileName);
        pos->fnName   = umkaMakeStr(umka, fnName);
        pos->line     = line;

        umkaGetResult(params, result)->intVal = 0;
    }
    else
        umkaGetResult(params, result)->intVal = -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x792c
movl (%rax), %ebp
movq %r14, %rdi
movl $0x1, %esi
callq 0x792c
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 0x777a
movq $-0x1, %r13
testb %al, %al
je 0x16e62
movq (%r12), %rsi
movq %r15, %rdi
callq 0x78b2
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x78b2
leaq 0x110(%rsp), %rsi
movq %r15, %rdi
callq 0x78d1
movq %rax, (%r12)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x78d1
movq %rax, 0x8(%r12)
movslq 0xc(%rsp), %rax
movq %rax, 0x10(%r12)
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x795f
movq %r13, (%rax)
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4e38(%rdi), %r13
testq %r13, %r13
je 0x16fb1
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %r12
addq $0x4220, %r12           # imm = 0x4220
leaq 0x4e70(%rdi), %r14
cmpl $0x1, (%r13)
jne 0x16fa1
movq 0x108(%r13), %rdi
xorl %esi, %esi
callq 0x19ef5
testb %al, %al
je 0x16fa1
movl 0x114(%r13), %r15d
cmpl (%r12), %r15d
jne 0x16fa1
cmpb $0x1, 0x11b(%r13)
jne 0x16f0d
cmpb $0x1, 0x11a(%r13)
jne 0x16fa1
leaq 0x4(%r13), %rbp
movq %rbp, %rdi
leaq 0x5f4ec(%rip), %rsi     # 0x76407
callq 0x3210
testl %eax, %eax
je 0x16fa1
movq %rbp, %rdi
leaq 0x5b4b2(%rip), %rsi     # 0x723e0
callq 0x3210
testl %eax, %eax
jne 0x16f64
cmpq $0x0, 0x8(%r12)
jne 0x16f55
movq 0x5118(%rbx), %rdi
leaq 0x607bc(%rip), %rsi     # 0x77709
xorl %eax, %eax
callq *0x50f8(%rbx)
cmpb $0x1, 0x15(%r12)
jne 0x16fa1
movl 0x114(%r13), %r15d
testl %r15d, %r15d
je 0x16f86
movl 0x120(%r13), %edx
movq 0x108(%r13), %rcx
movq %r14, %rdi
movl $0x2d, %esi
callq 0x13565
jmp 0x16fa1
movq 0x108(%r13), %rcx
movq 0x120(%r13), %rdx
movq %r14, %rdi
movl $0x2d, %esi
callq 0x13511
movq 0x140(%r13), %r13
testq %r13, %r13
jne 0x16ec3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x4b84(%rdi), %r15d
testl %r15d, %r15d
jle 0x17005
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4220(%rdi), %r12
movl %r15d, %eax
leaq (%rax,%rax,2), %rax
cmpl %ebx, (%r12,%rax,8)
je 0x17005
movq %r14, %rdi
movl %r15d, %esi
callq 0x16e8c
leal -0x1(%r15), %eax
cmpl $0x1, %r15d
movl %eax, %r15d
jg 0x16fe0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17059
movq %rdi, %rbx
movq %r15, %rsi
callq 0xc9da
addq $0x4e70, %rbx           # imm = 0x4E70
movq 0x108(%r15), %rsi
movq %r14, %rdi
callq 0x19e29
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1328b
movq 0x108(%r15), %rsi
movq 0x120(%r15), %rbx
movq %r14, %rdi
callq 0x19e29
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x9c54
// File: /workspace/github_c_makefile_star2_O3/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
movq %rbx, %rdi
movl $0x3c, %esi
callq 0x1637d
leaq 0x4220(%r14), %r15
movq %r15, %rdi
callq 0x8503
movq %r14, %rdi
callq 0x17fa7
movl 0x4b84(%r14), %esi
movq %r14, %rdi
callq 0x16e8c
addq $0x4e38, %r14           # imm = 0x4E38
movq %r15, %rdi
callq 0x85bf
movq %r14, %rdi
movl %eax, %esi
callq 0x1559f
movq %r15, %rdi
callq 0x85bf
movq %r14, %rdi
movl %eax, %esi
callq 0x14a1a
movq %r15, %rdi
callq 0x8584
movq %rbx, %rdi
movl $0x3d, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1637d
// File: /workspace/github_c_makefile_star2_O3/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
movq %r15, %rdi
movl $0xc, %esi
callq 0x1637d
leaq 0x4220(%rbx), %r14
movq %r14, %rdi
callq 0x8503
movq %rbx, %rdi
callq 0x19989
testb %al, %al
je 0x198bf
movq %rbx, %rdi
callq 0xb415
movq %r15, %rdi
movl $0x40, %esi
callq 0x1637d
movq 0x5268(%rbx), %rax
movq %rsp, %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x111c3
leaq 0x4e18(%rbx), %rdi
movq 0x5268(%rbx), %rsi
movq (%r12), %rdx
callq 0x1a277
leaq 0x4e70(%rbx), %r12
movq %r12, %rdi
callq 0x13f8b
movq %rbx, %rdi
callq 0x1953e
cmpl $0x6, 0x4bd0(%rbx)
jne 0x19934
movq %r12, %rdi
callq 0x13ffd
movq %r15, %rdi
callq 0x15914
cmpl $0xc, 0x4bd0(%rbx)
jne 0x1993e
movq %rbx, %rdi
callq 0x19870
jmp 0x19946
movq %r12, %rdi
callq 0x13fcc
jmp 0x1994e
movq %rbx, %rdi
callq 0x1953e
movq %r12, %rdi
callq 0x14071
movl 0x4b84(%rbx), %esi
movq %rbx, %rdi
callq 0x16e8c
addq $0x4e38, %rbx           # imm = 0x4E38
movq %r14, %rdi
callq 0x85bf
movq %rbx, %rdi
movl %eax, %esi
callq 0x1559f
movq %r14, %rdi
callq 0x8584
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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(%rbx)
jne 0x199d1
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x15914
movl 0x28(%rsp), %eax
cmpl $0x3f, %eax
jne 0x199d5
movq %rbx, %rdi
callq 0x15914
cmpl $0x45, 0x28(%rsp)
je 0x199b1
xorl %eax, %eax
jmp 0x199db
cmpl $0x37, %eax
sete %al
addq $0x270, %rsp            # imm = 0x270
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %r14, %rdi
movl $0x5, %esi
callq 0x1637d
movq %r14, %rdi
movl $0x41, %esi
callq 0x1637d
leaq 0x4220(%rbx), %r14
movq %r14, %rdi
callq 0x8503
movq %rbx, %rdi
callq 0x17fa7
movl 0x4b84(%rbx), %esi
movq %rbx, %rdi
callq 0x16e8c
addq $0x4e38, %rbx           # imm = 0x4E38
movq %r14, %rdi
callq 0x85bf
movq %rbx, %rdi
movl %eax, %esi
callq 0x1559f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8584
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x7a70
movq %rax, %r12
movl %ebx, (%rax)
movslq 0x964(%r14), %rax
leaq (%rax,%rax,2), %rax
movl (%r14,%rax,8), %eax
movl %eax, 0x4(%r12)
movq %r12, 0x20(%r12)
movq %r12, %rdi
callq 0x19ae9
movl %eax, 0xc0(%r12)
movq %r12, %rdi
callq 0x19c0a
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
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAlignmentRecompute
static int typeAlignmentRecompute(const Type *type)
{
    switch (type->kind)
    {
        case TYPE_VOID:     return 1;
        case TYPE_INT8:
        case TYPE_INT16:
        case TYPE_INT32:
        case TYPE_INT:
        case TYPE_UINT8:
        case TYPE_UINT16:
        case TYPE_UINT32:
        case TYPE_UINT:
        case TYPE_BOOL:
        case TYPE_CHAR:
        case TYPE_REAL32:
        case TYPE_REAL:
        case TYPE_PTR:
        case TYPE_WEAKPTR:
        case TYPE_STR:      return typeSizeRecompute(type);
        case TYPE_ARRAY:    return type->numItems > 0 ? typeAlignmentRecompute(type->base) : 1;
        case TYPE_DYNARRAY:
        case TYPE_MAP:      return sizeof(int64_t);
        case TYPE_STRUCT:
        case TYPE_INTERFACE:
        case TYPE_CLOSURE:
        {
            int alignment = 1;
            for (int i = 0; i < type->numItems; i++)
            {
                const int fieldAlignment = typeAlignmentRecompute(type->field[i]->type);
                if (fieldAlignment > alignment)
                    alignment = fieldAlignment;
            }
            return alignment;
        }
        case TYPE_FIBER:    return typeSizeRecompute(type);
        case TYPE_FN:       return sizeof(int64_t);
        default:            return 0;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5dd4b(%rip), %rax     # 0x77964
movl $0x1, %ebx
movl (%rdi), %ecx
addl $-0x2, %ecx
cmpl $0x18, %ecx
ja 0x19c88
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x0, 0x10(%rdi)
jle 0x19c8a
movq 0x8(%rdi), %rdi
jmp 0x19c1e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19ae9
movl $0x8, %ebx
jmp 0x19c8a
movslq 0x10(%rdi), %r14
testq %r14, %r14
jle 0x19c8a
movq 0x28(%rdi), %r15
movl $0x1, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rax
movq 0x108(%rax), %rdi
callq 0x19c0a
cmpl %ebx, %eax
cmovgl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x19c69
jmp 0x19c8a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeDeepCopy
void typeDeepCopy(Storage *storage, Type *dest, const Type *src)
{
    const Type *next = dest->next;
    *dest = *src;
    dest->next = next;

    if ((dest->kind == TYPE_STRUCT || dest->kind == TYPE_INTERFACE || dest->kind == TYPE_CLOSURE) && dest->numItems > 0)
    {
        dest->field = storageAdd(storage, dest->numItems * sizeof(Field *));
        for (int i = 0; i < dest->numItems; i++)
        {
            Field *field = storageAdd(storage, sizeof(Field));
            *field = *(src->field[i]);
            dest->field[i] = field;
        }
    }
    else if (typeEnum(dest) && dest->numItems > 0)
    {
        dest->enumConst = storageAdd(storage, dest->numItems * sizeof(EnumConst *));
        for (int i = 0; i < dest->numItems; i++)
        {
            EnumConst *enumConst = storageAdd(storage, sizeof(EnumConst));
            *enumConst = *(src->enumConst[i]);
            dest->enumConst[i] = enumConst;
        }
    }
    else if (dest->kind == TYPE_FN && dest->sig.numParams > 0)
    {
        for (int i = 0; i < dest->sig.numParams; i++)
        {
            Param *param = storageAdd(storage, sizeof(Param));
            *param = *(src->sig.param[i]);
            dest->sig.param[i] = param;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xc8(%rsi), %r12
movl $0xc8, %edx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x3260
movq %r12, 0xc8(%r14)
movl (%r14), %eax
leal -0x16(%rax), %ecx
cmpl $0x2, %ecx
ja 0x19d3c
movslq 0x10(%r14), %rsi
testq %rsi, %rsi
jle 0x19df7
shlq $0x3, %rsi
movq %r15, %rdi
callq 0x7a70
movq %rax, 0x28(%r14)
cmpl $0x0, 0x10(%r14)
jle 0x19df7
xorl %r13d, %r13d
movl $0x118, %esi            # imm = 0x118
movq %r15, %rdi
callq 0x7a70
movq %rax, %r12
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rsi
movl $0x118, %edx            # imm = 0x118
movq %r12, %rdi
callq 0x3260
movq 0x28(%r14), %rax
movq %r12, (%rax,%r13,8)
incq %r13
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jl 0x19cfe
jmp 0x19df7
leal -0x4(%rax), %ecx
cmpl $0x7, %ecx
ja 0x19db5
cmpb $0x1, 0x16(%r14)
jne 0x19df7
movslq 0x10(%r14), %rsi
testq %rsi, %rsi
jle 0x19df7
shlq $0x3, %rsi
movq %r15, %rdi
callq 0x7a70
movq %rax, 0x28(%r14)
cmpl $0x0, 0x10(%r14)
jle 0x19df7
xorl %r13d, %r13d
movl $0x110, %esi            # imm = 0x110
movq %r15, %rdi
callq 0x7a70
movq %rax, %r12
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rsi
movl $0x110, %edx            # imm = 0x110
movq %r12, %rdi
callq 0x3260
movq 0x28(%r14), %rax
movq %r12, (%rax,%r13,8)
incq %r13
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jl 0x19d7a
jmp 0x19df7
cmpl $0x1a, %eax
jne 0x19df7
cmpl $0x0, 0x28(%r14)
jle 0x19df7
xorl %r13d, %r13d
movl $0x118, %esi            # imm = 0x118
movq %r15, %rdi
callq 0x7a70
movq %rax, %r12
movq 0x38(%rbx,%r13,8), %rsi
movl $0x118, %edx            # imm = 0x118
movq %rax, %rdi
callq 0x3260
movq %r12, 0x38(%r14,%r13,8)
incq %r13
movslq 0x28(%r14), %rax
cmpq %rax, %r13
jl 0x19dc4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeSize
int typeSize(const Types *types, const Type *type)
{
    if (type->size < 0)
    {
        char buf[DEFAULT_STR_LEN + 1];
        types->error->handler(types->error->context, "Illegal type %s", typeSpelling(type, buf));
    }
    return type->size;
}

// Assembly:
movl 0xc0(%rsi), %eax
testl %eax, %eax
js 0x19e34
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %r12
movq 0x20(%rax), %r14
movq %rsp, %r15
movq %rsi, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x1adc2
leaq 0x5dc8a(%rip), %rsi     # 0x77af4
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq *%r12
movl 0xc0(%rbx), %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAlignment
int typeAlignment(const Types *types, const Type *type)
{
    if (type->alignment <= 0)
    {
        char buf[DEFAULT_STR_LEN + 1];
        types->error->handler(types->error->context, "Illegal type %s", typeSpelling(type, buf));
    }
    return type->alignment;
}

// Assembly:
movl 0xc4(%rsi), %eax
testl %eax, %eax
jle 0x19e9f
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %r12
movq 0x20(%rax), %r14
movq %rsp, %r15
movq %rsi, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x1adc2
leaq 0x5dc1f(%rip), %rsi     # 0x77af4
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq *%r12
movl 0xc4(%rbx), %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeHasPtr
bool typeHasPtr(const Type *type, bool alsoWeakPtr)
{
    if (type->kind == TYPE_PTR      || type->kind == TYPE_STR       || type->kind == TYPE_MAP     ||
        type->kind == TYPE_DYNARRAY || type->kind == TYPE_INTERFACE || type->kind == TYPE_CLOSURE || type->kind == TYPE_FIBER)
        return true;

    if (type->kind == TYPE_WEAKPTR && alsoWeakPtr)
        return true;

    if (type->kind == TYPE_ARRAY)
        return type->numItems > 0 && typeHasPtr(type->base, alsoWeakPtr);

    if (type->kind == TYPE_STRUCT)
        for (int i = 0; i < type->numItems; i++)
            if (typeHasPtr(type->field[i]->type, alsoWeakPtr))
                return true;

    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ecx
cmpl $0x12, %ecx
jne 0x19f10
cmpl $0x0, 0x10(%rdi)
jle 0x19f75
movq 0x8(%rdi), %rdi
jmp 0x19efd
xorl %eax, %eax
cmpl $0x19, %ecx
ja 0x19f23
movl $0x3b90000, %edx        # imm = 0x3B90000
btl %ecx, %edx
jae 0x19f2f
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x11, %ecx
je 0x19f79
cmpl $0x16, %ecx
jne 0x19f23
movslq 0x10(%rdi), %r14
testq %r14, %r14
jle 0x19f75
movq 0x28(%rdi), %r15
decq %r14
xorl %r12d, %r12d
movzbl %sil, %ebx
movq (%r15,%r12,8), %rax
movq 0x108(%rax), %rdi
movl %ebx, %esi
callq 0x19ef5
testb %al, %al
jne 0x19f23
leaq 0x1(%r12), %rcx
cmpq %r12, %r14
movq %rcx, %r12
jne 0x19f50
jmp 0x19f23
xorl %eax, %eax
jmp 0x19f23
movl %esi, %eax
jmp 0x19f23
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeCompatible
bool typeCompatible(const Type *left, const Type *right)
{
    if (typeEquivalent(left, right))
        return true;

    if (typeInteger(left) && typeInteger(right))
        return true;

    if (typeReal(left) && typeReal(right))
        return true;

    return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x19f81
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1a26f
movl (%r14), %ecx
leal -0x4(%rcx), %edx
cmpl $0x7, %edx
ja 0x1a25b
cmpb $0x0, 0x16(%r14)
jne 0x1a25b
movl (%rbx), %edx
addl $-0x4, %edx
cmpl $0x7, %edx
ja 0x1a25b
cmpb $0x1, 0x16(%rbx)
jne 0x1a26f
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0x1a26d
movl (%rbx), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
je 0x1a26f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeValidOperator
bool typeValidOperator(const Type *type, TokenKind op)
{
    switch (op)
    {
        case TOK_PLUS:      return typeInteger(type) || typeReal(type) || type->kind == TYPE_STR;
        case TOK_MINUS:
        case TOK_MUL:
        case TOK_DIV:
        case TOK_MOD:       return typeInteger(type) || typeReal(type);
        case TOK_AND:
        case TOK_OR:
        case TOK_XOR:
        case TOK_SHL:
        case TOK_SHR:       return typeInteger(type);
        case TOK_PLUSEQ:    return typeInteger(type) || typeReal(type) || type->kind == TYPE_STR;
        case TOK_MINUSEQ:
        case TOK_MULEQ:
        case TOK_DIVEQ:
        case TOK_MODEQ:     return typeInteger(type) || typeReal(type);
        case TOK_ANDEQ:
        case TOK_OREQ:
        case TOK_XOREQ:
        case TOK_SHLEQ:
        case TOK_SHREQ:     return typeInteger(type);
        case TOK_ANDAND:
        case TOK_OROR:      return type->kind == TYPE_BOOL;
        case TOK_PLUSPLUS:
        case TOK_MINUSMINUS:return typeInteger(type);
        case TOK_EQEQ:
        case TOK_LESS:
        case TOK_GREATER:   return typeComparable(type);
        case TOK_EQ:        return true;
        case TOK_NOT:       return type->kind == TYPE_BOOL;
        case TOK_NOTEQ:
        case TOK_LESSEQ:
        case TOK_GREATEREQ: return typeComparable(type);
        default:            return false;
    }
}

// Assembly:
addl $-0x16, %esi
cmpl $0x20, %esi
ja 0x1a425
movb $0x1, %al
leaq 0x5d5e8(%rip), %rcx     # 0x779dc
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x7, %eax
ja 0x1a425
movb 0x16(%rdi), %al
xorb $0x1, %al
retq
movl (%rdi), %ecx
leal -0x4(%rcx), %edx
cmpl $0x7, %edx
ja 0x1a41d
cmpb $0x1, 0x16(%rdi)
jne 0x1a40c
andl $-0x2, %ecx
cmpl $0xe, %ecx
jmp 0x1a44e
xorl %eax, %eax
retq
jmp 0x1a452
cmpl $0xc, (%rdi)
jmp 0x1a44e
movl (%rdi), %ecx
leal -0x4(%rcx), %edx
cmpl $0x7, %edx
ja 0x1a441
cmpb $0x0, 0x16(%rdi)
jne 0x1a44b
jmp 0x1a40c
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0xe, %edx
je 0x1a40c
cmpl $0x14, %ecx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeComparable
static bool typeComparable(const Type *type)
{
    if (typeOrdinal(type) || typeReal(type) || type->kind == TYPE_PTR || type->kind == TYPE_WEAKPTR || type->kind == TYPE_STR)
        return true;

    if (type->kind == TYPE_ARRAY)
        return typeComparable(type->base);

    if (type->kind == TYPE_STRUCT)
    {
        for (int i = 0; i < type->numItems; i++)
            if (!typeComparable(type->field[i]->type))
                return false;
        return true;
    }

    return false;
}

// Assembly:
movl (%rdi), %ecx
leal -0x4(%rcx), %eax
cmpl $0xa, %eax
setb %al
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0xe, %edx
sete %dl
orb %al, %dl
movb $0x1, %al
jne 0x1a4dc
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x12, %ecx
jne 0x1a492
movq 0x8(%rdi), %rdi
movl (%rdi), %ecx
leal -0x4(%rcx), %edx
cmpl $0xa, %edx
jb 0x1a4d7
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0xe, %edx
jne 0x1a473
jmp 0x1a4d7
leal -0x10(%rcx), %edx
cmpl $0x2, %edx
jb 0x1a4d7
cmpl $0x14, %ecx
je 0x1a4d7
cmpl $0x16, %ecx
jne 0x1a4d5
movslq 0x10(%rdi), %rbx
testq %rbx, %rbx
jle 0x1a4d7
movq 0x28(%rdi), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rax
movq 0x108(%rax), %rdi
callq 0x1a452
testb %al, %al
je 0x1a4d5
incq %r15
cmpq %r15, %rbx
jne 0x1a4b4
setbe %al
jmp 0x1a4d7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeEnableForward
void typeEnableForward(Types *types, bool enable)
{
    types->forwardTypesEnabled = enable;

    if (!enable)
        for (const Type *type = types->first; type; type = type->next)
            if (type->kind == TYPE_FORWARD)
                types->error->handler(types->error->context, "Unresolved forward declaration of %s", (Ident *)(type->typeIdent)->name);
}

// Assembly:
movb %sil, 0x8(%rdi)
testl %esi, %esi
jne 0x1a5a0
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1a59b
leaq 0x5d61a(%rip), %r14     # 0x77b8c
cmpl $0x1, (%r15)
jne 0x1a58f
movq 0x18(%rbx), %rcx
movq 0x20(%rcx), %rdi
movq 0x18(%r15), %rdx
addq $0x4, %rdx
movq %r14, %rsi
xorl %eax, %eax
callq *(%rcx)
movq 0xc8(%r15), %r15
testq %r15, %r15
jne 0x1a572
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeFindField
const Field *typeFindField(const Type *structType, const char *name, int *index)
{
    if (structType->kind == TYPE_STRUCT || structType->kind == TYPE_INTERFACE || structType->kind == TYPE_CLOSURE)
    {
        unsigned int nameHash = hash(name);
        for (int i = 0; i < structType->numItems; i++)
            if (structType->field[i]->hash == nameHash && strcmp(structType->field[i]->name, name) == 0)
            {
                if (index)
                    *index = i;
                return structType->field[i];
            }
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
addl $-0x16, %eax
cmpl $0x2, %eax
ja 0x1a626
movq %rsi, %r15
movb (%rsi), %al
testb %al, %al
je 0x1a5e2
leaq 0x1(%r15), %rcx
movl $0x1505, %ebp           # imm = 0x1505
movl %ebp, %esi
shll $0x5, %esi
addl %ebp, %esi
movsbl %al, %ebp
addl %esi, %ebp
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x1a5cb
jmp 0x1a5e7
movl $0x1505, %ebp           # imm = 0x1505
movslq 0x10(%rdi), %rbx
testq %rbx, %rbx
jle 0x1a626
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x28(%rdi), %r14
xorl %r13d, %r13d
movq (%r14,%r13,8), %r12
cmpl %ebp, 0x100(%r12)
jne 0x1a61e
movq %r12, %rdi
movq %r15, %rsi
callq 0x3210
testl %eax, %eax
je 0x1a63b
incq %r13
cmpq %r13, %rbx
jne 0x1a601
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1a629
movl %r13d, (%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax,%r13,8), %r12
jmp 0x1a629
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAssertFindField
const Field *typeAssertFindField(const Types *types, const Type *structType, const char *name, int *index)
{
    const Field *res = typeFindField(structType, name, index);
    if (!res)
        types->error->handler(types->error->context, "Unknown field %s", name);
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1a5a1
movq %rax, %r14
testq %rax, %rax
jne 0x1a68e
movq 0x18(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5d52a(%rip), %rsi     # 0x77bb1
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeFindEnumConst
const EnumConst *typeFindEnumConst(const Type *enumType, const char *name)
{
    if (typeEnum(enumType))
    {
        unsigned int nameHash = hash(name);
        for (int i = 0; i < enumType->numItems; i++)
            if (enumType->enumConst[i]->hash == nameHash && strcmp(enumType->enumConst[i]->name, name) == 0)
                return enumType->enumConst[i];
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x7, %eax
ja 0x1a92a
cmpb $0x1, 0x16(%rdi)
jne 0x1a92a
movq %rsi, %rbx
movb (%rsi), %al
testb %al, %al
je 0x1a8f1
leaq 0x1(%rbx), %rcx
movl $0x1505, %ebp           # imm = 0x1505
movl %ebp, %edx
shll $0x5, %edx
addl %ebp, %edx
movsbl %al, %ebp
addl %edx, %ebp
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x1a8da
jmp 0x1a8f6
movl $0x1505, %ebp           # imm = 0x1505
movslq 0x10(%rdi), %r15
testq %r15, %r15
jle 0x1a92a
movq 0x28(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %r14
cmpl %ebp, 0x100(%r14)
jne 0x1a922
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3210
testl %eax, %eax
je 0x1a92d
incq %r13
cmpq %r13, %r15
jne 0x1a906
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAssertFindEnumConst
const EnumConst *typeAssertFindEnumConst(const Types *types, const Type *enumType, const char *name)
{
    const EnumConst *res = typeFindEnumConst(enumType, name);
    if (!res)
        types->error->handler(types->error->context, "Unknown enumeration constant %s", name);
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1a8ad
movq %rax, %r14
testq %rax, %rax
jne 0x1a973
movq 0x18(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5d2c2(%rip), %rsi     # 0x77c2e
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAddEnumConst
const EnumConst *typeAddEnumConst(const Types *types, Type *enumType, const char *name, Const val)
{
    if (typeFindEnumConst(enumType, name))
        types->error->handler(types->error->context, "Duplicate enumeration constant %s", name);

    if (typeFindEnumConstByVal(enumType, val))
        types->error->handler(types->error->context, "Duplicate enumeration constant value %lld", val.intVal);

    EnumConst *enumConst = storageAdd(types->storage, sizeof(EnumConst));

    strncpy(enumConst->name, name, MAX_IDENT_LEN);
    enumConst->name[MAX_IDENT_LEN] = 0;

    enumConst->hash = hash(name);
    enumConst->val = val;

    if (enumType->numItems > 0)
        enumType->enumConst = storageRealloc(types->storage, enumType->enumConst, (enumType->numItems + 1) * sizeof(EnumConst *));
    else
        enumType->enumConst = storageAdd(types->storage, sizeof(EnumConst *));

    enumType->numItems++;
    enumType->enumConst[enumType->numItems - 1] = enumConst;

    return enumConst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1a8ad
testq %rax, %rax
je 0x1a9ee
movq 0x18(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5d267(%rip), %rsi     # 0x77c4e
movq %r12, %rdx
xorl %eax, %eax
callq *(%rcx)
movl (%rbx), %eax
addl $-0x4, %eax
cmpl $0x7, %eax
ja 0x1aa3a
cmpb $0x1, 0x16(%rbx)
jne 0x1aa3a
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x1aa3a
movq 0x28(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
cmpq %r15, 0x108(%rsi)
je 0x1aa24
incq %rdx
cmpq %rdx, %rax
jne 0x1aa0d
jmp 0x1aa3a
movq 0x18(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5d23d(%rip), %rsi     # 0x77c70
movq %r15, %rdx
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r14), %rdi
movl $0x110, %esi            # imm = 0x110
callq 0x7a70
movq %rax, %r13
movl $0xff, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3080
movb $0x0, 0xff(%r13)
movb (%r12), %cl
testb %cl, %cl
je 0x1aa8c
incq %r12
movl $0x1505, %eax           # imm = 0x1505
movl %eax, %edx
shll $0x5, %edx
addl %eax, %edx
movsbl %cl, %eax
addl %edx, %eax
movb (%r12), %cl
incq %r12
testb %cl, %cl
jne 0x1aa73
jmp 0x1aa91
movl $0x1505, %eax           # imm = 0x1505
movl %eax, 0x100(%r13)
movq %r15, 0x108(%r13)
movl 0x10(%rbx), %eax
movq 0x10(%r14), %rdi
testl %eax, %eax
jle 0x1aabd
movq 0x28(%rbx), %rsi
leaq 0x8(,%rax,8), %rdx
callq 0x7be8
jmp 0x1aac7
movl $0x8, %esi
callq 0x7a70
movq %rax, 0x28(%rbx)
movslq 0x10(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movq %r13, (%rax,%rcx,8)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq