LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseRcvSignature
static void parseRcvSignature(Compiler *comp, Signature *sig)
{
    lexEat(&comp->lex, TOK_LPAR);
    lexEat(&comp->lex, TOK_IDENT);

    IdentName rcvName;
    strcpy(rcvName, comp->lex.tok.name);

    lexEat(&comp->lex, TOK_COLON);
    const Type *rcvType = parseType(comp, NULL);

    if (rcvType->kind != TYPE_PTR || !rcvType->base->typeIdent)
        comp->error.handler(comp->error.context, "Receiver should be a pointer to a defined type");

     if (rcvType->base->typeIdent->module != comp->blocks.module)
        comp->error.handler(comp->error.context, "Receiver base type cannot be defined in another module");

    if (rcvType->base->kind == TYPE_PTR || rcvType->base->kind == TYPE_INTERFACE)
    	comp->error.handler(comp->error.context, "Receiver base type cannot be a pointer or an interface");

    sig->isMethod = true;
    typeAddParam(&comp->types, sig, rcvType, rcvName, (Const){0});

    lexEat(&comp->lex, TOK_RPAR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x38, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b150
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
movl $0x41, %esi
callq 0x1b150
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9b80
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
cmpl $0x10, (%rax)
jne 0xc733
movq -0x118(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0xc754
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cbda5(%rip), %rsi    # 0x1d84f5
movb $0x0, %al
callq *%rcx
movq -0x118(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl 0x110(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4b88(%rcx), %eax
je 0xc796
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cbd92(%rip), %rsi    # 0x1d8524
movb $0x0, %al
callq *%rcx
movq -0x118(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x10, (%rax)
je 0xc7b6
movq -0x118(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x17, (%rax)
jne 0xc7d7
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cbd88(%rip), %rsi    # 0x1d855b
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
movq -0x118(%rbp), %rdx
leaq -0x110(%rbp), %rcx
movq $0x0, -0x120(%rbp)
movq -0x120(%rbp), %r8
callq 0x23790
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseImport
static void parseImport(Compiler *comp)
{
    lexEat(&comp->lex, TOK_IMPORT);

    if (comp->lex.tok.kind == TOK_LPAR)
    {
        lexNext(&comp->lex);
        while (comp->lex.tok.kind == TOK_STRLITERAL || comp->lex.tok.kind == TOK_IDENT)
        {
            parseImportItem(comp);
            lexEat(&comp->lex, TOK_SEMICOLON);
        }
        lexEat(&comp->lex, TOK_RPAR);
    }
    else
        parseImportItem(comp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0xa, %esi
callq 0x1b150
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
jne 0xc8e1
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x49, 0x4bd0(%rcx)
movb %al, -0x9(%rbp)
je 0xc8a1
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xc8aa
jmp 0xc8ca
movq -0x8(%rbp), %rdi
callq 0xc940
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xc87e
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x39, %esi
callq 0x1b150
jmp 0xc8ea
movq -0x8(%rbp), %rdi
callq 0xc940
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseDecls
static void parseDecls(Compiler *comp)
{
    while (1)
    {
        parseDecl(comp);
        if (comp->lex.tok.kind == TOK_EOF)
            break;
        lexEat(&comp->lex, TOK_SEMICOLON);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaa80
movq -0x8(%rbp), %rax
cmpl $0x4c, 0x4bd0(%rax)
jne 0xc914
jmp 0xc92b
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x40, %esi
callq 0x1b150
jmp 0xc8fc
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: doPushConst
void doPushConst(Compiler *comp, const Type *type, const Const *constant)
{
    if (type->kind == TYPE_UINT)
        genPushUIntConst(&comp->gen, constant->uintVal);
    else if (typeOrdinal(type) || type->kind == TYPE_FN)
        genPushIntConst(&comp->gen, constant->intVal);
    else if (typeReal(type))
        genPushRealConst(&comp->gen, constant->realVal);
    else if (type->kind == TYPE_PTR || type->kind == TYPE_STR || type->kind == TYPE_FIBER || typeStructured(type))
        genPushGlobalPtr(&comp->gen, constant->ptrVal);
    else if (type->kind == TYPE_WEAKPTR)
        genPushUIntConst(&comp->gen, constant->weakPtrVal);
    else
        comp->error.handler(comp->error.context, "Illegal type");
}

// 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
cmpl $0xb, (%rax)
jne 0xce69
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x168a0
jmp 0xcf55
movq -0x10(%rbp), %rdi
callq 0xcf60
testb $0x1, %al
jne 0xce7f
movq -0x10(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0xce9b
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x16850
jmp 0xcf53
movq -0x10(%rbp), %rdi
callq 0xcf80
testb $0x1, %al
jne 0xceaa
jmp 0xcec7
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x168f0
jmp 0xcf51
movq -0x10(%rbp), %rax
cmpl $0x10, (%rax)
je 0xcef1
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
je 0xcef1
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
je 0xcef1
movq -0x10(%rbp), %rdi
callq 0xcfa0
testb $0x1, %al
jne 0xcef1
jmp 0xcf0a
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x16950
jmp 0xcf4f
movq -0x10(%rbp), %rax
cmpl $0x11, (%rax)
jne 0xcf2c
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x168a0
jmp 0xcf4d
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cb097(%rip), %rsi    # 0x1d7fe0
movb $0x0, %al
callq *%rcx
jmp 0xcf4f
jmp 0xcf51
jmp 0xcf53
jmp 0xcf55
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: doTryRemoveCopyResultToTempVar
bool doTryRemoveCopyResultToTempVar(Compiler *comp)
{
    if (!comp->idents.lastTempVarForResult)
        return false;

    const int resultCopyOffset = genTryRemoveCopyResultToTempVar(&comp->gen);
    if (resultCopyOffset == 0)
        return false;

    if (resultCopyOffset != comp->idents.lastTempVarForResult->offset)
        comp->error.handler(comp->error.context, "Result copy optimization failed");

    comp->idents.lastTempVarForResult->used = false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4e40(%rax)
jne 0xd110
movb $0x0, -0x1(%rbp)
jmp 0xd17e
movq -0x10(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x18e50
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xd12f
movb $0x0, -0x1(%rbp)
jmp 0xd17e
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x4e40(%rcx), %rcx
cmpq 0x120(%rcx), %rax
je 0xd168
movq -0x10(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cb6e8(%rip), %rsi    # 0x1d884c
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq 0x4e40(%rax), %rax
movb $0x0, 0x11a(%rax)
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_expr.c
// Function: doOrdinalToOrdinalOrRealToRealConv
static void doOrdinalToOrdinalOrRealToRealConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
    {
        if (typeConvOverflow(dest->kind, (*src)->kind, *constant))
            comp->error.handler(comp->error.context, "Overflow of %s", typeKindSpelling(dest->kind));
    }
    else
        genAssertRange(&comp->gen, dest->kind, *src);

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd9b1
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x10600
testb $0x1, %al
jne 0xd970
jmp 0xd9af
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x23b40
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq %rax, %rdx
leaq 0x1ca8d5(%rip), %rsi    # 0x1d8280
movb $0x0, %al
callq *%rcx
jmp 0xd9ce
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x17cd0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doInterfaceToPtrConv
static void doInterfaceToPtrConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion from interface is not allowed in constant expressions");

    genAssertType(&comp->gen, dest);
    *src = dest;
}

// 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)
cmpq $0x0, -0x20(%rbp)
je 0xdaa0
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cb0c7(%rip), %rsi    # 0x1d8b63
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rsi
callq 0x17c70
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%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: doInterfaceToValueConv
static void doInterfaceToValueConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion from interface is not allowed in constant expressions");

    const Type *destPtrType = typeAddPtrTo(&comp->types, &comp->blocks, dest);
    genAssertType(&comp->gen, destPtrType);
    genDeref(&comp->gen, dest->kind);
    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdb10
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1cb057(%rip), %rsi    # 0x1d8b63
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x10(%rbp), %rdx
callq 0x21fa0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x28(%rbp), %rsi
callq 0x17c70
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x16fa0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doDynArrayToStrConv
static void doDynArrayToStrConv(Compiler *comp, const Type *dest, const Type **src, Const *constant, bool lhs)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion to string is not allowed in constant expressions");

    if (lhs)
        genSwap(&comp->gen);

    genCallTypedBuiltin(&comp->gen, *src, BUILTIN_MAKETOSTR);
    doCopyResultToTempVar(comp, dest);

    if (lhs)
        genSwap(&comp->gen);

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdbb8
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1caff0(%rip), %rsi    # 0x1d8ba4
movb $0x0, %al
callq *%rcx
testb $0x1, -0x21(%rbp)
je 0xdbce
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1a, %edx
callq 0x182e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
testb $0x1, -0x21(%rbp)
je 0xdc0d
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doStrToDynArrayConv
static void doStrToDynArrayConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
    {
        int len = getStrDims((char *)constant->ptrVal)->len;
        DynArray *array = storageAddDynArray(&comp->storage, dest, len);
        memcpy(array->data, constant->ptrVal, len);
        constant->ptrVal = array;
    }
    else
    {
        int resultOffset = identAllocStack(&comp->idents, &comp->types, &comp->blocks, dest);
        genPushLocalPtr(&comp->gen, resultOffset);                          // Pointer to result (hidden parameter)
        genCallTypedBuiltin(&comp->gen, dest, BUILTIN_MAKEFROMSTR);
        doCopyResultToTempVar(comp, dest);
    }

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdc92
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x10870
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movq -0x10(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x4cd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3270
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xdcf8
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 -0x10(%rbp), %rcx
callq 0x1a320
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x34(%rbp), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rsi
movl $0x18, %edx
callq 0x182e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doApplyStrCat
static void doApplyStrCat(Compiler *comp, Const *constant, const Const *rightConstant, TokenKind op)
{
    if (constant)
    {
        if (op == TOK_PLUSEQ)
            comp->error.handler(comp->error.context, "Operator is not allowed in constant expressions");

        int len = getStrDims((char *)constant->ptrVal)->len + getStrDims((char *)rightConstant->ptrVal)->len;
        char *buf = storageAddStr(&comp->storage, len);
        strcpy(buf, (char *)constant->ptrVal);

        constant->ptrVal = buf;
        constBinary(&comp->consts, constant, rightConstant, TOK_PLUS, TYPE_STR);    // "+" only
    }
    else
    {
        genBinary(&comp->gen, op, TYPE_STR, 0);                                     // "+" or "+=" only
        doCopyResultToTempVar(comp, comp->strType);
    }
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0xe42d
cmpl $0x20, -0x1c(%rbp)
jne 0xe3a9
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ca895(%rip), %rsi    # 0x1d8c3a
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10870
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10870
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq (%rcx), %rax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4c60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x30a0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x4e68, %rdi           # imm = 0x4E68
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x16, %ecx
movl $0x14, %r8d
callq 0x8c30
jmp 0xe45b
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x1c(%rbp), %esi
movl $0x14, %edx
xorl %ecx, %ecx
callq 0x17790
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x5288(%rax), %rsi
callq 0xd070
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: parseQualIdent
const Ident *parseQualIdent(Compiler *comp)
{
    lexCheck(&comp->lex, TOK_IDENT);

    int moduleToSeekIn = comp->blocks.module;

    Lexer lookaheadLex = comp->lex;
    lexNext(&lookaheadLex);
    if (lookaheadLex.tok.kind == TOK_COLONCOLON)
    {
        const Ident *moduleIdent = identAssertFindModule(&comp->idents, &comp->modules, &comp->blocks, comp->blocks.module, comp->lex.tok.name);

        lexNext(&comp->lex);
        lexNext(&comp->lex);
        lexCheck(&comp->lex, TOK_IDENT);

        moduleToSeekIn = moduleIdent->moduleVal;
    }

    const Ident *ident = identAssertFind(&comp->idents, &comp->modules, &comp->blocks, moduleToSeekIn, comp->lex.tok.name, NULL);

    if (identIsOuterLocalVar(&comp->blocks, ident))
        comp->error.handler(comp->error.context, "%s is not specified as a captured variable", ident->name);

    return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b080
movq -0x8(%rbp), %rax
movl 0x4b88(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rsi
addq $0x4ba8, %rsi           # imm = 0x4BA8
leaq -0x280(%rbp), %rdi
movl $0x270, %edx            # imm = 0x270
callq 0x3270
leaq -0x280(%rbp), %rdi
callq 0x1ad90
cmpl $0x42, -0x258(%rbp)
jne 0xe566
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
movq -0x8(%rbp), %rax
movl 0x4b88(%rax), %ecx
movq -0x8(%rbp), %r8
addq $0x4ba8, %r8            # imm = 0x4BA8
addq $0x28, %r8
addq $0x8, %r8
callq 0x19960
movq %rax, -0x288(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
callq 0x1ad90
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi           # imm = 0x4BA8
movl $0x45, %esi
callq 0x1b080
movq -0x288(%rbp), %rax
movq 0x120(%rax), %rax
movl %eax, -0xc(%rbp)
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
movq -0x8(%rbp), %r8
addq $0x4ba8, %r8            # imm = 0x4BA8
addq $0x28, %r8
addq $0x8, %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x19880
movq %rax, -0x290(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4220, %rdi           # imm = 0x4220
movq -0x290(%rbp), %rsi
callq 0x199e0
testb $0x1, %al
jne 0xe5cb
jmp 0xe5f7
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
movq -0x290(%rbp), %rdx
addq $0x4, %rdx
leaq 0x1ca279(%rip), %rsi    # 0x1d886c
movb $0x0, %al
callq *%rcx
movq -0x290(%rbp), %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseDesignator
static void parseDesignator(Compiler *comp, const Type **type, Const *constant, bool *isVar, bool *isCall, bool *isCompLit)
{
    const Ident *ident = NULL;
    if (comp->lex.tok.kind == TOK_IDENT && (ident = parseQualIdent(comp)) && ident->kind != IDENT_TYPE)
    {
        parsePrimary(comp, ident, type, constant, isVar, isCall);
        *isCompLit = false;
    }
    else
        parseTypeCastOrCompositeLiteralOrEnumConst(comp, ident, type, constant, isVar, isCall, isCompLit);

    parseSelectors(comp, type, constant, isVar, isCall, isCompLit);

    if (((*type)->kind == TYPE_FN && (*type)->sig.isMethod) ||
        ((*type)->kind == TYPE_PTR && (*type)->base->kind == TYPE_FN && (*type)->base->sig.isMethod))
    {
        comp->error.handler(comp->error.context, "Method must be called");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x45, 0x4bd0(%rax)
jne 0xe807
movq -0x8(%rbp), %rdi
callq 0xe470
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xe807
movq -0x38(%rbp), %rax
cmpl $0x2, (%rax)
je 0xe807
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x10890
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe82c
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x10ab0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x10bf0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1a, (%rax)
jne 0xe862
movq -0x10(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x30(%rax)
jne 0xe88f
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10, (%rax)
jne 0xe8b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x1a, (%rax)
jne 0xe8b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x30(%rax)
je 0xe8b0
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1ca3be(%rip), %rsi    # 0x1d8c6a
movb $0x0, %al
callq *%rcx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doIntToRealConv
static void doIntToRealConv(Compiler *comp, const Type *dest, const Type **src, Const *constant, bool lhs)
{
    BuiltinFunc builtin = lhs ? BUILTIN_REAL_LHS : BUILTIN_REAL;
    if (constant)
        constCallBuiltin(&comp->consts, constant, NULL, (*src)->kind, builtin);
    else
        genCallBuiltin(&comp->gen, (*src)->kind, builtin);

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %dl
movl $0x6, %eax
movl $0x7, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf584
movq -0x8(%rbp), %rdi
addq $0x4e68, %rdi           # imm = 0x4E68
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movl -0x28(%rbp), %r8d
xorl %eax, %eax
movl %eax, %edx
callq 0x9390
jmp 0xf5a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movl -0x28(%rbp), %edx
callq 0x18040
movq -0x10(%rbp), %rcx
movq -0x18(%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: doCharToStrConv
static void doCharToStrConv(Compiler *comp, const Type *dest, const Type **src, Const *constant, bool lhs)
{
    if (constant)
    {
        char *buf = NULL;
        if (constant->intVal)
        {
            buf = storageAddStr(&comp->storage, 1);
            buf[0] = constant->intVal;
            buf[1] = 0;
        }
        else
            buf = storageAddStr(&comp->storage, 0);

        constant->ptrVal = buf;
    }
    else
    {
        if (lhs)
            genSwap(&comp->gen);

        genCallTypedBuiltin(&comp->gen, *src, BUILTIN_MAKETOSTR);
        doCopyResultToTempVar(comp, dest);

        if (lhs)
            genSwap(&comp->gen);
    }

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf650
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf62b
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movl $0x1, %esi
callq 0x4c60
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax)
jmp 0xf643
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf6a7
testb $0x1, -0x21(%rbp)
je 0xf666
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1a, %edx
callq 0x182e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
testb $0x1, -0x21(%rbp)
je 0xf6a5
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
jmp 0xf6a7
movq -0x10(%rbp), %rcx
movq -0x18(%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: doDynArrayToArrayConv
static void doDynArrayToArrayConv(Compiler *comp, const Type *dest, const Type **src, Const *constant, bool lhs)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion to array is not allowed in constant expressions");

    if (lhs)
        genSwap(&comp->gen);

    int resultOffset = identAllocStack(&comp->idents, &comp->types, &comp->blocks, dest);
    genPushLocalPtr(&comp->gen, resultOffset);                          // Pointer to result (hidden parameter)
    genCallTypedBuiltin(&comp->gen, dest, BUILTIN_MAKETOARR);
    doCopyResultToTempVar(comp, dest);

    if (lhs)
        genSwap(&comp->gen);

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf708
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c9269(%rip), %rsi    # 0x1d896d
movb $0x0, %al
callq *%rcx
testb $0x1, -0x21(%rbp)
je 0xf71e
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
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 -0x10(%rbp), %rcx
callq 0x1a320
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x28(%rbp), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rsi
movl $0x19, %edx
callq 0x182e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
testb $0x1, -0x21(%rbp)
je 0xf79a
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
movq -0x10(%rbp), %rcx
movq -0x18(%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: doArrayToDynArrayConv
static void doArrayToDynArrayConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
    {
        DynArray *array = storageAddDynArray(&comp->storage, dest, (*src)->numItems);
        memcpy(array->data, constant->ptrVal, (*src)->numItems * array->itemSize);
        constant->ptrVal = array;
    }
    else
    {
        int resultOffset = identAllocStack(&comp->idents, &comp->types, &comp->blocks, dest);

        genPushIntConst(&comp->gen, (*src)->numItems);                      // Dynamic array length
        genPushLocalPtr(&comp->gen, resultOffset);                          // Pointer to result (hidden parameter)
        genCallTypedBuiltin(&comp->gen, dest, BUILTIN_MAKEFROMARR);
        doCopyResultToTempVar(comp, dest);
    }

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf82a
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq 0x10(%rax), %rdx
callq 0x4cd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq 0x10(%rax), %rdx
movq -0x28(%rbp), %rax
imulq 0x8(%rax), %rdx
callq 0x3270
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf8ab
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 -0x10(%rbp), %rcx
callq 0x1a320
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq 0x10(%rax), %rsi
callq 0x16850
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x2c(%rbp), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rsi
movl $0x17, %edx
callq 0x182e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doValueToInterfaceConv
static void doValueToInterfaceConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion to interface is not allowed in constant expressions");

    *src = typeAddPtrTo(&comp->types, &comp->blocks, *src);
    doEscapeToHeap(comp, *src);
    doPtrToInterfaceConv(comp, dest, src, constant);
}

// 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)
cmpq $0x0, -0x20(%rbp)
je 0x10090
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c891c(%rip), %rsi    # 0x1d89a8
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x8(%rbp), %rsi
addq $0x4220, %rsi           # imm = 0x4220
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x21fa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x10530
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xfc40
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: doPtrToWeakPtrConv
static void doPtrToWeakPtrConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion to weak pointer is not allowed in constant expressions");

    genWeakenPtr(&comp->gen);

    *src = dest;
}

// 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)
cmpq $0x0, -0x20(%rbp)
je 0x10160
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c88ff(%rip), %rsi    # 0x1d8a5b
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x17d30
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%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: doWeakPtrToPtrConv
static void doWeakPtrToPtrConv(Compiler *comp, const Type *dest, const Type **src, Const *constant, bool lhs)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion from weak pointer is not allowed in constant expressions");

    if (lhs)
        genSwap(&comp->gen);

    genStrengthenPtr(&comp->gen);

    if (lhs)
        genSwap(&comp->gen);

    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x101d8
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c88c9(%rip), %rsi    # 0x1d8a9d
movb $0x0, %al
callq *%rcx
testb $0x1, -0x21(%rbp)
je 0x101ee
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x17d80
testb $0x1, -0x21(%rbp)
je 0x10214
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16f00
movq -0x10(%rbp), %rcx
movq -0x18(%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: doFnToClosureConv
static void doFnToClosureConv(Compiler *comp, const Type *dest, const Type **src, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Conversion to closure is not allowed in constant expressions");

    int destOffset = identAllocStack(&comp->idents, &comp->types, &comp->blocks, dest);

    genPushLocalPtr(&comp->gen, destOffset);
    genZero(&comp->gen, typeSize(&comp->types, dest));

    genPushLocalPtr(&comp->gen, destOffset + dest->field[0]->offset);   // Push dest.#fn pointer
    genSwapAssign(&comp->gen, TYPE_FN, 0);                              // Assign to dest.#fn

    genPushLocalPtr(&comp->gen, destOffset);
    *src = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10270
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c8875(%rip), %rsi    # 0x1d8ae1
movb $0x0, %al
callq *%rcx
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 -0x10(%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), %rax
addq $0x4e70, %rax           # imm = 0x4E70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rsi
callq 0x21fe0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x16f50
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
addl 0x110(%rax), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x1a, %esi
xorl %edx, %edx
callq 0x17120
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x24(%rbp), %esi
callq 0x169a0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doEscapeToHeap
static void doEscapeToHeap(Compiler *comp, const Type *ptrType)
{
    // Allocate heap
    genPushIntConst(&comp->gen, typeSize(&comp->types, ptrType->base));
    genCallTypedBuiltin(&comp->gen, ptrType->base, BUILTIN_NEW);

    // Copy to heap and use heap pointer
    genDup(&comp->gen);
    genPopReg(&comp->gen, REG_HEAP_COPY);
    genSwapChangeRefCntAssign(&comp->gen, ptrType->base);
    genPushReg(&comp->gen, REG_HEAP_COPY);

    doCopyResultToTempVar(comp, ptrType);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x4e70, %rax           # imm = 0x4E70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e18, %rdi           # imm = 0x4E18
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x21fe0
movq -0x18(%rbp), %rdi
movslq %eax, %rsi
callq 0x16850
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x15, %edx
callq 0x182e0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x16eb0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x2, %esi
callq 0x16df0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x17500
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl $0x2, %esi
callq 0x16b60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
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: parseTypeCastOrCompositeLiteralOrEnumConst
static void parseTypeCastOrCompositeLiteralOrEnumConst(Compiler *comp, const Ident *ident, const Type **type, Const *constant, bool *isVar, bool *isCall, bool *isCompLit)
{
    if (*type && (comp->lex.tok.kind == TOK_LBRACE || comp->lex.tok.kind == TOK_OR || comp->lex.tok.kind == TOK_PERIOD))
    {
        // No type to parse - use the inferred type instead, i.e., the type specified as an initial value to the type parameter of parseExpr() or parseExprList()
    }
    else
    {
        *type = parseType(comp, ident);
    }

    if (comp->lex.tok.kind == TOK_LPAR)
    {
        parseTypeCast(comp, type, constant);
        *isCompLit = false;
    }
    else if (comp->lex.tok.kind == TOK_LBRACE || comp->lex.tok.kind == TOK_OR)
    {
        parseCompositeLiteral(comp, type, constant);
        *isCompLit = true;
    }
    else if (comp->lex.tok.kind == TOK_PERIOD)
    {
        parseEnumConst(comp, type, constant);
        *isCompLit = false;
    }
    else
        comp->error.handler(comp->error.context, "Type cast or composite literal or enumeration constant expected");

    *isVar = typeStructured(*type);
    *isCall = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10b07
movq -0x8(%rbp), %rax
cmpl $0x3c, 0x4bd0(%rax)
je 0x10b05
movq -0x8(%rbp), %rax
cmpl $0x1c, 0x4bd0(%rax)
je 0x10b05
movq -0x8(%rbp), %rax
cmpl $0x43, 0x4bd0(%rax)
jne 0x10b07
jmp 0x10b1e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9b80
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
jne 0x10b48
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13460
movq 0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x10bc8
movq -0x8(%rbp), %rax
cmpl $0x3c, 0x4bd0(%rax)
je 0x10b62
movq -0x8(%rbp), %rax
cmpl $0x1c, 0x4bd0(%rax)
jne 0x10b7c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13570
movq 0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x10bc6
movq -0x8(%rbp), %rax
cmpl $0x43, 0x4bd0(%rax)
jne 0x10ba3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13640
movq 0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x10bc4
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c814b(%rip), %rsi    # 0x1d8d0b
movb $0x0, %al
callq *%rcx
jmp 0x10bc6
jmp 0x10bc8
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xcfa0
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseSelectors
static void parseSelectors(Compiler *comp, const Type **type, Const *constant, bool *isVar, bool *isCall, bool *isCompLit)
{
    while (comp->lex.tok.kind == TOK_CARET  || comp->lex.tok.kind == TOK_LBRACKET ||
           comp->lex.tok.kind == TOK_PERIOD || comp->lex.tok.kind == TOK_LPAR)
    {
        if (constant)
            comp->error.handler(comp->error.context, "Selector %s is not allowed for constants", lexSpelling(comp->lex.tok.kind));

        *isCompLit = false;

        switch (comp->lex.tok.kind)
        {
            case TOK_CARET:     parseDerefSelector(comp, type, isVar, isCall); break;
            case TOK_LBRACKET:  parseIndexSelector(comp, type, isVar, isCall); break;
            case TOK_PERIOD:    parseFieldSelector(comp, type, isVar, isCall); break;
            case TOK_LPAR:      parseCallSelector (comp, type, isVar, isCall); break;
            default:            break;
        } // switch
    } // while
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x3e, 0x4bd0(%rcx)
movb %al, -0x31(%rbp)
je 0x10c57
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x3a, 0x4bd0(%rcx)
movb %al, -0x31(%rbp)
je 0x10c57
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x43, 0x4bd0(%rcx)
movb %al, -0x31(%rbp)
je 0x10c57
movq -0x8(%rbp), %rax
cmpl $0x38, 0x4bd0(%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x10c63
jmp 0x10d43
cmpq $0x0, -0x18(%rbp)
je 0x10cad
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %edi
callq 0x1b130
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq %rax, %rdx
leaq 0x1c81f0(%rip), %rsi    # 0x1d8e99
movb $0x0, %al
callq *%rcx
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movl 0x4bd0(%rax), %eax
addl $-0x38, %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0xb, %eax
ja 0x10d3c
movq -0x50(%rbp), %rax
leaq 0x1c7959(%rip), %rcx    # 0x1d8630
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x14ad0
jmp 0x10d3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x14c20
jmp 0x10d3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x14f90
jmp 0x10d3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x15360
jmp 0x10d3e
jmp 0x10d3e
jmp 0x10c10
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseBuiltinCopyCall
static void parseBuiltinCopyCall(Compiler *comp, const Type **type, Const *constant)
{
    if (constant)
        comp->error.handler(comp->error.context, "Function is not allowed in constant expressions");

    // Dynamic array
    *type = NULL;
    parseExpr(comp, type, NULL);
    typeAssertCompatibleBuiltin(&comp->types, *type, BUILTIN_COPY, (*type)->kind == TYPE_DYNARRAY || (*type)->kind == TYPE_MAP);

    // Pointer to result (hidden parameter)
    int resultOffset = identAllocStack(&comp->idents, &comp->types, &comp->blocks, *type);
    genPushLocalPtr(&comp->gen, resultOffset);

    genCallTypedBuiltin(&comp->gen, *type, BUILTIN_COPY);
}

// 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 0x1192c
movq -0x8(%rbp), %rax
movq 0x50f8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x5118(%rax), %rdi
leaq 0x1c73b3(%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), %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, -0x1d(%rbp)
je 0x11982
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x15, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb -0x1d(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x1b, %edx
callq 0x229e0
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 -0x10(%rbp), %rax
movq (%rax), %rcx
callq 0x1a320
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movl -0x1c(%rbp), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
addq $0x4e70, %rdi           # imm = 0x4E70
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x1b, %edx
callq 0x182e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)