LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x7100
leaq 0x4(,%rax,4), %rdi
callq *0xd462(%rip)           # 0x203c8
movq %rax, %r14
testq %rax, %rax
je 0x12f79
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7160
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x12fc6
testq %rsi, %rsi
je 0x12fe5
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x12f49
testq %rax, %rax
je 0x12fbc
movq %rax, %r14
movq (%rbx), %rdi
callq *0xd28a(%rip)           # 0x20238
movq %r14, (%rbx)
movl $0x1, 0x10(%rbx)
xorl %eax, %eax
jmp 0x12fc1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7860(%rip), %rdi      # 0x1a82d
leaq 0x6aa2(%rip), %rsi      # 0x19a76
leaq 0x757f(%rip), %rcx      # 0x1a55a
movl $0x19a1, %edx           # imm = 0x19A1
callq 0x7120
leaq 0x74ab(%rip), %rdi      # 0x1a497
leaq 0x6a83(%rip), %rsi      # 0x19a76
leaq 0x7560(%rip), %rcx      # 0x1a55a
movl $0x19a2, %edx           # imm = 0x19A2
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1303e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x130a4
movq %rsi, %rbx
cmpl $0x1, %edx
jne 0x13041
cmpq %rbx, (%rax)
jbe 0x130a4
movq 0x8(%rax), %rcx
imulq 0x18(%rax), %rbx
movq (%rcx,%rbx), %rax
jmp 0x130a6
xorl %eax, %eax
retq
leaq -0x20(%rbp), %r15
testq %rax, %rax
je 0x1304f
cmpq %rbx, (%rax)
ja 0x1302f
callq 0x12e45
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x130a4
movq (%r14), %rdi
movq %r15, %rsi
callq 0xf2aa
testl %eax, %eax
js 0x13071
movq (%r14), %rax
jmp 0x13045
movq -0x20(%rbp), %rbx
testq %rbx, %rbx
je 0x130a4
movq (%rbx), %r14
testq %r14, %r14
je 0x1309b
movq (%r14), %rdi
callq *0xd1ad(%rip)           # 0x20238
movq $0x0, (%r14)
movq %r14, %rdi
callq *0xd19d(%rip)           # 0x20238
movq %rbx, %rdi
callq *0xd194(%rip)           # 0x20238
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x130f6
testq %rsi, %rsi
je 0x13115
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xdab3
testq %rax, %rax
je 0x130ec
movq %rax, %r14
movq (%rbx), %rdi
callq *0xd15a(%rip)           # 0x20238
movq %r14, (%rbx)
movl $0x2, 0x10(%rbx)
xorl %eax, %eax
jmp 0x130f1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7730(%rip), %rdi      # 0x1a82d
leaq 0x6972(%rip), %rsi      # 0x19a76
leaq 0x7518(%rip), %rcx      # 0x1a623
movl $0x19b4, %edx           # imm = 0x19B4
callq 0x7120
leaq 0x737b(%rip), %rdi      # 0x1a497
leaq 0x6953(%rip), %rsi      # 0x19a76
leaq 0x74f9(%rip), %rcx      # 0x1a623
movl $0x19b5, %edx           # imm = 0x19B5
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
cmpq %rsi, 0x10(%rdi)
jae 0x13167
movq %rdi, %rbx
imulq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdi
callq *0xd27e(%rip)           # 0x203d0
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7610(%rip), %rdi      # 0x1a77e
leaq 0x6901(%rip), %rsi      # 0x19a76
leaq 0x75d5(%rip), %rcx      # 0x1a751
movl $0x1c47, %edx           # imm = 0x1C47
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
xorl %edx, %edx
callq 0x14403
movl $0xfffffffc, %r14d      # imm = 0xFFFFFFFC
testq %rax, %rax
je 0x132ab
movq %rax, %r12
movq 0x8(%rbx), %rax
movl 0x178(%rax), %eax
testl %eax, %eax
je 0x1321c
cmpl $0x1, %eax
jne 0x132dc
cmpq $0x0, (%r12)
je 0x132ab
movq %r15, -0x30(%rbp)
movq 0x20(%rbx), %r15
callq 0x12e45
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x13257
movq %rax, %r13
movq (%r12), %rdi
leaq -0x38(%rbp), %rsi
movq %r15, %rdx
callq 0xf525
testl %eax, %eax
js 0x1322c
movq (%r12), %rax
movq 0x8(%rax), %rcx
imulq 0x18(%rax), %r15
movq (%rcx,%r15), %rax
jmp 0x13259
movq 0x20(%rbx), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x13004
jmp 0x1325d
movq (%r13), %r15
testq %r15, %r15
je 0x1324e
movq (%r15), %rdi
callq *0xcffa(%rip)           # 0x20238
movq $0x0, (%r15)
movq %r15, %rdi
callq *0xcfea(%rip)           # 0x20238
movq %r13, %rdi
callq *0xcfe1(%rip)           # 0x20238
xorl %eax, %eax
movq -0x30(%rbp), %r15
testq %rax, %rax
je 0x132ab
movq (%rax), %rdi
testq %rdi, %rdi
je 0x132bd
movl 0x8(%r15), %eax
cmpl $0x2, %eax
je 0x13290
cmpl $0x1, %eax
je 0x13286
testl %eax, %eax
jne 0x132ab
movq (%r15), %rsi
callq 0x12ec6
jmp 0x13298
movq (%r15), %rsi
callq 0x12f81
jmp 0x13298
movq (%r15), %rsi
callq 0x130b1
testl %eax, %eax
js 0x132a5
incq 0x20(%rbx)
xorl %r14d, %r14d
jmp 0x132ab
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x755f(%rip), %rdi      # 0x1a823
leaq 0x67ab(%rip), %rsi      # 0x19a76
leaq 0x751b(%rip), %rcx      # 0x1a7ed
movl $0xa01, %edx            # imm = 0xA01
callq 0x7120
leaq 0x67be(%rip), %rdi      # 0x19aa1
leaq 0x678c(%rip), %rsi      # 0x19a76
leaq 0x74af(%rip), %rcx      # 0x1a7a0
movl $0x1b51, %edx           # imm = 0x1B51
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x13fe9
movq (%rsi), %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x10, %ecx
callq 0x140c5
movslq %eax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x20, %ecx
callq 0x140c5
movslq %eax, %r12
addq %r13, %r12
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x13fa7
cmpq $0x0, (%rdi)
je 0x13fa7
callq 0x14499
addq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x140c5
cltq
cmpq %rax, %r12
ja 0x13fd7
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x140c5
movslq %eax, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6904(%rip), %rdi      # 0x1a8f4
leaq 0x5a7f(%rip), %rsi      # 0x19a76
leaq 0x68b9(%rip), %rcx      # 0x1a8b7
movl $0x93f, %edx            # imm = 0x93F
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x140a6
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x4, %ecx
callq 0x140c5
movslq %eax, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x8, %ecx
callq 0x140c5
movslq %eax, %rbx
addq %r14, %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x40, %ecx
callq 0x140c5
movq -0x30(%rbp), %rcx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x14094
cmpq $0x0, (%rdi)
je 0x14094
movslq %eax, %r14
callq 0x14ae1
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 0x6847(%rip), %rdi      # 0x1a8f4
leaq 0x59c2(%rip), %rsi      # 0x19a76
leaq 0x6873(%rip), %rcx      # 0x1a92e
movl $0x970, %edx            # imm = 0x970
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x14336
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 0x14c0b
movq %r12, %rdi
callq 0x70d0
movq %rax, %r13
leaq -0x1b0(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x14cc4
movq %r12, %rdi
callq 0x70d0
movq %rax, %r12
addq %r13, %r12
leaq -0x130(%rbp), %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x14d70
movq %r13, %rdi
callq 0x70d0
movq %rax, %r13
leaq -0xb0(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rcx, %rbx
callq 0x14e70
movq %rbx, %rdi
callq 0x70d0
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 0x65b7(%rip), %rdi      # 0x1a8f4
leaq 0x5732(%rip), %rsi      # 0x19a76
leaq 0x66b9(%rip), %rcx      # 0x1aa04
movl $0x953, %edx            # imm = 0x953
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x143e4
movq (%rdi), %rax
testq %rax, %rax
je 0x143d3
movq (%rax), %rcx
cmpq %rsi, %rcx
jbe 0x143d3
movq 0x8(%rax), %rdx
movq 0x18(%rax), %rdi
movq %rdi, %rax
imulq %rsi, %rax
movq (%rdx,%rax), %r8
testq %r8, %r8
je 0x143d3
movl $0x1, %eax
cmpl $0x1, 0x8(%r8)
jne 0x143d5
leaq 0x1(%rsi), %r10
cmpq %r10, %rcx
movq %r10, %r8
cmovaq %rcx, %r8
movq %rdi, %rax
imulq %r10, %rax
addq %rax, %rdx
movq %rsi, %r9
cmpq %rcx, %r10
jae 0x143d7
incq %r9
movq (%rdx), %r11
testq %r11, %r11
je 0x143dc
movq %r10, %rax
incq %r10
addq %rdi, %rdx
cmpl $0x2, 0x8(%r11)
je 0x143b1
jmp 0x143df
xorl %eax, %eax
popq %rbp
retq
movq %r8, %rax
jmp 0x143df
movq %r9, %rax
subq %rsi, %rax
jmp 0x143d5
leaq 0x6282(%rip), %rdi      # 0x1a66d
leaq 0x5684(%rip), %rsi      # 0x19a76
leaq 0x68b5(%rip), %rcx      # 0x1acae
movl $0x1596, %edx           # imm = 0x1596
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x1448c
movq %rsi, %rbx
cmpl $0x1, %edx
jne 0x14431
cmpq %rbx, (%rax)
jbe 0x1448c
movq 0x8(%rax), %rcx
imulq 0x18(%rax), %rbx
movq (%rcx,%rbx), %rax
jmp 0x1448e
movq %rdi, %r14
leaq -0x20(%rbp), %r15
cmpq %rbx, (%rax)
ja 0x14422
xorl %edi, %edi
callq 0x12b11
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x1448c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xf2aa
testl %eax, %eax
js 0x14483
movq (%r14), %rax
testq %rax, %rax
jne 0x14438
leaq 0x62df(%rip), %rdi      # 0x1a74a
leaq 0x5604(%rip), %rsi      # 0x19a76
leaq 0x6d57(%rip), %rcx      # 0x1b1d0
movl $0x1c74, %edx           # imm = 0x1C74
callq 0x7120
movq -0x20(%rbp), %rdi
callq 0xedfa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x14731
movq %rsi, %r13
movq %rdi, %r15
movq %rdi, %r12
testq %rsi, %rsi
je 0x14712
movq %r15, %rdi
movl $0xa, %esi
callq 0x70e0
decq %r13
je 0x14707
xorl %r12d, %r12d
testq %rax, %rax
je 0x14734
incq %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x70e0
decq %r13
jne 0x146ed
testq %rax, %rax
je 0x14731
incq %rax
movq %rax, %r12
movq %r12, %rdi
movl $0xa, %esi
callq 0x70e0
testq %rax, %rax
jne 0x14736
movq %r15, %rdi
callq 0x70d0
addq %r15, %rax
jmp 0x14736
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_O3/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
testq %rdi, %rdi
je 0x147ce
movq %rsi, %r13
movq %rdi, %r15
movq %rdi, %r12
testq %rsi, %rsi
je 0x147ae
movq %r15, %rdi
movl $0xa, %esi
callq 0x7230
decq %r13
je 0x147a2
xorl %r12d, %r12d
testq %rax, %rax
je 0x147d1
addq $0x4, %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x7230
decq %r13
jne 0x14787
testq %rax, %rax
je 0x147ce
addq $0x4, %rax
movq %rax, %r12
movq %r12, %rdi
movl $0xa, %esi
callq 0x7230
testq %rax, %rax
jne 0x147d3
movq %r15, %rdi
callq 0x7100
leaq (%r15,%rax,4), %rax
jmp 0x147d3
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_O3/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 0x1496d
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
leaq 0x4d8f(%rip), %rdx      # 0x19590
subq $0x1, %rsi
jb 0x14970
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x20, %r8d
jl 0x14972
leal -0x7f(%r8), %r9d
cmpl $0x21, %r9d
jb 0x14972
leal -0xe01f0(%r8), %eax
cmpl $0xfff20110, %eax       # imm = 0xFFF20110
jae 0x14926
movl $0x1, %eax
cmpl $0x1100, %r8d           # imm = 0x1100
jl 0x1490f
cmpl $0x1160, %r8d           # imm = 0x1160
setb %al
leal -0x2329(%r8), %r9d
cmpl $0x2, %r9d
setb %r9b
orb %al, %r9b
movl $0x2, %eax
jne 0x1490f
leal -0x2e80(%r8), %r9d
cmpl $0x7650, %r9d           # imm = 0x7650
setb %r9b
cmpl $0x303f, %r8d           # imm = 0x303F
setne %r10b
testb %r9b, %r10b
jne 0x1490f
leal -0xac00(%r8), %r9d
cmpl $0x2ba4, %r9d           # imm = 0x2BA4
jb 0x1490f
leal -0xf900(%r8), %r9d
cmpl $0x200, %r9d            # imm = 0x200
jb 0x1490f
leal -0xfe10(%r8), %r9d
cmpl $0xa, %r9d
jb 0x1490f
leal -0xfe30(%r8), %r9d
cmpl $0x40, %r9d
jb 0x1490f
leal -0xff00(%r8), %r9d
cmpl $0x61, %r9d
jb 0x1490f
leal -0xffe0(%r8), %r9d
cmpl $0x7, %r9d
jb 0x1490f
leal -0x20000(%r8), %r9d
cmpl $0xfffe, %r9d           # imm = 0xFFFE
jb 0x1490f
addl $0xfffd0000, %r8d       # imm = 0xFFFD0000
cmpl $0xfffe, %r8d           # imm = 0xFFFE
movl $0x0, %eax
adcl $0x1, %eax
addl %eax, %ecx
movl 0x4(%rdi), %r8d
addq $0x4, %rdi
movl %ecx, %eax
testl %r8d, %r8d
jne 0x14801
jmp 0x14972
xorl %r9d, %r9d
movl $0x8d, %r10d
cmpl %r9d, %r10d
jl 0x1483a
leal (%r9,%r10), %r11d
movl %r11d, %eax
shrl $0x1f, %eax
addl %r11d, %eax
sarl %eax
movslq %eax, %r11
cmpl %r8d, 0x4(%rdx,%r11,8)
jge 0x1495f
leal 0x1(%rax), %r9d
cmpl %eax, %r10d
jg 0x14938
jmp 0x1483a
leal -0x1(%r11), %r10d
xorl %eax, %eax
cmpl %r8d, (%rdx,%r11,8)
jg 0x1492f
jmp 0x1490f
xorl %eax, %eax
retq
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x14a1d
movq %rsi, %r13
movq %rdi, %r15
movq %rdi, %r12
testq %rsi, %rsi
je 0x149fe
movq %rbx, -0x30(%rbp)
movq %r15, %rdi
movl $0xa, %esi
callq 0xd89b
decq %r13
je 0x149e1
xorl %r12d, %r12d
leaq -0x34(%rbp), %rbx
testq %rax, %rax
je 0x14a37
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd354
movq %rax, %rdi
movl $0xa, %esi
callq 0xd89b
decq %r13
jne 0x149bf
testq %rax, %rax
movq -0x30(%rbp), %rbx
je 0x14a1d
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xd354
movq %rax, %r12
testq %rax, %rax
je 0x14a1d
movq %r12, %rdi
movl $0xa, %esi
callq 0xd89b
testq %rax, %rax
jne 0x14a22
movq %r15, %rdi
callq 0x70d0
addq %r15, %rax
jmp 0x14a22
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
xorl %eax, %eax
movq -0x30(%rbp), %rbx
jmp 0x14a22
// File: /workspace/github_c_makefile_star2_O3/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 0xd12a(%rip), %rax      # 0x21b80
testq %rax, %rax
je 0x14a72
leaq -0x20(%rbp), %rdx
movq $0x0, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
je 0x14ab0
subq %r14, %rbx
leaq 0x1(%rbx), %rdi
callq *0xb949(%rip)           # 0x203c8
testq %rax, %rax
je 0x14ac2
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x71e0
movb $0x0, (%r15,%rbx)
movq %r15, %rdi
callq 0xddea
movq %rax, %rbx
movq %r15, %rdi
callq *0xb78a(%rip)           # 0x20238
jmp 0x14ab4
movq -0x20(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e33(%rip), %rdi      # 0x1a8fc
leaq 0x4fa6(%rip), %rsi      # 0x19a76
leaq 0x5e29(%rip), %rcx      # 0x1a900
movl $0x19fa, %edx           # imm = 0x19FA
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x14b79
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x14b79
movl 0x10(%rdi), %r14d
cmpl $0x2, %r14d
je 0x14b2a
cmpl $0x1, %r14d
je 0x14b20
testl %r14d, %r14d
jne 0x14bec
movq %rbx, %rdi
callq 0x70d0
jmp 0x14b32
movq %rbx, %rdi
callq 0x7100
jmp 0x14b32
movq %rbx, %rdi
callq 0xdaff
testq %rax, %rax
je 0x14b79
movq %rbx, %rdi
movl $0xa, %esi
cmpl $0x2, %r14d
je 0x14b87
cmpl $0x1, %r14d
jne 0x14bbc
callq 0x7230
testq %rax, %rax
je 0x14be5
movl $0x1, %ebx
addq $0x4, %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x7230
incq %rbx
testq %rax, %rax
jne 0x14b5e
jmp 0x14b7b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xd89b
testq %rax, %rax
je 0x14be5
movl $0x1, %ebx
leaq -0x14(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xd354
movq %rax, %rdi
movl $0xa, %esi
callq 0xd89b
incq %rbx
testq %rax, %rax
jne 0x14b9a
jmp 0x14b7b
callq 0x70e0
testq %rax, %rax
je 0x14be5
movl $0x1, %ebx
incq %rax
movq %rax, %rdi
movl $0xa, %esi
callq 0x70e0
incq %rbx
testq %rax, %rax
jne 0x14bcb
jmp 0x14b7b
movl $0x1, %ebx
jmp 0x14b7b
leaq 0x5747(%rip), %rdi      # 0x1a33a
leaq 0x4e7c(%rip), %rsi      # 0x19a76
leaq 0x5d6c(%rip), %rcx      # 0x1a96d
movl $0x1854, %edx           # imm = 0x1854
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x140c5
movl %eax, %r14d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x140c5
movb $0x0, (%rbx)
cmpl $0xff, %eax
ja 0x14ca5
movl %eax, %r15d
leaq 0xa9e7(%rip), %r12      # 0x1f640
xorl %r13d, %r13d
btl %r13d, %r15d
jae 0x14c6e
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x7250
incq %r13
addq $0x8, %r12
cmpq $0x8, %r13
jne 0x14c5c
cmpl $0x10, %r14d
ja 0x14ca5
movl %r14d, %eax
leaq 0xa9f5(%rip), %rcx      # 0x1f680
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7250
leaq 0x568e(%rip), %rdi      # 0x1a33a
leaq 0x4dc3(%rip), %rsi      # 0x19a76
leaq 0x5d8f(%rip), %rcx      # 0x1aa49
movl $0x10f0, %edx           # imm = 0x10F0
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x140c5
movl %eax, %r14d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x140c5
movb $0x0, (%rbx)
cmpl $0xff, %eax
ja 0x14d51
xorl %ecx, %ecx
movl $0x1, %edx
shll %cl, %edx
testq %rcx, %rcx
je 0x14d1a
andl %eax, %edx
jne 0x14d2e
incq %rcx
cmpq $0x8, %rcx
jne 0x14d0a
cmpl $0x10, %r14d
ja 0x14d51
testl %r14d, %r14d
je 0x14d42
movq %rbx, %rdi
callq 0x70d0
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 0x55e2(%rip), %rdi      # 0x1a33a
leaq 0x4d17(%rip), %rsi      # 0x19a76
leaq 0x5dc8(%rip), %rcx      # 0x1ab2e
movl $0x111b, %edx           # imm = 0x111B
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x140c5
movl %eax, %r12d
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x140c5
movl %eax, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x140c5
movb $0x0, (%rbx)
cmpl $0xff, %r12d
ja 0x14e51
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %r14d
leaq 0xa862(%rip), %r15      # 0x1f640
xorl %r13d, %r13d
btl %r13d, %r12d
jae 0x14df2
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7250
incq %r13
addq $0x8, %r15
cmpq $0x8, %r13
jne 0x14de1
cmpl $0x10, %r14d
movl -0x2c(%rbp), %r15d
ja 0x14e51
testl %r14d, %r14d
je 0x14e27
movl %r14d, %eax
leaq 0x4be8(%rip), %rcx      # 0x19a00
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x7250
cmpl $0x10, %r15d
ja 0x14e51
movl %r15d, %eax
leaq 0xa849(%rip), %rcx      # 0x1f680
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7250
leaq 0x54e2(%rip), %rdi      # 0x1a33a
leaq 0x4c17(%rip), %rsi      # 0x19a76
leaq 0x5d28(%rip), %rcx      # 0x1ab8e
movl $0x1148, %edx           # imm = 0x1148
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x140c5
movl %eax, %r13d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x140c5
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x140c5
movb $0x0, (%rbx)
cmpl $0xff, %r13d
ja 0x14f4a
xorl %ecx, %ecx
movl $0x1, %edx
shll %cl, %edx
testq %rcx, %rcx
je 0x14edf
andl %r13d, %edx
jne 0x14efd
incq %rcx
cmpq $0x8, %rcx
jne 0x14ece
cmpl $0x10, -0x2c(%rbp)
ja 0x14f4a
cmpl $0x0, -0x2c(%rbp)
jne 0x14efd
cmpl $0x10, %eax
ja 0x14f4a
testl %eax, %eax
je 0x14f3b
movq %rbx, %rdi
callq 0x70d0
movl $0x6d305b1b, (%rbx,%rax) # imm = 0x6D305B1B
movb $0x0, 0x4(%rbx,%rax)
movq %rbx, %rdi
callq 0x70d0
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 0x14c0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53e9(%rip), %rdi      # 0x1a33a
leaq 0x4b1e(%rip), %rsi      # 0x19a76
leaq 0x5cec(%rip), %rcx      # 0x1ac4b
movl $0x117e, %edx           # imm = 0x117E
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x14fbb
testq %rdx, %rdx
je 0x14fb9
xorl %eax, %eax
movl $0x0, %ecx
testq %rdi, %rdi
je 0x14fae
movq (%rdi), %r8
testq %r8, %r8
je 0x14fae
cmpq %rax, (%r8)
jbe 0x14fae
movq 0x8(%r8), %rcx
movq 0x18(%r8), %r8
imulq %rax, %r8
movq (%rcx,%r8), %r8
movl $0x0, %ecx
testq %r8, %r8
je 0x14fae
movl 0x8(%r8), %ecx
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x14f79
popq %rbp
retq
leaq 0x5e59(%rip), %rdi      # 0x1ae1b
leaq 0x4aad(%rip), %rsi      # 0x19a76
leaq 0x5e07(%rip), %rcx      # 0x1add7
movl $0x15b0, %edx           # imm = 0x15B0
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 0x14ffb
cmpl $0x1, %eax
je 0x15030
testl %eax, %eax
jne 0x15079
subq %rsi, %rbx
movq 0x8(%r14), %rcx
incq %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rbx, %rcx
jb 0x1506e
movq (%r14), %rdi
movq %rbx, %rdx
callq 0x71e0
movq (%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, (%r14)
subq %rbx, 0x8(%r14)
movb $0x0, (%rax,%rbx)
movl %ebx, %eax
jmp 0x1506e
subq %rsi, %rbx
movq %rbx, %r15
sarq $0x2, %r15
movq 0x8(%r14), %rcx
incq %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %rcx
jb 0x1506e
movq (%r14), %rdi
movq %rbx, %rdx
callq 0x71e0
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 0x52ba(%rip), %rdi      # 0x1a33a
leaq 0x49ef(%rip), %rsi      # 0x19a76
leaq 0x5f29(%rip), %rcx      # 0x1afb7
movl $0x1a69, %edx           # imm = 0x1A69
callq 0x7120
// File: /workspace/github_c_makefile_star2_O3/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 *0xb31a(%rip)           # 0x203c8
testq %rax, %rax
je 0x150c6
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7130
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15111
movq %rdi, %rbx
testq %r15, %r15
je 0x15124
movq %r15, %rdi
callq *0xb2d8(%rip)           # 0x203c8
testq %rax, %rax
je 0x1512d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x71e0
movq %rbx, %rdi
callq *0xb129(%rip)           # 0x20238
jmp 0x15130
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0xb2a4(%rip)           # 0x203c8
movq %rbx, %rdi
callq *0xb10b(%rip)           # 0x20238
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jle 0x132a
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 0x132f
testq %r15, %r15
jle 0x12ff
xorl %r14d, %r14d
leaq 0x4(%rsp), %r12
callq 0x10c0
testl %eax, %eax
je 0x1307
movl %eax, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1070
testl %eax, %eax
jle 0x1325
movl 0x4(%rsp), %eax
movzbl %ah, %ecx
testl %ecx, %ecx
cmovel %r14d, %ecx
testb $0x7f, %al
cmovel %ecx, %r14d
decq %r15
jne 0x12ce
movl %r14d, %edi
callq 0x1090
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x1080
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1160
callq 0x1185
callq 0x1134
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_new
GtCsvlineReader *gt_csvline_reader_new(void)
{
  GtCsvlineReader *csvline_reader = gt_malloc(sizeof *csvline_reader);
  gt_assert(csvline_reader != NULL);
  GT_INITARRAY(&csvline_reader->line,char);
  GT_INITARRAY(&csvline_reader->dist.alphabet,char);
  GT_INITARRAY(&csvline_reader->columnoffset,GtUword);
  csvline_reader->empty = true;
  csvline_reader->separator = 0;
  csvline_reader->dist.charcount
    = gt_calloc(UCHAR_MAX+1,sizeof *csvline_reader->dist.charcount);
  return csvline_reader;
}

// Assembly:
pushq %rbx
leaq 0x1fdd8d(%rip), %rsi    # 0x341d35
movl $0x58, %edi
movl $0x29, %edx
callq 0x2d5f0
testq %rax, %rax
je 0x144003
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x40(%rax)
movw $0x1, 0x50(%rax)
leaq 0x1fdd4f(%rip), %rdx    # 0x341d35
movl $0x100, %edi            # imm = 0x100
movl $0x8, %esi
movl $0x31, %ecx
callq 0x2fef0
movq %rax, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x386ee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_delete
void gt_csvline_reader_delete(GtCsvlineReader *csvline_reader)
{
  if (csvline_reader != NULL)
  {
    GT_FREEARRAY(&csvline_reader->columnoffset,GtUword);
    GT_FREEARRAY(&csvline_reader->line,char);
    GT_FREEARRAY(&csvline_reader->dist.alphabet,char);
    gt_free(csvline_reader->dist.charcount);
    gt_free(csvline_reader);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1440c8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x144045
leaq 0x18(%rbx), %r14
leaq 0x1fdd09(%rip), %rsi    # 0x341d35
movl $0x43, %edx
callq 0x2feb0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x14406c
leaq 0x1fdce1(%rip), %rsi    # 0x341d35
movl $0x44, %edx
callq 0x2feb0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x144099
leaq 0x30(%rbx), %r14
leaq 0x1fdcb5(%rip), %rsi    # 0x341d35
movl $0x45, %edx
callq 0x2feb0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x48(%rbx), %rdi
leaq 0x1fdc91(%rip), %r14    # 0x341d35
movq %r14, %rsi
movl $0x46, %edx
callq 0x2feb0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x47, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2feb0
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_clear
void gt_csvline_reader_clear(GtCsvlineReader *csvline_reader)
{
  GtUword idx;

  csvline_reader->line.nextfreechar = 0;
  for (idx = 0; idx < csvline_reader->dist.alphabet.nextfreechar; idx++)
  {
    char cc = csvline_reader->dist.alphabet.spacechar[idx];
    csvline_reader->dist.charcount[(int) cc] = 0;
  }
  csvline_reader->dist.alphabet.nextfreechar = 0;
  for (idx = 0; idx <= UCHAR_MAX; idx++)
  {
    gt_assert(csvline_reader->dist.charcount[idx] == 0);
  }
  csvline_reader->columnoffset.nextfreeGtUword = 0;
  csvline_reader->empty = true;
}

// Assembly:
pushq %rax
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x40(%rdi)
je 0x1440fb
movq 0x30(%rdi), %rcx
movq 0x48(%rdi), %rax
xorl %edx, %edx
movsbq (%rcx,%rdx), %rsi
movq $0x0, (%rax,%rsi,8)
incq %rdx
cmpq 0x40(%rdi), %rdx
jb 0x1440e3
jmp 0x1440ff
movq 0x48(%rdi), %rax
movq $0x0, 0x40(%rdi)
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x14412a
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x144109
movq $0x0, 0x28(%rdi)
movb $0x1, 0x50(%rdi)
popq %rax
retq
callq 0x38725