LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_u8nwrite
int ft_u8nwrite(ft_table_t *table, size_t n, const void *cell_content, ...)
{
    size_t i = 0;
    assert(table);
    int status = ft_u8write_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 void *cell = va_arg(va, const void *);
        status = ft_u8write_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 0x167b1
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 0x167e3
jmp 0x16802
leaq 0xc3a6(%rip), %rdi      # 0x22b90
leaq 0xc3a5(%rip), %rsi      # 0x22b96
movl $0xe4b, %edx            # imm = 0xE4B
leaq 0xca40(%rip), %rcx      # 0x2323d
callq 0x7120
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16920
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x16823
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1690e
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 0x16904
leaq -0x50(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x168a4
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 0x168c1
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 0x16920
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x168f1
leaq -0x50(%rbp), %rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1690e
jmp 0x168f3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1685b
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_u8nwrite_ln
int ft_u8nwrite_ln(ft_table_t *table, size_t n, const void *cell_content, ...)
{
    size_t i = 0;
    assert(table);
    int status = ft_u8write_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 void *cell = va_arg(va, const void *);
        status = ft_u8write_impl(table, cell);
        if (FT_IS_ERROR(status)) {
            va_end(va);
            return status;
        }
    }
    va_end(va);

    ft_ln(table);
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x169a1
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 0x169d3
jmp 0x169f2
leaq 0xc1b6(%rip), %rdi      # 0x22b90
leaq 0xc1b5(%rip), %rsi      # 0x22b96
movl $0xe63, %edx            # imm = 0xE63
leaq 0xc889(%rip), %rcx      # 0x23276
callq 0x7120
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16920
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x16a13
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16b07
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 0x16af4
leaq -0x50(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x16a94
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 0x16ab1
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 0x16920
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x16ae1
leaq -0x50(%rbp), %rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16b07
jmp 0x16ae3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x16a4b
leaq -0x50(%rbp), %rax
movq -0x10(%rbp), %rdi
callq 0x13940
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_u8printf
int ft_u8printf(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 = UTF8_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 0x16b5e
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 0x16b8b
jmp 0x16baa
leaq 0xbffe(%rip), %rdi      # 0x22b90
leaq 0xbffd(%rip), %rsi      # 0x22b96
movl $0xe7c, %edx            # imm = 0xE7C
leaq 0xc70d(%rip), %rcx      # 0x232b2
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 $0x2, -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_u8printf_ln
int ft_u8printf_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 = UTF8_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 0x16c3e
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 0x16c6b
jmp 0x16c8a
leaq 0xbf1e(%rip), %rdi      # 0x22b90
leaq 0xbf1d(%rip), %rsi      # 0x22b96
movl $0xe8b, %edx            # imm = 0xE8B
leaq 0xc65e(%rip), %rcx      # 0x232e3
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 $0x2, -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 0x16ce8
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: split_row
FT_INTERNAL
f_row_t *split_row(f_row_t *row, size_t pos)
{
    assert(row);

    f_vector_t *cells = vector_split(row->cells, pos);
    if (!cells)
        return NULL;
    f_row_t *tail = create_row_impl(cells);
    if (!tail) {
        destroy_each_cell(cells);
        destroy_vector(cells);
    }
    return tail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16d79
jmp 0x16d98
leaq 0xcac4(%rip), %rdi      # 0x23844
leaq 0xbe0f(%rip), %rsi      # 0x22b96
movl $0x14f0, %edx           # imm = 0x14F0
leaq 0xc66e(%rip), %rcx      # 0x23401
callq 0x7120
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x16e00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x16dbd
movq $0x0, -0x8(%rbp)
jmp 0x16deb
movq -0x20(%rbp), %rdi
callq 0x16f00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x16de3
movq -0x20(%rbp), %rdi
callq 0x16fa0
movq -0x20(%rbp), %rdi
callq 0x13080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: vector_split
FT_INTERNAL
f_vector_t *vector_split(f_vector_t *vector, size_t pos)
{
    size_t trailing_sz = vector->m_size > pos ? vector->m_size - pos : 0;
    f_vector_t *new_vector = create_vector(vector->m_item_size, trailing_sz);
    if (!new_vector)
        return new_vector;
    if (new_vector->m_capacity < trailing_sz) {
        destroy_vector(new_vector);
        return NULL;
    }

    if (trailing_sz == 0)
        return new_vector;

    size_t offset = vector->m_item_size * pos;
    memcpy(new_vector->m_data, (char *)vector->m_data + offset,
           trailing_sz * vector->m_item_size);
    new_vector->m_size = trailing_sz;
    vector->m_size = pos;
    return new_vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x16e2e
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x16e36
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x16e36
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x12fa0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x16e67
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16eee
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x16e88
movq -0x28(%rbp), %rdi
callq 0x13080
movq $0x0, -0x8(%rbp)
jmp 0x16eee
cmpq $0x0, -0x20(%rbp)
jne 0x16e99
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16eee
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rdx
callq 0x71d0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: create_row_impl
static
f_row_t *create_row_impl(f_vector_t *cells)
{
    f_row_t *row = (f_row_t *)F_CALLOC(1, sizeof(f_row_t));
    if (row == NULL)
        return NULL;
    if (cells) {
        row->cells = cells;
    } else {
        row->cells = create_vector(sizeof(f_cell_t *), DEFAULT_VECTOR_CAPACITY);
        if (row->cells == NULL) {
            F_FREE(row);
            return NULL;
        }
    }
    return row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq *0x13304(%rip)          # 0x2a220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16f31
movq $0x0, -0x8(%rbp)
jmp 0x16f89
cmpq $0x0, -0x10(%rbp)
je 0x16f45
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16f81
movl $0x8, %edi
movl $0xa, %esi
callq 0x12fa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x16f7f
movq 0x132b9(%rip), %rax     # 0x2a228
movq -0x18(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x16f89
jmp 0x16f81
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: destroy_each_cell
static
void destroy_each_cell(f_vector_t *cells)
{
    size_t i = 0;
    size_t cells_n = vector_size(cells);
    for (i = 0; i < cells_n; ++i) {
        f_cell_t *cell = VECTOR_AT(cells, i, f_cell_t *);
        destroy_cell(cell);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x132b0
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x16ffe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17010
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16fc9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: destroy_cell
FT_INTERNAL
void destroy_cell(f_cell_t *cell)
{
    if (cell == NULL)
        return;
    destroy_string_buffer(cell->str_buffer);
    F_FREE(cell);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x17025
jmp 0x1703e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13410
movq 0x131f0(%rip), %rax     # 0x2a228
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: insert_row
FT_INTERNAL
f_status insert_row(f_row_t *cur_row, f_row_t *ins_row, size_t pos)
{
    assert(cur_row);
    assert(ins_row);

    while (vector_size(cur_row->cells) < pos) {
        f_cell_t *new_cell = create_cell();
        if (!new_cell)
            return FT_GEN_ERROR;
        vector_push(cur_row->cells, &new_cell);
    }

    size_t sz = vector_size(ins_row->cells);
    size_t i = 0;
    for (i = 0; i < sz; ++i) {
        f_cell_t *cell = VECTOR_AT(ins_row->cells, i, f_cell_t *);
        if (FT_IS_ERROR(vector_insert(cur_row->cells, &cell, pos + i))) {
            /* clean up what we have inserted */
            while (i--) {
                vector_erase(cur_row->cells, pos);
            }
            return FT_GEN_ERROR;
        }
    }
    /* Clear cells so that it will be safe to destroy this row */
    vector_clear(ins_row->cells);
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1721d
jmp 0x1723c
leaq 0xc61c(%rip), %rdi      # 0x23840
leaq 0xb96b(%rip), %rsi      # 0x22b96
movl $0x1577, %edx           # imm = 0x1577
leaq 0xc611(%rip), %rcx      # 0x23848
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x17245
jmp 0x17264
leaq 0xc62e(%rip), %rdi      # 0x2387a
leaq 0xb943(%rip), %rsi      # 0x22b96
movl $0x1578, %edx           # imm = 0x1578
leaq 0xc5e9(%rip), %rcx      # 0x23848
callq 0x7120
jmp 0x17266
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
cmpq -0x20(%rbp), %rax
jae 0x172a6
callq 0x18140
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x17294
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x17359
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13720
jmp 0x17266
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x17346
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
addq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x13b40
cmpl $0x0, %eax
jge 0x17336
jmp 0x17306
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1732d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x142c0
jmp 0x17306
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x17359
jmp 0x17338
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x172c6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x186d0
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: swap_row
FT_INTERNAL
f_status swap_row(f_row_t *cur_row, f_row_t *ins_row, size_t pos)
{
    assert(cur_row);
    assert(ins_row);
    size_t cur_sz = vector_size(cur_row->cells);
    if (cur_sz == 0 && pos == 0) {
        f_row_t tmp;
        memcpy(&tmp, cur_row, sizeof(f_row_t));
        memcpy(cur_row, ins_row, sizeof(f_row_t));
        memcpy(ins_row, &tmp, sizeof(f_row_t));
        return FT_SUCCESS;
    }

    return vector_swap(cur_row->cells, ins_row->cells, pos);
}

// 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 0x1738d
jmp 0x173ac
leaq 0xc4ac(%rip), %rdi      # 0x23840
leaq 0xb7fb(%rip), %rsi      # 0x22b96
movl $0x1565, %edx           # imm = 0x1565
leaq 0xc4db(%rip), %rcx      # 0x23882
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x173b5
jmp 0x173d4
leaq 0xc4be(%rip), %rdi      # 0x2387a
leaq 0xb7d3(%rip), %rsi      # 0x22b96
movl $0x1566, %edx           # imm = 0x1566
leaq 0xc4b3(%rip), %rcx      # 0x23882
callq 0x7120
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1741f
cmpq $0x0, -0x20(%rbp)
jne 0x1741f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x17439
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x186f0
movl %eax, -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_string_buffer
FT_INTERNAL
f_string_buffer_t *create_string_buffer(size_t n_chars, enum f_string_type type)
{
    size_t char_sz = 0;
    switch (type) {
        case CHAR_BUF:
            char_sz = 1;
            break;
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            char_sz = sizeof(wchar_t);
            break;
#endif
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            char_sz = 4;
            break;
#endif
    }

    size_t sz = n_chars * char_sz;
    f_string_buffer_t *result = (f_string_buffer_t *)F_MALLOC(sizeof(f_string_buffer_t));
    if (result == NULL)
        return NULL;
    result->str.data = F_MALLOC(sz);
    if (result->str.data == NULL) {
        F_FREE(result);
        return NULL;
    }
    result->data_sz = sz;
    result->type = type;

    if (sz) {
        switch (type) {
            case CHAR_BUF:
                result->str.cstr[0] = '\0';
                break;
#ifdef FT_HAVE_WCHAR
            case W_CHAR_BUF:
                result->str.wstr[0] = L'\0';
                break;
#endif
#ifdef FT_HAVE_UTF8
            case UTF8_BUF:
                result->str.cstr[0] = '\0';
                break;
#endif
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x17487
jmp 0x17473
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x17491
jmp 0x1747d
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x1749b
jmp 0x174a3
movq $0x1, -0x20(%rbp)
jmp 0x174a3
movq $0x4, -0x20(%rbp)
jmp 0x174a3
movq $0x4, -0x20(%rbp)
movq -0x10(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x18, %edi
callq *0x12efd(%rip)          # 0x2a3b8
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x174d3
movq $0x0, -0x8(%rbp)
jmp 0x17577
movq 0x12ede(%rip), %rax     # 0x2a3b8
movq -0x28(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1750b
movq 0x12d2d(%rip), %rax     # 0x2a228
movq -0x30(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x17577
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x1756f
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
testl %eax, %eax
je 0x17548
jmp 0x17534
movl -0x38(%rbp), %eax
subl $0x1, %eax
je 0x17554
jmp 0x1753e
movl -0x38(%rbp), %eax
subl $0x2, %eax
je 0x17563
jmp 0x1756d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
jmp 0x1756d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
jmp 0x1756d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
jmp 0x1756f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: number_of_columns_in_format_string
FT_INTERNAL
size_t number_of_columns_in_format_string(const f_string_view_t *fmt)
{
    switch (fmt->type) {
        case CHAR_BUF:
            return columns_number_in_fmt_string(fmt->u.cstr);
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            return columns_number_in_fmt_wstring(fmt->u.wstr);
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return columns_number_in_fmt_u8string(fmt->u.u8str);
#endif /* FT_HAVE_UTF8 */
        default:
            assert(0);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x175c0
jmp 0x175ac
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x175d2
jmp 0x175b6
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x175e4
jmp 0x175f6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17a90
movq %rax, -0x8(%rbp)
jmp 0x17615
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17b00
movq %rax, -0x8(%rbp)
jmp 0x17615
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17b70
movq %rax, -0x8(%rbp)
jmp 0x17615
leaq 0xbe81(%rip), %rdi      # 0x2347e
leaq 0xb592(%rip), %rsi      # 0x22b96
movl $0xf7e, %edx            # imm = 0xF7E
leaq 0xbe70(%rip), %rcx      # 0x23480
callq 0x7120
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: vsnprintf_buffer
static int
vsnprintf_buffer(f_string_buffer_t *buffer, const struct f_string_view *fmt,
                 va_list *va)
{
    /* Disable compiler diagnostic (format string is not a string literal) */
#if defined(FT_CLANG_COMPILER)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
#if defined(FT_GCC_COMPILER)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
    size_t width_capacity = string_buffer_width_capacity(buffer);
    switch (buffer->type) {
        case CHAR_BUF:
            return vsnprintf(buffer->str.cstr, width_capacity, fmt->u.cstr, *va);
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            return vswprintf(buffer->str.wstr, width_capacity, fmt->u.wstr, *va);
#endif
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return vsnprintf(buffer->str.cstr, width_capacity, fmt->u.cstr, *va);
#endif
        default:
            assert(0);
            return 0;
    }
#if defined(FT_CLANG_COMPILER)
#pragma clang diagnostic pop
#endif
#if defined(FT_GCC_COMPILER)
#pragma GCC diagnostic pop
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x176f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x17665
jmp 0x17651
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x17685
jmp 0x1765b
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x176a5
jmp 0x176c5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x70a0
movl %eax, -0x4(%rbp)
jmp 0x176e4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x7160
movl %eax, -0x4(%rbp)
jmp 0x176e4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x70a0
movl %eax, -0x4(%rbp)
jmp 0x176e4
leaq 0xbdb2(%rip), %rdi      # 0x2347e
leaq 0xb4c3(%rip), %rsi      # 0x22b96
movl $0x1777, %edx           # imm = 0x1777
leaq 0xbde4(%rip), %rcx      # 0x234c3
callq 0x7120
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: string_buffer_width_capacity
FT_INTERNAL
size_t string_buffer_width_capacity(const f_string_buffer_t *buffer)
{
    assert(buffer);
    switch (buffer->type) {
        case CHAR_BUF:
            return buffer->data_sz;
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            return buffer->data_sz / sizeof(wchar_t);
#endif
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return buffer->data_sz / 4;
#endif
        default:
            assert(0);
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17705
jmp 0x17724
leaq 0xc36d(%rip), %rdi      # 0x23a79
leaq 0xb483(%rip), %rsi      # 0x22b96
movl $0x1ab1, %edx           # imm = 0x1AB1
leaq 0xbdf7(%rip), %rcx      # 0x23516
callq 0x7120
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x17748
jmp 0x17734
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x17756
jmp 0x1773e
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x17768
jmp 0x1777a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x17799
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x17799
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x17799
leaq 0xbcfd(%rip), %rdi      # 0x2347e
leaq 0xb40e(%rip), %rsi      # 0x22b96
movl $0x1abe, %edx           # imm = 0x1ABE
leaq 0xbd82(%rip), %rcx      # 0x23516
callq 0x7120
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: realloc_string_buffer_without_copy
FT_INTERNAL
f_status realloc_string_buffer_without_copy(f_string_buffer_t *buffer)
{
    assert(buffer);
    char *new_str = (char *)F_MALLOC(buffer->data_sz * 2);
    if (new_str == NULL) {
        return FT_MEMORY_ERROR;
    }
    F_FREE(buffer->str.data);
    buffer->str.data = new_str;
    buffer->data_sz *= 2;
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x177c5
jmp 0x177e4
leaq 0xc2ad(%rip), %rdi      # 0x23a79
leaq 0xb3c3(%rip), %rsi      # 0x22b96
movl $0x197f, %edx           # imm = 0x197F
leaq 0xbd76(%rip), %rcx      # 0x23555
callq 0x7120
movq 0x12bcd(%rip), %rax     # 0x2a3b8
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
shlq %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1780c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1783d
movq 0x12a15(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: number_of_columns_in_format_buffer
FT_INTERNAL
size_t number_of_columns_in_format_buffer(const f_string_buffer_t *fmt)
{
    switch (fmt->type) {
        case CHAR_BUF:
            return columns_number_in_fmt_string(fmt->str.cstr);
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            return columns_number_in_fmt_wstring(fmt->str.wstr);
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return columns_number_in_fmt_u8string(fmt->str.u8str);
#endif /* FT_HAVE_UTF8 */
        default:
            assert(0);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x17880
jmp 0x1786c
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x17892
jmp 0x17876
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x178a4
jmp 0x178b6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17a90
movq %rax, -0x8(%rbp)
jmp 0x178d5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17b00
movq %rax, -0x8(%rbp)
jmp 0x178d5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17b70
movq %rax, -0x8(%rbp)
jmp 0x178d5
leaq 0xbbc1(%rip), %rdi      # 0x2347e
leaq 0xb2d2(%rip), %rsi      # 0x22b96
movl $0xf92, %edx            # imm = 0xF92
leaq 0xbcc6(%rip), %rcx      # 0x23596
callq 0x7120
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: create_row_from_buffer
FT_INTERNAL
f_row_t *create_row_from_buffer(const f_string_buffer_t *buffer)
{
    switch (buffer->type) {
        case CHAR_BUF:
            return create_row_from_string(buffer->str.cstr);
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            return create_row_from_wstring(buffer->str.wstr);
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return create_row_from_string((const char *)buffer->str.u8str);
#endif /* FT_HAVE_UTF8 */
        default:
            assert(0);
            return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x17910
jmp 0x178fc
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x17922
jmp 0x17906
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x17934
jmp 0x17946
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17be0
movq %rax, -0x8(%rbp)
jmp 0x17965
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17e10
movq %rax, -0x8(%rbp)
jmp 0x17965
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17be0
movq %rax, -0x8(%rbp)
jmp 0x17965
leaq 0xbb31(%rip), %rdi      # 0x2347e
leaq 0xb242(%rip), %rsi      # 0x22b96
movl $0x1758, %edx           # imm = 0x1758
leaq 0xbc7b(%rip), %rcx      # 0x235db
callq 0x7120
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: fill_cell_from_buffer
FT_INTERNAL
f_status fill_cell_from_buffer(f_cell_t *cell, const f_string_buffer_t *buffer)
{
    assert(cell);
    assert(buffer);
    switch (buffer->type) {
        case CHAR_BUF:
            return fill_cell_from_string(cell, buffer->str.cstr);
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            return fill_cell_from_wstring(cell, buffer->str.wstr);
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return fill_cell_from_u8string(cell, buffer->str.u8str);
#endif /* FT_HAVE_UTF8 */
        default:
            assert(0);
            return FT_GEN_ERROR;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x179b9
jmp 0x179d8
leaq 0xbc93(%rip), %rdi      # 0x23653
leaq 0xb1cf(%rip), %rsi      # 0x22b96
movl $0xa08, %edx            # imm = 0xA08
leaq 0xbda6(%rip), %rcx      # 0x23779
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x179e1
jmp 0x17a00
leaq 0xc091(%rip), %rdi      # 0x23a79
leaq 0xb1a7(%rip), %rsi      # 0x22b96
movl $0xa09, %edx            # imm = 0xA09
leaq 0xbd7e(%rip), %rcx      # 0x23779
callq 0x7120
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x17a24
jmp 0x17a10
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x17a39
jmp 0x17a1a
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x17a4e
jmp 0x17a63
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x180c0
movl %eax, -0x4(%rbp)
jmp 0x17a82
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x18310
movl %eax, -0x4(%rbp)
jmp 0x17a82
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x18590
movl %eax, -0x4(%rbp)
jmp 0x17a82
leaq 0xba14(%rip), %rdi      # 0x2347e
leaq 0xb125(%rip), %rsi      # 0x22b96
movl $0xa16, %edx            # imm = 0xA16
leaq 0xbcfc(%rip), %rcx      # 0x23779
callq 0x7120
movl -0x4(%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: columns_number_in_fmt_string
static
size_t columns_number_in_fmt_string(const char *fmt)
{
    size_t separator_counter = 0;
    const char *pos = fmt;
    while (1) {
        pos = strchr(pos, g_col_separator);
        if (pos == NULL)
            break;

        separator_counter++;
        ++pos;
    }
    return separator_counter + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movsbl 0x12779(%rip), %esi     # 0x2a230
callq 0x70e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17ac9
jmp 0x17ae3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x17aac
movq -0x10(%rbp), %rax
addq $0x1, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: columns_number_in_fmt_wstring
static
size_t columns_number_in_fmt_wstring(const wchar_t *fmt)
{
    size_t separator_counter = 0;
    const wchar_t *pos = fmt;
    while (1) {
        pos = wcschr(pos, g_col_separator);
        if (pos == NULL)
            break;

        separator_counter++;
        ++pos;
    }
    return separator_counter + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movsbl 0x12709(%rip), %esi     # 0x2a230
callq 0x7220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17b39
jmp 0x17b53
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x17b1c
movq -0x10(%rbp), %rax
addq $0x1, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: columns_number_in_fmt_u8string
static
size_t columns_number_in_fmt_u8string(const void *fmt)
{
    size_t separator_counter = 0;
    const char *pos = (const char *)fmt;
    while (1) {
        pos = (const char *)utf8chr(pos, g_col_separator);
        if (pos == NULL)
            break;

        separator_counter++;
        ++pos;
    }
    return separator_counter + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movsbl 0x12699(%rip), %esi     # 0x2a230
callq 0x10c60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17ba9
jmp 0x17bc3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x17b8c
movq -0x10(%rbp), %rax
addq $0x1, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: fort_strdup
FT_INTERNAL
char *fort_strdup(const char *str)
{
    if (str == NULL)
        return NULL;

    size_t sz = strlen(str);
    char *str_copy = (char *)F_MALLOC((sz + 1) * sizeof(char));
    if (str_copy == NULL)
        return NULL;

    strcpy(str_copy, str);
    return str_copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1805d
movq $0x0, -0x8(%rbp)
jmp 0x180a9
movq -0x10(%rbp), %rdi
callq 0x70d0
movq %rax, -0x18(%rbp)
movq 0x12347(%rip), %rax     # 0x2a3b8
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x18094
movq $0x0, -0x8(%rbp)
jmp 0x180a9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7050
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: create_cell
FT_INTERNAL
f_cell_t *create_cell(void)
{
    f_cell_t *cell = (f_cell_t *)F_CALLOC(sizeof(f_cell_t), 1);
    if (cell == NULL)
        return NULL;
    cell->str_buffer = create_string_buffer(DEFAULT_STR_BUF_SIZE, CHAR_BUF);
    if (cell->str_buffer == NULL) {
        F_FREE(cell);
        return NULL;
    }
    cell->cell_type = COMMON_CELL;
    return cell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
movl $0x1, %esi
callq *0x120c8(%rip)          # 0x2a220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1816d
movq $0x0, -0x8(%rbp)
jmp 0x181b7
movl $0x400, %edi            # imm = 0x400
xorl %esi, %esi
callq 0x17450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x181a4
movq 0x12094(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x181b7
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: fill_buffer_from_string
FT_INTERNAL
f_status fill_buffer_from_string(f_string_buffer_t *buffer, const char *str)
{
    assert(buffer);
    assert(str);

    char *copy = F_STRDUP(str);
    if (copy == NULL)
        return FT_MEMORY_ERROR;

    F_FREE(buffer->str.data);
    buffer->str.cstr = copy;
    buffer->type = CHAR_BUF;

    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 0x181e9
jmp 0x18208
leaq 0xb889(%rip), %rdi      # 0x23a79
leaq 0xa99f(%rip), %rsi      # 0x22b96
movl $0x198e, %edx           # imm = 0x198E
leaq 0xb455(%rip), %rcx      # 0x23658
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x18211
jmp 0x18230
leaq 0xb3fe(%rip), %rdi      # 0x23616
leaq 0xa977(%rip), %rsi      # 0x22b96
movl $0x198f, %edx           # imm = 0x198F
leaq 0xb42d(%rip), %rcx      # 0x23658
callq 0x7120
movq -0x18(%rbp), %rdi
callq 0x18040
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1824d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1827a
movq 0x11fd4(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: fort_wcsdup
FT_INTERNAL
wchar_t *fort_wcsdup(const wchar_t *str)
{
    if (str == NULL)
        return NULL;

    size_t sz = wcslen(str);
    wchar_t *str_copy = (wchar_t *)F_MALLOC((sz + 1) * sizeof(wchar_t));
    if (str_copy == NULL)
        return NULL;

    wcscpy(str_copy, str);
    return str_copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x182ad
movq $0x0, -0x8(%rbp)
jmp 0x182f9
movq -0x10(%rbp), %rdi
callq 0x7100
movq %rax, -0x18(%rbp)
movq 0x120f7(%rip), %rax     # 0x2a3b8
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x2, %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x182e4
movq $0x0, -0x8(%rbp)
jmp 0x182f9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7150
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: fill_buffer_from_wstring
FT_INTERNAL
f_status fill_buffer_from_wstring(f_string_buffer_t *buffer, const wchar_t *str)
{
    assert(buffer);
    assert(str);

    wchar_t *copy = F_WCSDUP(str);
    if (copy == NULL)
        return FT_MEMORY_ERROR;

    F_FREE(buffer->str.data);
    buffer->str.wstr = copy;
    buffer->type = W_CHAR_BUF;

    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 0x183a9
jmp 0x183c8
leaq 0xb6c9(%rip), %rdi      # 0x23a79
leaq 0xa7df(%rip), %rsi      # 0x22b96
movl $0x19a1, %edx           # imm = 0x19A1
leaq 0xb316(%rip), %rcx      # 0x236d9
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x183d1
jmp 0x183f0
leaq 0xb23e(%rip), %rdi      # 0x23616
leaq 0xa7b7(%rip), %rsi      # 0x22b96
movl $0x19a2, %edx           # imm = 0x19A2
leaq 0xb2ee(%rip), %rcx      # 0x236d9
callq 0x7120
movq -0x18(%rbp), %rdi
callq 0x18290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1840d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1843a
movq 0x11e14(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_cell_impl
static
f_cell_t *get_cell_impl(f_row_t *row, size_t col, enum f_get_policy policy)
{
    if (row == NULL || row->cells == NULL) {
        return NULL;
    }

    switch (policy) {
        case DONT_CREATE_ON_NULL:
            if (col < columns_in_row(row)) {
                return VECTOR_AT(row->cells, col, f_cell_t *);
            }
            return NULL;
        case CREATE_ON_NULL:
            while (col >= columns_in_row(row)) {
                f_cell_t *new_cell = create_cell();
                if (new_cell == NULL)
                    return NULL;
                if (FT_IS_ERROR(vector_push(row->cells, &new_cell))) {
                    destroy_cell(new_cell);
                    return NULL;
                }
            }
            return VECTOR_AT(row->cells, col, f_cell_t *);
    }

    assert(0 && "Shouldn't be here!");
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18474
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x18481
movq $0x0, -0x8(%rbp)
jmp 0x1857c
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x184e1
jmp 0x1848d
movl -0x2c(%rbp), %eax
subl $0x1, %eax
jne 0x1855d
jmp 0x1849b
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14270
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x184d4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1857c
movq $0x0, -0x8(%rbp)
jmp 0x1857c
jmp 0x184e3
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14270
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x18544
callq 0x18140
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1851a
movq $0x0, -0x8(%rbp)
jmp 0x1857c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13720
cmpl $0x0, %eax
jge 0x18542
movq -0x28(%rbp), %rdi
callq 0x17010
movq $0x0, -0x8(%rbp)
jmp 0x1857c
jmp 0x184e3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1857c
leaq 0xb1bd(%rip), %rdi      # 0x23721
leaq 0xa62b(%rip), %rsi      # 0x22b96
movl $0x1537, %edx           # imm = 0x1537
leaq 0xb1c4(%rip), %rcx      # 0x2373b
callq 0x7120
movq -0x8(%rbp), %rax
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: fill_buffer_from_u8string
FT_INTERNAL
f_status fill_buffer_from_u8string(f_string_buffer_t *buffer, const void *str)
{
    assert(buffer);
    assert(str);

    void *copy = F_UTF8DUP(str);
    if (copy == NULL)
        return FT_MEMORY_ERROR;

    F_FREE(buffer->str.u8str);
    buffer->str.u8str = copy;
    buffer->type = UTF8_BUF;

    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 0x18629
jmp 0x18648
leaq 0xb449(%rip), %rdi      # 0x23a79
leaq 0xa55f(%rip), %rsi      # 0x22b96
movl $0x19b4, %edx           # imm = 0x19B4
leaq 0xb1b7(%rip), %rcx      # 0x237fa
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x18651
jmp 0x18670
leaq 0xafbe(%rip), %rdi      # 0x23616
leaq 0xa537(%rip), %rsi      # 0x22b96
movl $0x19b5, %edx           # imm = 0x19B5
leaq 0xb18f(%rip), %rcx      # 0x237fa
callq 0x7120
movq -0x18(%rbp), %rdi
callq 0x110f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1868d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x186ba
movq 0x11b94(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: vector_reallocate_
static int vector_reallocate_(f_vector_t *vector, size_t new_capacity)
{
    assert(vector);
    assert(new_capacity > vector->m_capacity);

    size_t new_size = new_capacity * vector->m_item_size;
    vector->m_data = F_REALLOC(vector->m_data, new_size);
    if (vector->m_data == NULL)
        return -1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x189e9
jmp 0x18a08
leaq 0xaf41(%rip), %rdi      # 0x23931
leaq 0xa19f(%rip), %rsi      # 0x22b96
movl $0x1c46, %edx           # imm = 0x1C46
leaq 0xaf60(%rip), %rcx      # 0x23963
callq 0x7120
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x18a18
jmp 0x18a37
leaq 0xaf71(%rip), %rdi      # 0x23990
leaq 0xa170(%rip), %rsi      # 0x22b96
movl $0x1c47, %edx           # imm = 0x1C47
leaq 0xaf31(%rip), %rcx      # 0x23963
callq 0x7120
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movq 0x11971(%rip), %rax     # 0x2a3c0
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x18a7c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18a83
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)