LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xca54
testb %al, %al
jne 0x125f1
leaq 0x4e70(%r14), %rdi
movl $0x2c, %esi
movq %rbx, %rdx
callq 0x13476
movl (%rbx), %ebp
cmpl $0x18, %ebp
ja 0x12631
movl $0x1ec7770, %eax        # imm = 0x1EC7770
btl %ebp, %eax
jae 0x12631
leaq 0x4e70(%r14), %r15
addq $0x4e18, %r14           # imm = 0x4E18
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19e29
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13440
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_expr.c
// Function: parseLogicalTerm
static void parseLogicalTerm(Compiler *comp, const Type **type, Const *constant)
{
    parseRelation(comp, type, constant);

    while (comp->lex.tok.kind == TOK_ANDAND)
    {
        TokenKind op = comp->lex.tok.kind;
        lexNext(&comp->lex);

        if (constant)
        {
            if (constant->intVal)
            {
                Const rightConstantBuf, *rightConstant = &rightConstantBuf;

                const Type *rightType = *type;
                parseRelation(comp, &rightType, rightConstant);
                doApplyOperator(comp, type, &rightType, constant, rightConstant, op, false, true);
                constant->intVal = rightConstant->intVal;
            }
            else
                constant->intVal = false;
        }
        else
        {
            genShortCircuitProlog(&comp->gen);

            blocksEnter(&comp->blocks);

            const Type *rightType = *type;
            parseRelation(comp, &rightType, NULL);
            doApplyOperator(comp, type, &rightType, NULL, NULL, op, false, true);

            doGarbageCollection(comp);
            identWarnIfUnusedAll(&comp->idents, blocksCurrent(&comp->blocks));
            blocksLeave(&comp->blocks);

            genShortCircuitEpilog(&comp->gen, op);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, 0x18(%rsp)
callq 0x127ac
cmpl $0x2a, 0x4bd0(%r15)
jne 0x1279d
leaq 0x4ba8(%r15), %r12
leaq 0x4e70(%r15), %rax
movq %rax, 0x10(%rsp)
leaq 0x4220(%r15), %rax
movq %rax, 0x20(%rsp)
leaq 0x4e38(%r15), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
callq 0x15914
testq %rbx, %rbx
je 0x126fe
cmpq $0x0, (%rbx)
je 0x1278f
movq 0x18(%rsp), %r14
movq (%r14), %rax
movq %rax, 0x30(%rsp)
movq %r15, %rdi
leaq 0x30(%rsp), %rbp
movq %rbp, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x127ac
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r13, %r8
movl $0x2a, %r9d
pushq $0x1
pushq $0x0
callq 0xd9c7
addq $0x10, %rsp
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x1278f
movq 0x10(%rsp), %rdi
callq 0x14434
movq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x8503
movq 0x18(%rsp), %r13
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rbp
leaq 0x8(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x127ac
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %r12
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x2a, %r9d
pushq $0x1
pushq $0x0
callq 0xd9c7
addq $0x10, %rsp
movq %r15, %rdi
callq 0x16e84
movq %r14, %rdi
callq 0x85bf
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x1559f
movq %r14, %rdi
callq 0x8584
movq 0x10(%rsp), %rdi
movl $0x2a, %esi
callq 0x14490
cmpl $0x2a, 0x4bd0(%r15)
je 0x12693
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12852
movl 0x4bd0(%r14), %r12d
cmpq $0x36, %r12
ja 0x12843
movabsq $0x71c00000000000, %rax # imm = 0x71C00000000000
btq %r12, %rax
jae 0x12843
leaq 0x4ba8(%r14), %rdi
callq 0x15914
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 0x12852
movl $0x1, %eax
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movl %r12d, %r9d
pushq %rax
pushq %rax
callq 0xd9c7
addq $0x10, %rsp
movq 0x5268(%r14), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x128fe
testq %rbx, %rbx
leaq 0x20(%rsp), %r12
movq %rbx, 0x10(%rsp)
cmoveq %rbx, %r12
leaq 0x4ba8(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rbp
movl $0x1, %r13d
movl 0x4bd0(%r15), %ebx
cmpl $0x1d, %ebx
ja 0x128ef
movl $0x30c00000, %eax       # imm = 0x30C00000
btl %ebx, %eax
jae 0x128ef
movq 0x8(%rsp), %rdi
callq 0x15914
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x128fe
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
movl %ebx, %r9d
pushq %r13
pushq %r13
callq 0xd9c7
addq $0x10, %rsp
jmp 0x12896
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x129ab
leaq 0x4ba8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rbx, %rbx
leaq 0x20(%rsp), %r13
movq %rbx, 0x10(%rsp)
cmoveq %rbx, %r13
leaq 0x18(%rsp), %rbp
movl $0x1, %r12d
movl 0x4bd0(%r15), %ebx
leal -0x18(%rbx), %eax
cmpl $0x4, %eax
jb 0x12959
leal -0x1e(%rbx), %eax
cmpl $0x1, %eax
ja 0x1299c
movq 0x8(%rsp), %rdi
callq 0x15914
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x129ab
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movl %ebx, %r9d
pushq %r12
pushq %r12
callq 0xd9c7
addq $0x10, %rsp
jmp 0x12942
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genInit
void genInit(CodeGen *gen, Storage *storage, DebugInfo *debug, Error *error)
{
    gen->storage = storage;
    gen->capacity = 1000;
    gen->ip = 0;
    gen->code = storageAdd(gen->storage, gen->capacity * sizeof(Instruction));
    gen->top = -1;
    gen->lastJump = 0;
    gen->breaks = gen->continues = gen->returns = NULL;
    gen->debug = debug;
    gen->debugPerInstr = storageAdd(gen->storage, gen->capacity * sizeof(DebugInfo));
    gen->error = error;
    genUnnotify(gen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x1c0(%rdi)
movabsq $0x3e800000000, %rcx    # imm = 0x3E800000000
movq %rcx, 0x8(%rdi)
movl $0x7d00, %esi           # imm = 0x7D00
movq %rax, %rdi
callq 0x7a70
movq %rax, (%rbx)
movl $0xffffffff, 0x1a0(%rbx) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x1a4(%rbx)
movups %xmm0, 0x1b0(%rbx)
movq %r15, 0x1c8(%rbx)
movq 0x1c0(%rbx), %rdi
movslq 0xc(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
callq 0x7a70
movq %rax, 0x1d0(%rbx)
movq %r14, 0x1e0(%rbx)
movl $0x0, 0x1d8(%rbx)
movl 0x8(%rbx), %eax
movl %eax, 0x1dc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12e90
leal (%rdx,%rdx), %eax
movl %eax, 0xc(%rbx)
movq (%rbx), %rsi
movq 0x1c0(%rbx), %rdi
shlq $0x6, %rdx
callq 0x7be8
movq %rax, (%rbx)
movq 0x1c0(%rbx), %rdi
movq 0x1d0(%rbx), %rsi
movslq 0xc(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
callq 0x7be8
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
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movl $0x0, 0x1d8(%rbx)
movl %eax, 0x1dc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genPushReg
static Instruction *getPrevInstr(CodeGen *gen, int depth)
{
    // No branching within the peephole
    if (gen->ip - depth < gen->lastJump)
        return NULL;

    return &gen->code[gen->ip - depth];
}

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x19ef5
testb %al, %al
je 0x13673
movsd 0x6392f(%rip), %xmm0    # 0x76f80
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movq %rbx, %rdi
callq 0x12e36
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 0x133bf
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genChangeLeftRefCntAssign
void genChangeLeftRefCntAssign(CodeGen *gen, const Type *type)
{
    if (typeGarbageCollected(type))
    {
        const Instruction instr = {.opcode = OP_CHANGE_REF_CNT_ASSIGN, .tokKind = TOK_MINUSMINUS, .type = type};
        genAddInstr(gen, &instr);
    }
    else
        genAssign(gen, type->kind, type->size);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x19ef5
testb %al, %al
je 0x136c2
movaps 0x638e2(%rip), %xmm0    # 0x76f90
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
jmp 0x136ec
movl (%r14), %eax
movslq 0xc0(%r14), %rcx
movq %rsp, %rsi
movq $0xe, (%rsi)
movl $0x0, 0x8(%rsi)
movl %eax, 0xc(%rsi)
movq $0x0, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rbx, %rdi
callq 0x12e36
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13b2f
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)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x12e36
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13b85
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)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x12e36
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13bdb
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)
movl $0x0, 0x14(%rax)
movq %rcx, 0x18(%rax)
movq %rax, %rsi
callq 0x12e36
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13b0a
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genGoFromToIf
void genGoFromToIf(CodeGen *gen, int start, int dest)
{
    int next = gen->ip;
    gen->ip = start;
    genGotoIf(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 0x13b60
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13bb6
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x3, %esi
callq 0x130d2
movq (%r14), %rax
movaps 0x62e5e(%rip), %xmm0    # 0x76f30
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x12e36
movq %rbx, %rdi
movl $0x2e, %esi
movq %r15, %rdx
callq 0x137c1
movl 0x8(%rbx), %eax
cmpl %eax, 0x1a4(%rbx)
jge 0x1410d
movl %eax, 0x1a4(%rbx)
movslq 0x1a0(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x1a0(%rbx)
movl %eax, 0x14(%rbx,%rcx,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12e36
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x14188
movl %esi, %ebp
movl 0x8(%rbx), %r15d
leal 0x1(%r15), %r14d
movslq 0x1a0(%rbx), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rbx)
movl 0x10(%rbx,%rax,4), %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13b60
movl %r15d, 0x8(%rbx)
decl %ebp
jne 0x1415c
jmp 0x1418c
movl 0x8(%rbx), %r15d
cmpl %r15d, 0x1a4(%rbx)
jge 0x1419c
movl %r15d, 0x1a4(%rbx)
movslq 0x1a0(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x1a0(%rbx)
movl %r15d, 0x14(%rbx,%rax,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12e36
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x62c1d(%rip), %rsi     # 0x77060
callq 0x12e36
movl 0x8(%rbx), %eax
cmpl %eax, 0x1a4(%rbx)
jge 0x14459
movl %eax, 0x1a4(%rbx)
movslq 0x1a0(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x1a0(%rbx)
movl %eax, 0x14(%rbx,%rcx,4)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12e36
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x131c1
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genShortCircuitEpilog
void genShortCircuitEpilog(CodeGen *gen, TokenKind op)
{
    if (op == TOK_ANDAND)
        genGoFromToIfNot(gen, genRestorePos(gen), gen->ip); // Goto expression end (fixup)
    else
        genGoFromToIf(gen, genRestorePos(gen), gen->ip);    // Goto expression end (fixup)
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1a0(%rdi), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x1a0(%rdi)
movl 0x10(%rdi,%rax,4), %eax
movl 0x8(%rdi), %ebp
movl %eax, 0x8(%rdi)
cmpl $0x2a, %esi
jne 0x144be
movl %ebp, %esi
callq 0x13bb6
jmp 0x144c5
movl %ebp, %esi
callq 0x13b60
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x28, %rsp
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)
leaq 0x8(%rsp), %rax
movl $0x26, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movl $0x0, 0x14(%rax)
movq %rsi, 0x18(%rax)
movq %rax, %rsi
callq 0x12e36
movl %ebp, 0x8(%rbx)
leaq 0x62b9e(%rip), %rsi     # 0x77100
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x12e36
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x8(%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x1a4(%rdi), %ecx
jle 0x145bc
movq %rcx, %rdx
shlq $0x5, %rdx
addq (%rdi), %rdx
movq %rdx, %rsi
addq $-0x20, %rsi
je 0x145bc
cmpl $0x1, (%rsi)
jne 0x145bc
cmpl $0x0, -0x1c(%rdx)
je 0x145bd
retq
movl -0x8(%rdx), %eax
decl %ecx
movl %ecx, 0x8(%rdi)
movl $0x0, 0x1d8(%rdi)
movl %ecx, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x190(%rsi), %eax
cmpl $0x64, %eax
jl 0x1461c
movq 0x1e0(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x62b2f(%rip), %rsi     # 0x77140
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)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12e36
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x629b4(%rip), %rsi     # 0x77060
callq 0x12e36
movq %r15, %rdi
movl %ebx, %esi
callq 0x12f97
movl (%r14), %esi
movl 0xc0(%r14), %edx
movq %r15, %rdi
callq 0x133bf
movl $0x1, 0x1d8(%r15)
movl 0x8(%r15), %eax
movl %eax, 0x1dc(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x1, 0x1d8(%rdi)
jne 0x1479f
movslq 0x1dc(%rdi), %rsi
cmpl 0x8(%rdi), %esi
jne 0x1479f
movl 0x1a4(%rdi), %r8d
cmpl %r8d, %esi
jle 0x14727
movq (%rdi), %rax
movq %rsi, %rcx
shlq $0x5, %rcx
addq %rax, %rcx
addq $-0x20, %rcx
jmp 0x14729
xorl %ecx, %ecx
movq %rsi, %rdx
addq $-0x2, %rdx
xorl %eax, %eax
cmpl %r8d, %edx
jge 0x1473b
xorl %edx, %edx
jmp 0x14742
shlq $0x5, %rdx
addq (%rdi), %rdx
addl $-0x3, %esi
cmpl %r8d, %esi
jl 0x1479f
movq (%rdi), %r8
testq %r8, %r8
je 0x1479f
movslq %esi, %r9
shlq $0x5, %r9
addq %r9, %r8
cmpl $0xa, (%r8)
jne 0x1479f
cmpl $0x0, 0x4(%r8)
jne 0x1479f
testq %rdx, %rdx
je 0x1479f
cmpl $0x3, (%rdx)
jne 0x1479f
cmpl $0x0, 0x4(%rdx)
jne 0x1479f
testq %rcx, %rcx
je 0x1479f
cmpl $0xe, (%rcx)
jne 0x1479f
cmpl $0xb, 0x4(%rcx)
jne 0x1479f
movl 0x18(%rdx), %eax
movl %esi, 0x8(%rdi)
movl $0x0, 0x1d8(%rdi)
movl %esi, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x14a6b
movq %rdi, %r14
cmpl %ebx, 0x114(%rsi)
jne 0x14a6b
movq 0x140(%rsi), %r15
cmpb $0x1, 0x119(%rsi)
jne 0x14a57
movq 0x18(%r14), %rdi
movq 0x120(%rsi), %rsi
callq 0x7bb0
movq (%r14), %rsi
movq 0x18(%r14), %rdi
callq 0x7bb0
movq %r15, (%r14)
movq %r15, %rsi
testq %r15, %r15
jne 0x14a2c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
pushq $0x0
pushq $0x1
callq 0x14a85
addq $0x10, %rsp
movq %rax, %r15
testq %rax, %rax
jne 0x14cad
movq 0x28(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x62501(%rip), %rsi     # 0x771a7
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
movl $0x1, %eax
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0x14a85
addq $0x10, %rsp
movq %rax, %r15
testq %rax, %rax
jne 0x14d07
movq 0x28(%r14), %rcx
movq 0x20(%rcx), %rdi
leaq 0x624bd(%rip), %rsi     # 0x771bd
movq %rbx, %rdx
xorl %eax, %eax
callq *(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x14d5e
cmpl $0x1, (%rsi)
jne 0x14d5e
movl 0x114(%rsi), %ecx
testl %ecx, %ecx
je 0x14d5e
movl 0x964(%rdi), %edx
testl %edx, %edx
js 0x14d5e
xorl %esi, %esi
movl %edx, %eax
leaq (%rax,%rax,2), %r8
cmpl %ecx, (%rdi,%r8,8)
sete %al
andb %sil, %al
jne 0x14d5d
leaq (%rdi,%r8,8), %r8
cmpq $0x0, 0x8(%r8)
setne %r8b
orb %r8b, %sil
leal -0x1(%rdx), %r8d
testl %edx, %edx
movl %r8d, %edx
jg 0x14d30
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl 0x10(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rdi)
leaq 0x621a2(%rip), %rdx     # 0x772e1
leaq 0x10(%rsp), %rbp
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3170
movl $0x0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
movq %r14, %r9
callq 0x14d8c
movq %rbx, 0x120(%rax)
movb $0x1, 0x11b(%rax)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %r8, %rax
movq %rcx, %r8
movq 0x20(%rsp), %rbx
movl %r9d, (%rsp)
movl $0x1, %ecx
movq %rax, %r9
callq 0x14d8c
movq %rbx, 0x120(%rax)
movb $0x1, 0x119(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movl 0x964(%rdx), %eax
testl %eax, %eax
jle 0x15298
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
cmpq $0x0, 0x8(%rdx,%rcx,8)
jne 0x152b0
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
movl %ecx, %eax
jge 0x15280
movq 0x28(%rdi), %rcx
movq 0x20(%rcx), %rdi
leaq 0x61f28(%rip), %rsi     # 0x771cf
xorl %r15d, %r15d
xorl %eax, %eax
callq *(%rcx)
jmp 0x152b8
leaq (%rdx,%rcx,8), %r15
addq $0x10, %r15
movslq (%r15), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19e29
movslq %eax, %r13
addq %r12, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19e94
movslq %eax, %rsi
leaq (%rsi,%r13), %rcx
decq %rcx
movq %rcx, %rax
cqto
idivq %rsi
subl %edx, %ecx
movl %ecx, (%r15)
movl $0xfffffff0, %eax       # imm = 0xFFFFFFF0
subl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
cmpl $0x0, 0x964(%rcx)
je 0x1535f
movq %r13, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x15267
movl %eax, %ebp
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x14d8c
movslq %ebp, %rcx
movq %rcx, 0x120(%rax)
jmp 0x153ab
movq 0x18(%r13), %rbp
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x19e29
movslq %eax, %rsi
movq %rbp, %rdi
callq 0x7a70
movq %rax, %rbp
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x14d8c
movq %rbp, 0x120(%rax)
movb $0x1, 0x119(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %r9d, 0xc(%rsp)
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rdi)
leaq 0x61ef2(%rip), %rdx     # 0x772e1
leaq 0x10(%rsp), %rbp
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3170
movl $0x0, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x152ff
movq %rax, %r15
movb $0x1, 0x11b(%rax)
cmpl $0x0, 0xc(%rsp)
je 0x15453
cmpl $0x0, 0x964(%r14)
jne 0x1544f
movq 0x28(%rbx), %rcx
movq 0x20(%rcx), %rdi
leaq 0x61d9d(%rip), %rsi     # 0x771e8
xorl %eax, %eax
callq *(%rcx)
movq %r15, 0x8(%rbx)
movq %r15, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movq 0x108(%rsi), %rax
movq 0x38(%rax), %rax
movq 0x108(%rax), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x19e8a
movq 0x18(%r14), %rdi
movl $0x201, %esi            # imm = 0x201
callq 0x7a70
movq %rax, %r14
addq $0x4, %rbx
leaq 0x61ce3(%rip), %rdx     # 0x77209
movl $0x201, %esi            # imm = 0x201
movq %rax, %rdi
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3170
movq %r14, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x15913
pushq %rbx
movq %rdi, %rbx
movq 0x258(%rdi), %rdi
callq 0x7bb0
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexNext
void lexNext(Lexer *lex)
{
    do
    {
        lexNextWithEOLN(lex);

        // Replace end of line with implicit semicolon
        if (lex->tok.kind == TOK_EOLN)
            if (lex->prevTok.kind == TOK_BREAK       ||
                lex->prevTok.kind == TOK_CONTINUE    ||
                lex->prevTok.kind == TOK_RETURN      ||
                lex->prevTok.kind == TOK_STR         ||
                lex->prevTok.kind == TOK_PLUSPLUS    ||
                lex->prevTok.kind == TOK_MINUSMINUS  ||
                lex->prevTok.kind == TOK_RPAR        ||
                lex->prevTok.kind == TOK_RBRACKET    ||
                lex->prevTok.kind == TOK_RBRACE      ||
                lex->prevTok.kind == TOK_CARET       ||
                lex->prevTok.kind == TOK_IDENT       ||
                lex->prevTok.kind == TOK_INTNUMBER   ||
                lex->prevTok.kind == TOK_REALNUMBER  ||
                lex->prevTok.kind == TOK_CHARLITERAL ||
                lex->prevTok.kind == TOK_STRLITERAL)
            {
               lex->tok.kind = TOK_IMPLICIT_SEMICOLON;
            }

        lex->prevTok = lex->tok;
    } while (lex->tok.kind == TOK_EOLN);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1599f
leaq 0x28(%rbx), %r14
cmpl $0x4b, 0x28(%rbx)
jne 0x1597d
leaq 0x140(%rbx), %r15
movabsq $0x6a00300000018012, %r12 # imm = 0x6A00300000018012
movl (%r15), %eax
cmpq $0x3e, %rax
ja 0x1594e
btq %rax, %r12
jb 0x15976
addl $-0x45, %eax
cmpl $0x5, %eax
jb 0x15976
movl $0x118, %edx            # imm = 0x118
movq %r15, %rdi
movq %r14, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x1599f
cmpl $0x4b, 0x28(%rbx)
je 0x1593f
jmp 0x1597d
movl $0x4a, (%r14)
addq $0x140, %rbx            # imm = 0x140
movl $0x118, %edx            # imm = 0x118
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexNextForcedSemicolon
void lexNextForcedSemicolon(Lexer *lex)
{
    lexNextWithEOLN(lex);

    // Replace end of line with implicit semicolon
    if (lex->tok.kind == TOK_EOLN)
        lex->tok.kind = TOK_IMPLICIT_SEMICOLON;

    lex->prevTok = lex->tok;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1599f
leaq 0x28(%rbx), %rsi
cmpl $0x4b, 0x28(%rbx)
jne 0x16314
movl $0x4a, (%rsi)
addq $0x140, %rbx            # imm = 0x140
movl $0x118, %edx            # imm = 0x118
movq %rbx, %rdi
popq %rbx
jmp 0x3260
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexCheck
bool lexCheck(Lexer *lex, TokenKind kind)
{
    bool res = lex->tok.kind == kind || (lex->tok.kind == TOK_IMPLICIT_SEMICOLON && kind == TOK_SEMICOLON);
    if (!res)
        lex->error->handler(lex->error->context, "%s expected but %s found", lexSpelling(kind), lexSpelling(lex->tok.kind));
    return res;
}

// Assembly:
pushq %rbx
movl 0x28(%rdi), %eax
movb $0x1, %bl
cmpl %esi, %eax
je 0x1636b
movl %eax, %ecx
xorl $0x4a, %ecx
movl %esi, %edx
xorl $0x40, %edx
orl %ecx, %edx
je 0x1636b
movq 0x268(%rdi), %r8
movq 0x20(%r8), %rdi
movl %esi, %ecx
leaq 0x7055b(%rip), %rsi     # 0x868b0
movq (%rsi,%rcx,8), %rdx
movq (%rsi,%rax,8), %rcx
leaq 0x61077(%rip), %rsi     # 0x773db
xorl %ebx, %ebx
xorl %eax, %eax
callq *(%r8)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexEat
void lexEat(Lexer *lex, TokenKind kind)
{
    // Allow omitting semicolon before ")" or "}"
    if (!(kind == TOK_SEMICOLON && (lex->tok.kind == TOK_RPAR || lex->tok.kind == TOK_RBRACE)))
    {
        lexCheck(lex, kind);
        lexNext(lex);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x40, %esi
jne 0x1639a
movl 0x28(%rbx), %eax
cmpl $0x3f, %eax
jg 0x163ab
cmpl $0x39, %eax
je 0x16398
cmpl $0x3d, %eax
jne 0x163b5
popq %rbx
retq
movq %rbx, %rdi
callq 0x16329
movq %rbx, %rdi
popq %rbx
jmp 0x15914
cmpl $0x40, %eax
je 0x163a2
cmpl $0x4a, %eax
je 0x163a2
movq 0x268(%rbx), %r8
movq 0x20(%r8), %rdi
leaq 0x704e9(%rip), %rcx     # 0x868b0
movq (%rcx,%rax,8), %rcx
leaq 0x61009(%rip), %rsi     # 0x773db
leaq 0x610b8(%rip), %rdx     # 0x77491
xorl %eax, %eax
callq *(%r8)
jmp 0x163a2
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexChar
static char lexChar(Lexer *lex)
{
    char ch = lex->buf[lex->bufPos];
    if (ch)
    {
        lex->bufPos++;
        lex->pos++;
        if (ch == '\n')
        {
            lex->line++;
            lex->pos = 1;
        }
    }
    return lex->buf[lex->bufPos];
}

// Assembly:
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
movb (%rax,%rcx), %dl
testb %dl, %dl
je 0x16415
incl %ecx
movl %ecx, 0x18(%rdi)
incl 0x20(%rdi)
cmpb $0xa, %dl
jne 0x16415
incl 0x1c(%rdi)
movl $0x1, 0x20(%rdi)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_lexer.c
// Function: lexCharDigit
static int lexCharDigit(char c, int base)
{
    switch (base)
    {
        case 10: return c >= '0' && c <= '9' ? c - '0' : -1;
        case 16: return c >= '0' && c <= '9' ? c - '0' :
                        c >= 'a' && c <= 'f' ? c - 'a' + 10 :
                        c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
    }
    return -1;
}

// Assembly:
cmpl $0x10, %esi
je 0x16443
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xa, %esi
jne 0x16442
movzbl %dil, %ecx
addb $-0x30, %dil
addl $-0x30, %ecx
cmpb $0xa, %dil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbl %ecx, %eax
retq
movsbl %dil, %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x16453
addl $-0x30, %eax
retq
leal -0x61(%rdi), %ecx
cmpb $0x5, %cl
ja 0x1645f
addl $-0x57, %eax
retq
addb $-0x41, %dil
addl $-0x37, %eax
cmpb $0x6, %dil
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovbl %eax, %ecx
movl %ecx, %eax
retq