LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_types.h
// Function: typeResizeArray
static inline void typeResizeArray(Type *type, int numItems)
{
    if (type->kind == TYPE_ARRAY)
    {
        type->numItems = numItems;
        type->size = type->numItems * type->base->size;
        type->alignment = type->base->alignment;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x8176
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imull 0xc0(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xc4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc4(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_compiler.c
// Function: compilerAsm
char *compilerAsm(Compiler *comp)
{
    const int chars = genAsm(&comp->gen, NULL, 0);
    if (chars < 0)
        return NULL;

    char *buf = storageAdd(&comp->storage, chars + 1);
    genAsm(&comp->gen, buf, chars);
    buf[chars] = 0;
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x18f80
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x82b5
movq $0x0, -0x8(%rbp)
jmp 0x82fd
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4b20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x18f80
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_compiler.c
// Function: compilerAddModule
bool compilerAddModule(Compiler *comp, const char *fileName, const char *sourceString)
{
    char modulePath[DEFAULT_STR_LEN + 1] = "";
    moduleAssertRegularizePath(&comp->modules, fileName, comp->modules.curFolder, modulePath, DEFAULT_STR_LEN + 1);

    if (moduleFindSource(&comp->modules, modulePath))
        return false;

    moduleAddSource(&comp->modules, modulePath, sourceString, false);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x3190
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x100, %rdx            # imm = 0x100
addq $0x4008, %rdx           # imm = 0x4008
leaq -0x120(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
callq 0x5d90
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x120(%rbp), %rsi
callq 0x5870
cmpq $0x0, %rax
je 0x8390
movb $0x0, -0x1(%rbp)
jmp 0x83b1
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x120(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5910
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_compiler.c
// Function: compilerAddFunc
bool compilerAddFunc(Compiler *comp, const char *name, ExternFunc func)
{
    if (externalFind(&comp->externals, name))
        return false;

    externalAdd(&comp->externals, name, func, false);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4b98, %rdi           # imm = 0x4B98
movq -0x18(%rbp), %rsi
callq 0x6080
cmpq $0x0, %rax
je 0x83f4
movb $0x0, -0x1(%rbp)
jmp 0x8412
movq -0x10(%rbp), %rdi
addq $0x4b98, %rdi           # imm = 0x4B98
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x6100
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_compiler.c
// Function: compilerGetFunc
bool compilerGetFunc(Compiler *comp, const char *moduleName, const char *funcName, FuncContext *fn)
{
    int module = 1;
    if (moduleName)
    {
        char modulePath[DEFAULT_STR_LEN + 1] = "";
        moduleAssertRegularizePath(&comp->modules, moduleName, comp->modules.curFolder, modulePath, DEFAULT_STR_LEN + 1);
        module = moduleFind(&comp->modules, modulePath);
    }

    const Ident *fnIdent = identFind(&comp->idents, &comp->modules, &comp->blocks, module, funcName, NULL, false);
    if (!fnIdent || fnIdent->kind != IDENT_CONST || fnIdent->type->kind != TYPE_FN)
        return false;

    identSetUsed(fnIdent);

    compilerMakeFuncContext(comp, fnIdent->type, fnIdent->offset, fn);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x84a9
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x3190
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x100, %rdx            # imm = 0x100
addq $0x4008, %rdx           # imm = 0x4008
leaq -0x130(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
callq 0x5d90
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x130(%rbp), %rsi
callq 0x52a0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4e38, %rdi           # imm = 0x4E38
movq -0x10(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
movq -0x10(%rbp), %rdx
addq $0x4220, %rdx           # imm = 0x4220
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x19580
movq %rax, -0x138(%rbp)
cmpq $0x0, -0x138(%rbp)
je 0x8514
movq -0x138(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8514
movq -0x138(%rbp), %rax
movq 0x108(%rax), %rax
cmpl $0x1a, (%rax)
je 0x851a
movb $0x0, -0x1(%rbp)
jmp 0x8555
movq -0x138(%rbp), %rdi
callq 0x8570
movq -0x10(%rbp), %rdi
movq -0x138(%rbp), %rax
movq 0x108(%rax), %rsi
movq -0x138(%rbp), %rax
movq 0x120(%rax), %rax
movl %eax, %edx
movq -0x28(%rbp), %rcx
callq 0x8590
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_compiler.c
// Function: compilerMakeFuncContext
void compilerMakeFuncContext(Compiler *comp, const Type *fnType, int entryOffset, FuncContext *fn)
{
    fn->entryOffset = entryOffset;

    int paramSlots = typeParamSizeTotal(&comp->types, &fnType->sig) / sizeof(Slot);
    fn->params = (Slot *)storageAdd(&comp->storage, (paramSlots + 4) * sizeof(Slot)) + 4;          // + 4 slots for compatibility with umkaGetParam()

    const ParamLayout *paramLayout = typeMakeParamLayout(&comp->types, &fnType->sig);
    fn->params[-4].ptrVal = (ParamLayout *)paramLayout;

    fn->result = storageAdd(&comp->storage, sizeof(Slot));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x23920
cltq
shrq $0x3, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movl -0x24(%rbp), %eax
addl $0x4, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x4b20
movq %rax, %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x239a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, -0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movl $0x8, %esi
callq 0x4b20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_const.c
// Function: constUnary
void constUnary(const Consts *consts, Const *arg, TokenKind tokKind, TypeKind typeKind)
{
    if (typeKind == TYPE_REAL || typeKind == TYPE_REAL32)
        switch (tokKind)
        {
            case TOK_PLUS:  break;
            case TOK_MINUS: arg->realVal = -arg->realVal; break;
            default:        consts->error->handler(consts->error->context, "Illegal operator");
        }
    else
        switch (tokKind)
        {
            case TOK_PLUS:  break;
            case TOK_MINUS: arg->intVal = -arg->intVal; break;
            case TOK_NOT:   arg->intVal = !arg->intVal; break;
            case TOK_XOR:   arg->intVal = ~arg->intVal; break;
            default:        consts->error->handler(consts->error->context, "Illegal operator");
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0xf, -0x18(%rbp)
je 0x8b32
cmpl $0xe, -0x18(%rbp)
jne 0x8b99
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x16, %eax
je 0x8b49
jmp 0x8b3f
movl -0x1c(%rbp), %eax
subl $0x17, %eax
je 0x8b4b
jmp 0x8b74
jmp 0x8b94
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x8b94
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1cf47a(%rip), %rsi    # 0x1d800a
movb $0x0, %al
callq *%rcx
jmp 0x8c26
movl -0x14(%rbp), %eax
addl $-0x16, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x1d, %eax
ja 0x8c04
movq -0x28(%rbp), %rax
leaq 0x1cf0eb(%rip), %rcx    # 0x1d7ca0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x8c24
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8c24
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8c24
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8c24
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1cf3ea(%rip), %rsi    # 0x1d800a
movb $0x0, %al
callq *%rcx
jmp 0x8c26
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_const.c
// Function: constArrayAlloc
void constArrayAlloc(ConstArray *array, Storage *storage, const Type *type)
{
    array->storage = storage;
    array->type = type;
    array->len = 0;
    array->capacity = 4;
    array->data = storageAdd(array->storage, array->capacity * sizeof(Const));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rsi
shlq $0x3, %rsi
callq 0x4b20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_const.c
// Function: constArrayAppend
void constArrayAppend(ConstArray *array, Const val)
{
    if (array->len == array->capacity)
    {
        array->capacity *= 2;
        array->data = storageRealloc(array->storage, array->data, array->capacity * sizeof(Const));
    }
    array->data[array->len++] = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x9777
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
shll %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x1c(%rax), %rdx
shlq $0x3, %rdx
callq 0x4e10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x18(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x18(%rdx)
movslq %ecx, %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_const.c
// Function: constArrayFind
int constArrayFind(const Consts *consts, const ConstArray *array, Const val)
{
    for (int i = 0; i < array->len; i++)
    {
        Const result = array->data[i];
        constBinary(consts, &result, &val, TOK_EQEQ, array->type->kind);
        if (result.intVal)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x9818
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %r8d
leaq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x2e, %ecx
callq 0x8c30
cmpq $0x0, -0x30(%rbp)
je 0x980b
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x981f
jmp 0x980d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x97bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_const.c
// Function: constArrayFindEquivalentType
int constArrayFindEquivalentType(const Consts *consts, const ConstArray *array, Const val)
{
    for (int i = 0; i < array->len; i++)
    {
        if (typeEquivalent((Type *)array->data[i].ptrVal, (Type *)val.ptrVal))
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x988b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x22250
testb $0x1, %al
jne 0x9876
jmp 0x987e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9892
jmp 0x9880
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x984b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseType
const Type *parseType(Compiler *comp, const Ident *ident)
{
    if (ident)
    {
        if (ident->kind != IDENT_TYPE)
            comp->error.handler(comp->error.context, "Type expected");
        lexNext(&comp->lex);
        return ident->type;
    }

    switch (comp->lex.tok.kind)
    {
        case TOK_IDENT:     return parseType(comp, parseQualIdent(comp));
        case TOK_CARET:
        case TOK_WEAK:      return parsePtrType(comp);
        case TOK_LBRACKET:  return parseArrayType(comp);
        case TOK_STR:       return parseStrType(comp);
        case TOK_ENUM:      return parseEnumType(comp);
        case TOK_MAP:       return parseMapType(comp);
        case TOK_STRUCT:    return parseStructType(comp);
        case TOK_INTERFACE: return parseInterfaceType(comp);
        case TOK_FN:        return parseClosureType(comp);

        default:            comp->error.handler(comp->error.context, "Type expected"); return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9be5
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x9bc1
movq -0x10(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ce64b(%rip), %rsi    # 0x1d8208
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rax
movl 0x4bd0(%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3e, %eax
ja 0x9cb9
movq -0x20(%rbp), %rax
leaq 0x1ce490(%rip), %rcx    # 0x1d809c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe470
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x9b80
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0x9cf0
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0x9d80
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0x9f40
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0x9f80
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0xa100
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0xa330
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0xa4d0
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rdi
callq 0xa820
movq %rax, -0x8(%rbp)
jmp 0x9ce2
movq -0x10(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ce532(%rip), %rsi    # 0x1d8208
movb $0x0, %al
callq *%rcx
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parsePtrType
static const Type *parsePtrType(Compiler *comp)
{
    bool weak = false;
    if (comp->lex.tok.kind == TOK_WEAK)
    {
        weak = true;
        lexNext(&comp->lex);
    }

    lexEat(&comp->lex, TOK_CARET);

    const Type *baseType = parseTypeOrForwardType(comp);
    Type *ptrType = typeAddPtrTo(&comp->types, &comp->blocks, baseType);
    if (weak)
        ptrType->kind = TYPE_WEAKPTR;

    return ptrType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x15, 0x4bd0(%rax)
jne 0x9d21
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3e, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
callq 0xb140
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x18(%rbp), %rdx
callq 0x21fa0
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x9d76
movq -0x20(%rbp), %rax
movl $0x11, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseEnumType
static const Type *parseEnumType(Compiler *comp)
{
    lexEat(&comp->lex, TOK_ENUM);

    const Type *baseType = comp->intType;
    if (comp->lex.tok.kind == TOK_LPAR)
    {
        lexNext(&comp->lex);
        baseType = parseType(comp, NULL);
        typeAssertCompatible(&comp->types, comp->intType, baseType);
        lexEat(&comp->lex, TOK_RPAR);
    }

    Type *type = typeAdd(&comp->types, &comp->blocks, baseType->kind);
    type->isEnum = true;

    Const constant = {.intVal = -1};

    lexEat(&comp->lex, TOK_LBRACE);
    while (comp->lex.tok.kind == TOK_IDENT)
    {
        parseEnumItem(comp, type, &constant);
        lexEat(&comp->lex, TOK_SEMICOLON);
    }
    lexEat(&comp->lex, TOK_RBRACE);

    const Const zero = {.intVal = 0};
    if (!typeFindEnumConstByVal(type, zero))
        typeAddEnumConst(&comp->types, type, "zero", zero);

    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x7, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
jne 0xa012
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9b80
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 $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x21950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x16(%rax)
movq 0x1ce1ba(%rip), %rax    # 0x1d8200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3c, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
jne 0xa094
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xb3b0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xa05f
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3d, %esi
callq 0x1b150
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3190
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x234f0
cmpq $0x0, %rax
jne 0xa0eb
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq 0x1cdf41(%rip), %rdx    # 0x1d8027
callq 0x23580
movq -0x18(%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_decl.c
// Function: parseStructType
static const Type *parseStructType(Compiler *comp)
{
    lexEat(&comp->lex, TOK_STRUCT);
    lexEat(&comp->lex, TOK_LBRACE);

    Type *type = typeAdd(&comp->types, &comp->blocks, TYPE_STRUCT);

    while (comp->lex.tok.kind == TOK_IDENT)
    {
        IdentName fieldNames[MAX_IDENTS_IN_LIST];
        bool fieldExported[MAX_IDENTS_IN_LIST];
        const Type *fieldType = NULL;
        int numFields = 0;
        parseTypedIdentList(comp, fieldNames, fieldExported, MAX_IDENTS_IN_LIST, &numFields, &fieldType, false);

        for (int i = 0; i < numFields; i++)
        {
            typeAddField(&comp->types, type, fieldType, fieldNames[i]);
            if (fieldExported[i])
                comp->error.handler(comp->error.context, "Field %s cannot be exported", fieldNames[i]);
        }

        lexEat(&comp->lex, TOK_SEMICOLON);
    }
    lexEat(&comp->lex, TOK_RBRACE);
    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10130, %rsp          # imm = 0x10130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x11, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3c, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movl $0x16, %edx
callq 0x21950
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
jne 0xa4a9
movq $0x0, -0x10118(%rbp)
movl $0x0, -0x1011c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10010(%rbp), %rsi
leaq -0x10110(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
leaq -0x1011c(%rbp), %r8
leaq -0x10118(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xb7f0
movl $0x0, -0x10120(%rbp)
movl -0x10120(%rbp), %eax
cmpl -0x1011c(%rbp), %eax
jge 0xa48f
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
movq -0x10118(%rbp), %rdx
movslq -0x10120(%rbp), %rax
leaq -0x10010(%rbp), %rcx
shlq $0x8, %rax
addq %rax, %rcx
callq 0x23070
movslq -0x10120(%rbp), %rax
testb $0x1, -0x10110(%rbp,%rax)
je 0xa479
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
movslq -0x10120(%rbp), %rax
leaq -0x10010(%rbp), %rdx
shlq $0x8, %rax
addq %rax, %rdx
leaq 0x1cde69(%rip), %rsi    # 0x1d82de
movb $0x0, %al
callq *%rcx
jmp 0xa47b
movl -0x10120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10120(%rbp)
jmp 0xa3f0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xa38d
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3d, %esi
callq 0x1b150
movq -0x10(%rbp), %rax
addq $0x10130, %rsp          # imm = 0x10130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseClosureType
static const Type *parseClosureType(Compiler *comp)
{
    lexEat(&comp->lex, TOK_FN);

    Type *type = typeAdd(&comp->types, &comp->blocks, TYPE_CLOSURE);

    // Function field
    Type *fnType = typeAdd(&comp->types, &comp->blocks, TYPE_FN);
    parseSignature(comp, &fnType->sig);
    typeAddField(&comp->types, type, fnType, "#fn");

    // Upvalues field
    typeAddField(&comp->types, type, comp->anyType, "#upvalues");

    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x8, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movl $0x18, %edx
callq 0x21950
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movl $0x1a, %edx
callq 0x21950
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0xb940
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1c9b3e(%rip), %rcx    # 0x1d43f2
callq 0x23070
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x52a8(%rax), %rdx
leaq 0x1c9b0e(%rip), %rcx    # 0x1d43e8
callq 0x23070
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseShortVarDecl
void parseShortVarDecl(Compiler *comp)
{
    IdentName varNames[MAX_IDENTS_IN_LIST];
    bool varExported[MAX_IDENTS_IN_LIST];
    int numVars = 0;
    parseIdentList(comp, varNames, varExported, MAX_IDENTS_IN_LIST, &numVars);

    lexEat(&comp->lex, TOK_COLONEQ);
    parseDeclAssignmentStmt(comp, varNames, varExported, numVars, comp->blocks.top == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10120, %rsp          # imm = 0x10120
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10114(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10010(%rbp), %rsi
leaq -0x10110(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
leaq -0x10114(%rbp), %r8
callq 0xa980
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x37, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
leaq -0x10010(%rbp), %rsi
leaq -0x10110(%rbp), %rdx
movl -0x10114(%rbp), %ecx
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4b84(%rax)
sete %al
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x1df50
addq $0x10120, %rsp          # imm = 0x10120
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseIdentList
static void parseIdentList(Compiler *comp, IdentName *names, bool *exported, int capacity, int *num)
{
    *num = 0;
    while (1)
    {
        lexCheck(&comp->lex, TOK_IDENT);

        if (*num >= capacity)
            comp->error.handler(comp->error.context, "Too many identifiers");
        strcpy(names[*num], comp->lex.tok.name);

        lexNext(&comp->lex);
        exported[*num] = parseExportMark(comp);
        (*num)++;

        if (comp->lex.tok.kind != TOK_COMMA)
            break;
        lexNext(&comp->lex);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b080
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jl 0xa9e6
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cda75(%rip), %rsi    # 0x1d8457
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq (%rax), %rax
shlq $0x8, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
addq $0x28, %rsi
addq $0x8, %rsi
callq 0x30a0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
callq 0xbe90
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x3f, 0x4bd0(%rax)
je 0xaa56
jmp 0xaa6b
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
jmp 0xa9a5
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseDecl
void parseDecl(Compiler *comp)
{
    switch (comp->lex.tok.kind)
    {
        case TOK_TYPE:   parseTypeDecl(comp);       break;
        case TOK_CONST:  parseConstDecl(comp);      break;
        case TOK_VAR:    parseFullVarDecl(comp);    break;
        case TOK_IDENT:  parseShortVarDecl(comp);   break;
        case TOK_FN:     parseFnDecl(comp);         break;

        case TOK_EOF:    if (comp->blocks.top == 0)
                             break;

        default: comp->error.handler(comp->error.context, "Declaration expected but %s found", lexSpelling(comp->lex.tok.kind)); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
je 0xaae0
jmp 0xaaa0
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0xab01
jmp 0xaaaa
movl -0xc(%rbp), %eax
subl $0x13, %eax
je 0xaad2
jmp 0xaab4
movl -0xc(%rbp), %eax
subl $0x14, %eax
je 0xaaeb
jmp 0xaabe
movl -0xc(%rbp), %eax
subl $0x45, %eax
je 0xaaf6
jmp 0xaac8
movl -0xc(%rbp), %eax
subl $0x4c, %eax
je 0xab0c
jmp 0xab1d
movq -0x8(%rbp), %rdi
callq 0xab70
jmp 0xab60
movq -0x8(%rbp), %rdi
callq 0xac30
jmp 0xab60
movq -0x8(%rbp), %rdi
callq 0xace0
jmp 0xab60
movq -0x8(%rbp), %rdi
callq 0xa8f0
jmp 0xab60
movq -0x8(%rbp), %rdi
callq 0xad80
jmp 0xab60
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4b84(%rax)
jne 0xab1b
jmp 0xab60
jmp 0xab1d
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %edi
callq 0x1b130
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq %rax, %rdx
leaq 0x1cd6ba(%rip), %rsi    # 0x1d8216
movb $0x0, %al
callq *%rcx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseTypeDecl
static void parseTypeDecl(Compiler *comp)
{
    lexEat(&comp->lex, TOK_TYPE);

    typeEnableForward(&comp->types, true);

    if (comp->lex.tok.kind == TOK_LPAR)
    {
        lexNext(&comp->lex);
        while (comp->lex.tok.kind == TOK_IDENT)
        {
            parseTypeDeclItem(comp);
            lexEat(&comp->lex, TOK_SEMICOLON);
        }
        lexEat(&comp->lex, TOK_RPAR);
    }
    else
        parseTypeDeclItem(comp);

    typeEnableForward(&comp->types, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x13, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movl $0x1, %esi
callq 0x22e50
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
jne 0xac07
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
jne 0xabf0
movq -0x8(%rbp), %rdi
callq 0xbed0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xabc3
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
jmp 0xac10
movq -0x8(%rbp), %rdi
callq 0xbed0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
xorl %esi, %esi
callq 0x22e50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseConstDecl
static void parseConstDecl(Compiler *comp)
{
    lexEat(&comp->lex, TOK_CONST);

    const Type *type = NULL;
    Const constant;

    if (comp->lex.tok.kind == TOK_LPAR)
    {
        lexNext(&comp->lex);
        while (comp->lex.tok.kind == TOK_IDENT)
        {
            parseConstDeclItem(comp, &type, &constant);
            lexEat(&comp->lex, TOK_SEMICOLON);
        }
        lexEat(&comp->lex, TOK_RPAR);
    }
    else
        parseConstDeclItem(comp, &type, &constant);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3, %esi
callq 0x1b150
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
jne 0xacc2
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
jne 0xacab
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xc000
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xac76
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
jmp 0xacd3
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xc000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseFullVarDecl
static void parseFullVarDecl(Compiler *comp)
{
    lexEat(&comp->lex, TOK_VAR);

    if (comp->lex.tok.kind == TOK_LPAR)
    {
        lexNext(&comp->lex);
        while (comp->lex.tok.kind == TOK_IDENT)
        {
            parseVarDeclItem(comp);
            lexEat(&comp->lex, TOK_SEMICOLON);
        }
        lexEat(&comp->lex, TOK_RPAR);
    }
    else
        parseVarDeclItem(comp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x14, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
jne 0xad62
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
jne 0xad4b
movq -0x8(%rbp), %rdi
callq 0xc360
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xad1e
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
jmp 0xad6b
movq -0x8(%rbp), %rdi
callq 0xc360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseProgram
void parseProgram(Compiler *comp)
{
    // Entry point stub
    genNop(&comp->gen);

    lexNext(&comp->lex);
    int mainModule = parseModule(comp);

    // Entry point
    genEntryPoint(&comp->gen, 0);

    const Ident *mainFn = identFind(&comp->idents, &comp->modules, &comp->blocks, mainModule, "main", NULL, false);
    if (mainFn && identIsMain(mainFn))
    {
        genPushZero(&comp->gen, sizeof(Interface) / sizeof(Slot));  // Dummy upvalue
        genCall(&comp->gen, mainFn->offset);
    }

    doGarbageCollection(comp);
    genHalt(&comp->gen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16760
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
callq 0xb0a0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
xorl %esi, %esi
callq 0x18b90
movq -0x8(%rbp), %rdi
addq $0x4e38, %rdi           # imm = 0x4E38
movq -0x8(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
movq -0x8(%rbp), %rdx
addq $0x4220, %rdx           # imm = 0x4220
movl -0xc(%rbp), %ecx
leaq 0x1cd223(%rip), %r8     # 0x1d8238
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x19580
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb074
movq -0x18(%rbp), %rdi
callq 0x1a840
testb $0x1, %al
jne 0xb042
jmp 0xb074
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x2, %esi
callq 0x16c70
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq 0x120(%rax), %rax
movl %eax, %esi
callq 0x17f50
movq -0x8(%rbp), %rdi
callq 0x1d3a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x18440
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseModule
static int parseModule(Compiler *comp)
{
    comp->blocks.module = moduleAdd(&comp->modules, comp->lex.fileName);

    if (comp->lex.tok.kind == TOK_IMPORT)
    {
        parseImport(comp);
        lexEat(&comp->lex, TOK_SEMICOLON);
    }
    parseDecls(comp);
    doResolveExtern(comp);

    comp->modules.module[comp->blocks.module]->isCompiled = true;
    return comp->blocks.module;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x8(%rbp), %rax
movq 0x4ba8(%rax), %rsi
callq 0x5400
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4b88(%rax)
movq -0x8(%rbp), %rax
cmpl $0xa, 0x4bd0(%rax)
jne 0xb0fe
movq -0x8(%rbp), %rdi
callq 0xc840
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
callq 0xc8f0
movq -0x8(%rbp), %rdi
callq 0x1d680
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x4b88(%rcx), %rcx
movq 0x100(%rax,%rcx,8), %rax
movb $0x1, 0x2310(%rax)
movq -0x8(%rbp), %rax
movl 0x4b88(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseEnumItem
static void parseEnumItem(Compiler *comp, Type *type, Const *constant)
{
    lexCheck(&comp->lex, TOK_IDENT);
    IdentName name;
    strcpy(name, comp->lex.tok.name);

    lexNext(&comp->lex);

    if (comp->lex.tok.kind != TOK_EQ)
        constant->intVal++;
    else
    {
        lexEat(&comp->lex, TOK_EQ);
        const Type *rightType = NULL;
        parseExpr(comp, &rightType, constant);
        typeAssertCompatible(&comp->types, comp->intType, rightType);
    }

    if (typeOverflow(type->kind, *constant))
        comp->error.handler(comp->error.context, "Overflow of %s", typeKindSpelling(type->kind));

    typeAddEnumConst(&comp->types, type, name, *constant);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b080
leaq -0x120(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
addq $0x28, %rsi
addq $0x8, %rsi
callq 0x30a0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rax
cmpl $0x31, 0x4bd0(%rax)
je 0xb428
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xb47e
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x31, %esi
callq 0x1b150
movq $0x0, -0x128(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x128(%rbp), %rsi
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rsi
movq -0x128(%rbp), %rdx
callq 0x22870
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xb510
testb $0x1, %al
jne 0xb496
jmp 0xb4e1
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rax
movq %rax, -0x130(%rbp)
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x23b40
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rcx
movq %rax, %rdx
leaq 0x1ccda3(%rip), %rsi    # 0x1d8280
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
leaq -0x120(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
callq 0x23580
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseTypedIdentList
static void parseTypedIdentList(Compiler *comp, IdentName *names, bool *exported, int capacity, int *num, const Type **type, bool allowVariadicParamList)
{
    parseIdentList(comp, names, exported, capacity, num);
    lexEat(&comp->lex, TOK_COLON);

    if (allowVariadicParamList && comp->lex.tok.kind == TOK_ELLIPSIS)
    {
        if (*num != 1)
            comp->error.handler(comp->error.context, "Only one variadic parameter list is allowed");

        lexNext(&comp->lex);
        const Type *itemType = parseType(comp, NULL);
        if (itemType->kind == TYPE_VOID)
            comp->error.handler(comp->error.context, "Variadic parameters cannot be void");

        Type *variadicListType = typeAdd(&comp->types, &comp->blocks, TYPE_DYNARRAY);
        variadicListType->base = itemType;
        variadicListType->isVariadicParamList = true;
        *type = variadicListType;
    }
    else
        *type = parseType(comp, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0xa980
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x41, %esi
callq 0x1b150
testb $0x1, -0x31(%rbp)
je 0xb919
movq -0x8(%rbp), %rax
cmpl $0x44, 0x4bd0(%rax)
jne 0xb919
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
je 0xb889
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cca75(%rip), %rsi    # 0x1d82fa
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9b80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xb8d4
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cca56(%rip), %rsi    # 0x1d8326
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movl $0x13, %edx
callq 0x21950
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0xb930
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseExportMark
static bool parseExportMark(Compiler *comp)
{
    if (comp->lex.tok.kind == TOK_MUL)
    {
        lexNextForcedSemicolon(&comp->lex);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x18, 0x4bd0(%rax)
jne 0xbebf
movq -0x10(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1b030
movb $0x1, -0x1(%rbp)
jmp 0xbec3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseTypeDeclItem
static void parseTypeDeclItem(Compiler *comp)
{
    lexCheck(&comp->lex, TOK_IDENT);
    IdentName name;
    strcpy(name, comp->lex.tok.name);

    lexNext(&comp->lex);
    bool exported = parseExportMark(comp);

    lexEat(&comp->lex, TOK_EQ);

    const Type *type = parseType(comp, NULL);
    Type *newType = typeAdd(&comp->types, &comp->blocks, type->kind);
    typeDeepCopy(&comp->storage, newType, type);
    newType->typeIdent = identAddType(&comp->idents, &comp->modules, &comp->blocks, name, newType, exported);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b080
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
addq $0x28, %rsi
addq $0x8, %rsi
callq 0x30a0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
callq 0xbe90
andb $0x1, %al
movb %al, -0x111(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x31, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9b80
movq %rax, -0x120(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x120(%rbp), %rax
movl (%rax), %edx
callq 0x21950
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movq -0x128(%rbp), %rsi
movq -0x120(%rbp), %rdx
callq 0x21d40
movq -0x8(%rbp), %rdi
addq $0x4e38, %rdi           # imm = 0x4E38
movq -0x8(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
movq -0x8(%rbp), %rdx
addq $0x4220, %rdx           # imm = 0x4220
leaq -0x110(%rbp), %rcx
movq -0x128(%rbp), %r8
movb -0x111(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x1a1e0
movq %rax, %rcx
movq -0x128(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)