LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinCapCall
static void parseBuiltinCapCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    *type = NULL;
    parseExpr(comp, type, NULL);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_CAP, (*type)->kind == TYPE_DYNARRAY);

    genCallBuiltin(&comp->gen, TYPE_DYNARRAY, BUILTIN_CAP);
    *type = comp->intType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x127cc
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c6513(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x13, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x23, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x13, %esi
movl $0x23, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinSizeofselfCall
static void parseBuiltinSizeofselfCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_SIZEOFSELF, (*type)->kind == TYPE_INTERFACE);

    genCallBuiltin(&comp->gen, TYPE_INTERFACE, BUILTIN_SIZEOFSELF);
    *type = comp->intType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12a3c
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c62a3(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x17, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x25, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x17, %esi
movl $0x25, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinSelfptrCall
static void parseBuiltinSelfptrCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_SELFPTR, (*type)->kind == TYPE_INTERFACE);

    genCallBuiltin(&comp->gen, TYPE_INTERFACE, BUILTIN_SELFPTR);
    *type = comp->ptrVoidType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12afc
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c61e3(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x17, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x26, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x17, %esi
movl $0x26, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5298(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinSelfhasptrCall
static void parseBuiltinSelfhasptrCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_SELFHASPTR, (*type)->kind == TYPE_INTERFACE);

    genCallBuiltin(&comp->gen, TYPE_INTERFACE, BUILTIN_SELFHASPTR);
    *type = comp->boolType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12bbc
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c6123(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x17, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x27, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x17, %esi
movl $0x27, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinSelftypeeqCall
static void parseBuiltinSelftypeeqCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    // Left interface
    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_SELFTYPEEQ, (*type)->kind == TYPE_INTERFACE);

    lexEat(&comp->lex, TOK_COMMA);

    // Right interface
    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_SELFTYPEEQ, (*type)->kind == TYPE_INTERFACE);

    genCallBuiltin(&comp->gen, TYPE_INTERFACE, BUILTIN_SELFTYPEEQ);
    *type = comp->boolType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12c7c
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c6063(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x17, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x28, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3f, %esi
callq 0x1b150
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x17, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x28, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x17, %esi
movl $0x28, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinTypeptrCall
static void parseBuiltinTypeptrCall(Compiler *comp, const Type **type, Const *constant)
{
    *type = parseType(comp, NULL);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_TYPEPTR, (*type)->kind != TYPE_VOID && (*type)->kind != TYPE_NULL);

    if (constant)
        constant->ptrVal = (Type *)(*type);
    else
        genPushGlobalPtr(&comp->gen, (Type *)(*type));

    *type = comp->ptrVoidType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9b80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x4e18, %rax           # imm = 0x4E18
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x19(%rbp)
je 0x12dc5
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
setne %al
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb -0x19(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x29, %edx
callq 0x229e0
cmpq $0x0, -0x18(%rbp)
je 0x12df7
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12e0e
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x16950
movq -0x8(%rbp), %rax
movq 0x5298(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinValidCall
static void parseBuiltinValidCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_VALID, (*type)->kind == TYPE_DYNARRAY || (*type)->kind == TYPE_MAP || (*type)->kind == TYPE_INTERFACE || (*type)->kind == TYPE_FN || (*type)->kind == TYPE_CLOSURE || (*type)->kind == TYPE_FIBER);

    genCallBuiltin(&comp->gen, (*type)->kind, BUILTIN_VALID);
    *type = comp->boolType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12e6c
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c5e73(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rax
addq $0x4e18, %rax           # imm = 0x4E18
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x13, (%rcx)
movb %al, -0x19(%rbp)
je 0x12f06
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x15, (%rcx)
movb %al, -0x19(%rbp)
je 0x12f06
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x17, (%rcx)
movb %al, -0x19(%rbp)
je 0x12f06
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x1a, (%rcx)
movb %al, -0x19(%rbp)
je 0x12f06
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x18, (%rcx)
movb %al, -0x19(%rbp)
je 0x12f06
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x19, (%rax)
sete %al
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb -0x19(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x2a, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movl $0x2a, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinValidkeyCall
static void parseBuiltinValidkeyCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    // Map
    *type = NULL;
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_VALIDKEY, (*type)->kind == TYPE_MAP);

    lexEat(&comp->lex, TOK_COMMA);

    // Map key
    const Type *keyType = typeMapKey(*type);
    parseExpr(comp, &keyType, constant);
    doAssertImplicitTypeConv(comp, typeMapKey(*type), &keyType, NULL);

    genCallBuiltin(&comp->gen, (*type)->kind, BUILTIN_VALIDKEY);
    *type = comp->boolType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12f9c
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c5d43(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x15, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x2b, %edx
callq 0x229e0
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3f, %esi
callq 0x1b150
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13410
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0xe8c0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13410
movq -0x28(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xd6e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movl $0x2b, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinKeysCall
static void parseBuiltinKeysCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    // Map
    parseExpr(comp, type, constant);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_KEYS, (*type)->kind == TYPE_MAP);

    // Result type (hidden parameter)
    Type *keysType = typeAdd(&comp->types, &comp->blocks, TYPE_DYNARRAY);
    keysType->base = typeMapKey(*type);

    // Pointer to result (hidden parameter)
    int resultOffset = identAllocStack(&comp->idents, &comp->types, &comp->blocks, keysType);
    genPushLocalPtr(&comp->gen, resultOffset);

    genCallTypedBuiltin(&comp->gen, keysType, BUILTIN_KEYS);
    *type = keysType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x130bc
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c5c23(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x15, (%rax)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x2c, %edx
callq 0x229e0
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, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13410
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x4e38, %rdi           # imm = 0x4E38
movq -0x8(%rbp), %rsi
addq $0x4e18, %rsi           # imm = 0x4E18
movq -0x8(%rbp), %rdx
addq $0x4220, %rdx           # imm = 0x4220
movq -0x20(%rbp), %rcx
callq 0x1a320
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x24(%rbp), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x20(%rbp), %rsi
movl $0x2c, %edx
callq 0x182e0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinResumeCall
static void parseBuiltinResumeCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    if (comp->lex.tok.kind != TOK_RPAR)
    {
        // Child fiber
        parseExpr(comp, type, constant);
        doAssertImplicitTypeConv(comp, comp->fiberType, type, constant);
    }
    else
    {
        // Parent fiber (implied)
        genPushGlobalPtr(&comp->gen, NULL);
    }

    genCallBuiltin(&comp->gen, TYPE_NONE, BUILTIN_RESUME);
    *type = comp->voidType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x131ec
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c5af3(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
cmpl $0x39, 0x4bd0(%rax)
je 0x13228
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x5290(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xd6e0
jmp 0x1323c
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
xorl %eax, %eax
movl %eax, %esi
callq 0x16950
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
xorl %esi, %esi
movl $0x2d, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5218(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinMemusageCall
static void parseBuiltinMemusageCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    genCallBuiltin(&comp->gen, TYPE_INT, BUILTIN_MEMUSAGE);
    *type = comp->intType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x132ac
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c5a33(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x7, %esi
movl $0x2e, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinExitCall
static void parseBuiltinExitCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    *type = comp->intType;
    parseExpr(comp, type, constant);
    doAssertImplicitTypeConv(comp, comp->intType, type, constant);

    if (comp->lex.tok.kind == TOK_RPAR)
    {
        genPushGlobalPtr(&comp->gen, storageAddStr(&comp->storage, 0));
    }
    else
    {
        lexEat(&comp->lex, TOK_COMMA);

        parseExpr(comp, type, constant);
        doAssertImplicitTypeConv(comp, comp->strType, type, constant);
    }

    genCallBuiltin(&comp->gen, TYPE_VOID, BUILTIN_EXIT);
    *type = comp->voidType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1331c
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c59c3(%rip), %rsi    # 0x1d8cdb
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x5240(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xd6e0
movq -0x8(%rbp), %rax
cmpl $0x39, 0x4bd0(%rax)
jne 0x13398
movq -0x8(%rbp), %rax
addq $0x4e70, %rax           # imm = 0x4E70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x16950
jmp 0x133da
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x3f, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe8c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x5288(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xd6e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x2, %esi
movl $0x2f, %edx
callq 0x18040
movq -0x8(%rbp), %rax
movq 0x5218(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseTypeCast
static void parseTypeCast(Compiler *comp, const Type **type, Const *constant)
{
    lexEat(&comp->lex, TOK_LPAR);

    const Type *originalType = NULL;
    parseExpr(comp, &originalType, constant);

    const Type *castType = originalType;
    doExplicitTypeConv(comp, *type, &castType, constant);

    if (!typeEquivalent(*type, castType))
    {
        char srcBuf[DEFAULT_STR_LEN + 1], destBuf[DEFAULT_STR_LEN + 1];
        comp->error.handler(comp->error.context, "Cannot cast %s to %s", typeSpelling(originalType, srcBuf), typeSpelling(*type, destBuf));
    }

    lexEat(&comp->lex, TOK_RPAR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x38, %esi
callq 0x1b150
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0xe8c0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0xd730
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x22250
testb $0x1, %al
jne 0x1354b
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rax
movq %rax, -0x238(%rbp)
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rax
movq %rax, -0x248(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x22070
movq %rax, -0x240(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x230(%rbp), %rsi
callq 0x22070
movq -0x248(%rbp), %rdi
movq -0x240(%rbp), %rdx
movq -0x238(%rbp), %r8
movq %rax, %rcx
leaq 0x1c56df(%rip), %rsi    # 0x1d8c25
movb $0x0, %al
callq *%r8
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseCompositeLiteral
static void parseCompositeLiteral(Compiler *comp, const Type **type, Const *constant)
{
    if ((*type)->kind == TYPE_ARRAY || (*type)->kind == TYPE_STRUCT)
        parseArrayOrStructLiteral(comp, type, constant);
    else if ((*type)->kind == TYPE_DYNARRAY)
        parseDynArrayLiteral(comp, type, constant);
    else if ((*type)->kind == TYPE_MAP)
        parseMapLiteral(comp, type, constant);
    else if ((*type)->kind == TYPE_CLOSURE)
        parseClosureLiteral(comp, type, constant);
    else
        comp->error.handler(comp->error.context, "Composite literals are only allowed for arrays, maps, structures and closures");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x12, (%rax)
je 0x1359c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x16, (%rax)
jne 0x135b2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13770
jmp 0x13636
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x13, (%rax)
jne 0x135d1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13d40
jmp 0x13634
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x15, (%rax)
jne 0x135f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x140e0
jmp 0x13632
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x18, (%rax)
jne 0x1360f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14340
jmp 0x13630
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c571f(%rip), %rsi    # 0x1d8d4b
movb $0x0, %al
callq *%rcx
jmp 0x13632
jmp 0x13634
jmp 0x13636
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseEnumConst
static void parseEnumConst(Compiler *comp, const Type **type, Const *constant)
{
    if (!typeEnum(*type))
    {
        char typeBuf[DEFAULT_STR_LEN + 1];
        comp->error.handler(comp->error.context, "Type %s is not an enumeration", typeSpelling(*type, typeBuf));
    }

    lexEat(&comp->lex, TOK_PERIOD);
    lexCheck(&comp->lex, TOK_IDENT);

    const EnumConst *enumConst = typeAssertFindEnumConst(&comp->types, *type, comp->lex.tok.name);

    if (constant)
        *constant = enumConst->val;
    else
        doPushConst(comp, *type, &enumConst->val);

    lexNext(&comp->lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x14a90
testb $0x1, %al
jne 0x136ba
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
movq (%rax), %rdi
leaq -0x120(%rbp), %rsi
callq 0x22070
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rcx
movq %rax, %rdx
leaq 0x1c57c5(%rip), %rsi    # 0x1d8e7b
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x43, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b080
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x4ba8, %rdx           # imm = 0x4BA8
addq $0x28, %rdx
addq $0x8, %rdx
callq 0x23490
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13733
movq -0x18(%rbp), %rax
movq -0x128(%rbp), %rcx
movq 0x108(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x13751
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x128(%rbp), %rdx
addq $0x108, %rdx            # imm = 0x108
callq 0xce30
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseDerefSelector
static void parseDerefSelector(Compiler *comp, const Type **type, bool *isVar, bool *isCall)
{
    if (*isVar)   // This is always the case, except for type-cast lvalues like ^T(x)^ which are not variables
    {
        if ((*type)->kind != TYPE_PTR)
            comp->error.handler(comp->error.context, "Typed pointer expected");

        genDeref(&comp->gen, (*type)->base->kind);
        *type = (*type)->base;
    }

    if (((*type)->kind != TYPE_PTR && (*type)->kind != TYPE_WEAKPTR) ||
        ((*type)->base->kind == TYPE_VOID || (*type)->base->kind == TYPE_NULL))
    {
        comp->error.handler(comp->error.context, "Typed pointer expected");
    }

    if ((*type)->kind == TYPE_WEAKPTR)
    {
        genStrengthenPtr(&comp->gen);
        *type = typeAddPtrTo(&comp->types, &comp->blocks, (*type)->base);
    }

    lexNext(&comp->lex);
    *isVar = true;
    *isCall = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x14b4d
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10, (%rax)
je 0x14b1e
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c43a8(%rip), %rsi    # 0x1d8ec2
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x16fa0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10, (%rax)
je 0x14b65
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x11, (%rax)
jne 0x14b85
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
je 0x14b85
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x3, (%rax)
jne 0x14ba6
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c4320(%rip), %rsi    # 0x1d8ec2
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x11, (%rax)
jne 0x14bf2
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x17d80
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
callq 0x21fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseCallSelector
static void parseCallSelector(Compiler *comp, const Type **type, bool *isVar, bool *isCall)
{
    // Implicit dereferencing: f^(x) == f(x)
    doTryImplicitDeref(comp, type);

    if ((*type)->kind == TYPE_PTR && ((*type)->base->kind == TYPE_FN || (*type)->base->kind == TYPE_CLOSURE))
    {
        genDeref(&comp->gen, (*type)->base->kind);
        *type = (*type)->base;
    }

    if ((*type)->kind != TYPE_FN && (*type)->kind != TYPE_CLOSURE)
        comp->error.handler(comp->error.context, "Function or closure expected");

    parseCall(comp, type);

    // Push result
    if ((*type)->kind != TYPE_VOID)
        genPushReg(&comp->gen, REG_RESULT);

    // Copy result to a temporary local variable to collect it as garbage when leaving the block
    if (typeGarbageCollected(*type))
        doCopyResultToTempVar(comp, *type);

    *isVar = typeStructured(*type);
    *isCall = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15490
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10, (%rax)
jne 0x153e0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x1a, (%rax)
je 0x153b1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x18, (%rax)
jne 0x153e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x16fa0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1a, (%rax)
je 0x15419
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x18, (%rax)
je 0x15419
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c3b1d(%rip), %rsi    # 0x1d8f32
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15570
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
je 0x15444
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
xorl %esi, %esi
callq 0x16b60
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xee80
testb $0x1, %al
jne 0x15456
jmp 0x15466
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xd070
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xcfa0
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doTryImplicitDeref
static void doTryImplicitDeref(Compiler *comp, const Type **type)
{
    if ((*type)->kind == TYPE_PTR && (*type)->base->kind == TYPE_PTR)
    {
        genDeref(&comp->gen, TYPE_PTR);
        *type = (*type)->base;
    }
    else if ((*type)->kind == TYPE_PTR && (*type)->base->kind == TYPE_WEAKPTR)
    {
        genDeref(&comp->gen, TYPE_WEAKPTR);
        genStrengthenPtr(&comp->gen);
        *type = typeAddPtrTo(&comp->types, &comp->blocks, (*type)->base->base);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10, (%rax)
jne 0x154e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x10, (%rax)
jne 0x154e5
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x10, %esi
callq 0x16fa0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1555c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10, (%rax)
jne 0x1555a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x11, (%rax)
jne 0x1555a
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x11, %esi
callq 0x16fa0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x17d80
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x21fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1555c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doPassParam
static void doPassParam(Compiler *comp, const Type *formalParamType)
{
    if (doTryRemoveCopyResultToTempVar(comp))
    {
        // Optimization: if the actual parameter is a function call, assume its reference count to be already increased before return
        // The formal parameter variable will hold this additional reference, so we can remove the temporary "reference holder" variable
    }
    else
    {
        // General case: increase parameter's reference count
        genChangeRefCnt(&comp->gen, TOK_PLUSPLUS, formalParamType);
    }

    // Non-trivial assignment to parameters
    if (typeNarrow(formalParamType) || typeStructured(formalParamType))
        genAssignParam(&comp->gen, formalParamType->kind, typeSize(&comp->types, formalParamType));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd0f0
testb $0x1, %al
jne 0x15b8f
jmp 0x15b91
jmp 0x15baa
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rdx
movl $0x2c, %esi
callq 0x17270
movq -0x10(%rbp), %rdi
callq 0x15c10
testb $0x1, %al
jne 0x15bc6
movq -0x10(%rbp), %rdi
callq 0xcfa0
testb $0x1, %al
jne 0x15bc6
jmp 0x15bff
movq -0x8(%rbp), %rax
addq $0x4e70, %rax           # imm = 0x4E70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
callq 0x21fe0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl %eax, %edx
callq 0x17220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_types.h
// Function: typeNarrow
static inline bool typeNarrow(const Type *type)
{
    // Types that occupy less than 64 bits but are still represented by 64-bit temporaries
    return type->kind == TYPE_INT8  || type->kind == TYPE_INT16  || type->kind == TYPE_INT32  ||
           type->kind == TYPE_UINT8 || type->kind == TYPE_UINT16 || type->kind == TYPE_UINT32 ||
           type->kind == TYPE_CHAR  || type->kind == TYPE_BOOL   ||
           type->kind == TYPE_REAL32;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x4, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x5, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x6, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x8, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x9, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0xa, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0xd, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0xc, (%rcx)
movb %al, -0x9(%rbp)
je 0x15c95
movq -0x8(%rbp), %rax
cmpl $0xe, (%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseRelation
static void parseRelation(Compiler *comp, const Type **type, Const *constant)
{
    parseRelationTerm(comp, type, constant);

    if (comp->lex.tok.kind == TOK_EQEQ   || comp->lex.tok.kind == TOK_NOTEQ   || comp->lex.tok.kind == TOK_LESS ||
        comp->lex.tok.kind == TOK_LESSEQ || comp->lex.tok.kind == TOK_GREATER || comp->lex.tok.kind == TOK_GREATEREQ)
    {
        TokenKind op = comp->lex.tok.kind;
        lexNext(&comp->lex);

        Const rightConstantBuf, *rightConstant;
        if (constant)
            rightConstant = &rightConstantBuf;
        else
            rightConstant = NULL;

        const Type *rightType = *type;
        parseRelationTerm(comp, &rightType, rightConstant);
        doApplyOperator(comp, type, &rightType, constant, rightConstant, op, true, true);

        *type = comp->boolType;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15f50
movq -0x8(%rbp), %rax
cmpl $0x2e, 0x4bd0(%rax)
je 0x15eb7
movq -0x8(%rbp), %rax
cmpl $0x34, 0x4bd0(%rax)
je 0x15eb7
movq -0x8(%rbp), %rax
cmpl $0x2f, 0x4bd0(%rax)
je 0x15eb7
movq -0x8(%rbp), %rax
cmpl $0x35, 0x4bd0(%rax)
je 0x15eb7
movq -0x8(%rbp), %rax
cmpl $0x30, 0x4bd0(%rax)
je 0x15eb7
movq -0x8(%rbp), %rax
cmpl $0x36, 0x4bd0(%rax)
jne 0x15f47
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
cmpq $0x0, -0x18(%rbp)
je 0x15ee5
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x15eed
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x15f50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x1c(%rbp), %r9d
leaq -0x38(%rbp), %rdx
movl $0x1, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0xe1d0
movq -0x8(%rbp), %rax
movq 0x5268(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseRelationTerm
static void parseRelationTerm(Compiler *comp, const Type **type, Const *constant)
{
    parseTerm(comp, type, constant);

    while (comp->lex.tok.kind == TOK_PLUS || comp->lex.tok.kind == TOK_MINUS ||
           comp->lex.tok.kind == TOK_OR   || comp->lex.tok.kind == TOK_XOR)
    {
        TokenKind op = comp->lex.tok.kind;
        lexNext(&comp->lex);

        Const rightConstantBuf, *rightConstant;
        if (constant)
            rightConstant = &rightConstantBuf;
        else
            rightConstant = NULL;

        const Type *rightType = *type;
        parseTerm(comp, &rightType, rightConstant);
        doApplyOperator(comp, type, &rightType, constant, rightConstant, op, true, true);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16060
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x16, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x15fbc
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x17, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x15fbc
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x1c, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x15fbc
movq -0x8(%rbp), %rax
cmpl $0x1d, 0x4bd0(%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x15fc8
jmp 0x1604b
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
cmpq $0x0, -0x18(%rbp)
je 0x15ff6
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x15ffe
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x16060
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x1c(%rbp), %r9d
leaq -0x38(%rbp), %rdx
movl $0x1, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0xe1d0
jmp 0x15f75
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseTerm
static void parseTerm(Compiler *comp, const Type **type, Const *constant)
{
    parseFactor(comp, type, constant);

    while (comp->lex.tok.kind == TOK_MUL || comp->lex.tok.kind == TOK_DIV || comp->lex.tok.kind == TOK_MOD ||
           comp->lex.tok.kind == TOK_SHL || comp->lex.tok.kind == TOK_SHR || comp->lex.tok.kind == TOK_AND)
    {
        TokenKind op = comp->lex.tok.kind;
        lexNext(&comp->lex);

        Const rightConstantBuf, *rightConstant;
        if (constant)
            rightConstant = &rightConstantBuf;
        else
            rightConstant = NULL;

        const Type *rightType = *type;
        parseFactor(comp, &rightType, rightConstant);
        doApplyOperator(comp, type, &rightType, constant, rightConstant, op, true, true);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16190
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x18, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x160f0
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x19, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x160f0
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x1a, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x160f0
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x1e, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x160f0
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x1f, 0x4bd0(%rcx)
movb %al, -0x39(%rbp)
je 0x160f0
movq -0x8(%rbp), %rax
cmpl $0x1b, 0x4bd0(%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x160fc
jmp 0x1617f
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
cmpq $0x0, -0x18(%rbp)
je 0x1612a
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x16132
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x16190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x1c(%rbp), %r9d
leaq -0x38(%rbp), %rdx
movl $0x1, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0xe1d0
jmp 0x16085
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genInit
void genInit(CodeGen *gen, Storage *storage, DebugInfo *debug, Error *error)
{
    gen->storage = storage;
    gen->capacity = 1000;
    gen->ip = 0;
    gen->code = storageAdd(gen->storage, gen->capacity * sizeof(Instruction));
    gen->top = -1;
    gen->lastJump = 0;
    gen->breaks = gen->continues = gen->returns = NULL;
    gen->debug = debug;
    gen->debugPerInstr = storageAdd(gen->storage, gen->capacity * sizeof(DebugInfo));
    gen->error = error;
    genUnnotify(gen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1c0(%rax)
movq -0x8(%rbp), %rax
movl $0x3e8, 0xc(%rax)       # imm = 0x3E8
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x5, %rsi
callq 0x4b20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1a0(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x1a4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1b8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1b0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1a8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1c8(%rax)
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
imulq $0x18, %rax, %rsi
callq 0x4b20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1d0(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1e0(%rax)
movq -0x8(%rbp), %rdi
callq 0x16740
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genAddInstr
static void genAddInstr(CodeGen *gen, const Instruction *instr)
{
    if (gen->ip >= gen->capacity)
        genRealloc(gen);

    gen->code[gen->ip] = *instr;
    gen->debugPerInstr[gen->ip] = *gen->debug;

    gen->ip++;
    genUnnotify(gen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x167b9
movq -0x8(%rbp), %rdi
callq 0x19310
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x1c8(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x16740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)