LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_write_impl_
static int ft_write_impl_(ft_table_t *table, const f_string_view_t *cell_content)
{
    assert(table);
    f_string_buffer_t *buf = get_cur_str_buffer_and_create_if_not_exists(table);
    if (buf == NULL)
        return FT_GEN_ERROR;

    int status = FT_SUCCESS;
    switch (cell_content->type) {
        case CHAR_BUF:
            status = fill_buffer_from_string(buf, cell_content->u.cstr);
            break;
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            status = fill_buffer_from_wstring(buf, cell_content->u.wstr);
            break;
#endif
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            status = fill_buffer_from_u8string(buf, cell_content->u.u8str);
            break;
#endif
        default:
            status = FT_GEN_ERROR;
    }
    if (FT_IS_SUCCESS(status)) {
        table->cur_col++;
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x14a13
testq %rax, %rax
je 0x137e6
movq %rax, %r12
movq 0x8(%rbx), %rax
movl 0x178(%rax), %eax
testl %eax, %eax
je 0x13770
cmpl $0x1, %eax
jne 0x13843
cmpq $0x0, (%r12)
je 0x137b5
movq 0x20(%rbx), %r15
callq 0x13368
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x137b5
movq (%r12), %rdi
leaq -0x28(%rbp), %rsi
movq %r15, %rdx
callq 0xf75c
testl %eax, %eax
js 0x13780
movq (%r12), %rax
movq 0x8(%rax), %rcx
imulq 0x18(%rax), %r15
movq (%rcx,%r15), %rax
jmp 0x137b7
movq 0x20(%rbx), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x13562
jmp 0x137b7
movq -0x28(%rbp), %r15
testq %r15, %r15
je 0x137b5
movq (%r15), %r12
testq %r12, %r12
je 0x137ac
movq (%r12), %rdi
callq *0xda9d(%rip)           # 0x21238
movq $0x0, (%r12)
movq %r12, %rdi
callq *0xda8c(%rip)           # 0x21238
movq %r15, %rdi
callq *0xda83(%rip)           # 0x21238
xorl %eax, %eax
testq %rax, %rax
je 0x137e3
movq (%rax), %r15
testq %r15, %r15
jne 0x137e6
leaq 0x70c9(%rip), %rdi      # 0x1a894
leaq 0x62b4(%rip), %rsi      # 0x19a86
leaq 0x7085(%rip), %rcx      # 0x1a85e
movl $0xa01, %edx            # imm = 0xA01
callq 0x7130
xorl %r15d, %r15d
testq %r15, %r15
je 0x1380f
movl 0x8(%r14), %ecx
cmpl $0x2, %ecx
je 0x13823
cmpl $0x1, %ecx
je 0x13816
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %ecx, %ecx
jne 0x1382e
movq (%r14), %rsi
movq %r15, %rdi
callq 0x133f2
jmp 0x1382e
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x13836
movq (%r14), %rsi
movq %r15, %rdi
callq 0x134df
jmp 0x1382e
movq (%r14), %rsi
movq %r15, %rdi
callq 0x13615
testl %eax, %eax
js 0x13836
incq 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6267(%rip), %rdi      # 0x19ab1
leaq 0x6235(%rip), %rsi      # 0x19a86
leaq 0x6fb9(%rip), %rcx      # 0x1a811
movl $0x1b51, %edx           # imm = 0x1B51
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: cell_vis_width
FT_INTERNAL
size_t cell_vis_width(const f_cell_t *cell, const f_context_t *context)
{
    /* todo:
     * At the moment min width includes paddings. Maybe it is better that min width weren't include
     * paddings but be min width of the cell content without padding
     */

    assert(cell);
    assert(context);

    f_table_properties_t *properties = context->table_properties;
    size_t row = context->row;
    size_t column = context->column;

    size_t padding_left = get_cell_property_hierarchically(properties, row, column, FT_CPROP_LEFT_PADDING);
    size_t padding_right = get_cell_property_hierarchically(properties, row, column, FT_CPROP_RIGHT_PADDING);
    size_t result = padding_left + padding_right;
    if (cell->str_buffer && cell->str_buffer->str.data) {
        result += buffer_text_visible_width(cell->str_buffer);
    }
    result = MAX(result, (size_t)get_cell_property_hierarchically(properties, row, column, FT_CPROP_MIN_WIDTH));
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
testq %rsi, %rsi
je 0x145be
movq (%rsi), %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x10, %ecx
callq 0x1469a
movslq %eax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x20, %ecx
callq 0x1469a
movslq %eax, %r12
addq %r13, %r12
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1457c
cmpq $0x0, (%rdi)
je 0x1457c
callq 0x14ab1
addq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x1469a
cltq
cmpq %rax, %r12
ja 0x145ac
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x1469a
movslq %eax, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x63a0(%rip), %rdi      # 0x1a965
leaq 0x54ba(%rip), %rsi      # 0x19a86
leaq 0x6355(%rip), %rcx      # 0x1a928
movl $0x93f, %edx            # imm = 0x93F
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: hint_height_cell
FT_INTERNAL
size_t hint_height_cell(const f_cell_t *cell, const f_context_t *context)
{
    assert(cell);
    assert(context);
    f_table_properties_t *properties = context->table_properties;
    size_t row = context->row;
    size_t column = context->column;

    size_t padding_top = get_cell_property_hierarchically(properties, row, column, FT_CPROP_TOP_PADDING);
    size_t padding_bottom = get_cell_property_hierarchically(properties, row, column, FT_CPROP_BOTTOM_PADDING);
    size_t empty_string_height = get_cell_property_hierarchically(properties, row, column, FT_CPROP_EMPTY_STR_HEIGHT);

    size_t result = padding_top + padding_bottom;
    if (cell->str_buffer && cell->str_buffer->str.data) {
        size_t text_height = buffer_text_visible_height(cell->str_buffer);
        result += text_height == 0 ? empty_string_height : text_height;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
testq %rsi, %rsi
je 0x1467b
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x4, %ecx
callq 0x1469a
movslq %eax, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x8, %ecx
callq 0x1469a
movslq %eax, %rbx
addq %r14, %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x40, %ecx
callq 0x1469a
movq -0x30(%rbp), %rcx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x14669
cmpq $0x0, (%rdi)
je 0x14669
movslq %eax, %r14
callq 0x150b8
testq %rax, %rax
cmovneq %rax, %r14
addq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x62e3(%rip), %rdi      # 0x1a965
leaq 0x53fd(%rip), %rsi      # 0x19a86
leaq 0x630f(%rip), %rcx      # 0x1a99f
movl $0x970, %edx            # imm = 0x970
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: cell_invis_codes_width
FT_INTERNAL
size_t cell_invis_codes_width(const f_cell_t *cell, const f_context_t *context)
{
    assert(cell);
    assert(context);

    f_table_properties_t *properties = context->table_properties;
    size_t row = context->row;
    size_t column = context->column;

    size_t result = 0;
    char cell_style_tag[TEXT_STYLE_TAG_MAX_SIZE];
    get_style_tag_for_cell(properties, row, column, cell_style_tag, TEXT_STYLE_TAG_MAX_SIZE);
    result += strlen(cell_style_tag);

    char reset_cell_style_tag[TEXT_STYLE_TAG_MAX_SIZE];
    get_reset_style_tag_for_cell(properties, row, column, reset_cell_style_tag, TEXT_STYLE_TAG_MAX_SIZE);
    result += strlen(reset_cell_style_tag);

    char content_style_tag[TEXT_STYLE_TAG_MAX_SIZE];
    get_style_tag_for_content(properties, row, column, content_style_tag, TEXT_STYLE_TAG_MAX_SIZE);
    result += strlen(content_style_tag);

    char reset_content_style_tag[TEXT_STYLE_TAG_MAX_SIZE];
    get_reset_style_tag_for_content(properties, row, column, reset_content_style_tag, TEXT_STYLE_TAG_MAX_SIZE);
    result += strlen(reset_content_style_tag);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
testq %rdi, %rdi
je 0x14937
movq (%rdi), %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
leaq -0x230(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x15225
movq %r12, %rdi
callq 0x70e0
movq %rax, %r13
leaq -0x1b0(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x152de
movq %r12, %rdi
callq 0x70e0
movq %rax, %r12
addq %r13, %r12
leaq -0x130(%rbp), %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x1538a
movq %r13, %rdi
callq 0x70e0
movq %rax, %r13
leaq -0xb0(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rcx, %rbx
callq 0x1548a
movq %rbx, %rdi
callq 0x70e0
addq %r13, %rax
addq %r12, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6027(%rip), %rdi      # 0x1a965
leaq 0x5141(%rip), %rsi      # 0x19a86
leaq 0x616b(%rip), %rcx      # 0x1aab7
movl $0x953, %edx            # imm = 0x953
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: group_cell_number
FT_INTERNAL
size_t group_cell_number(const f_row_t *row, size_t master_cell_col)
{
    assert(row);
    const f_cell_t *master_cell = get_cell_c(row, master_cell_col);
    if (master_cell == NULL)
        return 0;

    if (get_cell_type(master_cell) != GROUP_MASTER_CELL)
        return 1;

    size_t total_cols = vector_size(row->cells);
    size_t slave_col = master_cell_col + 1;
    while (slave_col < total_cols) {
        const f_cell_t *cell = get_cell_c(row, slave_col);
        if (cell && get_cell_type(cell) == GROUP_SLAVE_CELL) {
            ++slave_col;
        } else {
            break;
        }
    }
    return slave_col - master_cell_col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x149d5
movq (%rdi), %rax
testq %rax, %rax
je 0x1497e
cmpq %rsi, (%rax)
jbe 0x1497e
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
imulq %rsi, %rax
movq (%rcx,%rax), %rcx
jmp 0x14980
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x149d1
movl $0x1, %eax
cmpl $0x1, 0x8(%rcx)
jne 0x149d3
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x149f4
movq (%rcx), %rdx
leaq 0x1(%rsi), %rax
cmpq %rdx, %rax
jae 0x149cc
movq 0x8(%rcx), %rdi
movq 0x18(%rcx), %r8
imulq %rax, %r8
movq (%rdi,%r8), %r8
xorl %edi, %edi
testq %r8, %r8
je 0x149c7
cmpl $0x2, 0x8(%r8)
sete %dil
addq %rdi, %rax
testb %dil, %dil
jne 0x1499f
subq %rsi, %rax
jmp 0x149d3
xorl %eax, %eax
popq %rbp
retq
leaq 0x5d02(%rip), %rdi      # 0x1a6de
leaq 0x50a3(%rip), %rsi      # 0x19a86
leaq 0x6377(%rip), %rcx      # 0x1ad61
movl $0x1596, %edx           # imm = 0x1596
callq 0x7130
leaq 0x5dc0(%rip), %rdi      # 0x1a7bb
leaq 0x5084(%rip), %rsi      # 0x19a86
leaq 0x6994(%rip), %rcx      # 0x1b39d
movl $0x1c74, %edx           # imm = 0x1C74
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_row_impl
static
f_row_t *get_row_impl(ft_table_t *table, size_t row, enum f_get_policy policy)
{
    if (table == NULL || table->rows == NULL) {
        return NULL;
    }

    switch (policy) {
        case DONT_CREATE_ON_NULL:
            if (row < vector_size(table->rows)) {
                return VECTOR_AT(table->rows, row, f_row_t *);
            }
            return NULL;
        case CREATE_ON_NULL:
            while (row >= vector_size(table->rows)) {
                f_row_t *new_row = create_row();
                if (new_row == NULL)
                    return NULL;
                if (FT_IS_ERROR(vector_push(table->rows, &new_row))) {
                    destroy_row(new_row);
                    return NULL;
                }
            }
            return VECTOR_AT(table->rows, row, f_row_t *);
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x14aa4
movq %rsi, %rbx
cmpl $0x1, %edx
jne 0x14a41
cmpq %rbx, (%rax)
jbe 0x14aa4
movq 0x8(%rax), %rcx
imulq 0x18(%rax), %rbx
movq (%rcx,%rbx), %rax
jmp 0x14aa6
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x14a7c
leaq -0x20(%rbp), %r15
cmpq %rbx, (%rax)
ja 0x14a32
xorl %edi, %edi
callq 0x12e1d
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x14aa4
movq (%r14), %rdi
movq %r15, %rsi
callq 0xf454
testl %eax, %eax
js 0x14a9b
movq (%r14), %rax
testq %rax, %rax
jne 0x14a50
leaq 0x5d38(%rip), %rdi      # 0x1a7bb
leaq 0x4ffc(%rip), %rsi      # 0x19a86
leaq 0x690c(%rip), %rcx      # 0x1b39d
movl $0x1c74, %edx           # imm = 0x1C74
callq 0x7130
movq -0x20(%rbp), %rdi
callq 0xef82
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: str_n_substring
FT_INTERNAL
void str_n_substring(const char *str, char ch_separator, size_t n, const char **begin, const char **end)
{
    const char *beg = str_n_substring_beg(str, ch_separator, n);
    if (beg == NULL) {
        *begin = NULL;
        *end = NULL;
        return;
    }

    const char *en = strchr(beg, ch_separator);
    if (en == NULL) {
        en = str + strlen(str);
    }

    *begin = beg;
    *end = en;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rdi, %rdi
je 0x14ca0
movq %rsi, %r13
movq %r15, %r12
testq %rsi, %rsi
je 0x14ca3
movq %r15, %rdi
movl $0xa, %esi
callq 0x70f0
decq %r13
je 0x14c93
xorl %r12d, %r12d
testq %rax, %rax
je 0x14ca3
incq %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x70f0
decq %r13
jne 0x14c79
leaq 0x1(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
jmp 0x14ca3
xorl %r12d, %r12d
testq %r12, %r12
je 0x14cc7
movq %r12, %rdi
movl $0xa, %esi
callq 0x70f0
testq %rax, %rax
jne 0x14ccc
movq %r15, %rdi
callq 0x70e0
addq %r15, %rax
jmp 0x14ccc
xorl %r12d, %r12d
xorl %eax, %eax
movq %r12, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: wstr_n_substring
FT_INTERNAL
void wstr_n_substring(const wchar_t *str, wchar_t ch_separator, size_t n, const wchar_t **begin, const wchar_t **end)
{
    const wchar_t *beg = wstr_n_substring_beg(str, ch_separator, n);
    if (beg == NULL) {
        *begin = NULL;
        *end = NULL;
        return;
    }

    const wchar_t *en = wcschr(beg, ch_separator);
    if (en == NULL) {
        en = str + wcslen(str);
    }

    *begin = beg;
    *end = en;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rdi, %rdi
je 0x14d45
movq %rsi, %r13
movq %r15, %r12
testq %rsi, %rsi
je 0x14d48
movq %r15, %rdi
movl $0xa, %esi
callq 0x7240
decq %r13
je 0x14d38
xorl %r12d, %r12d
testq %rax, %rax
je 0x14d48
addq $0x4, %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x7240
decq %r13
jne 0x14d1d
leaq 0x4(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
jmp 0x14d48
xorl %r12d, %r12d
testq %r12, %r12
je 0x14d6d
movq %r12, %rdi
movl $0xa, %esi
callq 0x7240
testq %rax, %rax
jne 0x14d72
movq %r15, %rdi
callq 0x7110
leaq (%r15,%rax,4), %rax
jmp 0x14d72
xorl %r12d, %r12d
xorl %eax, %eax
movq %r12, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: mk_wcswidth
FT_INTERNAL
int mk_wcswidth(const wchar_t *pwcs, size_t n)
{
    int width = 0;

    for (; *pwcs && n-- > 0; pwcs++) {
        int w;
        if ((w = mk_wcwidth(*pwcs)) < 0)
            return -1;
        else
            width += w;
    }

    return width;
}

// Assembly:
movl (%rdi), %r8d
testl %r8d, %r8d
je 0x14f44
pushq %rbp
movq %rsp, %rbp
pushq %rbx
xorl %ecx, %ecx
leaq 0x47ff(%rip), %rdx      # 0x195a0
subq $0x1, %rsi
jb 0x14f47
cmpl $0x20, %r8d
setl %al
leal -0x7f(%r8), %r9d
cmpl $0x21, %r9d
setb %r9b
orb %al, %r9b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
jne 0x14f27
leal -0xe01f0(%r8), %r9d
cmpl $0xfff20110, %r9d       # imm = 0xFFF20110
jae 0x14eda
movl $0x1, %r9d
cmpl $0x1100, %r8d           # imm = 0x1100
jl 0x14f27
cmpl $0x1160, %r8d           # imm = 0x1160
setl %r9b
leal -0x2329(%r8), %r10d
cmpl $0x2, %r10d
setb %r10b
orb %r9b, %r10b
movl $0x2, %r9d
jne 0x14f27
leal -0x2e80(%r8), %r10d
cmpl $0x7650, %r10d          # imm = 0x7650
setb %r10b
cmpl $0x303f, %r8d           # imm = 0x303F
setne %r11b
testb %r10b, %r11b
jne 0x14f27
leal -0xac00(%r8), %r10d
cmpl $0x2ba4, %r10d          # imm = 0x2BA4
jb 0x14f27
leal -0xf900(%r8), %r10d
cmpl $0x200, %r10d           # imm = 0x200
jb 0x14f27
leal -0xfe10(%r8), %r10d
cmpl $0xa, %r10d
jb 0x14f27
leal -0xfe30(%r8), %r10d
cmpl $0x40, %r10d
jb 0x14f27
leal -0xff00(%r8), %r10d
cmpl $0x61, %r10d
jb 0x14f27
leal -0xffe0(%r8), %r10d
cmpl $0x7, %r10d
jb 0x14f27
leal -0x20000(%r8), %r10d
cmpl $0xfffe, %r10d          # imm = 0xFFFE
jb 0x14f27
addl $0xfffd0000, %r8d       # imm = 0xFFFD0000
cmpl $0xfffe, %r8d           # imm = 0xFFFE
movl $0x0, %r9d
adcl $0x1, %r9d
jmp 0x14f27
xorl %r10d, %r10d
movl $0x8d, %r9d
cmpl %r10d, %r9d
jl 0x14de6
leal (%r10,%r9), %ebx
movl %ebx, %r11d
shrl $0x1f, %r11d
addl %ebx, %r11d
sarl %r11d
movslq %r11d, %rbx
cmpl %r8d, 0x4(%rdx,%rbx,8)
jge 0x14f11
incl %r11d
movb $0x1, %bl
movl %r11d, %r10d
jmp 0x14f20
cmpl %r8d, (%rdx,%rbx,8)
leal -0x1(%rbx), %r11d
setg %bl
cmovgl %r11d, %r9d
testb %bl, %bl
jne 0x14ee3
xorl %r9d, %r9d
testl %r9d, %r9d
js 0x14f49
addl %r9d, %ecx
movl 0x4(%rdi), %r8d
addq $0x4, %rdi
movl %ecx, %eax
testl %r8d, %r8d
jne 0x14da1
jmp 0x14f49
xorl %eax, %eax
retq
movl %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8_n_substring
FT_INTERNAL
void utf8_n_substring(const void *str, utf8_int32_t ch_separator, size_t n, const void **begin, const void **end)
{
    const char *beg = (const char *)utf8_n_substring_beg(str, ch_separator, n);
    if (beg == NULL) {
        *begin = NULL;
        *end = NULL;
        return;
    }

    const char *en = (const char *)utf8chr(beg, ch_separator);
    if (en == NULL) {
        en = (const char *)str + strlen((const char *)str);
    }

    *begin = beg;
    *end = en;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rdi, %rdi
je 0x14fcf
movq %rsi, %r13
movq %r15, %r12
testq %rsi, %rsi
je 0x14fd8
movq %r15, %rdi
movl $0xa, %esi
callq 0xd9e3
decq %r13
movq %rbx, -0x30(%rbp)
je 0x14fb5
xorl %r12d, %r12d
leaq -0x34(%rbp), %rbx
testq %rax, %rax
je 0x14fd4
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd49c
movq %rax, %rdi
movl $0xa, %esi
callq 0xd9e3
decq %r13
jne 0x14f93
testq %rax, %rax
movq -0x30(%rbp), %rbx
je 0x14fcf
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xd49c
movq %rax, %r12
jmp 0x14fd8
xorl %r12d, %r12d
jmp 0x14fd8
movq -0x30(%rbp), %rbx
testq %r12, %r12
je 0x14ffc
movq %r12, %rdi
movl $0xa, %esi
callq 0xd9e3
testq %rax, %rax
jne 0x15001
movq %r15, %rdi
callq 0x70e0
addq %r15, %rax
jmp 0x15001
xorl %r12d, %r12d
xorl %eax, %eax
movq %r12, (%r14)
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8_width
static
size_t utf8_width(const void *beg, const void *end)
{
    if (_custom_u8strwid) {
        size_t width = 0;
        if (!_custom_u8strwid(beg, end, &width))
            return width;
    }

    size_t sz = (size_t)((const char *)end - (const char *)beg);
    char *tmp = (char *)F_MALLOC(sizeof(char) * (sz + 1));
    // @todo: add check to tmp
    assert(tmp);

    memcpy(tmp, beg, sz);
    tmp[sz] = '\0';
    size_t result = utf8width(tmp);
    F_FREE(tmp);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xdb53(%rip), %rax      # 0x22b80
testq %rax, %rax
je 0x15049
leaq -0x20(%rbp), %rdx
movq $0x0, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
je 0x15087
subq %r14, %rbx
leaq 0x1(%rbx), %rdi
callq *0xc372(%rip)           # 0x213c8
testq %rax, %rax
je 0x15099
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x71f0
movb $0x0, (%r15,%rbx)
movq %r15, %rdi
callq 0xdf57
movq %rax, %rbx
movq %r15, %rdi
callq *0xc1b3(%rip)           # 0x21238
jmp 0x1508b
movq -0x20(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58cd(%rip), %rdi      # 0x1a96d
leaq 0x49df(%rip), %rsi      # 0x19a86
leaq 0x58c3(%rip), %rcx      # 0x1a971
movl $0x19fa, %edx           # imm = 0x19FA
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: buffer_text_visible_height
FT_INTERNAL
size_t buffer_text_visible_height(const f_string_buffer_t *buffer)
{
    if (buffer == NULL || buffer->str.data == NULL || buf_str_len(buffer) == 0) {
        return 0;
    }
    if (buffer->type == CHAR_BUF)
        return 1 + strchr_count(buffer->str.cstr, '\n');
#ifdef FT_HAVE_WCHAR
    else if (buffer->type == W_CHAR_BUF)
        return 1 + wstrchr_count(buffer->str.wstr, L'\n');
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
    else if (buffer->type == UTF8_BUF)
        return 1 + utf8chr_count(buffer->str.u8str, '\n');
#endif /* FT_HAVE_WCHAR */

    assert(0);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x15160
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x15160
movl 0x10(%rdi), %r14d
cmpl $0x2, %r14d
je 0x15105
cmpl $0x1, %r14d
je 0x150fb
testl %r14d, %r14d
jne 0x151e7
movq %rbx, %rdi
callq 0x70e0
jmp 0x1510d
movq %rbx, %rdi
callq 0x7110
jmp 0x1510d
movq %rbx, %rdi
callq 0xdc6c
testq %rax, %rax
je 0x15160
cmpl $0x2, %r14d
je 0x151a0
cmpl $0x1, %r14d
je 0x1516e
testl %r14d, %r14d
jne 0x15206
movq %rbx, %rdi
movl $0xa, %esi
callq 0x70f0
testq %rax, %rax
je 0x151dd
movl $0x1, %ebx
incq %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x70f0
incq %rbx
testq %rax, %rax
jne 0x15146
jmp 0x15162
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7240
testq %rax, %rax
je 0x151dd
movl $0x1, %ebx
addq $0x4, %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x7240
incq %rbx
testq %rax, %rax
jne 0x15185
jmp 0x15162
movq %rbx, %rdi
movl $0xa, %esi
callq 0xd9e3
testq %rax, %rax
je 0x151dd
movl $0x1, %ebx
leaq -0x14(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xd49c
movq %rax, %rdi
movl $0xa, %esi
callq 0xd9e3
incq %rbx
testq %rax, %rax
jne 0x151bb
jmp 0x15162
movl $0x1, %ebx
jmp 0x15162
leaq 0x5182(%rip), %rdi      # 0x1a370
leaq 0x4891(%rip), %rsi      # 0x19a86
leaq 0x581f(%rip), %rcx      # 0x1aa1b
movl $0x1854, %edx           # imm = 0x1854
callq 0x7130
leaq 0x5163(%rip), %rdi      # 0x1a370
leaq 0x4872(%rip), %rsi      # 0x19a86
leaq 0x57c3(%rip), %rcx      # 0x1a9de
movl $0x19d4, %edx           # imm = 0x19D4
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_style_tag_for_cell
void get_style_tag_for_cell(const f_table_properties_t *props,
                            size_t row, size_t col, char *style_tag, size_t sz)
{
    (void)sz;
    size_t i = 0;

    unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_BG_COLOR);
    unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_TEXT_STYLE);

    style_tag[0] = '\0';

    if (text_style < (1U << n_styles)) {
        for (i = 0; i < n_styles; ++i) {
            if (text_style & (1 << i)) {
                strcat(style_tag, text_styles[i]);
            }
        }
    } else {
        goto error;
    }

    if (bg_color_number < n_bg_colors) {
        strcat(style_tag, bg_colors[bg_color_number]);
    } else {
        goto error;
    }

    return;

error:
    /* shouldn't be here */
    assert(0);
    style_tag[0] = '\0';
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x200, %ecx            # imm = 0x200
callq 0x1469a
movl %eax, %r14d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x1469a
movb $0x0, (%rbx)
cmpl $0xff, %eax
ja 0x152bf
movl %eax, %r15d
leaq 0xb3cd(%rip), %r12      # 0x20640
xorl %r13d, %r13d
btl %r13d, %r15d
jae 0x15288
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x7260
incq %r13
addq $0x8, %r12
cmpq $0x8, %r13
jne 0x15276
cmpl $0x10, %r14d
ja 0x152bf
movl %r14d, %eax
leaq 0xb3db(%rip), %rcx      # 0x20680
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7260
leaq 0x50aa(%rip), %rdi      # 0x1a370
leaq 0x47b9(%rip), %rsi      # 0x19a86
leaq 0x5828(%rip), %rcx      # 0x1aafc
movl $0x10f0, %edx           # imm = 0x10F0
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_reset_style_tag_for_cell
void get_reset_style_tag_for_cell(const f_table_properties_t *props,
                                  size_t row, size_t col, char *reset_style_tag, size_t sz)
{
    (void)sz;
    size_t i = 0;

    unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_BG_COLOR);
    unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_TEXT_STYLE);

    reset_style_tag[0] = '\0';

    if (text_style < (1U << n_styles)) {
        for (i = 0; i < n_styles; ++i) {
            if (text_style & (1 << i)) {
                if (i != 0) // FT_TSTYLE_DEFAULT
                    goto reset_style;
            }
        }
    } else {
        goto error;
    }

    if (bg_color_number < n_bg_colors) {
        if (bg_color_number)
            goto reset_style;
    } else {
        goto error;
    }

    return;


reset_style:
    strcat(reset_style_tag, UNIVERSAL_RESET_TAG);
    return;

error:
    /* shouldn't be here */
    assert(0);
    reset_style_tag[0] = '\0';
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x200, %ecx            # imm = 0x200
callq 0x1469a
movl %eax, %r14d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x1469a
movb $0x0, (%rbx)
cmpl $0xff, %eax
ja 0x1536b
xorl %ecx, %ecx
movl $0x1, %edx
shll %cl, %edx
testq %rcx, %rcx
je 0x15334
andl %eax, %edx
jne 0x15348
incq %rcx
cmpq $0x8, %rcx
jne 0x15324
cmpl $0x10, %r14d
ja 0x1536b
testl %r14d, %r14d
je 0x1535c
movq %rbx, %rdi
callq 0x70e0
movl $0x6d305b1b, (%rbx,%rax) # imm = 0x6D305B1B
movb $0x0, 0x4(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ffe(%rip), %rdi      # 0x1a370
leaq 0x470d(%rip), %rsi      # 0x19a86
leaq 0x5861(%rip), %rcx      # 0x1abe1
movl $0x111b, %edx           # imm = 0x111B
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_style_tag_for_content
void get_style_tag_for_content(const f_table_properties_t *props,
                               size_t row, size_t col, char *style_tag, size_t sz)
{
    (void)sz;
    size_t i = 0;

    unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_TEXT_STYLE);
    unsigned fg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_FG_COLOR);
    unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_BG_COLOR);

    style_tag[0] = '\0';

    if (text_style < (1U << n_styles)) {
        for (i = 0; i < n_styles; ++i) {
            if (text_style & (1 << i)) {
                strcat(style_tag, text_styles[i]);
            }
        }
    } else {
        goto error;
    }

    if (fg_color_number < n_fg_colors) {
        if (fg_color_number)
            strcat(style_tag, fg_colors[fg_color_number]);
    } else {
        goto error;
    }

    if (bg_color_number < n_bg_colors) {
        strcat(style_tag, bg_colors[bg_color_number]);
    } else {
        goto error;
    }

    return;

error:
    /* shouldn't be here */
    assert(0);
    style_tag[0] = '\0';
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movl $0x1000, %ecx           # imm = 0x1000
callq 0x1469a
movl %eax, %r12d
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x1469a
movl %eax, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x1469a
movb $0x0, (%rbx)
cmpl $0xff, %r12d
ja 0x1546b
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %r14d
leaq 0xb248(%rip), %r15      # 0x20640
xorl %r13d, %r13d
btl %r13d, %r12d
jae 0x1540c
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7260
incq %r13
addq $0x8, %r15
cmpq $0x8, %r13
jne 0x153fb
cmpl $0x10, %r14d
movl -0x2c(%rbp), %r15d
ja 0x1546b
testl %r14d, %r14d
je 0x15441
movl %r14d, %eax
leaq 0x45de(%rip), %rcx      # 0x19a10
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x7260
cmpl $0x10, %r15d
ja 0x1546b
movl %r15d, %eax
leaq 0xb22f(%rip), %rcx      # 0x20680
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7260
leaq 0x4efe(%rip), %rdi      # 0x1a370
leaq 0x460d(%rip), %rsi      # 0x19a86
leaq 0x57c1(%rip), %rcx      # 0x1ac41
movl $0x1148, %edx           # imm = 0x1148
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_reset_style_tag_for_content
void get_reset_style_tag_for_content(const f_table_properties_t *props,
                                     size_t row, size_t col, char *reset_style_tag, size_t sz)
{
    (void)sz;
    size_t i = 0;
    size_t len = 0;

    unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_TEXT_STYLE);
    unsigned fg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_FG_COLOR);
    unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_BG_COLOR);

    reset_style_tag[0] = '\0';

    if (text_style < (1U << n_styles)) {
        for (i = 0; i < n_styles; ++i) {
            if (text_style & (1 << i)) {
                if (i != 0) // FT_TSTYLE_DEFAULT
                    goto reset_style;
            }
        }
    } else {
        goto error;
    }

    if (fg_color_number < n_fg_colors) {
        if (fg_color_number)
            goto reset_style;
    } else {
        goto error;
    }

    if (bg_color_number < n_bg_colors) {
        if (bg_color_number)
            goto reset_style;
    } else {
        goto error;
    }

    return;


reset_style:
    strcat(reset_style_tag, UNIVERSAL_RESET_TAG);
    len = strlen(reset_style_tag);
    get_style_tag_for_cell(props, row, col, reset_style_tag + len, sz - len);
    return;

error:
    /* shouldn't be here */
    assert(0);
    reset_style_tag[0] = '\0';
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1000, %ecx           # imm = 0x1000
callq 0x1469a
movl %eax, %r13d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x1469a
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x1469a
movb $0x0, (%rbx)
cmpl $0xff, %r13d
ja 0x15564
xorl %ecx, %ecx
movl $0x1, %edx
shll %cl, %edx
testq %rcx, %rcx
je 0x154f9
andl %r13d, %edx
jne 0x15517
incq %rcx
cmpq $0x8, %rcx
jne 0x154e8
cmpl $0x10, -0x2c(%rbp)
ja 0x15564
cmpl $0x0, -0x2c(%rbp)
jne 0x15517
cmpl $0x10, %eax
ja 0x15564
testl %eax, %eax
je 0x15555
movq %rbx, %rdi
callq 0x70e0
movl $0x6d305b1b, (%rbx,%rax) # imm = 0x6D305B1B
movb $0x0, 0x4(%rbx,%rax)
movq %rbx, %rdi
callq 0x70e0
addq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15225
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e05(%rip), %rdi      # 0x1a370
leaq 0x4514(%rip), %rsi      # 0x19a86
leaq 0x5785(%rip), %rcx      # 0x1acfe
movl $0x117e, %edx           # imm = 0x117E
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_row_cell_types
FT_INTERNAL
int get_row_cell_types(const f_row_t *row, enum f_cell_type *types, size_t types_sz)
{
    assert(row);
    assert(types);
    size_t i = 0;
    for (i = 0; i < types_sz; ++i) {
        const f_cell_t *cell = get_cell_c(row, i);
        if (cell) {
            types[i] = get_cell_type(cell);
        } else {
            types[i] = COMMON_CELL;
        }
    }
    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x155d2
testq %rdx, %rdx
je 0x155d0
xorl %eax, %eax
testq %rdi, %rdi
je 0x155b7
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x155b7
cmpq %rax, (%rcx)
jbe 0x155b7
movq 0x8(%rcx), %r8
movq 0x18(%rcx), %rcx
imulq %rax, %rcx
movq (%r8,%rcx), %rcx
jmp 0x155b9
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x155c3
movl 0x8(%rcx), %ecx
jmp 0x155c5
xorl %ecx, %ecx
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x15593
popq %rbp
retq
leaq 0x58f5(%rip), %rdi      # 0x1aece
leaq 0x44a6(%rip), %rsi      # 0x19a86
leaq 0x58a3(%rip), %rcx      # 0x1ae8a
movl $0x15b0, %edx           # imm = 0x15B0
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: buffer_print_range
static int
buffer_print_range(f_conv_context_t *cntx, const void *beg, const void *end)
{
    size_t len;
    switch (cntx->b_type) {
        case CHAR_BUF:
            len = (size_t)((const char *)end - (const char *)beg);
            return ft_nprint(cntx, (const char *)beg, len);
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            len = (size_t)((const wchar_t *)end - (const wchar_t *)beg);
            return ft_nwprint(cntx, (const wchar_t *)beg, len);
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            return ft_nu8print(cntx, beg, end);
#endif /* FT_HAVE_UTF8 */
        default:
            assert(0);
            return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %eax
cmpl $0x2, %eax
je 0x15612
cmpl $0x1, %eax
je 0x15647
testl %eax, %eax
jne 0x15690
subq %rsi, %rbx
movq 0x8(%r14), %rcx
incq %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rbx, %rcx
jb 0x15685
movq (%r14), %rdi
movq %rbx, %rdx
callq 0x71f0
movq (%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, (%r14)
subq %rbx, 0x8(%r14)
movb $0x0, (%rax,%rbx)
movl %ebx, %eax
jmp 0x15685
subq %rsi, %rbx
movq %rbx, %r15
sarq $0x2, %r15
movq 0x8(%r14), %rcx
incq %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %rcx
jb 0x15685
movq (%r14), %rdi
movq %rbx, %rdx
callq 0x71f0
movq (%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, (%r14)
subq %rbx, 0x8(%r14)
movl $0x0, (%rax,%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4cd9(%rip), %rdi      # 0x1a370
leaq 0x43e8(%rip), %rsi      # 0x19a86
leaq 0x59c5(%rip), %rcx      # 0x1b06a
movl $0x1a69, %edx           # imm = 0x1A69
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: custom_fort_calloc
static void *custom_fort_calloc(size_t nmemb, size_t size)
{
    size_t total_size = nmemb * size;
    void *result = F_MALLOC(total_size);
    if (result != NULL)
        memset(result, 0, total_size);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
imulq %rsi, %rbx
movq %rbx, %rdi
callq *0xbd03(%rip)           # 0x213c8
testq %rax, %rax
je 0x156dd
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7140
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: custom_fort_realloc
static void *custom_fort_realloc(void *ptr, size_t size)
{
    if (ptr == NULL)
        return F_MALLOC(size);
    if (size == 0) {
        F_FREE(ptr);
        return NULL;
    }

    void *new_chunk = F_MALLOC(size);
    if (new_chunk == NULL)
        return NULL;

    /*
     * In theory we should copy MIN(size, size allocated for ptr) bytes,
     * but this is rather dummy implementation so we don't care about it
     */
    memcpy(new_chunk, ptr, size);
    F_FREE(ptr);
    return new_chunk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rdi, %rdi
je 0x15728
movq %rdi, %rbx
testq %r15, %r15
je 0x1573b
movq %r15, %rdi
callq *0xbcc1(%rip)           # 0x213c8
testq %rax, %rax
je 0x15744
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x71f0
movq %rbx, %rdi
callq *0xbb12(%rip)           # 0x21238
jmp 0x15747
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0xbc8d(%rip)           # 0x213c8
movq %rbx, %rdi
callq *0xbaf4(%rip)           # 0x21238
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neosploit[P]compiler/libfort/lib/fort.c
// Function: set_entire_table_property_internal
static f_status set_entire_table_property_internal(fort_entire_table_properties_t *properties, uint32_t property, int value)
{
    assert(properties);
    CHECK_NOT_NEGATIVE(value);
    if (PROP_IS_SET(property, FT_TPROP_LEFT_MARGIN)) {
        properties->left_margin = value;
    } else if (PROP_IS_SET(property, FT_TPROP_TOP_MARGIN)) {
        properties->top_margin = value;
    } else if (PROP_IS_SET(property, FT_TPROP_RIGHT_MARGIN)) {
        properties->right_margin = value;
    } else if (PROP_IS_SET(property, FT_TPROP_BOTTOM_MARGIN)) {
        properties->bottom_margin = value;
    } else if (PROP_IS_SET(property, FT_TPROP_ADDING_STRATEGY)) {
        properties->add_strategy = (enum ft_adding_strategy)value;
    } else {
        return FT_EINVAL;
    }
    return FT_SUCCESS;

fort_fail:
    return FT_EINVAL;
}

// Assembly:
testq %rdi, %rdi
je 0x15894
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %edx, %edx
js 0x15893
testb $0x1, %sil
jne 0x1588f
testb $0x2, %sil
jne 0x1587f
testb $0x4, %sil
jne 0x15885
testb $0x8, %sil
jne 0x1588b
testb $0x10, %sil
je 0x15893
addq $0x10, %rdi
jmp 0x1588f
addq $0x4, %rdi
jmp 0x1588f
addq $0x8, %rdi
jmp 0x1588f
addq $0xc, %rdi
movl %edx, (%rdi)
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5947(%rip), %rdi      # 0x1b1e6
leaq 0x41e0(%rip), %rsi      # 0x19a86
leaq 0x598e(%rip), %rcx      # 0x1b23b
movl $0x1402, %edx           # imm = 0x1402
callq 0x7130
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_qsort-def.c
// Function: main
int
main (int argc VL_UNUSED, char ** argv VL_UNUSED)
{
  float values [] = {.4, 12.3, 44.0, 1.2, 3.4, 5.6} ;
  vl_size n = sizeof(values) / sizeof(values[0]) ;
  vl_uindex i ;

  for (i = 0 ; i < n ; ++i) printf("%5.2f ", values [i]) ;
  printf("\n") ;

  my_qsort_sort (values, n) ;

  for (i = 0 ; i < n ; ++i) printf("%5.2f ", values [i]) ;
  printf("\n") ;

  return 0 ;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movaps 0xeb6(%rip), %xmm0      # 0x2010
movaps %xmm0, (%rsp)
movabsq $0x40b333334059999a, %rax # imm = 0x40B333334059999A
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0xeb1(%rip), %rbx       # 0x2028
xorps %xmm0, %xmm0
cvtss2sd (%rsp,%r14,4), %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x1040
incq %r14
cmpq $0x6, %r14
jne 0x1177
movl $0xa, %edi
callq 0x1030
xorl %r14d, %r14d
movq %rsp, %rdi
movl $0x5, %edx
xorl %esi, %esi
callq 0x11e6
leaq 0xe72(%rip), %rbx       # 0x2028
xorps %xmm0, %xmm0
cvtss2sd (%rsp,%r14,4), %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x1040
incq %r14
cmpq $0x6, %r14
jne 0x11b6
movl $0xa, %edi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/rep.c
// Function: usage
void usage(void){
	fputs("rep: repeatedly excute the same command\n", stderr);
	fputs("usage: rep <num> <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbx
movq 0x2f10(%rip), %rbx      # 0x3ff8
movq (%rbx), %rsi
leaq 0xf12(%rip), %rdi       # 0x2004
callq 0x1040
movq (%rbx), %rsi
leaq 0xf2c(%rip), %rdi       # 0x202d
callq 0x1040
movq (%rbx), %rsi
leaq 0xf40(%rip), %rdi       # 0x2050
callq 0x1040
movq (%rbx), %rsi
leaq 0xf53(%rip), %rdi       # 0x2072
callq 0x1040
movq (%rbx), %rsi
leaq 0xf65(%rip), %rdi       # 0x2093
popq %rbx
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/rep.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 3){
		usage();
		exit(1);
	}

	long rep = strtol(argv[1], NULL, 10);
	if(errno != 0){
		fprintf(stderr, "Error: %s\n", strerror(errno));
		exit(1);
	}

	int lasterror = 0;
	for(int i=0;i<rep;i++){
		int pid = fork();
		if(pid == 0){//child proc
			return -execvp(argv[2], &argv[2]);
		}

		int wstatus;
		int wpid;
		if((wpid = waitpid(pid, &wstatus, 0)) > 0){
			if(WIFEXITED(wstatus) && WEXITSTATUS(wstatus)){
				lasterror = WEXITSTATUS(wstatus);
			}
		}else{
			fprintf(stderr, "Error: waiting child error");
			exit(1);
		}
	}
	exit(lasterror);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, %edi
jle 0x137b
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
movl $0xa, %edx
callq 0x1060
movq %rax, %r15
callq 0x1030
movl (%rax), %edi
testl %edi, %edi
jne 0x1380
testq %r15, %r15
setg %r12b
jle 0x135d
addq $0x10, %rbx
movq %rbx, 0x8(%rsp)
movq %r15, %rax
negq %rax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movl $0x1, %ebx
xorl %r14d, %r14d
callq 0x10c0
movl %eax, %r13d
testl %eax, %eax
je 0x132a
movl %r13d, %edi
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x1070
testl %eax, %eax
jle 0x1376
movl 0x4(%rsp), %eax
movzbl %ah, %ecx
testl %ecx, %ecx
cmovel %r14d, %ecx
testb $0x7f, %al
cmovel %ecx, %r14d
jmp 0x133b
movq 0x8(%rsp), %rsi
movq (%rsi), %rdi
callq 0x1080
movl %eax, %ebp
negl %ebp
testl %r13d, %r13d
je 0x135f
cmpq %rbx, %r15
setg %r12b
movq 0x10(%rsp), %rax
addq %rbx, %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
jne 0x12f6
jmp 0x135f
xorl %ebp, %ebp
testb $0x1, %r12b
je 0x1385
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1160
callq 0x1185
callq 0x1134
movl %r14d, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/crcx[P]retroforth/tools/retro-embedimage.c
// Function: ngaLoadImage
CELL ngaLoadImage(char *imageFile) {
  FILE *fp;
  CELL imageSize;
  long fileLen;
  if ((fp = fopen(imageFile, "rb")) != NULL) {
    /* Determine length (in cells) */
    fseek(fp, 0, SEEK_END);
    fileLen = ftell(fp) / sizeof(CELL);
    rewind(fp);
    /* Read the file into memory */
    imageSize = fread(&memory, sizeof(CELL), fileLen, fp);
    fclose(fp);
  }
  else {
    printf("Unable to find the ngaImage!\n");
    exit(1);
  }
  return imageSize;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xe3d(%rip), %rsi       # 0x2004
callq 0x10a0
testq %rax, %rax
je 0x1227
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1090
movq %rbx, %rdi
callq 0x1080
movq %rax, %r14
shrq $0x2, %r14
movq %rbx, %rdi
callq 0x1070
leaq 0x2e7f(%rip), %rdi      # 0x4080
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1040
movq %rax, %r14
movq %rbx, %rdi
callq 0x1050
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xe3b(%rip), %rdi       # 0x2069
callq 0x1030
movl $0x1, %edi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/crcx[P]retroforth/tools/retro-embedimage.c
// Function: output_header
void output_header(int size) {
  printf("#include <stdint.h>\n");
  printf("#ifndef CELL\n");
  printf("#ifndef BIT64\n");
  printf("#define CELL int32_t\n");
  printf("#define CELL_MIN INT_MIN + 1\n");
  printf("#define CELL_MAX INT_MAX - 1\n");
  printf("#else\n");
  printf("#define CELL int64_t\n");
  printf("#define CELL_MIN LLONG_MIN + 1\n");
  printf("#define CELL_MAX LLONG_MAX - 1\n");
  printf("#endif\n");
  printf("#endif\n");
  printf("CELL ngaImageCells = %lld;\n", (long long)size);
  printf("CELL ngaImage[] = { ");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xe3c(%rip), %rdi       # 0x2086
callq 0x1030
leaq 0xe44(%rip), %rdi       # 0x209a
callq 0x1030
leaq 0xe45(%rip), %rdi       # 0x20a7
callq 0x1030
leaq 0xe47(%rip), %rdi       # 0x20b5
callq 0x1030
leaq 0xe50(%rip), %rdi       # 0x20ca
callq 0x1030
leaq 0xe61(%rip), %rdi       # 0x20e7
callq 0x1030
leaq 0xe72(%rip), %rdi       # 0x2104
callq 0x1030
leaq 0xe6c(%rip), %rdi       # 0x210a
callq 0x1030
leaq 0xe75(%rip), %rdi       # 0x211f
callq 0x1030
leaq 0xe88(%rip), %rdi       # 0x213e
callq 0x1030
leaq 0xe9b(%rip), %r14       # 0x215d
movq %r14, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movslq %ebx, %rsi
leaq 0xd2b(%rip), %rdi       # 0x2007
xorl %eax, %eax
callq 0x1060
leaq 0xd39(%rip), %rdi       # 0x2023
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/crcx[P]retroforth/tools/retro-embedimage.c
// Function: main
int main(int argc, char **argv) {
  int32_t size = 0;
  int32_t i;
  int32_t n;

  if (argc == 2)
      size = ngaLoadImage(argv[1]);
  else
      size = ngaLoadImage("ngaImage");

  output_header(size);

  i = 0;
  n = 0;
  while (i < size) {
    n++;
    if (n == 20) {
      printf("\n                       ");
      n = 0;
    }
    if (i+1 < size)
      printf("%lld,", (long long)memory[i]);
    else
      printf("%lld };\n", (long long)memory[i]);
    i++;
  }
  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x130e
movq 0x8(%rsi), %rdi
jmp 0x1315
leaq 0xd23(%rip), %rdi       # 0x2038
callq 0x11bc
movl %eax, %ebx
movl %eax, %edi
callq 0x123d
testl %ebx, %ebx
jle 0x138d
movl %ebx, %r14d
movq %r14, %r15
negq %r15
leaq 0x2d49(%rip), %r12      # 0x4080
movl $0x1, %r13d
leaq 0xd1c(%rip), %rbx       # 0x2060
xorl %ebp, %ebp
incl %ebp
cmpl $0x14, %ebp
jne 0x135d
xorl %ebp, %ebp
leaq 0xceb(%rip), %rdi       # 0x2041
xorl %eax, %eax
callq 0x1060
cmpq %r14, %r13
movslq (%r12), %rsi
movq %rbx, %rdi
leaq 0xcec(%rip), %rax       # 0x205a
cmovbq %rax, %rdi
xorl %eax, %eax
callq 0x1060
addq $0x4, %r12
leaq (%r15,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x1346
xorl %edi, %edi
callq 0x10b0