LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseStructType
static const Type *parseStructType(Compiler *comp)
{
    lexEat(&comp->lex, TOK_STRUCT);
    lexEat(&comp->lex, TOK_LBRACE);

    Type *type = typeAdd(&comp->types, &comp->blocks, TYPE_STRUCT);

    while (comp->lex.tok.kind == TOK_IDENT)
    {
        IdentName fieldNames[MAX_IDENTS_IN_LIST];
        bool fieldExported[MAX_IDENTS_IN_LIST];
        const Type *fieldType = NULL;
        int numFields = 0;
        parseTypedIdentList(comp, fieldNames, fieldExported, MAX_IDENTS_IN_LIST, &numFields, &fieldType, false);

        for (int i = 0; i < numFields; i++)
        {
            typeAddField(&comp->types, type, fieldType, fieldNames[i]);
            if (fieldExported[i])
                comp->error.handler(comp->error.context, "Field %s cannot be exported", fieldNames[i]);
        }

        lexEat(&comp->lex, TOK_SEMICOLON);
    }
    lexEat(&comp->lex, TOK_RBRACE);
    return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10128, %rsp          # imm = 0x10128
movq %rdi, %r14
leaq 0x4ba8(%rdi), %rbx
movq %rbx, %rdi
movl $0x11, %esi
callq 0x1b41f
movq %rbx, %rdi
movl $0x3c, %esi
callq 0x1b41f
leaq 0x4e18(%r14), %rdi
leaq 0x4220(%r14), %rsi
movq %rdi, %r12
movl $0x16, %edx
callq 0x1ea48
movq %rax, 0x10(%rsp)
cmpl $0x45, 0x4bd0(%r14)
jne 0x105a7
movq %rbx, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq %r14, %rdi
leaq 0x120(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl $0x100, %ecx            # imm = 0x100
leaq 0xc(%rsp), %r8
callq 0x10647
movq %rbx, %rdi
movl $0x41, %esi
callq 0x1b41f
movq %r14, %rdi
xorl %esi, %esi
callq 0xfb34
movslq 0xc(%rsp), %rbp
testq %rbp, %rbp
jle 0x10587
movq %rax, %r13
leaq 0x120(%rsp), %rbx
xorl %r15d, %r15d
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1f6e2
cmpb $0x1, 0x20(%rsp,%r15)
jne 0x10578
movq 0x5118(%r14), %rdi
leaq 0x66d2a(%rip), %rsi     # 0x77296
movq %rbx, %rdx
xorl %eax, %eax
callq *0x50f8(%r14)
incq %r15
addq $0x100, %rbx            # imm = 0x100
cmpq %r15, %rbp
jne 0x10543
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0x40, %esi
callq 0x1b41f
cmpl $0x45, 0x4bd0(%r14)
je 0x104ed
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x1b41f
movq 0x10(%rsp), %rax
addq $0x10128, %rsp          # imm = 0x10128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseShortVarDecl
void parseShortVarDecl(Compiler *comp)
{
    IdentName varNames[MAX_IDENTS_IN_LIST];
    bool varExported[MAX_IDENTS_IN_LIST];
    int numVars = 0;
    parseIdentList(comp, varNames, varExported, MAX_IDENTS_IN_LIST, &numVars);

    lexEat(&comp->lex, TOK_COLONEQ);
    parseDeclAssignmentStmt(comp, varNames, varExported, numVars, comp->blocks.top == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10118, %rsp          # imm = 0x10118
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x110(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
movl $0x100, %ecx            # imm = 0x100
movq %r14, %r8
callq 0x10647
leaq 0x4ba8(%rbx), %rdi
movl $0x37, %esi
callq 0x1b41f
movl (%r14), %ecx
xorl %r8d, %r8d
cmpl $0x0, 0x4b84(%rbx)
sete %r8b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1c75e
addq $0x10118, %rsp          # imm = 0x10118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseIdentList
static void parseIdentList(Compiler *comp, IdentName *names, bool *exported, int capacity, int *num)
{
    *num = 0;
    while (1)
    {
        lexCheck(&comp->lex, TOK_IDENT);

        if (*num >= capacity)
            comp->error.handler(comp->error.context, "Too many identifiers");
        strcpy(names[*num], comp->lex.tok.name);

        lexNext(&comp->lex);
        exported[*num] = parseExportMark(comp);
        (*num)++;

        if (comp->lex.tok.kind != TOK_COMMA)
            break;
        lexNext(&comp->lex);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl $0x0, (%r8)
leaq 0x4ba8(%rdi), %r13
leaq 0x4bd8(%rdi), %rbp
movq %r13, %rdi
movl $0x45, %esi
callq 0x1b3c8
movl 0xc(%rsp), %eax
cmpl %eax, (%rbx)
jl 0x106aa
movq 0x5118(%r12), %rdi
leaq 0x66d6f(%rip), %rsi     # 0x7740f
xorl %eax, %eax
callq *0x50f8(%r12)
movslq (%rbx), %rdi
shlq $0x8, %rdi
addq %r15, %rdi
movq %rbp, %rsi
callq 0x30a0
movq %r13, %rdi
callq 0x1a984
movl 0x4bd0(%r12), %r14d
cmpl $0x18, %r14d
jne 0x106da
movq %r13, %rdi
callq 0x1b39a
cmpl $0x18, %r14d
movslq (%rbx), %rax
movq 0x10(%rsp), %rcx
sete (%rcx,%rax)
incl %eax
movl %eax, (%rbx)
cmpl $0x3f, 0x4bd0(%r12)
jne 0x10706
movq %r13, %rdi
callq 0x1a984
jmp 0x1067c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseProgram
void parseProgram(Compiler *comp)
{
    // Entry point stub
    genNop(&comp->gen);

    lexNext(&comp->lex);
    int mainModule = parseModule(comp);

    // Entry point
    genEntryPoint(&comp->gen, 0);

    const Ident *mainFn = identFind(&comp->idents, &comp->modules, &comp->blocks, mainModule, "main", NULL, false);
    if (mainFn && identIsMain(mainFn))
    {
        genPushZero(&comp->gen, sizeof(Interface) / sizeof(Slot));  // Dummy upvalue
        genCall(&comp->gen, mainFn->offset);
    }

    doGarbageCollection(comp);
    genHalt(&comp->gen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4e70(%rdi), %rbx
movq %rbx, %rdi
callq 0x17df7
leaq 0x4ba8(%r14), %rdi
callq 0x1a984
movq %r14, %rdi
callq 0x10c82
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x195ac
leaq 0x4e38(%r14), %rdi
leaq 0x100(%r14), %rsi
leaq 0x4220(%r14), %rdx
movl $0x0, (%rsp)
leaq 0x665c2(%rip), %r8      # 0x771f0
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x19a9d
testq %rax, %rax
je 0x10c68
movq %rax, %r15
movq %rax, %rdi
callq 0x1a6aa
testb %al, %al
je 0x10c68
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1813d
movl 0x120(%r15), %esi
movq %rbx, %rdi
callq 0x18c2b
movq %r14, %rdi
callq 0x1bef8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18f70
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseModule
static int parseModule(Compiler *comp)
{
    comp->blocks.module = moduleAdd(&comp->modules, comp->lex.fileName);

    if (comp->lex.tok.kind == TOK_IMPORT)
    {
        parseImport(comp);
        lexEat(&comp->lex, TOK_SEMICOLON);
    }
    parseDecls(comp);
    doResolveExtern(comp);

    comp->modules.module[comp->blocks.module]->isCompiled = true;
    return comp->blocks.module;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x100, %rdi            # imm = 0x100
leaq 0x4ba8(%rbx), %r14
movq 0x4ba8(%rbx), %rsi
callq 0xd137
movl %eax, 0x4b88(%rbx)
cmpl $0xa, 0x4bd0(%rbx)
jne 0x10d1b
movq %r14, %rdi
movl $0xa, %esi
callq 0x1b41f
cmpl $0x38, 0x4bd0(%rbx)
jne 0x10cf7
movq %r14, %rdi
callq 0x1a984
movl 0x4bd0(%rbx), %eax
cmpl $0x49, %eax
je 0x10ce0
cmpl $0x45, %eax
jne 0x10d01
movq %rbx, %rdi
callq 0x11776
movq %r14, %rdi
movl $0x40, %esi
callq 0x1b41f
jmp 0x10cd0
movq %rbx, %rdi
callq 0x11776
jmp 0x10d0e
movq %r14, %rdi
movl $0x39, %esi
callq 0x1b41f
movq %r14, %rdi
movl $0x40, %esi
callq 0x1b41f
movq %rbx, %rdi
callq 0x10715
cmpl $0x4c, 0x4bd0(%rbx)
jne 0x10d0e
movq %rbx, %rdi
callq 0x1c0f3
movslq 0x4b88(%rbx), %rax
movq 0x100(%rbx,%rax,8), %rcx
movb $0x1, 0x2310(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseTypeOrForwardType
static const Type *parseTypeOrForwardType(Compiler *comp)
{
    const Type *type = NULL;

    // Forward declaration?
    bool forward = false;
    if (comp->types.forwardTypesEnabled && comp->lex.tok.kind == TOK_IDENT)
    {
        const Ident *ident = NULL;

        Lexer lookaheadLex = comp->lex;
        lexNext(&lookaheadLex);
        if (lookaheadLex.tok.kind == TOK_COLONCOLON)
            ident = identFindModule(&comp->idents, &comp->modules, &comp->blocks, comp->blocks.module, comp->lex.tok.name, true);
        else
            ident = identFind(&comp->idents, &comp->modules, &comp->blocks, comp->blocks.module, comp->lex.tok.name, NULL, true);

        if (!ident)
        {
            Type *forwardType = typeAdd(&comp->types, &comp->blocks, TYPE_FORWARD);
            forwardType->typeIdent = identAddType(&comp->idents, &comp->modules, &comp->blocks, comp->lex.tok.name, forwardType, false);
            identSetUsed(forwardType->typeIdent);

            lexNext(&comp->lex);

            type = forwardType;
            forward = true;
        }
    }

    // Conventional declaration
    if (!forward)
        type = parseType(comp, NULL);

    return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rdi, %rbx
cmpb $0x1, 0x4e20(%rdi)
jne 0x10de2
cmpl $0x45, 0x4bd0(%rbx)
jne 0x10de2
leaq 0x4ba8(%rbx), %rsi
leaq 0x18(%rsp), %r14
movl $0x270, %edx            # imm = 0x270
movq %r14, %rdi
movq %rsi, 0x10(%rsp)
callq 0x3260
movq %r14, %rdi
callq 0x1a984
leaq 0x4e38(%rbx), %rdi
leaq 0x100(%rbx), %r12
leaq 0x4220(%rbx), %r13
leaq 0x4bd8(%rbx), %rbp
cmpl $0x42, 0x28(%r14)
movl 0x4b88(%rbx), %ecx
movq %rdi, 0x8(%rsp)
jne 0x10e0f
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %r8
movl $0x1, %r9d
callq 0x19d0a
jmp 0x10e27
xorl %r15d, %r15d
xorl %r14d, %r14d
testb %r15b, %r15b
jne 0x10dfa
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfb34
movq %rax, %r14
movq %r14, %rax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, (%rsp)
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x19a9d
testq %rax, %rax
sete %r15b
jne 0x10de5
leaq 0x4e18(%rbx), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x1ea48
movq %rax, %r14
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1a25d
movq %rax, 0x18(%r14)
movb $0x1, 0x11a(%rax)
movq 0x10(%rsp), %rdi
callq 0x1a984
jmp 0x10de8
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseTypedIdentList
static void parseTypedIdentList(Compiler *comp, IdentName *names, bool *exported, int capacity, int *num, const Type **type, bool allowVariadicParamList)
{
    parseIdentList(comp, names, exported, capacity, num);
    lexEat(&comp->lex, TOK_COLON);

    if (allowVariadicParamList && comp->lex.tok.kind == TOK_ELLIPSIS)
    {
        if (*num != 1)
            comp->error.handler(comp->error.context, "Only one variadic parameter list is allowed");

        lexNext(&comp->lex);
        const Type *itemType = parseType(comp, NULL);
        if (itemType->kind == TYPE_VOID)
            comp->error.handler(comp->error.context, "Variadic parameters cannot be void");

        Type *variadicListType = typeAdd(&comp->types, &comp->blocks, TYPE_DYNARRAY);
        variadicListType->base = itemType;
        variadicListType->isVariadicParamList = true;
        *type = variadicListType;
    }
    else
        *type = parseType(comp, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r12
movq %rdi, %r14
movb 0x30(%rsp), %bpl
callq 0x10647
leaq 0x4ba8(%r14), %r15
movq %r15, %rdi
movl $0x41, %esi
callq 0x1b41f
testb %bpl, %bpl
je 0x10f2c
cmpl $0x44, 0x4bd0(%r14)
jne 0x10f2c
cmpl $0x1, (%r12)
je 0x10ed6
movq 0x5118(%r14), %rdi
leaq 0x663e5(%rip), %rsi     # 0x772b2
xorl %eax, %eax
callq *0x50f8(%r14)
movq %r15, %rdi
callq 0x1a984
movq %r14, %rdi
xorl %esi, %esi
callq 0xfb34
movq %rax, %r15
cmpl $0x2, (%rax)
jne 0x10f07
movq 0x5118(%r14), %rdi
leaq 0x663e0(%rip), %rsi     # 0x772de
xorl %eax, %eax
callq *0x50f8(%r14)
leaq 0x4e18(%r14), %rdi
addq $0x4220, %r14           # imm = 0x4220
movq %r14, %rsi
movl $0x13, %edx
callq 0x1ea48
movq %r15, 0x8(%rax)
movb $0x1, 0x15(%rax)
jmp 0x10f36
movq %r14, %rdi
xorl %esi, %esi
callq 0xfb34
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseTypeDeclItem
static void parseTypeDeclItem(Compiler *comp)
{
    lexCheck(&comp->lex, TOK_IDENT);
    IdentName name;
    strcpy(name, comp->lex.tok.name);

    lexNext(&comp->lex);
    bool exported = parseExportMark(comp);

    lexEat(&comp->lex, TOK_EQ);

    const Type *type = parseType(comp, NULL);
    Type *newType = typeAdd(&comp->types, &comp->blocks, type->kind);
    typeDeepCopy(&comp->storage, newType, type);
    newType->typeIdent = identAddType(&comp->idents, &comp->modules, &comp->blocks, name, newType, exported);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq 0x4ba8(%rdi), %r14
movq %r14, %rdi
movl $0x45, %esi
callq 0x1b3c8
leaq 0x4bd8(%rbx), %rsi
movq %rsp, %rdi
callq 0x30a0
movq %r14, %rdi
callq 0x1a984
movl 0x4bd0(%rbx), %r15d
cmpl $0x18, %r15d
jne 0x112cd
movq %r14, %rdi
callq 0x1b39a
xorl %ebp, %ebp
cmpl $0x18, %r15d
sete %bpl
movq %r14, %rdi
movl $0x31, %esi
callq 0x1b41f
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfb34
movq %rax, %r14
leaq 0x4e18(%rbx), %rdi
leaq 0x4220(%rbx), %r15
movl (%rax), %edx
movq %r15, %rsi
callq 0x1ea48
movq %rax, %r12
leaq 0xf0(%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1ec6f
leaq 0x4e38(%rbx), %rdi
addq $0x100, %rbx            # imm = 0x100
movq %rsp, %rcx
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %r8
movl %ebp, %r9d
callq 0x1a25d
movq %rax, 0x18(%r12)
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
cmpl $0xb, %eax
jne 0x11aba
addq $0x4e70, %rdi           # imm = 0x4E70
movq (%rdx), %rsi
jmp 0x17ef6
leal -0x4(%rax), %ecx
cmpl $0xa, %ecx
setae %cl
cmpl $0x1a, %eax
setne %sil
testb %cl, %sil
jne 0x11ade
addq $0x4e70, %rdi           # imm = 0x4E70
movq (%rdx), %rsi
jmp 0x17eca
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0x11af8
addq $0x4e70, %rdi           # imm = 0x4E70
movsd (%rdx), %xmm0
jmp 0x17f22
leal -0x12(%rax), %ecx
cmpl $0x8, %ecx
jae 0x11b0f
addq $0x4e70, %rdi           # imm = 0x4E70
movq (%rdx), %rsi
jmp 0x17f4c
cmpl $0x11, %eax
je 0x11aab
cmpl $0x10, %eax
je 0x11b00
movq 0x50f8(%rdi), %rcx
movq 0x5118(%rdi), %rdi
leaq 0x654e2(%rip), %rsi     # 0x77010
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x4e40(%rdi)
je 0x11c0a
pushq %rbx
movq %rdi, %rbx
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0x19729
movl %eax, %ecx
testl %eax, %eax
setne %al
je 0x11c08
movslq %ecx, %rax
movq 0x4e40(%rbx), %rcx
cmpq %rax, 0x120(%rcx)
je 0x11bf8
movq 0x5118(%rbx), %rdi
leaq 0x65b74(%rip), %rsi     # 0x77764
xorl %eax, %eax
callq *0x50f8(%rbx)
movq 0x4e40(%rbx), %rax
movb $0x0, 0x11a(%rax)
movb $0x1, %al
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rcx, %rcx
je 0x12858
movl (%r14), %eax
movq (%rbx), %rdx
movl (%rdx), %esi
movq (%rcx), %rdx
testq %rdx, %rdx
sets %r8b
cmpl $0xb, %esi
sete %cl
leal -0x4(%rax), %r9d
cmpl $0x16, %r9d
ja 0x128e3
andb %r8b, %cl
leaq 0x64d3f(%rip), %r8      # 0x77584
movslq (%r8,%r9,4), %r9
addq %r8, %r9
jmpq *%r9
cmpq $0x100, %rdx            # imm = 0x100
jmp 0x12882
addq $0x4e70, %rdi           # imm = 0x4E70
movl (%r14), %esi
movq (%rbx), %rdx
callq 0x18af0
jmp 0x1290a
movswq %dx, %rsi
jmp 0x128d7
cmpq $0x10000, %rdx          # imm = 0x10000
jmp 0x12882
cmpq $0x2, %rdx
setae %cl
jmp 0x128df
btrq $0x3f, %rdx
movq %rdx, %xmm0
ucomisd 0x64717(%rip), %xmm0    # 0x76fb0
jmp 0x128b6
shrq $0x20, %rdx
setne %cl
jmp 0x128df
btrq $0x3f, %rdx
movq %rdx, %xmm0
ucomisd 0x646f2(%rip), %xmm0    # 0x76fa8
seta %cl
jmp 0x128df
movslq %edx, %rsi
jmp 0x128d7
testq %rdx, %rdx
sets %dl
andl $-0x4, %esi
cmpl $0x4, %esi
sete %cl
andb %dl, %cl
jmp 0x128df
movsbq %dl, %rsi
cmpq %rdx, %rsi
setne %dl
orb %dl, %cl
testb %cl, %cl
je 0x1290a
movq 0x50f8(%rdi), %r12
movq 0x5118(%rdi), %r15
movl %eax, %edi
callq 0x1fe46
leaq 0x64939(%rip), %rsi     # 0x77238
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq *%r12
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x12949
movq 0x5118(%r15), %rdi
leaq 0x6517c(%rip), %rsi     # 0x77abc
xorl %eax, %eax
callq *0x50f8(%r15)
testb %bpl, %bpl
je 0x1295a
leaq 0x4e70(%r15), %rdi
callq 0x1827d
leaq 0x4e70(%r15), %r12
movq (%rbx), %rsi
movq %r12, %rdi
movl $0x1a, %edx
callq 0x18ec4
leaq 0x4e38(%r15), %rdi
leaq 0x4e18(%r15), %rsi
leaq 0x100(%r15), %rdx
addq $0x4220, %r15           # imm = 0x4220
movq %r15, %rcx
movq %r14, %r8
movl $0x1, %r9d
callq 0x1a429
movl 0x120(%rax), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x196d8
testb %bpl, %bpl
je 0x129bc
movq %r12, %rdi
callq 0x1827d
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x12a1c
movq %rcx, %r12
movq (%rcx), %rax
movslq -0x10(%rax), %r13
addq $0xf0, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xcd80
movq %rax, %r15
movq 0x10(%rax), %rdi
movq (%r12), %rsi
movq %r13, %rdx
callq 0x3260
movq %r15, (%r12)
jmp 0x12a9d
leaq 0x4e38(%r15), %r12
leaq 0x4e18(%r15), %r13
leaq 0x4220(%r15), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x1a2d1
movq %rbx, (%rsp)
leaq 0x4e70(%r15), %rbx
movq %rbx, %rdi
movl %eax, %esi
callq 0x17f78
movq %rbx, %rdi
movq %r14, %rsi
movl $0x18, %edx
callq 0x18ec4
addq $0x100, %r15            # imm = 0x100
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
movl $0x1, %r9d
callq 0x1a429
movl 0x120(%rax), %edx
movq %rbx, %rdi
movq (%rsp), %rbx
movq %r14, %rsi
callq 0x196d8
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rdi, %rbx
leaq 0x4ba8(%rdi), %r15
movq %r15, %rdi
movl $0x45, %esi
callq 0x1b3c8
leaq 0x4220(%rbx), %r14
movl 0x4b88(%rbx), %ebp
movq %rsp, %r12
movl $0x270, %edx            # imm = 0x270
movq %r12, %rdi
movq %r15, %rsi
callq 0x3260
movq %r12, %rdi
callq 0x1a984
cmpl $0x42, 0x28(%r12)
jne 0x12d3d
leaq 0x4e38(%rbx), %rdi
leaq 0x100(%rbx), %rsi
movl 0x4b88(%rbx), %ecx
leaq 0x4bd8(%rbx), %r8
movq %r14, %rdx
callq 0x19d1f
movq %rax, %r12
movq %r15, %rdi
callq 0x1a984
movq %r15, %rdi
callq 0x1a984
movq %r15, %rdi
movl $0x45, %esi
callq 0x1b3c8
movl 0x120(%r12), %ebp
leaq 0x4e38(%rbx), %rdi
leaq 0x100(%rbx), %rsi
leaq 0x4bd8(%rbx), %r8
movq %r14, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x19ccb
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x19d64
testb %al, %al
je 0x12d8e
movq 0x5118(%rbx), %rdi
movq %r15, %rdx
addq $0x4, %rdx
leaq 0x649fe(%rip), %rsi     # 0x77784
xorl %eax, %eax
callq *0x50f8(%rbx)
movq %r15, %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseDesignatorList
void parseDesignatorList(Compiler *comp, const Type **type, Const *constant, bool *isVar, bool *isCall, bool *isCompLit)
{
    parseDesignator(comp, type, constant, isVar, isCall, isCompLit);

    if (comp->lex.tok.kind == TOK_COMMA && (*isVar) && !(*isCall) && !(*isCompLit))
    {
        // Designator list (types formally encoded as structure field types - not a real structure)
        if (constant)
            comp->error.handler(comp->error.context, "Designator lists are not allowed for constants");

        const Type *fieldType = *type;

        Type *designatorListType = typeAdd(&comp->types, &comp->blocks, TYPE_STRUCT);
        designatorListType->isExprList = true;

        while (1)
        {
            typeAddField(&comp->types, designatorListType, fieldType, NULL);

            if (comp->lex.tok.kind != TOK_COMMA)
                break;

            lexNext(&comp->lex);

            bool fieldIsVar, fieldIsCall, fieldIsCompLit;
            parseDesignator(comp, &fieldType, NULL, &fieldIsVar, &fieldIsCall, &fieldIsCompLit);

            if (!fieldIsVar || fieldIsCall || fieldIsCompLit)
                comp->error.handler(comp->error.context, "Inconsistent designator list");
        }

        *type = designatorListType;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12ee0
cmpl $0x3f, 0x4bd0(%r14)
jne 0x12ed1
cmpb $0x1, (%rbp)
jne 0x12ed1
cmpb $0x0, (%r13)
jne 0x12ed1
cmpb $0x0, (%r12)
jne 0x12ed1
testq %r15, %r15
je 0x12e10
movq 0x5118(%r14), %rdi
leaq 0x649a8(%rip), %rsi     # 0x777af
xorl %eax, %eax
callq *0x50f8(%r14)
movq (%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x4e18(%r14), %r15
leaq 0x4220(%r14), %rsi
movq %r15, %rdi
movl $0x16, %edx
callq 0x1ea48
movq %rax, %r12
movb $0x1, 0x14(%rax)
movq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x1f6e2
cmpl $0x3f, 0x4bd0(%r14)
jne 0x12ece
leaq 0x4ba8(%r14), %r13
leaq 0xd(%rsp), %rbp
movq %r13, %rdi
callq 0x1a984
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
movq %rbp, %r9
callq 0x12ee0
cmpb $0x1, 0xf(%rsp)
jne 0x12e9b
cmpb $0x0, 0xe(%rsp)
jne 0x12e9b
cmpb $0x1, 0xd(%rsp)
jne 0x12eb2
movq 0x5118(%r14), %rdi
leaq 0x64935(%rip), %rsi     # 0x777de
xorl %eax, %eax
callq *0x50f8(%r14)
movq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x1f6e2
cmpl $0x3f, 0x4bd0(%r14)
je 0x12e62
movq %r12, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x16eca
movq 0x5118(%r15), %rdi
leaq 0x60b38(%rip), %rsi     # 0x779f9
xorl %eax, %eax
callq *0x50f8(%r15)
leaq 0x4e38(%r15), %rdi
leaq 0x4e18(%r15), %r12
leaq 0x4220(%r15), %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x1a2d1
movl %eax, %ebp
addq $0x4e70, %r15           # imm = 0x4E70
movq %r15, %rdi
movl %eax, %esi
callq 0x17f78
movq %r12, %rdi
movq %r14, %rsi
callq 0x1ede7
movq %r15, %rdi
movl %eax, %esi
callq 0x18289
movq 0x28(%r14), %rax
movq (%rax), %rax
movl 0x110(%rax), %esi
addl %ebp, %esi
movq %r15, %rdi
callq 0x17f78
movq %r15, %rdi
movl $0x1a, %esi
xorl %edx, %edx
callq 0x183d5
movq %r15, %rdi
movl %ebp, %esi
callq 0x17f78
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x4e70(%rdi), %r14
leaq 0x4e18(%rdi), %r12
movq 0x8(%rsi), %rsi
movq %r12, %rdi
callq 0x1ede7
movslq %eax, %rsi
movq %r14, %rdi
callq 0x17eca
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x15, %edx
callq 0x18ec4
movq %r14, %rdi
callq 0x18271
movq %r14, %rdi
movl $0x2, %esi
callq 0x181fd
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x18659
movq %r14, %rdi
movl $0x2, %esi
callq 0x180b4
leaq 0x4e38(%r15), %rdi
leaq 0x100(%r15), %rdx
addq $0x4220, %r15           # imm = 0x4220
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x1a429
movl 0x120(%rax), %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x196d8
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq (%rsi), %rax
movl (%rax), %ecx
cmpl $0x10, %ecx
jne 0x175b2
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rax), %rdx
cmpl $0x10, (%rdx)
jne 0x17565
addq $0x4e70, %r14           # imm = 0x4E70
movq %r14, %rdi
movl $0x10, %esi
callq 0x182ba
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
jmp 0x175b2
cmpl $0x10, %ecx
jne 0x175b2
movq 0x8(%rax), %rax
cmpl $0x11, (%rax)
jne 0x175b2
leaq 0x4e70(%r14), %r15
movq %r15, %rdi
movl $0x11, %esi
callq 0x182ba
movq %r15, %rdi
callq 0x18b2f
leaq 0x4e18(%r14), %rdi
addq $0x4220, %r14           # imm = 0x4220
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %r14, %rsi
callq 0x1edd3
jmp 0x17560
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11bac
testb %al, %al
jne 0x175e2
leaq 0x4e70(%r14), %rdi
movl $0x2c, %esi
movq %rbx, %rdx
callq 0x18496
movl (%rbx), %ebp
cmpl $0x18, %ebp
ja 0x17622
movl $0x1ec7770, %eax        # imm = 0x1EC7770
btl %ebp, %eax
jae 0x17622
leaq 0x4e70(%r14), %r15
addq $0x4e18, %r14           # imm = 0x4E18
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ede7
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18460
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseLogicalTerm
static void parseLogicalTerm(Compiler *comp, const Type **type, Const *constant)
{
    parseRelation(comp, type, constant);

    while (comp->lex.tok.kind == TOK_ANDAND)
    {
        TokenKind op = comp->lex.tok.kind;
        lexNext(&comp->lex);

        if (constant)
        {
            if (constant->intVal)
            {
                Const rightConstantBuf, *rightConstant = &rightConstantBuf;

                const Type *rightType = *type;
                parseRelation(comp, &rightType, rightConstant);
                doApplyOperator(comp, type, &rightType, constant, rightConstant, op, false, true);
                constant->intVal = rightConstant->intVal;
            }
            else
                constant->intVal = false;
        }
        else
        {
            genShortCircuitProlog(&comp->gen);

            blocksEnter(&comp->blocks);

            const Type *rightType = *type;
            parseRelation(comp, &rightType, NULL);
            doApplyOperator(comp, type, &rightType, NULL, NULL, op, false, true);

            doGarbageCollection(comp);
            identWarnIfUnusedAll(&comp->idents, blocksCurrent(&comp->blocks));
            blocksLeave(&comp->blocks);

            genShortCircuitEpilog(&comp->gen, op);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, 0x18(%rsp)
callq 0x177a6
cmpl $0x2a, 0x4bd0(%r15)
jne 0x17797
leaq 0x4ba8(%r15), %r12
leaq 0x4e70(%r15), %rax
movq %rax, 0x10(%rsp)
leaq 0x4220(%r15), %rax
movq %rax, 0x20(%rsp)
leaq 0x4e38(%r15), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
callq 0x1a984
testq %rbx, %rbx
je 0x176ef
cmpq $0x0, (%rbx)
je 0x17782
movq 0x18(%rsp), %r14
movq (%r14), %rax
movq %rax, 0x30(%rsp)
movq %r15, %rdi
leaq 0x30(%rsp), %rbp
movq %rbp, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x177a6
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r13, %r8
movl $0x2a, %r9d
pushq $0x1
pushq $0x0
callq 0x12aaf
addq $0x10, %rsp
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x17789
movq 0x10(%rsp), %rdi
callq 0x19470
movq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xd774
movq 0x18(%rsp), %r13
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rbp
leaq 0x8(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x177a6
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %r12
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x2a, %r9d
pushq $0x1
pushq $0x0
callq 0x12aaf
addq $0x10, %rsp
movq %r15, %rdi
callq 0x1bef8
movq %r14, %rdi
callq 0xd824
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x1a60e
movq %r14, %rdi
callq 0xd7f2
movq 0x10(%rsp), %rdi
movl $0x2a, %esi
callq 0x194cc
jmp 0x17789
movq $0x0, (%rbx)
cmpl $0x2a, 0x4bd0(%r15)
je 0x17684
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1784c
movl 0x4bd0(%r14), %r12d
cmpq $0x36, %r12
ja 0x1783d
movabsq $0x71c00000000000, %rax # imm = 0x71C00000000000
btq %r12, %rax
jae 0x1783d
leaq 0x4ba8(%r14), %rdi
callq 0x1a984
testq %r15, %r15
leaq 0x10(%rsp), %r13
cmoveq %r15, %r13
movq (%rbx), %rax
leaq 0x8(%rsp), %rbp
movq %rax, (%rbp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1784c
movl $0x1, %eax
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movl %r12d, %r9d
pushq %rax
pushq %rax
callq 0x12aaf
addq $0x10, %rsp
movq 0x5268(%r14), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x178f8
testq %rbx, %rbx
leaq 0x20(%rsp), %r12
movq %rbx, 0x10(%rsp)
cmoveq %rbx, %r12
leaq 0x4ba8(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rbp
movl $0x1, %r13d
movl 0x4bd0(%r15), %ebx
cmpl $0x1d, %ebx
ja 0x178e9
movl $0x30c00000, %eax       # imm = 0x30C00000
btl %ebx, %eax
jae 0x178e9
movq 0x8(%rsp), %rdi
callq 0x1a984
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x178f8
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
movl %ebx, %r9d
pushq %r13
pushq %r13
callq 0x12aaf
addq $0x10, %rsp
jmp 0x17890
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x179a5
leaq 0x4ba8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rbx, %rbx
leaq 0x20(%rsp), %r13
movq %rbx, 0x10(%rsp)
cmoveq %rbx, %r13
leaq 0x18(%rsp), %rbp
movl $0x1, %r12d
movl 0x4bd0(%r15), %ebx
leal -0x18(%rbx), %eax
cmpl $0x4, %eax
jb 0x17953
leal -0x1e(%rbx), %eax
cmpl $0x1, %eax
ja 0x17996
movq 0x8(%rsp), %rdi
callq 0x1a984
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x179a5
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movl %ebx, %r9d
pushq %r12
pushq %r12
callq 0x12aaf
addq $0x10, %rsp
jmp 0x1793c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x1c0(%rdi)
movabsq $0x3e800000000, %rcx    # imm = 0x3E800000000
movq %rcx, 0x8(%rdi)
movl $0x7d00, %esi           # imm = 0x7D00
movq %rax, %rdi
callq 0xcca8
movq %rax, (%rbx)
movl $0xffffffff, 0x1a0(%rbx) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x1a4(%rbx)
movups %xmm0, 0x1b0(%rbx)
movq %r15, 0x1c8(%rbx)
movq 0x1c0(%rbx), %rdi
movslq 0xc(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
callq 0xcca8
movq %rax, 0x1d0(%rbx)
movq %r14, 0x1e0(%rbx)
movl $0x0, 0x1d8(%rbx)
movl 0x8(%rbx), %eax
movl %eax, 0x1dc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0xc(%rdi), %rdx
cmpl %edx, 0x8(%rdi)
jl 0x17e67
leal (%rdx,%rdx), %eax
movl %eax, 0xc(%rbx)
movq (%rbx), %rsi
movq 0x1c0(%rbx), %rdi
shlq $0x6, %rdx
callq 0xce23
movq %rax, (%rbx)
movq 0x1c0(%rbx), %rdi
movq 0x1d0(%rbx), %rsi
movslq 0xc(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
callq 0xce23
movq %rax, 0x1d0(%rbx)
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
shlq $0x5, %rcx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq 0x1c8(%rbx), %rax
movq 0x1d0(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movl $0x0, 0x1d8(%rbx)
movl %eax, 0x1dc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genPushZero
static Instruction *getPrevInstr(CodeGen *gen, int depth)
{
    // No branching within the peephole
    if (gen->ip - depth < gen->lastJump)
        return NULL;

    return &gen->code[gen->ip - depth];
}

// Assembly:
movslq 0x8(%rdi), %rax
cmpl 0x1a4(%rdi), %eax
jle 0x18159
movq (%rdi), %rcx
shlq $0x5, %rax
addq %rcx, %rax
addq $-0x20, %rax
jmp 0x1815b
xorl %eax, %eax
testq %rax, %rax
je 0x18180
cmpl $0x2, (%rax)
jne 0x18180
movslq %esi, %rcx
addq %rcx, 0x18(%rax)
movl $0x0, 0x1d8(%rdi)
movl 0x8(%rdi), %eax
movl %eax, 0x1dc(%rdi)
retq
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x2, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x17e12
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genChangeRefCntAssign
void genChangeRefCntAssign(CodeGen *gen, const Type *type)
{
    if (typeGarbageCollected(type))
    {
        const Instruction instr = {.opcode = OP_CHANGE_REF_CNT_ASSIGN, .tokKind = TOK_NONE, .type = type};
        genAddInstr(gen, &instr);
    }
    else
        genAssign(gen, type->kind, type->size);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1eeaf
testb %al, %al
je 0x1861d
movss 0x5f9c9(%rip), %xmm0    # 0x77fd0
leaq 0x8(%rsp), %rsi
movups %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
jmp 0x18649
movl (%r14), %eax
movslq 0xc0(%r14), %rcx
leaq 0x8(%rsp), %rsi
movq $0xe, (%rsi)
movl $0x0, 0x8(%rsi)
movl %eax, 0xc(%rsi)
movq $0x0, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rbx, %rdi
callq 0x17e12
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genSwapChangeRefCntAssign
void genSwapChangeRefCntAssign(CodeGen *gen, const Type *type)
{
    if (typeGarbageCollected(type))
    {
        const Instruction instr = {.opcode = OP_CHANGE_REF_CNT_ASSIGN, .inlineOpcode = OP_SWAP, .tokKind = TOK_NONE, .type = type};
        genAddInstr(gen, &instr);
    }
    else
        genSwapAssign(gen, type->kind, type->size);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1eeaf
testb %al, %al
je 0x186a0
movsd 0x5f904(%rip), %xmm0    # 0x77f80
leaq 0x8(%rsp), %rsi
movups %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movq %rbx, %rdi
callq 0x17e12
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl (%r14), %esi
movl 0xc0(%r14), %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x183d5
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genChangeLeftRefCntAssign
void genChangeLeftRefCntAssign(CodeGen *gen, const Type *type)
{
    if (typeGarbageCollected(type))
    {
        const Instruction instr = {.opcode = OP_CHANGE_REF_CNT_ASSIGN, .tokKind = TOK_MINUSMINUS, .type = type};
        genAddInstr(gen, &instr);
    }
    else
        genAssign(gen, type->kind, type->size);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1eeaf
testb %al, %al
je 0x186f1
movaps 0x5f8b5(%rip), %xmm0    # 0x77f90
leaq 0x8(%rsp), %rsi
movups %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
jmp 0x1871d
movl (%r14), %eax
movslq 0xc0(%r14), %rcx
leaq 0x8(%rsp), %rsi
movq $0xe, (%rsi)
movl $0x0, 0x8(%rsi)
movl %eax, 0xc(%rsi)
movq $0x0, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rbx, %rdi
callq 0x17e12
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoto
void genGoto(CodeGen *gen, int dest)
{
    genUpdateLastJump(gen, gen->ip);
    genUpdateLastJump(gen, dest);

    const Instruction instr = {.opcode = OP_GOTO, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.intVal = dest};
    genAddInstr(gen, &instr);
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl %eax, 0x1a4(%rdi)
jge 0x18b4c
movl %eax, 0x1a4(%rdi)
cmpl %esi, 0x1a4(%rdi)
jge 0x18b5a
movl %esi, 0x1a4(%rdi)
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x1e, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x17e12
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGotoIf
void genGotoIf(CodeGen *gen, int dest)
{
    genUpdateLastJump(gen, gen->ip);
    genUpdateLastJump(gen, dest);

    const Instruction instr = {.opcode = OP_GOTO_IF, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.intVal = dest};
    genAddInstr(gen, &instr);
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl %eax, 0x1a4(%rdi)
jge 0x18b9c
movl %eax, 0x1a4(%rdi)
cmpl %esi, 0x1a4(%rdi)
jge 0x18baa
movl %esi, 0x1a4(%rdi)
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x1f, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x17e12
addq $0x28, %rsp
retq