LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizePushLocalPtr
static bool optimizePushLocalPtr(CodeGen *gen, int offset)
{
    Instruction *prev = getPrevInstr(gen, 1), *prev2 = getPrevInstr(gen, 2);

    // Optimization: PUSH_LOCAL_PTR + ZERO + PUSH_LOCAL_PTR -> PUSH_LOCAL_PTR_ZERO
    if (prev  && prev->opcode  == OP_ZERO &&
        prev2 && prev2->opcode == OP_PUSH_LOCAL_PTR)
    {
        if (offset == prev2->operand.intVal)
        {
            const int size = prev->operand.intVal;

            genRemoveInstr(gen);
            genRemoveInstr(gen);
            genPushLocalPtrZero(gen, offset, size);

            genUnnotify(gen);
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x18c30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16a9e
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x16a9e
cmpq $0x0, -0x28(%rbp)
je 0x16a9e
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x16a9e
movslq -0x14(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x16a9c
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18c80
movq -0x10(%rbp), %rdi
callq 0x18c80
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x16ab0
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x16aa2
jmp 0x16a9e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizePushReg
static bool optimizePushReg(CodeGen *gen, RegisterIndex regIndex)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: POP_REG SELF + PUSH_REG SELF -> 0
    // This is an inequivalent replacement since it cannot update REG_SELF, but the updated register is never actually used
    if (prev && prev->opcode == OP_POP_REG && prev->operand.intVal == REG_SELF && regIndex == REG_SELF)
    {
        genRemoveInstr(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16c11
movq -0x20(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x16c11
movq -0x20(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0x16c11
cmpl $0x1, -0x14(%rbp)
jne 0x16c11
movq -0x10(%rbp), %rdi
callq 0x18c80
movb $0x1, -0x1(%rbp)
jmp 0x16c15
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizePushZero
static bool optimizePushZero(CodeGen *gen, int slots)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH_ZERO (n) + PUSH_ZERO (m) -> PUSH_ZERO (n + m)
    if (prev && prev->opcode == OP_PUSH_ZERO)
    {
        prev->operand.intVal += slots;
        genUnnotify(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16d20
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x16d20
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x16d24
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizePop
static bool optimizePop(CodeGen *gen)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: POP (n) + POP -> POP (n + 1)
    if (prev && prev->opcode == OP_POP)
    {
        prev->operand.intVal++;
        genUnnotify(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16ddd
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x16ddd
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x16de1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizePopReg
static bool optimizePopReg(CodeGen *gen, RegisterIndex regIndex)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH_REG n + POP_REG n -> 0
    if (prev && prev->opcode == OP_PUSH_REG && prev->operand.intVal == regIndex)
    {
        genRemoveInstr(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16ea0
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x16ea0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jne 0x16ea0
movq -0x10(%rbp), %rdi
callq 0x18c80
movb $0x1, -0x1(%rbp)
jmp 0x16ea4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizeDeref
static bool optimizeDeref(CodeGen *gen, TypeKind typeKind)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH_LOCAL_PTR + DEREF -> PUSH_LOCAL
    // These sequences constitute 20...30 % of all instructions and need a special, more optimized single instruction
    if (prev && prev->opcode == OP_PUSH_LOCAL_PTR)
    {
        genRemoveInstr(gen);
        genPushLocal(gen, typeKind, prev->operand.intVal);
        return true;
    }

    // Optimization: (PUSH | ...) + DEREF -> (PUSH | ...); DEREF
    if (prev && ((prev->opcode == OP_PUSH && prev->typeKind == TYPE_PTR) ||
                  prev->opcode == OP_GET_ARRAY_PTR                       ||
                  prev->opcode == OP_GET_DYNARRAY_PTR                    ||
                  prev->opcode == OP_GET_FIELD_PTR)                      &&
                  prev->inlineOpcode == OP_NOP)
    {
        prev->inlineOpcode = OP_DEREF;
        prev->typeKind = typeKind;
        genUnnotify(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x17056
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x17056
movq -0x10(%rbp), %rdi
callq 0x18c80
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, %edx
callq 0x16b10
movb $0x1, -0x1(%rbp)
jmp 0x170bd
cmpq $0x0, -0x20(%rbp)
je 0x170b9
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x17070
movq -0x20(%rbp), %rax
cmpl $0x10, 0xc(%rax)
je 0x1708b
movq -0x20(%rbp), %rax
cmpl $0x16, (%rax)
je 0x1708b
movq -0x20(%rbp), %rax
cmpl $0x17, (%rax)
je 0x1708b
movq -0x20(%rbp), %rax
cmpl $0x19, (%rax)
jne 0x170b9
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x170b9
movq -0x20(%rbp), %rax
movl $0xd, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x170bd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizeSwapAssign
static bool optimizeSwapAssign(CodeGen *gen, TypeKind typeKind, int structSize)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: SWAP + SWAP_ASSIGN -> ASSIGN
    if (prev && prev->opcode == OP_SWAP)
    {
        genRemoveInstr(gen);
        const Instruction instr = {.opcode = OP_ASSIGN, .tokKind = TOK_NONE, .typeKind = typeKind, .operand.intVal = structSize};
        genAddInstr(gen, &instr);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1720b
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x1720b
movq -0x10(%rbp), %rdi
callq 0x18c80
movl $0xe, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x30(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16790
movb $0x1, -0x1(%rbp)
jmp 0x1720f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizeChangeRefCnt
static bool optimizeChangeRefCnt(CodeGen *gen, const Type *type)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH ^ + CHANGE_REF_CNT -> PUSH ^
    if (prev && prev->opcode == OP_PUSH && prev->inlineOpcode == OP_NOP && prev->typeKind == TYPE_PTR && (type->kind == TYPE_PTR || type->kind == TYPE_STR))
    {
        genUnnotify(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x17377
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x17377
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x17377
movq -0x20(%rbp), %rax
cmpl $0x10, 0xc(%rax)
jne 0x17377
movq -0x18(%rbp), %rax
cmpl $0x10, (%rax)
je 0x17368
movq -0x18(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x17377
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x1737b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x172f0
testb $0x1, %al
jne 0x1748f
jmp 0x174d6
movl $0x13, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3190
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16790
jmp 0x174ef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %edx
callq 0x170d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x172f0
testb $0x1, %al
jne 0x1751f
jmp 0x17566
movl $0x13, -0x30(%rbp)
movl $0xb, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3190
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16790
jmp 0x1757f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %edx
callq 0x17120
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x172f0
testb $0x1, %al
jne 0x175af
jmp 0x175f6
movl $0x13, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x2d, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3190
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16790
jmp 0x1760f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %edx
callq 0x170d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizeUnary
static bool optimizeUnary(CodeGen *gen, TokenKind tokKind, TypeKind typeKind)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH + UNARY -> PUSH
    if (prev && prev->opcode == OP_PUSH && prev->inlineOpcode == OP_NOP && tokKind != TOK_PLUSPLUS && tokKind != TOK_MINUSMINUS)
    {
        Const arg;
        if (typeKindReal(typeKind))
            arg.realVal = prev->operand.realVal;
        else
            arg.intVal = prev->operand.intVal;

        Consts consts = {.error = gen->error};
        constUnary(&consts, &arg, tokKind, typeKind);

        prev->typeKind = typeKind;

        if (typeKindReal(typeKind))
            prev->operand.realVal = arg.realVal;
        else
            prev->operand.intVal = arg.intVal;

        genUnnotify(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1777d
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1777d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1777d
cmpl $0x2c, -0x14(%rbp)
je 0x1777d
cmpl $0x2d, -0x14(%rbp)
je 0x1777d
movl -0x18(%rbp), %edi
callq 0x19390
testb $0x1, %al
jne 0x176fc
jmp 0x1770c
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x17718
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8b10
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x18(%rbp), %edi
callq 0x19390
testb $0x1, %al
jne 0x17752
jmp 0x17762
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x1776e
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x17781
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizeGetArrayPtr
static bool optimizeGetArrayPtr(CodeGen *gen, int itemSize, int len)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH + GET_ARRAY_PTR -> GET_FIELD_PTR
    if (prev && prev->opcode == OP_PUSH && prev->typeKind == TYPE_INT && prev->inlineOpcode == OP_NOP && len >= 0)
    {
        int index = prev->operand.intVal;

        if (index < 0 || index > len - 1)
            gen->error->handler(gen->error->context, "Index %d is out of range 0...%d", index, len - 1);

        genRemoveInstr(gen);
        genGetFieldPtr(gen, itemSize * index);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x17ae5
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x17ae5
movq -0x20(%rbp), %rax
cmpl $0x7, 0xc(%rax)
jne 0x17ae5
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x17ae5
cmpl $0x0, -0x18(%rbp)
jl 0x17ae5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x17a94
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x17ac6
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movq (%rax), %r8
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movq 0x20(%rax), %rdi
movl -0x24(%rbp), %edx
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
leaq 0x1c16f6(%rip), %rsi    # 0x1d91b7
movb $0x0, %al
callq *%r8
movq -0x10(%rbp), %rdi
callq 0x18c80
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
imull -0x24(%rbp), %esi
callq 0x17bb0
movb $0x1, -0x1(%rbp)
jmp 0x17ae9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: optimizeGetFieldPtr
static bool optimizeGetFieldPtr(CodeGen *gen, int fieldOffset)
{
    Instruction *prev = getPrevInstr(gen, 1);

    // Optimization: PUSH_LOCAL_PTR + GET_FIELD_PTR -> PUSH_LOCAL_PTR
    if (prev && prev->opcode == OP_PUSH_LOCAL_PTR)
    {
        prev->operand.intVal += fieldOffset;
        genUnnotify(gen);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x17c60
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x17c60
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x16740
movb $0x1, -0x1(%rbp)
jmp 0x17c64
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x17e40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x17e40
movl $0x1e, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x20(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16790
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x17dd0
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genCaseConstantCheck
void genCaseConstantCheck(CodeGen *gen, Const *constant)
{
    genPushReg(gen, REG_SWITCH_EXPR);                       // Compare switch expression to case constant
    genPushIntConst(gen, constant->intVal);
    genBinary(gen, TOK_EQEQ, TYPE_INT, 0);
    genSavePos(gen);
    genNop(gen);                                            // Goto "case" block start (stub)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x16b60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x16850
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
movl $0x7, %edx
xorl %ecx, %ecx
callq 0x17790
movq -0x8(%rbp), %rdi
callq 0x185b0
movq -0x8(%rbp), %rdi
callq 0x16760
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x187cf
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18640
movq -0x18(%rbp), %rdi
movl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
addl $0x1, %edx
callq 0x184e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18796
movq -0x8(%rbp), %rdi
callq 0x185b0
movq -0x8(%rbp), %rdi
callq 0x16760
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18640
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18640
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x17dd0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x184e0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl 0x1a0(%rsi), %ecx
addl $0x1, %ecx
movl %ecx, 0x1a0(%rsi)
movslq %ecx, %rcx
movl %edx, 0x10(%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16eb0
movq -0x8(%rbp), %rdi
callq 0x185b0
movq -0x8(%rbp), %rdi
callq 0x16760
movq -0x8(%rbp), %rdi
callq 0x16d30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18640
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x183a0
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x183f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genTryRemoveImmediateEntryPoint
int genTryRemoveImmediateEntryPoint(CodeGen *gen)
{
    Instruction *prev = getPrevInstr(gen, 1);
    if (prev && prev->opcode == OP_PUSH && prev->inlineOpcode == OP_NOP)
    {
        int entry = prev->operand.intVal;
        genRemoveInstr(gen);
        return entry;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x18c14
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x18c14
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x18c14
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18c80
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18c1b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x64, 0x190(%rax)
jl 0x18d25
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1c044f(%rip), %rsi    # 0x1d9170
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x190(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x190(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x16760
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16eb0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x169a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %edx
callq 0x17120
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x18e20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genTryRemoveCopyResultToTempVar
int genTryRemoveCopyResultToTempVar(CodeGen *gen)
{
    if (!genJustNotified(gen, GEN_NOTIFICATION_COPY_RESULT_TO_TEMP_VAR))
        return 0;

    Instruction *prev = getPrevInstr(gen, 1), *prev2 = getPrevInstr(gen, 2), *prev3 = getPrevInstr(gen, 3);

    if (prev3 && prev3->opcode == OP_DUP            && prev3->inlineOpcode == OP_NOP &&
        prev2 && prev2->opcode == OP_PUSH_LOCAL_PTR && prev2->inlineOpcode == OP_NOP &&
        prev  && prev->opcode  == OP_ASSIGN         && prev->inlineOpcode  == OP_SWAP)
    {
        int tempVarOffset = prev2->operand.intVal;
        genRemoveInstr(gen);
        genRemoveInstr(gen);
        genRemoveInstr(gen);
        return tempVarOffset;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18f40
testb $0x1, %al
jne 0x18e7a
movl $0x0, -0x4(%rbp)
jmp 0x18f33
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x18c30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x18c30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x18c30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x18f2c
movq -0x28(%rbp), %rax
cmpl $0xa, (%rax)
jne 0x18f2c
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x18f2c
cmpq $0x0, -0x20(%rbp)
je 0x18f2c
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x18f2c
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x18f2c
cmpq $0x0, -0x18(%rbp)
je 0x18f2c
movq -0x18(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x18f2c
movq -0x18(%rbp), %rax
cmpl $0xb, 0x4(%rax)
jne 0x18f2c
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18c80
movq -0x10(%rbp), %rdi
callq 0x18c80
movq -0x10(%rbp), %rdi
callq 0x18c80
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18f33
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identInit
void identInit(Idents *idents, Storage *storage, DebugInfo *debug, Error *error)
{
    idents->first = NULL;
    idents->lastTempVarForResult = NULL;
    idents->tempVarNameSuffix = 0;
    idents->storage = storage;
    idents->debug = debug;
    idents->error = error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identFree
void identFree(Idents *idents, int block)
{
    while (idents->first && idents->first->block == block)
    {
        Ident *next = idents->first->next;

        if (idents->first->globallyAllocated)
            storageRemove(idents->storage, idents->first->ptr);

        storageRemove(idents->storage, idents->first);
        idents->first = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x19504
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x114(%rax), %eax
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1950d
jmp 0x1956e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x119(%rax)
je 0x1954a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x120(%rax), %rsi
callq 0x4d80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4d80
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x194df
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAssertFind
const Ident *identAssertFind(const Idents *idents, const Modules *modules, const Blocks *blocks, int module, const char *name, const Type *rcvType)
{
    const Ident *res = identFind(idents, modules, blocks, module, name, rcvType, true);
    if (!res)
        idents->error->handler(idents->error->context, "Unknown identifier %s", name);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x1, (%rsp)
callq 0x19580
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x198f3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1bf8e8(%rip), %rsi    # 0x1d91d7
movb $0x0, %al
callq *%rcx
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAssertFindModule
const Ident *identAssertFindModule(const Idents *idents, const Modules *modules, const Blocks *blocks, int module, const char *name)
{
    const Ident *res = identFindModule(idents, modules, blocks, module, name, true);
    if (!res)
        idents->error->handler(idents->error->context, "Unknown module %s", name);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl $0x1, %r9d
callq 0x19900
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x199ca
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1bf827(%rip), %rsi    # 0x1d91ed
movb $0x0, %al
callq *%rcx
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identIsOuterLocalVar
bool identIsOuterLocalVar(const Blocks *blocks, const Ident *ident)
{
    if (!ident || ident->kind != IDENT_VAR || ident->block == 0)
        return false;

    bool curFnBlockFound = false;
    for (int i = blocks->top; i >= 0; i--)
    {
        if (blocks->item[i].block == ident->block && curFnBlockFound)
            return true;

        if (blocks->item[i].fn)
            curFnBlockFound = true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x19a09
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x19a09
movq -0x18(%rbp), %rax
cmpl $0x0, 0x114(%rax)
jne 0x19a0f
movb $0x0, -0x1(%rbp)
jmp 0x19a7a
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl 0x964(%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x19a76
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x114(%rcx), %eax
jne 0x19a4f
testb $0x1, -0x19(%rbp)
je 0x19a4f
movb $0x1, -0x1(%rbp)
jmp 0x19a7a
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x19a69
movb $0x1, -0x19(%rbp)
jmp 0x19a6b
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x19a20
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAddTempConst
Ident *identAddTempConst(Idents *idents, const Modules *modules, const Blocks *blocks, const Type *type, Const constant)
{
    IdentName tempName;
    identTempName(idents, tempName);

    Ident *ident = identAddConst(idents, modules, blocks, tempName, type, false, constant);
    ident->temporary = true;
    return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1a0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x130(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x8(%rbp), %rax
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x19a90
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movb $0x1, 0x11b(%rax)
movq -0x138(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAddGlobalVar
Ident *identAddGlobalVar(Idents *idents, const Modules *modules, const Blocks *blocks, const char *name, const Type *type, bool exported, void *ptr)
{
    Ident *ident = identAdd(idents, modules, blocks, IDENT_VAR, name, type, exported);
    ident->ptr = ptr;
    ident->globallyAllocated = true;
    return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movb -0x29(%rbp), %al
movl $0x1, %ecx
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x19b00
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x119(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocStack
int identAllocStack(Idents *idents, const Types *types, Blocks *blocks, const Type *type)
{
    int *localVarSize = NULL;
    for (int i = blocks->top; i >= 1; i--)
        if (blocks->item[i].fn)
        {
            localVarSize = &blocks->item[i].localVarSize;
            break;
        }
    if (!localVarSize)
        idents->error->handler(idents->error->context, "Stack frame is not found");

    *localVarSize = align(*localVarSize + typeSize(types, type), typeAlignment(types, type));
    return -2 * sizeof(Slot) - (*localVarSize);  // 2 extra slots for the stack frame ref count and parameter layout table
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x964(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jl 0x1a38f
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x1a382
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x1a38f
jmp 0x1a384
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a34d
cmpq $0x0, -0x28(%rbp)
jne 0x1a3b8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1bee4b(%rip), %rsi    # 0x1d91ff
movb $0x0, %al
callq *%rcx
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21fe0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
addl %ecx, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x220a0
movq -0x38(%rbp), %rdi
movslq %eax, %rsi
callq 0x1a420
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
movq $-0x10, %rax
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocVar
Ident *identAllocVar(Idents *idents, const Types *types, const Modules *modules, Blocks *blocks, const char *name, const Type *type, bool exported)
{
    Ident *ident;
    if (blocks->top == 0)       // Global
    {
        void *ptr = storageAdd(idents->storage, typeSize(types, type));
        ident = identAddGlobalVar(idents, modules, blocks, name, type, exported, ptr);
    }
    else                        // Local
    {
        const int offset = identAllocStack(idents, types, blocks, type);
        ident = identAddLocalVar(idents, modules, blocks, name, type, exported, offset);
    }
    return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x964(%rax)
jne 0x1a4e1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x21fe0
movq -0x58(%rbp), %rdi
movslq %eax, %rsi
callq 0x4b20
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movb -0x31(%rbp), %r9b
movq -0x48(%rbp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x1a0f0
movq %rax, -0x40(%rbp)
jmp 0x1a528
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x1a320
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movb -0x31(%rbp), %r9b
movl -0x4c(%rbp), %eax
andb $0x1, %r9b
movzbl %r9b, %r9d
movl %eax, (%rsp)
callq 0x1a170
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocTempVar
Ident *identAllocTempVar(Idents *idents, const Types *types, const Modules *modules, Blocks *blocks, const Type *type, bool isFuncResult)
{
    IdentName tempName;
    identTempName(idents, tempName);

    Ident *ident = identAllocVar(idents, types, modules, blocks, tempName, type, false);
    ident->temporary = true;

    if (isFuncResult)
    {
        if (blocks->top == 0)
            idents->error->handler(idents->error->context, "Temporary variable must be local");
        idents->lastTempVarForResult = ident;
    }

    return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1a0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x130(%rbp), %r8
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x1a450
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movb $0x1, 0x11b(%rax)
testb $0x1, -0x29(%rbp)
je 0x1a5f9
movq -0x20(%rbp), %rax
cmpl $0x0, 0x964(%rax)
jne 0x1a5ea
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1bec32(%rip), %rsi    # 0x1d9218
movb $0x0, %al
callq *%rcx
movq -0x138(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x138(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identAllocParam
Ident *identAllocParam(Idents *idents, const Types *types, const Modules *modules, const Blocks *blocks, const Signature *sig, int index)
{
    const int offset = typeParamOffset(types, sig, index);
    Ident *ident = identAddLocalVar(idents, modules, blocks, sig->param[index]->name, sig->param[index]->type, false, offset);
    identSetUsed(ident);                                                     // Do not warn about unused parameters
    return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x23950
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %r8
movq 0x10(%rax,%r8,8), %rax
movq 0x108(%rax), %r8
movl -0x30(%rbp), %eax
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x1a170
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1a6a0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_ident.c
// Function: identMethodNameWithRcv
const char *identMethodNameWithRcv(const Idents *idents, const Ident *method)
{
    char typeBuf[DEFAULT_STR_LEN + 1];
    typeSpelling(method->type->sig.param[0]->type, typeBuf);

    char *buf = storageAdd(idents->storage, 2 * DEFAULT_STR_LEN + 2 + 1);
    snprintf(buf, 2 * DEFAULT_STR_LEN + 2 + 1, "(%s)%s", typeBuf, method->name);

    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq 0x38(%rax), %rax
movq 0x108(%rax), %rdi
leaq -0x110(%rbp), %rsi
callq 0x22070
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x201, %esi            # imm = 0x201
callq 0x4b20
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
leaq -0x110(%rbp), %rcx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movl $0x201, %esi            # imm = 0x201
leaq 0x1beb09(%rip), %rdx    # 0x1d9239
movb $0x0, %al
callq 0x3170
movq -0x118(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexFree
void lexFree(Lexer *lex)
{
    if (lex->buf)
    {
        storageRemove(lex->storage, lex->buf);
        lex->fileName = NULL;
        lex->buf = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ad86
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4d80
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)