LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_ln
int ft_ln(ft_table_t *table)
{
    assert(table);
    fort_entire_table_properties_t *table_props = &table->properties->entire_table_properties;
    switch (table_props->add_strategy) {
        case FT_STRATEGY_INSERT: {
            f_row_t *new_row = NULL;
            if (FT_IS_ERROR(split_cur_row(table, &new_row))) {
                return FT_GEN_ERROR;
            }
            if (new_row) {
                if (FT_IS_ERROR(vector_insert(table->rows, &new_row, table->cur_row + 1))) {
                    destroy_row(new_row);
                    return FT_GEN_ERROR;
                }
            }
            break;
        }
        case FT_STRATEGY_REPLACE:
            // do nothing
            break;
        default:
            assert(0 && "Unexpected situation inside libfort");
            break;
    }
    table->cur_col = 0;
    table->cur_row++;
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13955
jmp 0x13974
leaq 0xf234(%rip), %rdi      # 0x22b90
leaq 0xf233(%rip), %rsi      # 0x22b96
movl $0xad5, %edx            # imm = 0xAD5
leaq 0xf23a(%rip), %rcx      # 0x22ba9
callq 0x7120
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x13a04
jmp 0x13996
movl -0x24(%rbp), %eax
subl $0x1, %eax
jne 0x13a06
jmp 0x139a0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13a60
cmpl $0x0, %eax
jge 0x139c6
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x13a48
cmpq $0x0, -0x20(%rbp)
je 0x13a02
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
leaq -0x20(%rbp), %rsi
callq 0x13b40
cmpl $0x0, %eax
jge 0x13a00
movq -0x20(%rbp), %rdi
callq 0x13300
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x13a48
jmp 0x13a02
jmp 0x13a25
jmp 0x13a25
leaq 0xf1b4(%rip), %rdi      # 0x22bc1
leaq 0xf182(%rip), %rsi      # 0x22b96
movl $0xae9, %edx            # imm = 0xAE9
leaq 0xf189(%rip), %rcx      # 0x22ba9
callq 0x7120
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: split_cur_row
static int split_cur_row(ft_table_t *table, f_row_t **tail_of_cur_row)
{
    if (table->cur_row >= vector_size(table->rows)) {
        tail_of_cur_row = NULL;
        return 0;
    }

    f_row_t *row = VECTOR_AT(table->rows, table->cur_row, f_row_t *);
    if (table->cur_col >= columns_in_row(row)) {
        tail_of_cur_row = NULL;
        return 0;
    }

    f_row_t *tail = split_row(row, table->cur_col);
    if (!tail) {
        tail_of_cur_row = NULL;
        return FT_GEN_ERROR;
    }

    *tail_of_cur_row = tail;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x13aa8
movq $0x0, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x13b34
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14270
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jb 0x13af5
movq $0x0, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x13b34
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x16d60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x13b22
movq $0x0, -0x18(%rbp)
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x13b34
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_row_erase_range
FT_INTERNAL
int ft_row_erase_range(f_row_t *row, size_t left, size_t right)
{
    assert(row);
    size_t cols_n = vector_size(row->cells);
    if (cols_n == 0 || (right < left))
        return FT_SUCCESS;

    f_cell_t *cell = NULL;
    size_t i = left;
    while (i < cols_n && i <= right) {
        cell = VECTOR_AT(row->cells, i, f_cell_t *);
        destroy_cell(cell);
        ++i;
    }
    size_t n_destroy = MIN(cols_n - 1, right) - left + 1;
    while (n_destroy--) {
        vector_erase(row->cells, left);
    }
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1414d
jmp 0x1416c
leaq 0xf6f0(%rip), %rdi      # 0x23844
leaq 0xea3b(%rip), %rsi      # 0x22b96
movl $0x1500, %edx           # imm = 0x1500
leaq 0x104ba(%rip), %rcx     # 0x24621
callq 0x7120
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1418d
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x14199
movl $0x0, -0x4(%rbp)
jmp 0x1425f
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x141c6
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
setbe %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x141cf
jmp 0x141fd
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x17010
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x141a9
movq -0x28(%rbp), %rax
subq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x14219
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x14221
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
subq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x40(%rbp)
cmpq $0x0, %rax
je 0x14258
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x142c0
jmp 0x14231
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: vector_erase
FT_INTERNAL
int vector_erase(f_vector_t *vector, size_t index)
{
    assert(vector);

    if (vector->m_size == 0 || index >= vector->m_size)
        return FT_GEN_ERROR;

    memmove((char *)vector->m_data + vector->m_item_size * index,
            (char *)vector->m_data + vector->m_item_size * (index + 1),
            (vector->m_size - 1 - index) * vector->m_item_size);
    vector->m_size--;
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x142d9
jmp 0x142f8
leaq 0xf651(%rip), %rdi      # 0x23931
leaq 0xe8af(%rip), %rsi      # 0x22b96
movl $0x1d1b, %edx           # imm = 0x1D1B
leaq 0x104a5(%rip), %rcx     # 0x24798
callq 0x7120
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1430f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x14318
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x14381
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
subq $0x1, %rdx
subq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rdx
callq 0x7200
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_printf
int FT_PRINTF(ft_table_t *table, const char *fmt, ...)
{
    assert(table);
    va_list va;
    va_start(va, fmt);

    struct f_string_view fmt_str;
    fmt_str.type = CHAR_BUF;
    fmt_str.u.cstr = fmt;
    int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
    va_end(va);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x143ce
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x143fb
jmp 0x1441a
leaq 0xe78e(%rip), %rdi      # 0x22b90
leaq 0xe78d(%rip), %rsi      # 0x22b96
movl $0xb91, %edx            # imm = 0xB91
leaq 0xe8f8(%rip), %rcx      # 0x22d0d
callq 0x7120
leaq -0x100(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq 0x18(%rdi), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x14470
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_printf_ln
int FT_PRINTF_LN(ft_table_t *table, const char *fmt, ...)
{
    assert(table);
    va_list va;
    va_start(va, fmt);

    struct f_string_view fmt_str;
    fmt_str.type = CHAR_BUF;
    fmt_str.u.cstr = fmt;
    int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
    if (result >= 0) {
        ft_ln(table);
    }
    va_end(va);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1467e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x146ab
jmp 0x146ca
leaq 0xe4de(%rip), %rdi      # 0x22b90
leaq 0xe4dd(%rip), %rsi      # 0x22b96
movl $0xb9f, %edx            # imm = 0xB9F
leaq 0xe677(%rip), %rcx      # 0x22d3c
callq 0x7120
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x14470
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x14728
movq -0x8(%rbp), %rdi
callq 0x13940
movl -0x44(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_wprintf
int ft_wprintf(ft_table_t *table, const wchar_t *fmt, ...)
{
    assert(table);
    va_list va;
    va_start(va, fmt);

    struct f_string_view fmt_str;
    fmt_str.type = W_CHAR_BUF;
    fmt_str.u.wstr = fmt;
    int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
    va_end(va);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1477e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x147ab
jmp 0x147ca
leaq 0xe3de(%rip), %rdi      # 0x22b90
leaq 0xe3dd(%rip), %rsi      # 0x22b96
movl $0xbb4, %edx            # imm = 0xBB4
leaq 0xe5a9(%rip), %rcx      # 0x22d6e
callq 0x7120
leaq -0x100(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq 0x18(%rdi), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x14470
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_wprintf_ln
int ft_wprintf_ln(ft_table_t *table, const wchar_t *fmt, ...)
{
    assert(table);
    va_list va;
    va_start(va, fmt);

    struct f_string_view fmt_str;
    fmt_str.type = W_CHAR_BUF;
    fmt_str.u.wstr = fmt;
    int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
    if (result >= 0) {
        ft_ln(table);
    }
    va_end(va);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1485e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1488b
jmp 0x148aa
leaq 0xe2fe(%rip), %rdi      # 0x22b90
leaq 0xe2fd(%rip), %rsi      # 0x22b96
movl $0xbc2, %edx            # imm = 0xBC2
leaq 0xe4fc(%rip), %rcx      # 0x22da1
callq 0x7120
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x1, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x14470
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x14908
movq -0x8(%rbp), %rdi
callq 0x13940
movl -0x44(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_nwrite
int ft_nwrite(ft_table_t *table, size_t count, const char *cell_content, ...)
{
    size_t i = 0;
    assert(table);
    int status = ft_write_impl(table, cell_content);
    if (FT_IS_ERROR(status))
        return status;

    va_list va;
    va_start(va, cell_content);
    --count;
    for (i = 0; i < count; ++i) {
        const char *cell = va_arg(va, const char *);
        status = ft_write_impl(table, cell);
        if (FT_IS_ERROR(status)) {
            va_end(va);
            return status;
        }
    }
    va_end(va);
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x14981
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x149b3
jmp 0x149d2
leaq 0xe1d6(%rip), %rdi      # 0x22b90
leaq 0xe1d5(%rip), %rsi      # 0x22b96
movl $0xc17, %edx            # imm = 0xC17
leaq 0xe40a(%rip), %rcx      # 0x22dd7
callq 0x7120
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14af0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x149f3
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14ade
leaq -0x50(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x14ad4
leaq -0x50(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x14a74
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x14a91
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x14af0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x14ac1
leaq -0x50(%rbp), %rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14ade
jmp 0x14ac3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14a2b
leaq -0x50(%rbp), %rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_nwwrite
int ft_nwwrite(ft_table_t *table, size_t n, const wchar_t *cell_content, ...)
{
    size_t i = 0;
    assert(table);
    int status = ft_wwrite_impl(table, cell_content);
    if (FT_IS_ERROR(status))
        return status;

    va_list va;
    va_start(va, cell_content);
    --n;
    for (i = 0; i < n; ++i) {
        const wchar_t *cell = va_arg(va, const wchar_t *);
        status = ft_wwrite_impl(table, cell);
        if (FT_IS_ERROR(status)) {
            va_end(va);
            return status;
        }
    }
    va_end(va);
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x14d31
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14d63
jmp 0x14d82
leaq 0xde26(%rip), %rdi      # 0x22b90
leaq 0xde25(%rip), %rsi      # 0x22b96
movl $0xc4c, %edx            # imm = 0xC4C
leaq 0xe0cb(%rip), %rcx      # 0x22e48
callq 0x7120
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14ea0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x14da3
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14e8e
leaq -0x50(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x14e84
leaq -0x50(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x14e24
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x14e41
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x14ea0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x14e71
leaq -0x50(%rbp), %rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14e8e
jmp 0x14e73
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14ddb
leaq -0x50(%rbp), %rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_row_write
int ft_row_write(ft_table_t *table, size_t cols, const char *cells[])
{
    size_t i = 0;
    assert(table);
    for (i = 0; i < cols; ++i) {
        int status = ft_write_impl(table, cells[i]);
        if (FT_IS_ERROR(status)) {
            /* todo: maybe current pos in case of error should be equal to the one before function call? */
            return status;
        }
    }
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x150c5
jmp 0x150e4
leaq 0xdac4(%rip), %rdi      # 0x22b90
leaq 0xdac3(%rip), %rsi      # 0x22b96
movl $0xc7e, %edx            # imm = 0xC7E
leaq 0xdde2(%rip), %rcx      # 0x22ec1
callq 0x7120
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1512c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14af0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x1511c
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15133
jmp 0x1511e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x150ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_row_write_ln
int ft_row_write_ln(ft_table_t *table, size_t cols, const char *cells[])
{
    assert(table);
    int status = ft_row_write(table, cols, cells);
    if (FT_IS_SUCCESS(status)) {
        ft_ln(table);
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1515d
jmp 0x1517c
leaq 0xda2c(%rip), %rdi      # 0x22b90
leaq 0xda2b(%rip), %rsi      # 0x22b96
movl $0xc8b, %edx            # imm = 0xC8B
leaq 0xdd80(%rip), %rcx      # 0x22ef7
callq 0x7120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x150a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1519f
movq -0x8(%rbp), %rdi
callq 0x13940
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_row_wwrite
int ft_row_wwrite(ft_table_t *table, size_t cols, const wchar_t *cells[])
{
    size_t i = 0;
    assert(table);
    for (i = 0; i < cols; ++i) {
        int status = ft_wwrite_impl(table, cells[i]);
        if (FT_IS_ERROR(status)) {
            /* todo: maybe current pos in case of error should be equal
             * to the one before function call?
             */
            return status;
        }
    }
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x151d5
jmp 0x151f4
leaq 0xd9b4(%rip), %rdi      # 0x22b90
leaq 0xd9b3(%rip), %rsi      # 0x22b96
movl $0xc97, %edx            # imm = 0xC97
leaq 0xdd41(%rip), %rcx      # 0x22f30
callq 0x7120
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1523c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14ea0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x1522c
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15243
jmp 0x1522e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x151fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_row_wwrite_ln
int ft_row_wwrite_ln(ft_table_t *table, size_t cols, const wchar_t *cells[])
{
    assert(table);
    int status = ft_row_wwrite(table, cols, cells);
    if (FT_IS_SUCCESS(status)) {
        ft_ln(table);
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1526d
jmp 0x1528c
leaq 0xd91c(%rip), %rdi      # 0x22b90
leaq 0xd91b(%rip), %rsi      # 0x22b96
movl $0xca6, %edx            # imm = 0xCA6
leaq 0xdce3(%rip), %rcx      # 0x22f6a
callq 0x7120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x151b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x152af
movq -0x8(%rbp), %rdi
callq 0x13940
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_table_write
int ft_table_write(ft_table_t *table, size_t rows, size_t cols, const char *table_cells[])
{
    size_t i = 0;
    assert(table);
    for (i = 0; i < rows; ++i) {
        int status = ft_row_write(table, cols, (const char **)&table_cells[i * cols]);
        if (FT_IS_ERROR(status)) {
            /* todo: maybe current pos in case of error should be equal
             * to the one before function call?
             */
            return status;
        }
        if (i != rows - 1)
            ft_ln(table);
    }
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x152e9
jmp 0x15308
leaq 0xd8a0(%rip), %rdi      # 0x22b90
leaq 0xd89f(%rip), %rsi      # 0x22b96
movl $0xcb4, %edx            # imm = 0xCB4
leaq 0xdca4(%rip), %rcx      # 0x22fa7
callq 0x7120
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x15376
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
imulq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x150a0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x1534c
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1537d
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x15366
movq -0x10(%rbp), %rdi
callq 0x13940
jmp 0x15368
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15310
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_table_write_ln
int ft_table_write_ln(ft_table_t *table, size_t rows, size_t cols, const char *table_cells[])
{
    assert(table);
    int status = ft_table_write(table, rows, cols, table_cells);
    if (FT_IS_SUCCESS(status)) {
        ft_ln(table);
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x153b1
jmp 0x153d0
leaq 0xd7d8(%rip), %rdi      # 0x22b90
leaq 0xd7d7(%rip), %rsi      # 0x22b96
movl $0xcc5, %edx            # imm = 0xCC5
leaq 0xdc1c(%rip), %rcx      # 0x22fe7
callq 0x7120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x152c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x153f7
movq -0x8(%rbp), %rdi
callq 0x13940
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_table_wwrite
int ft_table_wwrite(ft_table_t *table, size_t rows, size_t cols, const wchar_t *table_cells[])
{
    size_t i = 0;
    assert(table);
    for (i = 0; i < rows; ++i) {
        int status = ft_row_wwrite(table, cols, (const wchar_t **)&table_cells[i * cols]);
        if (FT_IS_ERROR(status)) {
            /* todo: maybe current pos in case of error should be equal
             * to the one before function call?
             */
            return status;
        }
        if (i != rows - 1)
            ft_ln(table);
    }
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15429
jmp 0x15448
leaq 0xd760(%rip), %rdi      # 0x22b90
leaq 0xd75f(%rip), %rsi      # 0x22b96
movl $0xcd2, %edx            # imm = 0xCD2
leaq 0xdbe7(%rip), %rcx      # 0x2302a
callq 0x7120
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x154b6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
imulq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x151b0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x1548c
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x154bd
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x154a6
movq -0x10(%rbp), %rdi
callq 0x13940
jmp 0x154a8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15450
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_table_wwrite_ln
int ft_table_wwrite_ln(ft_table_t *table, size_t rows, size_t cols, const wchar_t *table_cells[])
{
    assert(table);
    int status = ft_table_wwrite(table, rows, cols, table_cells);
    if (FT_IS_SUCCESS(status)) {
        ft_ln(table);
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x154f1
jmp 0x15510
leaq 0xd698(%rip), %rdi      # 0x22b90
leaq 0xd697(%rip), %rsi      # 0x22b96
movl $0xce3, %edx            # imm = 0xCE3
leaq 0xdb63(%rip), %rcx      # 0x2306e
callq 0x7120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x15400
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x15537
movq -0x8(%rbp), %rdi
callq 0x13940
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_add_separator
int ft_add_separator(ft_table_t *table)
{
    assert(table);
    assert(table->separators);

    while (vector_size(table->separators) <= table->cur_row) {
        f_separator_t *sep_p = create_separator(F_FALSE);
        if (sep_p == NULL)
            return FT_MEMORY_ERROR;
        int status = vector_push(table->separators, &sep_p);
        if (FT_IS_ERROR(status))
            return status;
    }

    f_separator_t **sep_p = &VECTOR_AT(table->separators, table->cur_row, f_separator_t *);
    if (*sep_p == NULL)
        *sep_p = create_separator(F_TRUE);
    else
        (*sep_p)->enabled = F_TRUE;

    if (*sep_p == NULL)
        return FT_GEN_ERROR;
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15b15
jmp 0x15b34
leaq 0xd074(%rip), %rdi      # 0x22b90
leaq 0xd073(%rip), %rsi      # 0x22b96
movl $0xd5c, %edx            # imm = 0xD5C
leaq 0xd586(%rip), %rcx      # 0x230b5
callq 0x7120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x15b41
jmp 0x15b60
leaq 0xd590(%rip), %rdi      # 0x230d8
leaq 0xd047(%rip), %rsi      # 0x22b96
movl $0xd5d, %edx            # imm = 0xD5D
leaq 0xd55a(%rip), %rcx      # 0x230b5
callq 0x7120
jmp 0x15b62
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x132b0
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x15bbb
xorl %edi, %edi
callq 0x15c30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15b97
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15c1b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13720
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x15bb9
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15c1b
jmp 0x15b62
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x13350
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15bf4
movl $0x1, %edi
callq 0x15c30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x15c01
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15c14
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x15c1b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: create_separator
FT_INTERNAL
f_separator_t *create_separator(int enabled)
{
    f_separator_t *res = (f_separator_t *)F_CALLOC(1, sizeof(f_separator_t));
    if (res == NULL)
        return NULL;
    res->enabled = enabled;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x1, %edi
movl $0x4, %esi
callq *0x145d5(%rip)          # 0x2a220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15c60
movq $0x0, -0x8(%rbp)
jmp 0x15c71
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_set_border_style
int ft_set_border_style(ft_table_t *table, const struct ft_border_style *style)
{
    assert(table);
    if (table->properties == NULL) {
        table->properties = create_table_properties();
        if (table->properties == NULL)
            return FT_MEMORY_ERROR;
    }
    set_border_props_for_props(table->properties, style);
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16039
jmp 0x16058
leaq 0xcb50(%rip), %rdi      # 0x22b90
leaq 0xcb4f(%rip), %rsi      # 0x22b96
movl $0xde1, %edx            # imm = 0xDE1
leaq 0xd097(%rip), %rcx      # 0x230ea
callq 0x7120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16089
callq 0x130e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16087
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x160a1
jmp 0x16089
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15cb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_set_cell_prop
int ft_set_cell_prop(ft_table_t *table, size_t row, size_t col, uint32_t property, int value)
{
    assert(table);

    if (table->properties == NULL) {
        table->properties = create_table_properties();
        if (table->properties == NULL)
            return FT_MEMORY_ERROR;
    }
    if (table->properties->cell_properties == NULL) {
        table->properties->cell_properties = create_cell_prop_container();
        if (table->properties->cell_properties == NULL) {
            return FT_GEN_ERROR;
        }
    }

    if (row == FT_CUR_ROW)
        row = table->cur_row;
    if (col == FT_CUR_COLUMN)
        col = table->cur_col;

    return set_cell_property(table->properties->cell_properties, row, col, property, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x160d4
jmp 0x160f3
leaq 0xcab5(%rip), %rdi      # 0x22b90
leaq 0xcab4(%rip), %rsi      # 0x22b96
movl $0xdef, %edx            # imm = 0xDEF
leaq 0xd042(%rip), %rcx      # 0x23130
callq 0x7120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16127
callq 0x130e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16125
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x161c1
jmp 0x16127
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x160(%rax)
jne 0x1616d
callq 0x161d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x160(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x160(%rax)
jne 0x1616b
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x161c1
jmp 0x1616d
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpq %rax, -0x18(%rbp)
jne 0x16184
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpq %rax, -0x20(%rbp)
jne 0x1619b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x160(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
callq 0x16200
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: set_cell_property
FT_INTERNAL
f_status set_cell_property(f_cell_prop_container_t *cont, size_t row, size_t col, uint32_t property, int value)
{
    f_cell_props_t *opt = get_cell_prop_and_create_if_not_exists(cont, row, col);
    if (opt == NULL)
        return FT_GEN_ERROR;

    return set_cell_property_impl(opt, property, value);
    /*
    PROP_SET(opt->propertiess, property);
    if (PROP_IS_SET(property, FT_CPROP_MIN_WIDTH)) {
        opt->col_min_width = value;
    } else if (PROP_IS_SET(property, FT_CPROP_TEXT_ALIGN)) {
        opt->align = value;
    }

    return FT_SUCCESS;
    */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ddd0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x16240
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x16252
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x1df10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_set_tbl_prop
int ft_set_tbl_prop(ft_table_t *table, uint32_t property, int value)
{
    assert(table);

    if (table->properties == NULL) {
        table->properties = create_table_properties();
        if (table->properties == NULL)
            return FT_MEMORY_ERROR;
    }
    return set_entire_table_property(table->properties, property, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1631b
jmp 0x1633a
leaq 0xc86e(%rip), %rdi      # 0x22b90
leaq 0xc86d(%rip), %rsi      # 0x22b96
movl $0xe12, %edx            # imm = 0xE12
leaq 0xce3d(%rip), %rcx      # 0x23172
callq 0x7120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1636b
callq 0x130e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16369
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16381
jmp 0x1636b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x16390
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: set_memory_funcs
FT_INTERNAL
void set_memory_funcs(void *(*f_malloc)(size_t size), void (*f_free)(void *ptr))
{
    assert((f_malloc == NULL && f_free == NULL) /* Use std functions */
           || (f_malloc != NULL && f_free != NULL) /* Use custom functions */);

    if (f_malloc == NULL && f_free == NULL) {
#if defined(FT_GCC_COMPILER) || defined(FT_CLANG_COMPILER)
        fort_malloc = &malloc;
        fort_free = &free;
        fort_calloc = &calloc;
        fort_realloc = &realloc;
#else
        fort_malloc = &local_malloc;
        fort_free = &local_free;
        fort_calloc = &local_calloc;
        fort_realloc = &local_realloc;
#endif
    } else {
        fort_malloc = f_malloc;
        fort_free = f_free;
        fort_calloc = &custom_fort_calloc;
        fort_realloc = &custom_fort_realloc;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1643e
cmpq $0x0, -0x10(%rbp)
je 0x1644c
cmpq $0x0, -0x8(%rbp)
je 0x1644e
cmpq $0x0, -0x10(%rbp)
je 0x1644e
jmp 0x1646d
leaq 0xdf67(%rip), %rdi      # 0x243bc
leaq 0xc73a(%rip), %rsi      # 0x22b96
movl $0xf03, %edx            # imm = 0xF03
leaq 0xdfa1(%rip), %rcx      # 0x24409
callq 0x7120
cmpq $0x0, -0x8(%rbp)
jne 0x164b5
cmpq $0x0, -0x10(%rbp)
jne 0x164b5
movq 0x13b4e(%rip), %rax     # 0x29fd0
movq %rax, 0x13f2f(%rip)     # 0x2a3b8
movq 0x13b08(%rip), %rax     # 0x29f98
movq %rax, 0x13d91(%rip)     # 0x2a228
movq 0x13b22(%rip), %rax     # 0x29fc0
movq %rax, 0x13d7b(%rip)     # 0x2a220
movq 0x13b2c(%rip), %rax     # 0x29fd8
movq %rax, 0x13f0d(%rip)     # 0x2a3c0
jmp 0x164e7
movq -0x8(%rbp), %rax
movq %rax, 0x13ef8(%rip)     # 0x2a3b8
movq -0x10(%rbp), %rax
movq %rax, 0x13d5d(%rip)     # 0x2a228
leaq 0x780e(%rip), %rax      # 0x1dce0
movq %rax, 0x13d47(%rip)     # 0x2a220
leaq 0x7850(%rip), %rax      # 0x1dd30
movq %rax, 0x13ed9(%rip)     # 0x2a3c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_strerror
const char *ft_strerror(int error_code)
{
    switch (error_code) {
        case FT_MEMORY_ERROR:
            return "Out of memory";
        case FT_GEN_ERROR:
            return "General error";
        case FT_EINVAL:
            return "Invalid argument";
        case FT_INTERN_ERROR:
            return "Internal libfort error";
        default:
            if (error_code < 0)
                return "Unknown error code";
            else
                return "Success";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x16550
movq -0x18(%rbp), %rax
leaq 0xc1ed(%rip), %rcx      # 0x22700
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xcc80(%rip), %rax      # 0x231a3
movq %rax, -0x8(%rbp)
jmp 0x1656e
leaq 0xcc81(%rip), %rax      # 0x231b1
movq %rax, -0x8(%rbp)
jmp 0x1656e
leaq 0xcc82(%rip), %rax      # 0x231bf
movq %rax, -0x8(%rbp)
jmp 0x1656e
leaq 0xcc86(%rip), %rax      # 0x231d0
movq %rax, -0x8(%rbp)
jmp 0x1656e
cmpl $0x0, -0xc(%rbp)
jge 0x16563
leaq 0xcc8a(%rip), %rax      # 0x231e7
movq %rax, -0x8(%rbp)
jmp 0x1656e
leaq 0xcc90(%rip), %rax      # 0x231fa
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_set_cell_span
int ft_set_cell_span(ft_table_t *table, size_t row, size_t col, size_t hor_span)
{
    assert(table);
    if (hor_span < 2)
        return FT_EINVAL;

    if (row == FT_CUR_ROW)
        row = table->cur_row;
    if (row == FT_CUR_COLUMN)
        col = table->cur_col;

    f_row_t *row_p = get_row_and_create_if_not_exists(table, row);
    if (row_p == NULL)
        return FT_GEN_ERROR;

    return row_set_cell_span(row_p, col, hor_span);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x165a1
jmp 0x165c0
leaq 0xc5e8(%rip), %rdi      # 0x22b90
leaq 0xc5e7(%rip), %rsi      # 0x22b96
movl $0xe36, %edx            # imm = 0xE36
leaq 0xcc47(%rip), %rcx      # 0x23202
callq 0x7120
cmpq $0x2, -0x28(%rbp)
jae 0x165d0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16633
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpq %rax, -0x18(%rbp)
jne 0x165e7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpq %rax, -0x18(%rbp)
jne 0x165fe
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16640
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1661f
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x16633
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x16670
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: row_set_cell_span
FT_INTERNAL
f_status row_set_cell_span(f_row_t *row, size_t cell_column, size_t hor_span)
{
    assert(row);

    if (hor_span < 2)
        return FT_EINVAL;

    f_cell_t *main_cell = get_cell_and_create_if_not_exists(row, cell_column);
    if (main_cell == NULL) {
        return FT_GEN_ERROR;
    }
    set_cell_type(main_cell, GROUP_MASTER_CELL);
    --hor_span;
    ++cell_column;

    while (hor_span) {
        f_cell_t *slave_cell = get_cell_and_create_if_not_exists(row, cell_column);
        if (slave_cell == NULL) {
            return FT_GEN_ERROR;
        }
        set_cell_type(slave_cell, GROUP_SLAVE_CELL);
        --hor_span;
        ++cell_column;
    }

    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1668d
jmp 0x166ac
leaq 0xd1b0(%rip), %rdi      # 0x23844
leaq 0xc4fb(%rip), %rsi      # 0x22b96
movl $0x15c1, %edx           # imm = 0x15C1
leaq 0xdfac(%rip), %rcx      # 0x24653
callq 0x7120
cmpq $0x2, -0x20(%rbp)
jae 0x166bf
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1675d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17970
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x166e0
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1675d
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1e500
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16756
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17970
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1672e
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1675d
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x1e500
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16706
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)