LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
leaq -0x280(%rbp), %rdi
movl $0x270, %edx            # imm = 0x270
callq 0x3270
cmpl $0x45, -0x258(%rbp)
je 0x1f94a
movb $0x0, -0x1(%rbp)
jmp 0x1f97e
leaq -0x280(%rbp), %rdi
callq 0x1ad90
cmpl $0x3f, -0x258(%rbp)
je 0x1f961
jmp 0x1f96f
leaq -0x280(%rbp), %rdi
callq 0x1ad90
jmp 0x1f93b
cmpl $0x37, -0x258(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseShortAssignmentStmt
static void parseShortAssignmentStmt(Compiler *comp, const Type *type, TokenKind op)
{
    if (!typeStructured(type))
    {
        if (type->kind != TYPE_PTR || type->base->kind == TYPE_VOID)
            comp->error.handler(comp->error.context, "Left side cannot be assigned to");
        type = type->base;
    }

    // Duplicate designator and treat it as an expression
    genDup(&comp->gen);
    genDeref(&comp->gen, type->kind);

    const Type *leftType = type;
    const Type *rightType = type;
    parseExpr(comp, &rightType, NULL);

    // Keep "+=" for strings as is for better optimizations
    const TokenKind shortOp = (leftType->kind == TYPE_STR && op == TOK_PLUSEQ) ? op : lexShortAssignment(op);

    doApplyOperator(comp, &leftType, &rightType, NULL, NULL, shortOp, true, false);
    genChangeRefCntAssign(&comp->gen, type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ecf0
testb $0x1, %al
jne 0x1f9f3
movq -0x10(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x1f9c6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
jne 0x1f9e7
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ba092(%rip), %rsi    # 0x1d9a75
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16eb0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x16fa0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xe8c0
movq -0x20(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x1fa51
cmpl $0x20, -0x14(%rbp)
jne 0x1fa51
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x1fa5c
movl -0x14(%rbp), %edi
callq 0x1b1a0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %r9d
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %eax, %eax
movq %r8, %rcx
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xe1d0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rsi
callq 0x17470
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: parseIncDecStmt
static void parseIncDecStmt(Compiler *comp, const Type *type, TokenKind op)
{
    if (!typeStructured(type))
    {
        if (type->kind != TYPE_PTR || type->base->kind == TYPE_VOID)
            comp->error.handler(comp->error.context, "Left side cannot be assigned to");
        type = type->base;
    }

    typeAssertCompatible(&comp->types, comp->intType, type);
    genUnary(&comp->gen, op, type->kind);
    lexNext(&comp->lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ecf0
testb $0x1, %al
jne 0x1fb13
movq -0x10(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x1fae6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
jne 0x1fb07
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1b9f72(%rip), %rsi    # 0x1d9a75
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x22870
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x17620
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: doTypeSwitchStmtLookahead
static bool doTypeSwitchStmtLookahead(Compiler *comp)
{
    // "switch" ident ":=" "type"
    Lexer lookaheadLex = comp->lex;
    if (lookaheadLex.tok.kind != TOK_SWITCH)
        return false;

    lexNext(&lookaheadLex);
    if (lookaheadLex.tok.kind != TOK_IDENT)
        return false;

    lexNext(&lookaheadLex);
    if (lookaheadLex.tok.kind != TOK_COLONEQ)
        return false;

    lexNext(&lookaheadLex);
    if (lookaheadLex.tok.kind != TOK_TYPE)
        return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
leaq -0x280(%rbp), %rdi
movl $0x270, %edx            # imm = 0x270
callq 0x3270
cmpl $0x12, -0x258(%rbp)
je 0x1fbaa
movb $0x0, -0x1(%rbp)
jmp 0x1fbff
leaq -0x280(%rbp), %rdi
callq 0x1ad90
cmpl $0x45, -0x258(%rbp)
je 0x1fbc5
movb $0x0, -0x1(%rbp)
jmp 0x1fbff
leaq -0x280(%rbp), %rdi
callq 0x1ad90
cmpl $0x37, -0x258(%rbp)
je 0x1fbe0
movb $0x0, -0x1(%rbp)
jmp 0x1fbff
leaq -0x280(%rbp), %rdi
callq 0x1ad90
cmpl $0x13, -0x258(%rbp)
je 0x1fbfb
movb $0x0, -0x1(%rbp)
jmp 0x1fbff
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x5, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x41, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x5e60
movq -0x8(%rbp), %rdi
callq 0x1ec10
movq -0x8(%rbp), %rdi
callq 0x1d3a0
movq -0x8(%rbp), %rax
addq $0x4e38, %rax           # imm = 0x4E38
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x6020
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x1a7e0
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
callq 0x5fa0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_stmt.c
// Function: doForPostIncDecStmtLookahead
static bool doForPostIncDecStmtLookahead(Compiler *comp)
{
    // ident ("++" | "--")
    Lexer lookaheadLex = comp->lex;
    if (lookaheadLex.tok.kind != TOK_IDENT)
        return false;

    lexNext(&lookaheadLex);
    if (lookaheadLex.tok.kind != TOK_PLUSPLUS && lookaheadLex.tok.kind != TOK_MINUSMINUS)
        return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
leaq -0x280(%rbp), %rdi
movl $0x270, %edx            # imm = 0x270
callq 0x3270
cmpl $0x45, -0x258(%rbp)
je 0x2184a
movb $0x0, -0x1(%rbp)
jmp 0x21872
leaq -0x280(%rbp), %rdi
callq 0x1ad90
cmpl $0x2c, -0x258(%rbp)
je 0x2186e
cmpl $0x2d, -0x258(%rbp)
je 0x2186e
movb $0x0, -0x1(%rbp)
jmp 0x21872
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeInit
void typeInit(Types *types, Storage *storage, Error *error)
{
    types->first = NULL;
    types->forwardTypesEnabled = false;
    types->storage = storage;
    types->error = error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0xd0, %esi
callq 0x4b20
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x964(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x21a00
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x20(%rbp), %rdi
callq 0x21c20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc4(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x18, %eax
ja 0x21d22
movq -0x28(%rbp), %rax
leaq 0x1b8049(%rip), %rcx    # 0x1d9c98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x21d29
movq -0x10(%rbp), %rdi
callq 0x21a00
movl %eax, -0x4(%rbp)
jmp 0x21d29
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x21c91
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21c20
movl %eax, -0x2c(%rbp)
jmp 0x21c9b
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x21c9b
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21d29
movl $0x8, -0x4(%rbp)
jmp 0x21d29
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x21d03
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x108(%rax), %rdi
callq 0x21c20
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x21cf6
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x21cf8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x21cbd
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21d29
movq -0x10(%rbp), %rdi
callq 0x21a00
movl %eax, -0x4(%rbp)
jmp 0x21d29
movl $0x8, -0x4(%rbp)
jmp 0x21d29
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, (%rax)
je 0x22183
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
je 0x22183
movq -0x10(%rbp), %rax
cmpl $0x15, (%rax)
je 0x22183
movq -0x10(%rbp), %rax
cmpl $0x13, (%rax)
je 0x22183
movq -0x10(%rbp), %rax
cmpl $0x17, (%rax)
je 0x22183
movq -0x10(%rbp), %rax
cmpl $0x18, (%rax)
je 0x22183
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
jne 0x2218c
movb $0x1, -0x1(%rbp)
jmp 0x2223d
movq -0x10(%rbp), %rax
cmpl $0x11, (%rax)
jne 0x221a4
testb $0x1, -0x11(%rbp)
je 0x221a4
movb $0x1, -0x1(%rbp)
jmp 0x2223d
movq -0x10(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x221de
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x10(%rcx)
movb %al, -0x19(%rbp)
jle 0x221d4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22130
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2223d
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x22239
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x22237
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x108(%rax), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22130
testb $0x1, %al
jne 0x22224
jmp 0x2222a
movb $0x1, -0x1(%rbp)
jmp 0x2223d
jmp 0x2222c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x221ee
jmp 0x22239
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22250
testb $0x1, %al
jne 0x227b3
jmp 0x227b9
movb $0x1, -0x1(%rbp)
jmp 0x22805
movq -0x10(%rbp), %rdi
callq 0x22810
testb $0x1, %al
jne 0x227c8
jmp 0x227dd
movq -0x18(%rbp), %rdi
callq 0x22810
testb $0x1, %al
jne 0x227d7
jmp 0x227dd
movb $0x1, -0x1(%rbp)
jmp 0x22805
movq -0x10(%rbp), %rdi
callq 0x22850
testb $0x1, %al
jne 0x227ec
jmp 0x22801
movq -0x18(%rbp), %rdi
callq 0x22850
testb $0x1, %al
jne 0x227fb
jmp 0x22801
movb $0x1, -0x1(%rbp)
jmp 0x22805
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
testb $0x1, -0x9(%rbp)
jne 0x22ed5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22ed3
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x22ec0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x4, %rdx
leaq 0x1b6f5c(%rip), %rsi    # 0x1d9e18
movb $0x0, %al
callq *%rcx
jmp 0x22ec2
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22e82
jmp 0x22ed5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
je 0x22f13
movq -0x10(%rbp), %rax
cmpl $0x17, (%rax)
je 0x22f13
movq -0x10(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x22fa0
movq -0x18(%rbp), %rdi
callq 0x22fc0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x22f9e
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x100(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x22f91
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x22f91
cmpq $0x0, -0x20(%rbp)
je 0x22f7b
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x22fa8
jmp 0x22f93
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x22f26
jmp 0x22fa0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x22ee0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2305a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1b6de7(%rip), %rsi    # 0x1d9e3d
movb $0x0, %al
callq *%rcx
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21f60
testb $0x1, %al
jne 0x233ff
jmp 0x2347c
movq -0x18(%rbp), %rdi
callq 0x22fc0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2347a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x100(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2346d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x2346d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x23484
jmp 0x2346f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x23412
jmp 0x2347c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x233e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x234e2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1b69dc(%rip), %rsi    # 0x1d9eba
movb $0x0, %al
callq *%rcx
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_types.c
// Function: typeFindEnumConstByVal
const EnumConst *typeFindEnumConstByVal(const Type *enumType, Const val)
{
    if (typeEnum(enumType))
    {
        for (int i = 0; i < enumType->numItems; i++)
            if (enumType->enumConst[i]->val.intVal == val.intVal)
                return enumType->enumConst[i];
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21f60
testb $0x1, %al
jne 0x2350f
jmp 0x23564
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x23562
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x108(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x23555
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x2356c
jmp 0x23557
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23516
jmp 0x23564
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x233e0
cmpq $0x0, %rax
je 0x235d1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1b690d(%rip), %rsi    # 0x1d9eda
movb $0x0, %al
callq *%rcx
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x234f0
cmpq $0x0, %rax
je 0x2360a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1b68f6(%rip), %rsi    # 0x1d9efc
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x110, %esi            # imm = 0x110
callq 0x4b20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xff, %edx
callq 0x3080
movq -0x28(%rbp), %rax
movb $0x0, 0xff(%rax)
movq -0x20(%rbp), %rdi
callq 0x22fc0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x100(%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x108(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2369e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x4e10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x236bb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x8, %esi
callq 0x4b20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22fc0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x23771
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movl 0x100(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x23764
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
cmpl $0x0, %eax
jne 0x23764
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x23779
jmp 0x23766
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x23713
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x236f0
cmpq $0x0, %rax
je 0x237e5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1b6745(%rip), %rsi    # 0x1d9f26
movb $0x0, %al
callq *%rcx
movq -0x18(%rbp), %rax
cmpl $0x10, (%rax)
jle 0x23810
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1b6731(%rip), %rsi    # 0x1d9f3d
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x118, %esi            # imm = 0x118
callq 0x4b20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0xff, %edx
callq 0x3080
movq -0x30(%rbp), %rax
movb $0x0, 0xff(%rax)
movq -0x28(%rbp), %rdi
callq 0x22fc0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x100(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x110(%rax)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x2390b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq 0x108(%rax), %rsi
callq 0x21fe0
movslq %eax, %rdi
movl $0x8, %esi
callq 0x233b0
movq %rax, %rcx
movslq -0x18(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x238c1
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
shlq $0x3, %rsi
addq $0x18, %rsi
callq 0x4b20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x23a80
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23920
movslq %eax, %rcx
shrq $0x3, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x23a69
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x23950
movslq %eax, %rdx
shrq $0x3, %rdx
subq $0x2, %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23a2b
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x10, %esi
callq 0x4b20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22d90
testb $0x1, %al
jne 0x2439a
movq -0x20(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x243b5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movq -0x20(%rbp), %rdi
callq 0x22850
testb $0x1, %al
jne 0x243c4
jmp 0x243e6
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movq -0x20(%rbp), %rax
cmpl $0x11, (%rax)
jne 0x2440a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2441e
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x24439
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movq -0x20(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x2445a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movq -0x20(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x24483
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x3220
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movq -0x20(%rbp), %rax
cmpl $0x12, (%rax)
je 0x2449e
movq -0x20(%rbp), %rax
cmpl $0x16, (%rax)
je 0x2449e
movq -0x20(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x244c9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0xc0(%rax), %rdx
callq 0x3200
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244cd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: pageInit
static void pageInit(HeapPages *pages, Fiber *fiber, Error *error)
{
    pages->first = NULL;
    pages->lowest = pages->highest = NULL;
    pages->freeId = 1;
    pages->totalSize = 0;
    pages->fiber = fiber;
    pages->error = error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rax
shlq $0x3, %rax
addq %rax, %rcx
addq $-0x8, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0xf9e4e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
testb $0x1, -0x1(%rbp)
je 0xf9eb6
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x30d0
movl %eax, -0x104(%rbp)
jmp 0xf9ecd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3340
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xf9f2b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
testb $0x1, -0x1(%rbp)
je 0xf9f93
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3290
movl %eax, -0xf4(%rbp)
jmp 0xf9faa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3130
movl %eax, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lukexi[P]eglstreams-mini/acquire-thread-per-display.c
// Function: AcquireThreadMain
void* AcquireThreadMain(void* Arg) {
    egl_display* Display = Arg;

    while (1) {
        if (Display->PageFlipPending) {
            continue;
        }
        EGLint StreamState = EGLQueryStreamState(Display->DisplayDevice, Display->Stream);
        if (StreamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
            NEWTIME(StreamAcquire);
            EGLStreamAcquire(Display);
            ENDTIME(StreamAcquire);
        }

    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x2540
jmp 0x2534
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x3d30
movl %eax, -0x14(%rbp)
cmpl $0x3218, -0x14(%rbp)    # imm = 0x3218
jne 0x25a7
movb $0x0, %al
callq 0x4e00
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3480
movb $0x0, %al
callq 0x4e00
subss -0x18(%rbp), %xmm0
movss 0x3a7a(%rip), %xmm1     # 0x6004
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3a97(%rip), %rdi      # 0x6030
leaq 0x3aa3(%rip), %rsi      # 0x6043
movb $0x1, %al
callq 0x2050
jmp 0x2534
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lukexi[P]eglstreams-mini/src/edid.c
// Function: drm_edid_destroy
void drm_edid_destroy(drm_edid *edid) {
   free(edid->MonitorName);
   free(edid->SerialNumber);
   free(edid->EISAID);
   free(edid->PNPID);
   free(edid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x21f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21f0
movq -0x8(%rbp), %rdi
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lukexi[P]eglstreams-mini/src/edid.c
// Function: edid_parse_string
static char* edid_parse_string(const uint8_t *data) {
   char *text;
   int i;
   int replaced = 0;

   /* this is always 12 bytes, but we can't guarantee it's null
    * terminated or not junk. */
   text = strndup ((const char *) data, 12);

   /* remove insane chars */
   for (i = 0; text[i] != '\0'; i++) {
       if (text[i] == '\n' ||
           text[i] == '\r')
           text[i] = '\0';
   }

   /* nothing left? */
   if (text[0] == '\0') {
       free (text);
       text = NULL;
       goto out;
   }

   /* ensure string is printable */
   for (i = 0; text[i] != '\0'; i++) {
       if (!isprint (text[i])) {
           text[i] = '-';
           replaced++;
       }
   }

   /* if the string is random junk, ignore the string */
   if (replaced > 4) {
       free (text);
       text = NULL;
       goto out;
   }
out:
   return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xc, %esi
callq 0x2400
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2c48
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x2c2f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x2c3b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2c3d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2bfc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2c67
movq -0x10(%rbp), %rdi
callq 0x21f0
movq $0x0, -0x10(%rbp)
jmp 0x2ce1
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2cc6
callq 0x2230
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x2cb9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x2d, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2cbb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c6e
cmpl $0x4, -0x18(%rbp)
jle 0x2cdf
movq -0x10(%rbp), %rdi
callq 0x21f0
movq $0x0, -0x10(%rbp)
jmp 0x2ce1
jmp 0x2ce1
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)