LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7868
leaq 0x4ba8(%r14), %r15
pushq $0x41
popq %rsi
movq %r15, %rdi
callq 0x118d3
testb %bpl, %bpl
je 0x813f
cmpl $0x44, 0x4bd0(%r14)
jne 0x813f
cmpl $0x1, (%r12)
je 0x80eb
movq 0x5118(%r14), %rdi
leaq 0x62174(%rip), %rsi     # 0x6a256
xorl %eax, %eax
callq *0x50f8(%r14)
movq %r15, %rdi
callq 0x10f6e
movq %r14, %rdi
xorl %esi, %esi
callq 0x6e28
movq %rax, %r15
cmpl $0x2, (%rax)
jne 0x811c
movq 0x5118(%r14), %rdi
leaq 0x6216f(%rip), %rsi     # 0x6a282
xorl %eax, %eax
callq *0x50f8(%r14)
leaq 0x4e18(%r14), %rdi
addq $0x4220, %r14           # imm = 0x4220
pushq $0x13
popq %rdx
movq %r14, %rsi
callq 0x14da9
movq %r15, 0x8(%rax)
movb $0x1, 0x15(%rax)
jmp 0x8149
movq %r14, %rdi
xorl %esi, %esi
callq 0x6e28
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0x4ba8(%rdi), %r15
pushq $0x45
popq %rsi
movq %r15, %rdi
callq 0x1187f
leaq 0x4bd8(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x30a0
movq %r15, %rdi
callq 0x10f6e
movq %rbx, %rdi
callq 0x848a
movl %eax, %ebp
pushq $0x31
popq %rsi
movq %r15, %rdi
callq 0x118d3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6e28
movq %rax, %r15
leaq 0x4e18(%rbx), %rdi
leaq 0x4220(%rbx), %r12
movl (%rax), %edx
movq %r12, %rsi
callq 0x14da9
movq %rax, %r13
leaq 0xf0(%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x14fa7
leaq 0x4e38(%rbx), %rdi
addq $0x100, %rbx            # imm = 0x100
movzbl %bpl, %r9d
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x1092e
movq %rax, 0x18(%r13)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_decl.c
// Function: parseConstDeclItem
static void parseConstDeclItem(Compiler *comp, const Type **type, Const *constant)
{
    lexCheck(&comp->lex, TOK_IDENT);
    IdentName name;
    strcpy(name, comp->lex.tok.name);

    lexNext(&comp->lex);
    bool exported = parseExportMark(comp);

    if (*type && typeInteger(*type) && comp->lex.tok.kind != TOK_EQ)
    {
        constant->intVal++;

        if (typeOverflow((*type)->kind, *constant))
            comp->error.handler(comp->error.context, "Overflow of %s", typeKindSpelling((*type)->kind));
    }
    else
    {
        lexEat(&comp->lex, TOK_EQ);
        *type = NULL;
        parseExpr(comp, type, constant);

        if (!typeOrdinal(*type) && !typeReal(*type) && (*type)->kind != TYPE_STR && (*type)->kind != TYPE_CLOSURE)
            comp->error.handler(comp->error.context, "Constant must be ordinal, or real, or string, or closure");
    }

    identAddConst(&comp->idents, &comp->modules, &comp->blocks, name, *type, exported, *constant);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4ba8(%rdi), %r12
pushq $0x45
popq %rsi
movq %r12, %rdi
callq 0x1187f
leaq 0x4bd8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x30a0
movq %r12, %rdi
callq 0x10f6e
movq %rbx, %rdi
callq 0x848a
movl %eax, %ebp
movq (%r15), %rax
testq %rax, %rax
je 0x85e2
movl (%rax), %ecx
addl $-0x4, %ecx
cmpl $0x7, %ecx
ja 0x85e2
cmpb $0x0, 0x16(%rax)
jne 0x85e2
cmpl $0x31, 0x4bd0(%rbx)
jne 0x863e
pushq $0x31
popq %rsi
movq %r12, %rdi
callq 0x118d3
andq $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd3a5
movq (%r15), %rax
movl (%rax), %eax
leal -0x4(%rax), %ecx
cmpl $0xa, %ecx
setb %cl
movl %eax, %edx
andl $-0x2, %edx
cmpl $0xe, %edx
sete %dl
orb %cl, %dl
jne 0x8687
cmpl $0x14, %eax
je 0x8687
cmpl $0x18, %eax
je 0x8687
movq 0x5118(%rbx), %rdi
leaq 0x61d94(%rip), %rsi     # 0x6a3c8
xorl %eax, %eax
callq *0x50f8(%rbx)
jmp 0x8687
movq (%r14), %rsi
incq %rsi
movq %rsi, (%r14)
movq (%r15), %rax
movl (%rax), %r12d
movl %r12d, %edi
callq 0x8013
testb %al, %al
je 0x8687
movq 0x50f8(%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x5118(%rbx), %r13
movl %r12d, %edi
callq 0x1601e
leaq 0x61b61(%rip), %rsi     # 0x6a1dc
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq *0x8(%rsp)
leaq 0x4e38(%rbx), %rdi
leaq 0x100(%rbx), %rsi
addq $0x4220, %rbx           # imm = 0x4220
movq (%r15), %r8
movq (%r14), %rax
movq %rax, (%rsp)
movzbl %bpl, %r9d
leaq 0x10(%rsp), %rcx
movq %rbx, %rdx
callq 0x104c6
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8c1a
addq $0x4e70, %rdi           # imm = 0x4E70
movq (%rdx), %rsi
jmp 0xeac5
leal -0x4(%rax), %ecx
cmpl $0xa, %ecx
setae %cl
cmpl $0x1a, %eax
setne %sil
testb %cl, %sil
jne 0x8c3e
addq $0x4e70, %rdi           # imm = 0x4E70
movq (%rdx), %rsi
jmp 0xea9e
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0x8c58
addq $0x4e70, %rdi           # imm = 0x4E70
movsd (%rdx), %xmm0
jmp 0xeaec
leal -0x12(%rax), %ecx
cmpl $0x8, %ecx
jae 0x8c6f
addq $0x4e70, %rdi           # imm = 0x4E70
movq (%rdx), %rsi
jmp 0xeb11
cmpl $0x11, %eax
je 0x8c0b
cmpl $0x10, %eax
je 0x8c60
movq 0x50f8(%rdi), %rcx
movq 0x5118(%rdi), %rdi
leaq 0x61382(%rip), %rsi     # 0x6a010
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/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 0x8d63
pushq %rbx
movq %rdi, %rbx
addq $0x4e70, %rdi           # imm = 0x4E70
callq 0xfe60
testl %eax, %eax
je 0x8d66
movslq %eax, %rcx
movq 0x4e40(%rbx), %rax
cmpq %rcx, 0x120(%rax)
je 0x8d58
movq 0x5118(%rbx), %rdi
leaq 0x619bf(%rip), %rsi     # 0x6a708
xorl %eax, %eax
callq *0x50f8(%rbx)
movq 0x4e40(%rbx), %rax
movb $0x0, 0x11a(%rax)
movb $0x1, %al
jmp 0x8d68
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9d5a
movl (%r14), %eax
movq (%rbx), %rdx
movl (%rdx), %esi
movq (%rcx), %rcx
testq %rcx, %rcx
sets %r8b
cmpl $0xb, %esi
sete %dl
leal -0x4(%rax), %r9d
cmpl $0x16, %r9d
ja 0x9e09
andb %r8b, %dl
leaq 0x607ea(%rip), %r8      # 0x6a528
movslq (%r8,%r9,4), %r9
addq %r8, %r9
jmpq *%r9
cmpq $0xff, %rcx
ja 0x9e09
jmp 0x9e30
addq $0x4e70, %rdi           # imm = 0x4E70
movl (%r14), %esi
movq (%rbx), %rdx
callq 0xf56a
jmp 0x9e30
movslq %ecx, %rsi
jmp 0x9dff
cmpq $0xffff, %rcx           # imm = 0xFFFF
ja 0x9e09
jmp 0x9e30
cmpq $0x1, %rcx
ja 0x9e09
jmp 0x9e30
btrq $0x3f, %rcx
movq %rcx, %xmm0
ucomisd 0x60250(%rip), %xmm0    # 0x69ff8
ja 0x9e09
jmp 0x9e30
shrq $0x20, %rcx
jne 0x9e09
jmp 0x9e30
movsbq %cl, %rsi
cmpq %rcx, %rsi
sete %cl
xorb $0x1, %dl
testb %dl, %cl
je 0x9e09
jmp 0x9e30
btrq $0x3f, %rcx
movq %rcx, %xmm0
ucomisd 0x60214(%rip), %xmm0    # 0x69ff0
ja 0x9e09
jmp 0x9e30
testb %dl, %dl
jne 0x9e09
jmp 0x9e30
testq %rcx, %rcx
sets %cl
andl $-0x4, %esi
cmpl $0x4, %esi
sete %dl
testb %dl, %cl
jne 0x9e09
jmp 0x9e30
movswq %cx, %rsi
cmpq %rcx, %rsi
setne %cl
orb %dl, %cl
je 0x9e30
movq 0x50f8(%rdi), %r12
movq 0x5118(%rdi), %r15
movl %eax, %edi
callq 0x1601e
leaq 0x603b7(%rip), %rsi     # 0x6a1dc
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_O2/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 0x9e6f
movq 0x5118(%r15), %rdi
leaq 0x60bfa(%rip), %rsi     # 0x6aa60
xorl %eax, %eax
callq *0x50f8(%r15)
testb %bpl, %bpl
je 0x9e80
leaq 0x4e70(%r15), %rdi
callq 0xeddd
leaq 0x4e70(%r15), %r12
movq (%rbx), %rsi
pushq $0x1a
popq %rdx
movq %r12, %rdi
callq 0xf8f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x8cb9
testb %bpl, %bpl
je 0x9ead
movq %r12, %rdi
callq 0xeddd
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x9f08
movq %rcx, %r12
movq (%rcx), %rax
movslq -0x10(%rax), %r13
addq $0xf0, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4213
movq %rax, %r15
movq 0x10(%rax), %rdi
movq (%r12), %rsi
movq %r13, %rdx
callq 0x3260
movq %r15, (%r12)
jmp 0x9f4f
leaq 0x4e38(%r15), %rdi
leaq 0x4e18(%r15), %rsi
leaq 0x4220(%r15), %rdx
movq %r14, %rcx
callq 0x10996
leaq 0x4e70(%r15), %r12
movq %r12, %rdi
movl %eax, %esi
callq 0xeb38
pushq $0x18
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xf8f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x8cb9
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: doApplyOperator
void doApplyOperator(Compiler *comp, const Type **type, const Type **rightType, Const *constant, Const *rightConstant, TokenKind op, bool apply, bool convertLhs)
{
    // First, the right-hand side type is converted to the left-hand side type
    doImplicitTypeConvEx(comp, *type, rightType, rightConstant, false, true);

    // Second, the left-hand side type is converted to the right-hand side type for symmetric operators
    if (convertLhs)
        doImplicitTypeConvEx(comp, *rightType, type, constant, true, false);

    typeAssertCompatible(&comp->types, *type, *rightType);
    typeAssertValidOperator(&comp->types, *type, op);

    if (apply)
    {
        if ((*type)->kind == TYPE_STR && (op == TOK_PLUS || op == TOK_PLUSEQ))
            doApplyStrCat(comp, constant, rightConstant, op);
        else
        {
            if (constant)
                constBinary(&comp->consts, constant, rightConstant, op, *type);
            else
                genBinary(&comp->gen, op, *type);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movb 0x50(%rsp), %r15b
movb 0x58(%rsp), %r14b
movq (%rsi), %rsi
pushq $0x1
popq %r9
movq %r8, 0x10(%rsp)
movq %r8, %rcx
xorl %r8d, %r8d
callq 0x8d72
testb %r14b, %r14b
je 0x9fbc
movq (%r13), %rsi
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
xorl %r9d, %r9d
callq 0x8d72
leaq 0x4e18(%rbx), %r14
movq (%r12), %rsi
movq (%r13), %rdx
movq %r14, %rdi
callq 0x15600
movq (%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1584b
testb %r15b, %r15b
je 0xa07f
movq (%r12), %r8
cmpl $0x14, (%r8)
jne 0xa08e
cmpl $0x20, %ebp
je 0xa006
cmpl $0x16, %ebp
jne 0xa08e
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0xa0de
cmpl $0x20, %ebp
jne 0xa02f
movq 0x5118(%rbx), %rdi
leaq 0x60acf(%rip), %rsi     # 0x6aaf6
xorl %eax, %eax
callq *0x50f8(%rbx)
movq (%r12), %rax
movq 0x10(%rsp), %r15
movq (%r15), %rcx
movl -0x10(%rcx), %ecx
addl -0x10(%rax), %ecx
leaq 0xf0(%rbx), %rdi
movslq %ecx, %rsi
callq 0x41e7
movq %rax, %r14
movq (%r12), %rsi
movq %rax, %rdi
callq 0x30a0
movq %r14, (%r12)
movq 0x5288(%rbx), %r8
addq $0x4e68, %rbx           # imm = 0x4E68
pushq $0x16
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
jmp 0xa0a9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xa0bc
addq $0x4e68, %rbx           # imm = 0x4E68
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63f5
addq $0x4e70, %rbx           # imm = 0x4E70
movq %rbx, %rdi
movl %ebp, %esi
movq %r8, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf28f
leaq 0x4e70(%rbx), %rdi
movq 0x5288(%rbx), %rdx
movl %ebp, %esi
callq 0xf28f
movq 0x5288(%rbx), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cb9
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x45
popq %rsi
movq %r15, %rdi
callq 0x1187f
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 0x10f6e
cmpl $0x42, 0x28(%r12)
jne 0xa1ad
leaq 0x4e38(%rbx), %rdi
leaq 0x100(%rbx), %rsi
movl 0x4b88(%rbx), %ecx
leaq 0x4bd8(%rbx), %r8
movq %r14, %rdx
callq 0x1043f
movq %rax, %r12
movq %r15, %rdi
callq 0x10f6e
movq %r15, %rdi
callq 0x10f6e
pushq $0x45
popq %rsi
movq %r15, %rdi
callq 0x1187f
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 0x103e6
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1047a
testb %al, %al
je 0xa1fe
movq 0x5118(%rbx), %rdi
movq %r15, %rdx
addq $0x4, %rdx
leaq 0x60532(%rip), %rsi     # 0x6a728
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_O2/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 0xa337
cmpl $0x3f, 0x4bd0(%r14)
jne 0xa328
cmpb $0x1, (%rbp)
jne 0xa328
cmpb $0x0, (%r13)
jne 0xa328
cmpb $0x0, (%r12)
jne 0xa328
testq %r15, %r15
je 0xa280
movq 0x5118(%r14), %rdi
leaq 0x604dc(%rip), %rsi     # 0x6a753
xorl %eax, %eax
callq *0x50f8(%r14)
leaq 0x4ba8(%r14), %r15
movq (%rbx), %r12
leaq 0x10(%rsp), %rax
movq %r12, (%rax)
leaq 0x4e18(%r14), %r13
leaq 0x4220(%r14), %rsi
pushq $0x16
popq %rdx
movq %r13, %rdi
callq 0x14da9
movq %rax, %rbp
movb $0x1, 0x14(%rax)
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x159f0
cmpl $0x3f, 0x4bd0(%r14)
jne 0xa325
movq %r15, %rdi
callq 0x10f6e
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
leaq 0xd(%rsp), %r9
callq 0xa337
cmpb $0x1, 0xf(%rsp)
jne 0xa307
cmpb $0x0, 0xe(%rsp)
jne 0xa307
cmpb $0x1, 0xd(%rsp)
jne 0xa31e
movq 0x5118(%r14), %rdi
leaq 0x6046d(%rip), %rsi     # 0x6a782
xorl %eax, %eax
callq *0x50f8(%r14)
movq 0x10(%rsp), %r12
jmp 0xa2b2
movq %rbp, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e70(%rdi), %r15
addq $0x4e18, %rdi           # imm = 0x4E18
movq 0x8(%rsi), %rsi
callq 0x15124
movslq %eax, %rsi
movq %r15, %rdi
callq 0xea9e
movq 0x8(%rbx), %rsi
pushq $0x15
popq %rdx
movq %r15, %rdi
callq 0xf8f6
movq %r15, %rdi
callq 0xedd1
pushq $0x2
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0xed6a
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0xf122
movq %r15, %rdi
movl %ebp, %esi
callq 0xec45
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8cb9
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x10, (%rax)
jne 0xe1c0
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl $0x11, %eax
je 0xe182
cmpl $0x10, %eax
jne 0xe1c0
addq $0x4e70, %r14           # imm = 0x4E70
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0xee17
movq (%rbx), %rax
movq 0x8(%rax), %rax
jmp 0xe1bd
leaq 0x4e70(%r14), %r15
pushq $0x11
popq %rsi
movq %r15, %rdi
callq 0xee17
movq %r15, %rdi
callq 0xf5a3
leaq 0x4e18(%r14), %rdi
addq $0x4220, %r14           # imm = 0x4220
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %r14, %rsi
callq 0x15100
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8d0a
testb %al, %al
jne 0xe1ee
leaq 0x4e70(%r14), %rdi
pushq $0x2c
popq %rsi
movq %rbx, %rdx
callq 0xef90
movl (%rbx), %ebp
cmpl $0x18, %ebp
ja 0xe22e
movl $0x1ec7770, %eax        # imm = 0x1EC7770
btl %ebp, %eax
jae 0xe22e
leaq 0x4e70(%r14), %r15
addq $0x4e18, %r14           # imm = 0x4E18
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15124
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xef60
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, 0x18(%rsp)
callq 0xe39a
leaq 0x4ba8(%r15), %rax
movq %rax, 0x38(%rsp)
leaq 0x4e70(%r15), %rax
movq %rax, 0x10(%rsp)
leaq 0x4220(%r15), %rax
movq %rax, 0x28(%rsp)
leaq 0x4e38(%r15), %rax
movq %rax, 0x30(%rsp)
pushq $0x2a
popq %rbp
movq %rbx, 0x20(%rsp)
cmpl $0x2a, 0x4bd0(%r15)
jne 0xe38b
movq 0x38(%rsp), %rdi
callq 0x10f6e
testq %rbx, %rbx
je 0xe2fe
cmpq $0x0, (%rbx)
je 0xe28f
movq 0x18(%rsp), %r14
movq (%r14), %rax
movq %rax, 0x40(%rsp)
movq %r15, %rdi
leaq 0x40(%rsp), %r12
movq %r12, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0xe39a
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
movl %ebp, %r9d
pushq $0x1
pushq $0x0
callq 0x9f5c
popq %rax
popq %rcx
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0xe28f
movq 0x10(%rsp), %rdi
callq 0xfca2
movq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x4b13
movq 0x18(%rsp), %r13
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0xe39a
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %rbx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl %ebp, %r9d
pushq $0x1
pushq $0x0
callq 0x9f5c
popq %rax
popq %rcx
movq %r15, %rdi
callq 0x12350
movq %r14, %rdi
callq 0x4bcc
movq 0x30(%rsp), %rdi
movl %eax, %esi
callq 0x10c75
movq %r14, %rdi
callq 0x4b91
movq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0xfcc4
jmp 0xe28f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe43c
movl 0x4bd0(%r14), %r12d
cmpq $0x36, %r12
ja 0xe42d
movabsq $0x71c00000000000, %rax # imm = 0x71C00000000000
btq %r12, %rax
jae 0xe42d
leaq 0x4ba8(%r14), %rdi
callq 0x10f6e
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 0xe43c
pushq $0x1
popq %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movl %r12d, %r9d
pushq %rax
pushq %rax
callq 0x9f5c
popq %rax
popq %rcx
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_O2/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 0xe4e4
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
pushq $0x1
popq %r13
movl 0x4bd0(%r15), %ebx
cmpl $0x1d, %ebx
ja 0xe4d5
movl $0x30c00000, %eax       # imm = 0x30C00000
btl %ebx, %eax
jae 0xe4d5
movq 0x8(%rsp), %rdi
callq 0x10f6e
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe4e4
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
movl %ebx, %r9d
pushq %r13
pushq %r13
callq 0x9f5c
popq %rax
popq %rcx
jmp 0xe47e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe58c
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
pushq $0x1
popq %r13
movl 0x4bd0(%r15), %ebx
cmpl $0x1f, %ebx
ja 0xe57d
movl $0xcf000000, %eax       # imm = 0xCF000000
btl %ebx, %eax
jae 0xe57d
movq 0x8(%rsp), %rdi
callq 0x10f6e
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe58c
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
movl %ebx, %r9d
pushq %r13
pushq %r13
callq 0x9f5c
popq %rax
popq %rcx
jmp 0xe526
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
movq %rsi, 0x1c0(%rdi)
movabsq $0x3e800000000, %rcx    # imm = 0x3E800000000
movq %rcx, 0x8(%rdi)
movl $0x7d00, %esi           # imm = 0x7D00
movq %rax, %rdi
callq 0x4144
movq %rax, (%r15)
orl $-0x1, 0x1a0(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a4(%r15)
movups %xmm0, 0x1b0(%r15)
movq %r14, 0x1c8(%r15)
movq 0x1c0(%r15), %rdi
movslq 0xc(%r15), %rax
imulq $0x18, %rax, %rsi
callq 0x4144
movq %rax, 0x1d0(%r15)
movq %rbx, 0x1e0(%r15)
andl $0x0, 0x1d8(%r15)
movl 0x8(%r15), %eax
movl %eax, 0x1dc(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rdx
cmpl %edx, %eax
jl 0xea40
leal (%rdx,%rdx), %eax
movl %eax, 0xc(%rbx)
movq (%rbx), %rsi
movq 0x1c0(%rbx), %rdi
shlq $0x6, %rdx
callq 0x42b1
movq %rax, (%rbx)
movq 0x1c0(%rbx), %rdi
movq 0x1d0(%rbx), %rsi
movslq 0xc(%rbx), %rax
imulq $0x18, %rax, %rdx
callq 0x42b1
movq %rax, 0x1d0(%rbx)
movl 0x8(%rbx), %eax
movq (%rbx), %rcx
cltq
shlq $0x5, %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
movq 0x1c8(%rbx), %rax
movq 0x1d0(%rbx), %rcx
movslq 0x8(%rbx), %rdx
imulq $0x18, %rdx, %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
andl $0x0, 0x1d8(%rbx)
movl %eax, 0x1dc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genTryRemoveImmediateEntryPoint
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), %rcx
pushq $-0x1
popq %rax
cmpl 0x1a4(%rdi), %ecx
jle 0xfd68
movq %rcx, %rdx
shlq $0x5, %rdx
addq (%rdi), %rdx
movq %rdx, %rsi
addq $-0x20, %rsi
je 0xfd68
cmpl $0x1, (%rsi)
jne 0xfd68
cmpl $0x0, -0x1c(%rdx)
je 0xfd69
retq
movl -0x8(%rdx), %eax
decl %ecx
movl %ecx, 0x8(%rdi)
andl $0x0, 0x1d8(%rdi)
movl %ecx, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xf020
testb %al, %al
je 0xf109
movss 0x5be86(%rip), %xmm0    # 0x6af70
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
movq %rbx, %rdi
callq 0xe9ea
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 0xeeb9
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xf020
testb %al, %al
je 0xf162
movsd 0x5bddd(%rip), %xmm0    # 0x6af20
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
movq %rbx, %rdi
callq 0xe9ea
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 0xeee9
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xf020
testb %al, %al
je 0xf1ba
movaps 0x5bd95(%rip), %xmm0    # 0x6af30
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
movq %rbx, %rdi
callq 0xe9ea
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 0xeeb9
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x1a4(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
setge %cl
cmpl %esi, %eax
setge %dl
testb %dl, %cl
jne 0xf5d4
cmpl %esi, %eax
cmovlel %esi, %eax
movl %eax, 0x1a4(%rdi)
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x1e, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
andl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0xe9ea
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x1a4(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
setge %cl
cmpl %esi, %eax
setge %dl
testb %dl, %cl
jne 0xf627
cmpl %esi, %eax
cmovlel %esi, %eax
movl %eax, 0x1a4(%rdi)
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x1f, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
andl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0xe9ea
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGotoIfNot
void genGotoIfNot(CodeGen *gen, int dest)
{
    genUpdateLastJump(gen, gen->ip);
    genUpdateLastJump(gen, dest);

    const Instruction instr = {.opcode = OP_GOTO_IF_NOT, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.intVal = dest};
    genAddInstr(gen, &instr);
}

// Assembly:
movl 0x8(%rdi), %eax
movl 0x1a4(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
setge %cl
cmpl %esi, %eax
setge %dl
testb %dl, %cl
jne 0xf67a
cmpl %esi, %eax
cmovlel %esi, %eax
movl %eax, 0x1a4(%rdi)
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movl $0x20, (%rax)
movslq %esi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
andl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0xe9ea
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoFromTo
void genGoFromTo(CodeGen *gen, int start, int dest)
{
    int next = gen->ip;
    gen->ip = start;
    genGoto(gen, dest);
    gen->ip = next;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl %esi, 0x8(%rdi)
movl %edx, %esi
callq 0xf5af
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoFromToIfNot
void genGoFromToIfNot(CodeGen *gen, int start, int dest)
{
    int next = gen->ip;
    gen->ip = start;
    genGotoIfNot(gen, dest);
    gen->ip = next;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl %esi, 0x8(%rdi)
movl %edx, %esi
callq 0xf655
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCaseConstantCheck
void genCaseConstantCheck(CodeGen *gen, const Type *type, Const *constant)
{
    genPushReg(gen, REG_SWITCH_EXPR);                       // Compare switch expression to case constant
    genPushIntConst(gen, constant->intVal);
    genBinary(gen, TOK_EQEQ, type);
    genSavePos(gen);
    genNop(gen);                                            // Goto "case" block start (stub)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x3
popq %rsi
callq 0xec45
movq (%rbx), %rsi
movq %r15, %rdi
callq 0xea9e
pushq $0x2e
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0xf28f
movq %r15, %rdi
callq 0xfa11
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe9cf
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCaseBlockProlog
void genCaseBlockProlog(CodeGen *gen, int numCaseConstants)
{
    for (int i = 0; i < numCaseConstants; i++)
        genGoFromToIf(gen, genRestorePos(gen), gen->ip + 1); // Goto "case" block start (fixup)

    genSavePos(gen);
    genNop(gen);                                            // Goto next "case" or "default" (stub)
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
subl $0x1, %ebp
jb 0xfb24
movslq 0x1a0(%rbx), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rbx)
movl 0x10(%rbx,%rax,4), %esi
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
callq 0xf9c5
jmp 0xfafc
movq %rbx, %rdi
callq 0xfa11
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe9cf
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genForPostStmtEpilog
void genForPostStmtEpilog(CodeGen *gen)
{
    int condEpilog = genRestorePos(gen);
    int condProlog = genRestorePos(gen);

    genGoto(gen, condProlog);                               // Goto condition
    genGoFromToIf(gen, condEpilog, gen->ip);                // Goto post-statement end (fixup)

    gen->stack[++gen->top] = condEpilog;                    // Place to stack again
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1a0(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0x1a0(%rdi)
movl 0x10(%rdi,%rax,4), %ebp
leal -0x2(%rax), %ecx
movl %ecx, 0x1a0(%rdi)
movl 0xc(%rdi,%rax,4), %esi
callq 0xf5af
movl 0x8(%rbx), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf9c5
movslq 0x1a0(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x1a0(%rbx)
movl %ebp, 0x14(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genShortCircuitProlog
void genShortCircuitProlog(CodeGen *gen)
{
    genDup(gen);
    genSavePos(gen);
    genNop(gen);                                            // Goto expression end (stub)
    genPop(gen);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xedd1
movq %rbx, %rdi
callq 0xfa11
movq %rbx, %rdi
callq 0xe9cf
movq %rbx, %rdi
popq %rbx
jmp 0xed28
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genLeaveFrameFixup
void genLeaveFrameFixup(CodeGen *gen, const ParamAndLocalVarLayout *layout)
{
    // Fixup enter stub
    int next = gen->ip;
    gen->ip = genRestorePos(gen);

    genEnterFrame(gen, layout);
    gen->ip = next;

    genLeaveFrame(gen);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movslq 0x1a0(%rdi), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rdi)
movl 0x10(%rdi,%rax,4), %eax
movl %eax, 0x8(%rdi)
callq 0xf965
movl %ebp, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf990
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGotosAddStub
void genGotosAddStub(CodeGen *gen, Gotos *gotos)
{
    if (gotos->numGotos >= MAX_GOTOS)
        gen->error->handler(gen->error->context, "To many break/continue/return statements");

    gotos->start[gotos->numGotos++] = gen->ip;
    genNop(gen);                                            // Goto block/function end (stub)
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x190(%rsi), %eax
cmpl $0x64, %eax
jl 0xfdbf
movq 0x1e0(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x5b32c(%rip), %rsi     # 0x6b0e0
xorl %eax, %eax
callq *(%rcx)
movl 0x190(%r14), %eax
movl 0x8(%rbx), %ecx
leal 0x1(%rax), %edx
movl %edx, 0x190(%r14)
cltq
movl %ecx, (%r14,%rax,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9cf
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCopyResultToTempVar
void genCopyResultToTempVar(CodeGen *gen, const Type *type, int offset)
{
    genDup(gen);
    genPushLocalPtr(gen, offset);
    genSwapAssign(gen, type->kind, type->size);

    genNotify(gen, GEN_NOTIFICATION_COPY_RESULT_TO_TEMP_VAR);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0xedd1
movq %r15, %rdi
movl %ebx, %esi
callq 0xeb38
movl (%r14), %esi
movl 0xc0(%r14), %edx
movq %r15, %rdi
callq 0xeee9
movl $0x1, 0x1d8(%r15)
movl 0x8(%r15), %eax
movl %eax, 0x1dc(%r15)
popq %rbx
popq %r14
popq %r15
retq