LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1c026
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
leaq 0x5b4c9(%rip), %r15     # 0x77407
cmpl $0x1, (%r13)
jne 0x1c016
movq 0x108(%r13), %rdi
xorl %esi, %esi
callq 0x1eeaf
testb %al, %al
je 0x1c016
movl 0x114(%r13), %eax
cmpl (%r12), %eax
jne 0x1c016
cmpb $0x1, 0x11b(%r13)
jne 0x1bf88
cmpb $0x1, 0x11a(%r13)
jne 0x1c016
leaq 0x4(%r13), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3210
testl %eax, %eax
je 0x1c016
movq %rbp, %rdi
leaq 0x5743b(%rip), %rsi     # 0x733e0
callq 0x3210
testl %eax, %eax
jne 0x1bfd4
cmpq $0x0, 0x8(%r12)
jne 0x1bfcc
movq 0x5118(%rbx), %rdi
leaq 0x5c71d(%rip), %rsi     # 0x786e1
xorl %eax, %eax
callq *0x50f8(%rbx)
cmpb $0x1, 0x15(%r12)
jne 0x1c016
cmpl $0x0, 0x114(%r13)
je 0x1bffb
movl 0x120(%r13), %edx
movq 0x108(%r13), %rcx
movq %r14, %rdi
movl $0x2d, %esi
callq 0x1858c
jmp 0x1c016
movq 0x108(%r13), %rcx
movq 0x120(%r13), %rdx
movq %r14, %rdi
movl $0x2d, %esi
callq 0x18538
movq 0x140(%r13), %r13
testq %r13, %r13
jne 0x1bf3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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 0x1c07a
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4220(%rdi), %r12
movl %r15d, %eax
leaq (%rax,%rax,2), %rax
cmpl %ebx, (%r12,%rax,8)
je 0x1c07a
movq %r14, %rdi
movl %r15d, %esi
callq 0x1bf00
leal -0x1(%r15), %eax
cmpl $0x1, %r15d
movl %eax, %r15d
jg 0x1c055
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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 0x1c0ce
movq %rdi, %rbx
movq %r15, %rsi
callq 0x11b32
addq $0x4e70, %rbx           # imm = 0x4E70
movq 0x108(%r15), %rsi
movq %r14, %rdi
callq 0x1ede7
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x18289
movq 0x108(%r15), %rsi
movq 0x120(%r15), %rbx
movq %r14, %rdi
callq 0x1ede7
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xeeb8
// File: /workspace/github_c_makefile_star2_O1/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 0x1b41f
leaq 0x4220(%r14), %r15
movq %r15, %rdi
callq 0xd774
movq %r14, %rdi
callq 0x1d01e
movl 0x4b84(%r14), %esi
movq %r14, %rdi
callq 0x1bf00
addq $0x4e38, %r14           # imm = 0x4E38
movq %r15, %rdi
callq 0xd824
movq %r14, %rdi
movl %eax, %esi
callq 0x1a60e
movq %r15, %rdi
callq 0xd824
movq %r14, %rdi
movl %eax, %esi
callq 0x19a46
movq %r15, %rdi
callq 0xd7f2
movq %rbx, %rdi
movl $0x3d, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1b41f
// File: /workspace/github_c_makefile_star2_O1/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 0x1b41f
leaq 0x4220(%rbx), %r14
movq %r14, %rdi
callq 0xd774
movq %rbx, %rdi
callq 0x1e962
testb %al, %al
je 0x1e898
movq %rbx, %rdi
callq 0x105cb
movq %r15, %rdi
movl $0x40, %esi
callq 0x1b41f
movq 0x5268(%rbx), %rax
movq %rsp, %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1617b
leaq 0x4e18(%rbx), %rdi
movq 0x5268(%rbx), %rsi
movq (%r12), %rdx
callq 0x1f2a6
leaq 0x4e70(%rbx), %r12
movq %r12, %rdi
callq 0x18fd3
movq %rbx, %rdi
callq 0x1e54e
cmpl $0x6, 0x4bd0(%rbx)
jne 0x1e90d
movq %r12, %rdi
callq 0x19045
movq %r15, %rdi
callq 0x1a984
cmpl $0xc, 0x4bd0(%rbx)
jne 0x1e917
movq %rbx, %rdi
callq 0x1e849
jmp 0x1e91f
movq %r12, %rdi
callq 0x19014
jmp 0x1e927
movq %rbx, %rdi
callq 0x1e54e
movq %r12, %rdi
callq 0x190b9
movl 0x4b84(%rbx), %esi
movq %rbx, %rdi
callq 0x1bf00
addq $0x4e38, %rbx           # imm = 0x4E38
movq %r14, %rdi
callq 0xd824
movq %rbx, %rdi
movl %eax, %esi
callq 0x1a60e
movq %r14, %rdi
callq 0xd7f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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 0x1e9aa
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1a984
movl 0x28(%rsp), %eax
cmpl $0x3f, %eax
jne 0x1e9ae
movq %rbx, %rdi
callq 0x1a984
cmpl $0x45, 0x28(%rsp)
je 0x1e98a
xorl %eax, %eax
jmp 0x1e9b4
cmpl $0x37, %eax
sete %al
addq $0x270, %rsp            # imm = 0x270
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b41f
movq %r14, %rdi
movl $0x41, %esi
callq 0x1b41f
leaq 0x4220(%rbx), %r14
movq %r14, %rdi
callq 0xd774
movq %rbx, %rdi
callq 0x1d01e
movl 0x4b84(%rbx), %esi
movq %rbx, %rdi
callq 0x1bf00
addq $0x4e38, %rbx           # imm = 0x4E38
movq %r14, %rdi
callq 0xd824
movq %rbx, %rdi
movl %eax, %esi
callq 0x1a60e
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7f2
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xcca8
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 0x1eac1
movl %eax, 0xc0(%r12)
movq %r12, %rdi
callq 0x1ebe1
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_O1/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 0x59d4c(%rip), %rax     # 0x7893c
movl $0x1, %ebx
movl (%rdi), %ecx
addl $-0x2, %ecx
cmpl $0x18, %ecx
ja 0x1ec5f
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x0, 0x10(%rdi)
jle 0x1ec61
movq 0x8(%rdi), %rdi
jmp 0x1ebf5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1eac1
movl $0x8, %ebx
jmp 0x1ec61
movslq 0x10(%rdi), %r14
testq %r14, %r14
jle 0x1ec61
movq 0x28(%rdi), %r15
movl $0x1, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rax
movq 0x108(%rax), %rdi
callq 0x1ebe1
cmpl %ebx, %eax
cmovgl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x1ec40
jmp 0x1ec61
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
cmpl $0x0, 0xc0(%rsi)
jns 0x1ee31
movq 0x18(%rdi), %rax
movq (%rax), %r12
movq 0x20(%rax), %r14
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x1fe54
leaq 0x59cce(%rip), %rsi     # 0x78af4
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_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
cmpl $0x0, 0xc4(%rsi)
jg 0x1ee9a
movq 0x18(%rdi), %rax
movq (%rax), %r12
movq 0x20(%rax), %r14
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x1fe54
leaq 0x59c65(%rip), %rsi     # 0x78af4
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x59adf(%rip), %rax     # 0x789a0
movl (%rdi), %ecx
leal -0x10(%rcx), %edx
cmpl $0x9, %edx
ja 0x1ef51
movb $0x1, %bl
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
testb %sil, %sil
jne 0x1ef53
cmpl $0x12, %ecx
jne 0x1eef0
cmpl $0x0, 0x10(%rdi)
jle 0x1ef51
movq 0x8(%rdi), %rdi
jmp 0x1eec1
cmpl $0x16, %ecx
jne 0x1ef51
movslq 0x10(%rdi), %r14
testq %r14, %r14
setg %r12b
jle 0x1ef51
movq 0x28(%rdi), %r15
movq (%r15), %rax
movq 0x108(%rax), %rdi
movzbl %sil, %ebp
movl %ebp, %esi
callq 0x1eeaf
testb %al, %al
jne 0x1ef4c
leaq -0x1(%r14), %r13
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x1ef51
movq 0x8(%r15,%r12,8), %rax
movq 0x108(%rax), %rdi
movl %ebp, %esi
callq 0x1eeaf
incq %r12
testb %al, %al
je 0x1ef26
cmpq %r14, %r12
setb %r12b
testb %r12b, %r12b
jne 0x1ef53
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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 0x1ef68
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1f29e
movl (%r14), %ecx
leal -0x4(%rcx), %edx
cmpl $0x7, %edx
ja 0x1f28a
cmpb $0x0, 0x16(%r14)
jne 0x1f28a
movl (%rbx), %edx
addl $-0x4, %edx
cmpl $0x7, %edx
ja 0x1f28a
cmpb $0x1, 0x16(%rbx)
jne 0x1f29e
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0x1f29c
movl (%rbx), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
je 0x1f29e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f454
movb $0x1, %al
leaq 0x595b9(%rip), %rcx     # 0x789dc
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x7, %eax
ja 0x1f454
movb 0x16(%rdi), %al
xorb $0x1, %al
retq
movl (%rdi), %ecx
leal -0x4(%rcx), %edx
cmpl $0x7, %edx
ja 0x1f44c
cmpb $0x1, 0x16(%rdi)
jne 0x1f43b
andl $-0x2, %ecx
cmpl $0xe, %ecx
jmp 0x1f486
xorl %eax, %eax
retq
jmp 0x1f48a
cmpl $0xc, (%rdi)
jmp 0x1f486
movl (%rdi), %ecx
leal -0x4(%rcx), %edx
cmpl $0x7, %edx
ja 0x1f479
movl %ecx, %edx
notl %edx
testb $0xe, %dl
je 0x1f43b
cmpb $0x0, 0x16(%rdi)
jne 0x1f483
jmp 0x1f43b
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0xe, %edx
je 0x1f43b
cmpl $0x14, %ecx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
leal -0x4(%rax), %ecx
movb $0x1, %bl
cmpl $0xa, %ecx
jb 0x1f514
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
je 0x1f514
cmpl $0x12, %eax
jne 0x1f4b0
movq 0x8(%rdi), %rdi
jmp 0x1f48f
leal -0x10(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1f514
cmpl $0x14, %eax
je 0x1f514
cmpl $0x16, %eax
jne 0x1f512
movslq 0x10(%rdi), %r14
testq %r14, %r14
setle %bl
jle 0x1f514
movq 0x28(%rdi), %r15
movq (%r15), %rax
movq 0x108(%rax), %rdi
callq 0x1f48a
testb %al, %al
je 0x1f514
movl $0x1, %ecx
movq %rcx, %rbx
cmpq %rcx, %r14
je 0x1f50a
movq (%r15,%rbx,8), %rax
movq 0x108(%rax), %rdi
callq 0x1f48a
leaq 0x1(%rbx), %rcx
testb %al, %al
jne 0x1f4ea
cmpq %r14, %rbx
setae %bl
jmp 0x1f514
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f5df
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1f5da
leaq 0x595db(%rip), %r14     # 0x78b8c
cmpl $0x1, (%r15)
jne 0x1f5ce
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 0x1f5b1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rdi), %eax
addl $-0x16, %eax
cmpl $0x2, %eax
ja 0x1f69f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movb (%rsi), %al
testb %al, %al
je 0x1f625
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 0x1f60e
jmp 0x1f62a
movl $0x1505, %ebp           # imm = 0x1505
movslq 0x10(%rdi), %r14
testq %r14, %r14
setg %r12b
jle 0x1f66e
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x28(%rdi), %rbx
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
cmpl %ebp, 0x100(%rdi)
jne 0x1f660
movq %r15, %rsi
callq 0x3210
testl %eax, %eax
je 0x1f670
incq %r13
cmpq %r14, %r13
setb %r12b
jne 0x1f648
jmp 0x1f68a
jmp 0x1f68a
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1f67d
movl %r13d, (%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax,%r13,8), %rax
testb $0x1, %r12b
leaq 0x18(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jne 0x1f6a1
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f5e0
movq %rax, %r14
testq %rax, %rax
jne 0x1f6d9
movq 0x18(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x594df(%rip), %rsi     # 0x78bb1
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x7, %eax
ja 0x1f9b8
cmpb $0x1, 0x16(%rdi)
jne 0x1f9b8
movq %rsi, %rbx
movb (%rsi), %al
testb %al, %al
je 0x1f946
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 0x1f92f
jmp 0x1f94b
movl $0x1505, %ebp           # imm = 0x1505
movslq 0x10(%rdi), %r12
testq %r12, %r12
setg %r15b
jle 0x1f9b2
movq 0x28(%rdi), %rdx
movq %r12, %rdi
negq %rdi
movl $0x1, %r13d
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq -0x8(%rdx,%r13,8), %r14
cmpl %ebp, 0x100(%r14)
jne 0x1f999
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3210
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
testl %eax, %eax
je 0x1f9b2
cmpq %r12, %r13
setb %r15b
leaq (%rdi,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x1f972
jmp 0x1f9b2
testb $0x1, %r15b
jne 0x1f9bb
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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 0x1f8f7
movq %rax, %r14
testq %rax, %rax
jne 0x1fa01
movq 0x18(%r15), %rcx
movq 0x20(%rcx), %rdi
leaq 0x59234(%rip), %rsi     # 0x78c2e
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f8f7
testq %rax, %rax
je 0x1faa2
movq 0x18(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x591b3(%rip), %rsi     # 0x78c4e
movq %r12, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fa0a
testq %rax, %rax
je 0x1fac8
movq 0x18(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x591af(%rip), %rsi     # 0x78c70
movq %r15, %rdx
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r14), %rdi
movl $0x110, %esi            # imm = 0x110
callq 0xcca8
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 0x1fb1a
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 0x1fb01
jmp 0x1fb1f
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 0x1fb4b
movq 0x28(%rbx), %rsi
leaq 0x8(,%rax,8), %rdx
callq 0xce23
jmp 0x1fb55
movl $0x8, %esi
callq 0xcca8
movq %rax, 0x28(%rbx)
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movq 0x28(%rbx), %rcx
movq %r13, (%rcx,%rax,8)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeFindParam
const Param *typeFindParam(const Signature *sig, const char *name)
{
    const unsigned int nameHash = hash(name);
    for (int i = 0; i < sig->numParams; i++)
        if (sig->param[i]->hash == nameHash && strcmp(sig->param[i]->name, name) == 0)
            return sig->param[i];

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %al
testb %al, %al
je 0x1fbaf
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 0x1fb98
jmp 0x1fbb4
movl $0x1505, %ebp           # imm = 0x1505
movslq (%r14), %r12
testq %r12, %r12
jle 0x1fbe4
xorl %r13d, %r13d
movq 0x10(%r14,%r13,8), %r15
cmpl %ebp, 0x100(%r15)
jne 0x1fbdc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3210
testl %eax, %eax
je 0x1fbe7
incq %r13
cmpq %r13, %r12
jne 0x1fbbf
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeAddParam
const Param *typeAddParam(const Types *types, Signature *sig, const Type *type, const char *name, Const defaultVal)
{
    if (typeFindParam(sig, name))
        types->error->handler(types->error->context, "Duplicate parameter %s", name);

    if (sig->numParams > MAX_PARAMS)
        types->error->handler(types->error->context, "Too many parameters");

    Param *param = storageAdd(types->storage, sizeof(Param));

    strncpy(param->name, name, MAX_IDENT_LEN);
    param->name[MAX_IDENT_LEN] = 0;

    param->hash = hash(name);
    param->type = type;
    param->defaultVal = defaultVal;

    sig->param[sig->numParams++] = param;
    return param;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x1fb78
testq %rax, %rax
je 0x1fc37
movq 0x18(%r13), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5906a(%rip), %rsi     # 0x78c9a
movq %r12, %rdx
xorl %eax, %eax
callq *(%rcx)
cmpl $0x11, (%rbx)
jl 0x1fc4f
movq 0x18(%r13), %rcx
movq 0x20(%rcx), %rdi
leaq 0x59066(%rip), %rsi     # 0x78cb1
xorl %eax, %eax
callq *(%rcx)
movq 0x10(%r13), %rdi
movl $0x118, %esi            # imm = 0x118
callq 0xcca8
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 0x1fca1
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 0x1fc88
jmp 0x1fca6
movl $0x1505, %eax           # imm = 0x1505
movl %eax, 0x100(%r13)
movq %r15, 0x108(%r13)
movq %r14, 0x110(%r13)
movslq (%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
movq %r13, 0x10(%rbx,%rax,8)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeParamSizeUpTo
int typeParamSizeUpTo(const Types *types, const Signature *sig, int index)
{
    // All parameters are slot-aligned
    int size = 0;
    for (int i = 0; i <= index; i++)
        size += align(typeSize(types, sig->param[i]->type), sizeof(Slot));
    return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
js 0x1fd22
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
incl %ebx
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x10(%r14,%r12,8), %rax
movq 0x108(%rax), %rsi
movq %r15, %rdi
callq 0x1ede7
cltq
addq $0x7, %rax
leal 0x7(%rax), %ecx
testq %rax, %rax
cmovnsl %eax, %ecx
andl $-0x8, %ecx
addl %ecx, %ebp
incq %r12
cmpq %r12, %rbx
jne 0x1fcf0
jmp 0x1fd24
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeMakeParamLayout
const ParamLayout *typeMakeParamLayout(const Types *types, const Signature *sig)
{
    ParamLayout *layout = storageAdd(types->storage, sizeof(ParamLayout) + sig->numParams * sizeof(int64_t));

    layout->numParams = sig->numParams;
    layout->numResultParams = typeStructured(sig->resultType) ? 1 : 0;
    layout->numParamSlots = typeParamSizeTotal(types, sig) / sizeof(Slot);

    for (int i = 0; i < sig->numParams; i++)
        layout->firstSlotIndex[i] = typeParamOffset(types, sig, i) / sizeof(Slot) - 2;   // - 2 slots for old base pointer and return address

    return layout;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movslq (%rsi), %rax
leaq 0x18(,%rax,8), %rsi
callq 0xcca8
movq %rax, %r15
movslq (%rbx), %rax
movq %rax, (%r15)
movq 0x90(%rbx), %rcx
movl (%rcx), %ecx
addl $-0x12, %ecx
cmpl $0x6, %ecx
ja 0x1fdad
movl %ecx, %ecx
leaq 0x58cf9(%rip), %rdx     # 0x78aa0
movq (%rdx,%rcx,8), %rcx
jmp 0x1fdaf
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
leal -0x1(%rax), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fcd5
cltq
shrq $0x3, %rax
movq %rax, 0x10(%r15)
cmpl $0x0, (%rbx)
jle 0x1fe11
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1fcd5
movl %eax, %ebp
movl (%rbx), %edx
decl %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fcd5
subl %ebp, %eax
addl $0x10, %eax
cltq
shrq $0x3, %rax
addq $-0x2, %rax
movq %rax, 0x18(%r15,%r12,8)
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x1fdd3
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeMakeParamAndLocalVarLayout
const ParamAndLocalVarLayout *typeMakeParamAndLocalVarLayout(const Types *types, const ParamLayout *paramLayout, int localVarSlots)
{
    ParamAndLocalVarLayout *layout = storageAdd(types->storage, sizeof(ParamAndLocalVarLayout));
    layout->paramLayout = paramLayout;
    layout->localVarSlots = localVarSlots;
    return layout;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq 0x10(%rdi), %rdi
movl $0x10, %esi
callq 0xcca8
movq %r14, (%rax)
movslq %ebx, %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeDefaultParamEqual
static bool typeDefaultParamEqual(const Const *left, const Const *right, const Type *type)
{
    if (typeOrdinal(type) || type->kind == TYPE_FN)
        return left->intVal == right->intVal;

    if (typeReal(type))
        return left->realVal == right->realVal;

    if (type->kind == TYPE_WEAKPTR)
        return left->weakPtrVal == right->weakPtrVal;

    if (!left->ptrVal || !right->ptrVal)
        return left->ptrVal == right->ptrVal;

    if (type->kind == TYPE_PTR)
        return left->ptrVal == right->ptrVal;

    if (type->kind == TYPE_STR)
        return strcmp((char *)left->ptrVal, (char *)right->ptrVal) == 0;

    if (type->kind == TYPE_ARRAY || type->kind == TYPE_STRUCT || type->kind == TYPE_CLOSURE)
        return memcmp(left->ptrVal, right->ptrVal, type->size) == 0;

    return false;
}

// Assembly:
pushq %rax
movl (%rdx), %r8d
leal -0x4(%r8), %eax
cmpl $0xa, %eax
setae %al
cmpl $0x1a, %r8d
setne %cl
testb %al, %cl
jne 0x2034a
movq (%rdi), %rax
cmpq (%rsi), %rax
sete %al
jmp 0x20366
movl %r8d, %eax
andl $-0x2, %eax
cmpl $0xe, %eax
jne 0x20368
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
popq %rcx
retq
cmpl $0x11, %r8d
je 0x2033f
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x203ac
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x203ac
xorl %eax, %eax
addl $-0x10, %r8d
cmpl $0x8, %r8d
ja 0x20366
leaq 0x586e7(%rip), %rsi     # 0x78a78
movslq (%rsi,%r8,4), %r8
addq %rsi, %r8
jmpq *%r8
movslq 0xc0(%rdx), %rdx
movq %rcx, %rsi
callq 0x32c0
jmp 0x203b9
cmpq (%rsi), %rdi
jmp 0x20345
movq %rcx, %rsi
callq 0x3210
testl %eax, %eax
jmp 0x20345
cmpq %rcx, %rdi
jmp 0x20345
nop
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: qsortEx
void qsortEx(char *first, char *last, int itemSize, QSortCompareFn compare, void *context, void *temp)
{
    if (first >= last)
        return;

    char *partition = qsortPartition(first, last, itemSize, compare, context, temp);

    qsortEx(first, partition - itemSize, itemSize, compare, context, temp);
    qsortEx(partition + itemSize, last, itemSize, compare, context, temp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movslq %edx, %rax
movq %rax, 0x8(%rsp)
negq %rax
movq %rax, 0x10(%rsp)
cmpq %r12, %rbx
jae 0x204cc
movq %rbx, %rbp
movq %r12, %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%r15
cmpq %r13, %rbp
jae 0x20422
testl %eax, %eax
jg 0x20422
addq 0x8(%rsp), %rbp
jmp 0x20401
addq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%r15
cmpq %rbx, %r12
jbe 0x20437
testl %eax, %eax
jg 0x2041d
cmpq %r12, %rbp
jae 0x2046e
movq (%rsp), %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x3260
movq %rbp, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x3260
movq %r12, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3260
cmpq %r12, %rbp
jb 0x20401
movq (%rsp), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rbp
movq %rbp, %rdx
callq 0x3260
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x3260
movq %r12, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x3260
movq %r12, %rsi
subq %rbp, %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
movq (%rsp), %r9
callq 0x203c4
addq %rbp, %r12
movq %r12, %rbx
movq %r13, %r12
jmp 0x203f2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: vmReset
void vmReset(VM *vm, const Instruction *code, const DebugInfo *debugPerInstr)
{
    vm->fiber = vm->pages.fiber = vm->mainFiber;
    vm->fiber->code = code;
    vm->fiber->debugPerInstr = debugPerInstr;
    vm->fiber->ip = 0;
    vm->fiber->top = vm->fiber->base = vm->fiber->stack + vm->fiber->stackSize - 1;
}

// Assembly:
movq 0x8(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, (%rdi)
movq %rsi, (%rax)
movq %rdx, 0x60(%rax)
movl $0x0, 0x8(%rax)
movq 0x10(%rax), %rcx
movslq 0x28(%rax), %rdx
leaq (%rcx,%rdx,8), %rcx
addq $-0x8, %rcx
movq %rcx, 0x20(%rax)
movq %rcx, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: vmGetMapNodeData
void *vmGetMapNodeData(VM *vm, Map *map, Slot key)
{
    if (!map || !map->root)
        return NULL;

    const MapNode *node = *doGetMapNode(map, key, false, NULL, vm->error);
    return node ? node->data : NULL;
}

// Assembly:
testq %rsi, %rsi
je 0x4739d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x473b6
movq %rdx, %rbx
leaq 0x8(%r14), %rbp
movq 0x80(%rdi), %r15
leaq 0x32f73(%rip), %r12     # 0x7a21c
movq (%rbp), %rax
testq %rax, %rax
je 0x473a0
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x472f2
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq 0x108(%rax), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
addl $-0x4, %eax
cmpl $0x16, %eax
ja 0x47331
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq (%r13), %r13
jmp 0x47347
movl $0x1, %eax
jmp 0x4736f
movzbl (%r13), %r13d
jmp 0x47347
movslq (%r13), %r13
jmp 0x47347
movzwl (%r13), %r13d
jmp 0x47347
movl (%r13), %r13d
jmp 0x47347
movsbq (%r13), %r13
jmp 0x47347
movswq (%r13), %r13
jmp 0x47347
xorps %xmm0, %xmm0
cvtss2sd (%r13), %xmm0
movq %xmm0, %r13
jmp 0x47347
movq 0x20(%r15), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2fccf(%rip), %rdx     # 0x77010
xorl %eax, %eax
callq *0x8(%r15)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq 0x108(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x48d31
movl $0x20, %ecx
testq %rax, %rax
jle 0x47384
addq (%rbp), %rcx
movb $0x1, %al
movq %rcx, %rbp
jmp 0x4738c
js 0x47396
xorl %eax, %eax
movq %rbp, (%rsp)
testb %al, %al
jne 0x472a9
jmp 0x473a4
movl $0x18, %ecx
jmp 0x47379
xorl %eax, %eax
retq
movq %rbp, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x473b6
movq 0x10(%rax), %rax
jmp 0x473b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: vmMakeStr
char *vmMakeStr(VM *vm, const char *str)
{
    if (!str)
        return NULL;

    char *buf = doAllocStr(&vm->pages, strlen(str), vm->error);
    strcpy(buf, str);
    return buf;
}

// Assembly:
testq %rsi, %rsi
je 0x47491
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq %rsi, 0x20(%rsp)
movq %rsi, %rdi
callq 0x3130
leaq 0x2(,%rax,2), %rcx
movl $0x7ffffbff, %ebp       # imm = 0x7FFFFBFF
cmpq %rbp, %rcx
cmovlq %rcx, %rbp
cmpq %rax, %rbp
movq %rax, 0x18(%rsp)
cmovleq %rax, %rbp
leaq 0x18(%rbp), %rax
leaq 0x1f(%rbp), %rbx
testq %rax, %rax
cmovnsq %rax, %rbx
andq $-0x8, %rbx
leaq 0x67(%rbx), %rax
addq $0xa6, %rbx
testq %rax, %rax
cmovnsq %rax, %rbx
andq $-0x40, %rbx
movq %rbp, %r14
addq $0x10, %r14
js 0x475fa
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, %rbx
jge 0x475fa
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x47494
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movl 0xc(%rax), %edx
cmpl 0x8(%rax), %edx
jge 0x47486
movl 0x14(%rax), %edx
cmpl %ebx, %edx
je 0x47499
setg %sil
cmpl %ecx, %edx
setl %dil
testb %dil, %sil
cmovneq %rax, %r12
cmovnel %edx, %ecx
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x47463
jmp 0x4749c
xorl %eax, %eax
retq
xorl %r12d, %r12d
jmp 0x4749c
movq %rax, %r12
movq %r14, 0x10(%rsp)
testq %r12, %r12
jne 0x4756f
movl $0x100000, %eax         # imm = 0x100000
xorl %edx, %edx
idivq %rbx
testq %rax, %rax
movl $0x1, %r14d
cmovnel %eax, %r14d
movl %r14d, %eax
imull %ebx, %eax
cltq
movq %rax, 0x8(%rsp)
leaq 0x30(%rax), %rdi
callq 0x3290
movq %rax, %r13
movq %rax, %r12
testq %rax, %rax
je 0x4760a
movl 0x28(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r15)
movl %eax, (%r12)
movl $0x0, 0x4(%r12)
movl %r14d, 0x8(%r12)
xorl %eax, %eax
movq %rax, 0xc(%r12)
movl %ebx, 0x14(%r12)
movq %rax, 0x18(%r12)
movq 0x10(%r15), %rax
movq %rax, 0x20(%r12)
movq 0x8(%rsp), %rdx
leaq (%rdx,%r13), %rcx
addq $0x30, %rcx
movq %rcx, 0x28(%r12)
addq %rdx, 0x30(%r15)
testq %rax, %rax
je 0x4753c
movq %r12, 0x18(%rax)
addq $0x30, %r13
movq %r12, 0x10(%r15)
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x47552
cmpq %r13, %rax
jbe 0x47556
movq %r13, 0x18(%r15)
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x47566
cmpq 0x28(%r12), %rax
jae 0x4756f
movq 0x28(%r12), %rax
movq %rax, 0x20(%r15)
movslq 0xc(%r12), %rbx
movslq 0x14(%r12), %rdx
imulq %rdx, %rbx
leaq (%r12,%rbx), %r14
leaq (%r12,%rbx), %r13
addq $0x30, %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x3190
movl $0x1, (%r13)
movq 0x10(%rsp), %rax
movl %eax, 0x4(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movq 0x38(%r15), %rax
movslq 0x8(%rax), %rax
movq %rax, 0x18(%r13)
xorl %ecx, %ecx
movb %cl, 0x20(%r13)
incl 0xc(%r12)
incl 0x4(%r12)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%r13)
movq %rbp, 0x30(%r13)
leaq (%r12,%rbx), %rdi
addq $0x68, %rdi
movb %cl, 0x68(%rax,%r14)
movq 0x20(%rsp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x768c
jmp 0x47452
movq %r15, %rdi
callq 0x76ad
jmp 0x474e6
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: fsnprintf
static int fsnprintf(bool string, void *stream, int size, const char *format, ...)
{
    va_list args;
    va_start(args, format);

    int res = string ? vsnprintf((char *)stream, size, format, args) : vfprintf((FILE *)stream, format, args);

    va_end(args);
    return res;
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x4a609
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rsp)
testl %edi, %edi
je 0x4a643
movslq %edx, %rsi
movq %rsp, %rax
movq %r10, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x30e0
jmp 0x4a651
movq %rsp, %rdx
movq %r10, %rdi
movq %rcx, %rsi
callq 0x3340
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: fsscanf
static int fsscanf(bool string, void *stream, const char *format, ...)
{
    va_list args;
    va_start(args, format);

    int res = string ? vsscanf((char *)stream, format, args) : vfscanf((FILE *)stream, format, args);

    va_end(args);
    return res;
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x4a6ac
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsp)
movq %rsp, %rax
testl %edi, %edi
je 0x4a6e3
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3280
jmp 0x4a6f1
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3140
addq $0xd8, %rsp
retq