LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: cget_cell_prop
FT_INTERNAL
const f_cell_props_t *cget_cell_prop(const f_cell_prop_container_t *cont, size_t row, size_t col)
{
    assert(cont);
    size_t sz = vector_size(cont);
    size_t i = 0;
    for (i = 0; i < sz; ++i) {
        const f_cell_props_t *opt = &VECTOR_AT_C(cont, i, const f_cell_props_t);
        if (opt->cell_row == row && opt->cell_col == col)
            return opt;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b89d
jmp 0x1b8bc
leaq 0x84c3(%rip), %rdi      # 0x23d67
leaq 0x72eb(%rip), %rsi      # 0x22b96
movl $0x11d9, %edx           # imm = 0x11D9
leaq 0x84b5(%rip), %rcx      # 0x23d6c
callq 0x7120
movq -0x10(%rbp), %rdi
callq 0x132b0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1b929
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1baf0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1b919
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1b919
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b931
jmp 0x1b91b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1b8d9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x1a550
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x1a550
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x100, -0x38(%rbp)     # imm = 0x100
jae 0x1bbf6
movq $0x0, -0x30(%rbp)
cmpq $0x8, -0x30(%rbp)
jae 0x1bbf4
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1bbe4
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rcx
leaq 0xfcf5(%rip), %rax      # 0x2b8d0
movq (%rax,%rcx,8), %rsi
callq 0x7240
jmp 0x1bbe6
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1bbae
jmp 0x1bbf8
jmp 0x1bc24
movl -0x34(%rbp), %eax
cmpq $0x11, %rax
jae 0x1bc1c
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %ecx
leaq 0xfcff(%rip), %rax      # 0x2b910
movq (%rax,%rcx,8), %rsi
callq 0x7240
jmp 0x1bc1e
jmp 0x1bc24
addq $0x40, %rsp
popq %rbp
retq
leaq 0x7853(%rip), %rdi      # 0x2347e
leaq 0x6f64(%rip), %rsi      # 0x22b96
movl $0x10f0, %edx           # imm = 0x10F0
leaq 0x81c9(%rip), %rcx      # 0x23e07
callq 0x7120
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x1a550
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x1a550
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x100, -0x38(%rbp)     # imm = 0x100
jae 0x1bcf9
movq $0x0, -0x30(%rbp)
cmpq $0x8, -0x30(%rbp)
jae 0x1bcf7
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1bce7
cmpq $0x0, -0x30(%rbp)
je 0x1bce5
jmp 0x1bd12
jmp 0x1bce7
jmp 0x1bce9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1bcbe
jmp 0x1bcfb
jmp 0x1bd24
movl -0x34(%rbp), %eax
cmpq $0x11, %rax
jae 0x1bd0e
cmpl $0x0, -0x34(%rbp)
je 0x1bd0c
jmp 0x1bd12
jmp 0x1bd10
jmp 0x1bd24
jmp 0x1bd43
movq -0x20(%rbp), %rdi
leaq 0x62e5(%rip), %rsi      # 0x22002
callq 0x7240
jmp 0x1bd43
leaq 0x7753(%rip), %rdi      # 0x2347e
leaq 0x6e64(%rip), %rsi      # 0x22b96
movl $0x111b, %edx           # imm = 0x111B
leaq 0x81ae(%rip), %rcx      # 0x23eec
callq 0x7120
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x1a550
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x1a550
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x1a550
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x100, -0x34(%rbp)     # imm = 0x100
jae 0x1be1f
movq $0x0, -0x30(%rbp)
cmpq $0x8, -0x30(%rbp)
jae 0x1be1d
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1be0d
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rcx
leaq 0xfacc(%rip), %rax      # 0x2b8d0
movq (%rax,%rcx,8), %rsi
callq 0x7240
jmp 0x1be0f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1bdd7
jmp 0x1be21
jmp 0x1be79
movl -0x38(%rbp), %eax
cmpq $0x11, %rax
jae 0x1be4b
cmpl $0x0, -0x38(%rbp)
je 0x1be49
movq -0x20(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %ecx
leaq 0xfb60(%rip), %rax      # 0x2b9a0
movq (%rax,%rcx,8), %rsi
callq 0x7240
jmp 0x1be4d
jmp 0x1be79
movl -0x3c(%rbp), %eax
cmpq $0x11, %rax
jae 0x1be71
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %ecx
leaq 0xfaaa(%rip), %rax      # 0x2b910
movq (%rax,%rcx,8), %rsi
callq 0x7240
jmp 0x1be73
jmp 0x1be79
addq $0x40, %rsp
popq %rbp
retq
leaq 0x75fe(%rip), %rdi      # 0x2347e
leaq 0x6d0f(%rip), %rsi      # 0x22b96
movl $0x1148, %edx           # imm = 0x1148
leaq 0x80b9(%rip), %rcx      # 0x23f4c
callq 0x7120
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: snprint_n_strings
static
int snprint_n_strings(f_conv_context_t *cntx, size_t n, const char *str)
{
    int w = snprint_n_strings_impl(cntx->u.buf, cntx->raw_avail, n, str);
    if (w >= 0) {
        cntx->u.buf += w;
        cntx->raw_avail -= w;
    }
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1c3d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1c05f
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movslq -0x1c(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: u8nprint_n_strings
static
int u8nprint_n_strings(void *buf, size_t length, size_t n, const void *str)
{
    size_t str_size = utf8size(str) - 1; /* str_size - raw size in bytes, excluding \0 */
    if (length <= n * str_size)
        return -1;

    if (n == 0)
        return 0;

    /* To ensure valid return value it is safely not print such big strings */
    if (n * str_size > INT_MAX)
        return -1;

    if (str_size == 0)
        return 0;

    size_t i = n;
    while (i) {
        memcpy(buf, str, str_size);
        buf = (char *)buf + str_size;
        --i;
    }
    *(char *)buf = '\0';
    return (int)(n * str_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x111a0
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq -0x30(%rbp), %rcx
cmpq %rcx, %rax
ja 0x1c337
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c3be
cmpq $0x0, -0x20(%rbp)
jne 0x1c347
movl $0x0, -0x4(%rbp)
jmp 0x1c3be
movq -0x20(%rbp), %rax
imulq -0x30(%rbp), %rax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jbe 0x1c361
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c3be
cmpq $0x0, -0x30(%rbp)
jne 0x1c371
movl $0x0, -0x4(%rbp)
jmp 0x1c3be
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1c3ab
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x71d0
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1c379
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
imulq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: snprint_n_strings_impl
static
int snprint_n_strings_impl(char *buf, size_t length, size_t n, const char *str)
{
    size_t str_len = strlen(str);
    if (length <= n * str_len)
        return -1;

    if (n == 0)
        return 0;

    /* To ensure valid return value it is safely not print such big strings */
    if (n * str_len > INT_MAX)
        return -1;

    if (str_len == 0)
        return 0;

    int status = snprintf(buf, length, "%0*d", (int)(n * str_len), 0);
    if (status < 0)
        return status;

    size_t i = 0;
    for (i = 0; i < n; ++i) {
        const char *str_p = str;
        while (*str_p)
            *(buf++) = *(str_p++);
    }
    return (int)(n * str_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x70d0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq -0x30(%rbp), %rcx
cmpq %rcx, %rax
ja 0x1c413
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c4f6
cmpq $0x0, -0x20(%rbp)
jne 0x1c426
movl $0x0, -0x4(%rbp)
jmp 0x1c4f6
movq -0x20(%rbp), %rax
imulq -0x30(%rbp), %rax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jbe 0x1c443
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c4f6
cmpq $0x0, -0x30(%rbp)
jne 0x1c456
movl $0x0, -0x4(%rbp)
jmp 0x1c4f6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
imulq -0x30(%rbp), %rax
movl %eax, %ecx
leaq 0x7c7f(%rip), %rdx      # 0x240ef
xorl %r8d, %r8d
movb $0x0, %al
callq 0x7110
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x1c48b
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c4f6
movq $0x0, -0x40(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1c4ea
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1c4da
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x1c4ad
jmp 0x1c4dc
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x1c49b
movq -0x20(%rbp), %rax
imulq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cebd
jmp 0x1cedc
leaq 0x6980(%rip), %rdi      # 0x23844
leaq 0x5ccb(%rip), %rsi      # 0x22b96
movl $0x15af, %edx           # imm = 0x15AF
leaq 0x72be(%rip), %rcx      # 0x24195
callq 0x7120
cmpq $0x0, -0x10(%rbp)
je 0x1cee5
jmp 0x1cf04
leaq 0x72ed(%rip), %rdi      # 0x241d9
leaq 0x5ca3(%rip), %rsi      # 0x22b96
movl $0x15b0, %edx           # imm = 0x15B0
leaq 0x7296(%rip), %rcx      # 0x24195
callq 0x7120
movq $0x0, -0x20(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1cf6d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a230
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1cf4e
movq -0x28(%rbp), %rdi
callq 0x1a260
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1cf5d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x1cf5f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1cf14
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: buffer_substring
static void
buffer_substring(const f_string_buffer_t *buffer, size_t buffer_row, const void **begin, const void **end,  ptrdiff_t *str_it_width)
{
    switch (buffer->type) {
        case CHAR_BUF:
            str_n_substring(buffer->str.cstr, '\n', buffer_row, (const char **)begin, (const char **)end);
            if ((*(const char **)begin) && (*(const char **)end))
                *str_it_width = str_iter_width(*(const char **)begin, *(const char **)end);
            break;
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            wstr_n_substring(buffer->str.wstr, L'\n', buffer_row, (const wchar_t **)begin, (const wchar_t **)end);
            if ((*(const wchar_t **)begin) && (*(const wchar_t **)end))
                *str_it_width = wcs_iter_width(*(const wchar_t **)begin, *(const wchar_t **)end);
            break;
#endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8
        case UTF8_BUF:
            utf8_n_substring(buffer->str.u8str, '\n', buffer_row, begin, end);
            if ((*(const char **)begin) && (*(const char **)end))
                *str_it_width = utf8_width(*begin, *end);
            break;
#endif /* FT_HAVE_UTF8 */
        default:
            assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x1d887
jmp 0x1d86c
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x1d8da
jmp 0x1d876
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x1d92a
jmp 0x1d97a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0xa, %esi
callq 0x1ace0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d8d5
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d8d5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1da70
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d999
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0xa, %esi
callq 0x1ad90
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d928
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d928
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1dac0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d999
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0xa, %esi
callq 0x1aed0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d978
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d978
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1af70
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d999
leaq 0x5afd(%rip), %rdi      # 0x2347e
leaq 0x520e(%rip), %rsi      # 0x22b96
movl $0x1a52, %edx           # imm = 0x1A52
leaq 0x6902(%rip), %rcx      # 0x24296
callq 0x7120
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x1d9d8
jmp 0x1d9c4
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x1d9fd
jmp 0x1d9ce
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x1da26
jmp 0x1da3c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1db20
movl %eax, -0x4(%rbp)
jmp 0x1da5b
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1dba0
movl %eax, -0x4(%rbp)
jmp 0x1da5b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1dc40
movl %eax, -0x4(%rbp)
jmp 0x1da5b
leaq 0x5a3b(%rip), %rdi      # 0x2347e
leaq 0x514c(%rip), %rsi      # 0x22b96
movl $0x1a69, %edx           # imm = 0x1A69
leaq 0x691f(%rip), %rcx      # 0x24375
callq 0x7120
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_nprint
FT_INTERNAL
int ft_nprint(f_conv_context_t *cntx, const char *str, size_t strlen)
{
    if (cntx->raw_avail + 1/* for 0 */ < strlen)
        return -1;

    memcpy(cntx->u.buf, str, strlen);
    cntx->u.buf += strlen;
    cntx->raw_avail -= strlen;
    *cntx->u.buf = '\0'; /* Do we need this ? */
    return strlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x1db4f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1db95
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x71d0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_nwprint
int ft_nwprint(f_conv_context_t *cntx, const wchar_t *str, size_t strlen)
{
    if (cntx->raw_avail + 1/* for 0 */ < strlen)
        return -1;

    size_t raw_len = strlen * sizeof(wchar_t);

    memcpy(cntx->u.buf, str, raw_len);
    cntx->u.buf += raw_len;
    cntx->raw_avail -= raw_len;

    /* Do we need this ? */
    wchar_t end_of_string = L'\0';
    memcpy(cntx->u.buf, &end_of_string, sizeof(wchar_t));
    return strlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x1dbcf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1dc2a
movq -0x20(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x71d0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_nu8print
FT_INTERNAL
int ft_nu8print(f_conv_context_t *cntx, const void *beg, const void *end)
{
    const char *bc = (const char *)beg;
    const char *ec = (const char *)end;
    size_t raw_len = ec - bc;
    if (cntx->raw_avail + 1 < raw_len)
        return -1;

    memcpy(cntx->u.buf, beg, raw_len);
    cntx->u.buf += raw_len;
    cntx->raw_avail -= raw_len;
    *(cntx->u.buf) = '\0'; /* Do we need this ? */
    return raw_len; /* what return here ? */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
cmpq -0x38(%rbp), %rax
jae 0x1dc8e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1dcd4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x71d0
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xc6b4(%rip), %rax      # 0x2a3b8
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1dd24
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x7130
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1dd5a
movq 0xc66a(%rip), %rax      # 0x2a3b8
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x1ddc0
cmpq $0x0, -0x18(%rbp)
jne 0x1dd78
movq 0xc4c0(%rip), %rax      # 0x2a228
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x1ddc0
movq 0xc639(%rip), %rax      # 0x2a3b8
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1dd9a
movq $0x0, -0x8(%rbp)
jmp 0x1ddc0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x71d0
movq 0xc476(%rip), %rax      # 0x2a228
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: get_cell_prop_and_create_if_not_exists
FT_INTERNAL
f_cell_props_t *get_cell_prop_and_create_if_not_exists(f_cell_prop_container_t *cont, size_t row, size_t col)
{
    assert(cont);
    size_t sz = vector_size(cont);
    size_t i = 0;
    for (i = 0; i < sz; ++i) {
        f_cell_props_t *opt = &VECTOR_AT(cont, i, f_cell_props_t);
        if (opt->cell_row == row && opt->cell_col == col)
            return opt;
    }

    f_cell_props_t opt;
    if (row == FT_ANY_ROW && col == FT_ANY_COLUMN)
        memcpy(&opt, &g_default_cell_properties, sizeof(f_cell_props_t));
    else
        memset(&opt, 0, sizeof(f_cell_props_t));

    opt.cell_row = row;
    opt.cell_col = col;
    if (FT_IS_SUCCESS(vector_push(cont, &opt))) {
        return &VECTOR_AT(cont, sz, f_cell_props_t);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ddf0
jmp 0x1de0f
leaq 0x5f70(%rip), %rdi      # 0x23d67
leaq 0x4d98(%rip), %rsi      # 0x22b96
movl $0x11e8, %edx           # imm = 0x11E8
leaq 0x663a(%rip), %rcx      # 0x24444
callq 0x7120
movq -0x10(%rbp), %rdi
callq 0x132b0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1de7f
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13350
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1de6f
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1de6f
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1def9
jmp 0x1de71
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1de2c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jne 0x1deac
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
jne 0x1deac
leaq -0x80(%rbp), %rdi
leaq 0xd9e8(%rip), %rsi      # 0x2b888
movl $0x48, %edx
callq 0x71d0
jmp 0x1debc
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x7130
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x13720
cmpl $0x0, %eax
jl 0x1def1
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13350
movq %rax, -0x8(%rbp)
jmp 0x1def9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e19b
jmp 0x1e1ba
leaq 0x634f(%rip), %rdi      # 0x244f1
leaq 0x49ed(%rip), %rsi      # 0x22b96
movl $0x1402, %edx           # imm = 0x1402
leaq 0x6391(%rip), %rcx      # 0x24546
callq 0x7120
jmp 0x1e1bc
cmpl $0x0, -0x18(%rbp)
jge 0x1e1c7
jmp 0x1e255
jmp 0x1e1c9
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1e1df
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1e24c
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1e1f6
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x1e24a
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1e20d
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1e248
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1e224
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x1e246
movl -0x14(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1e23b
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x1e244
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1e25c
jmp 0x1e246
jmp 0x1e248
jmp 0x1e24a
jmp 0x1e24c
movl $0x0, -0x4(%rbp)
jmp 0x1e25c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: copy_cell_properties
static
f_cell_prop_container_t *copy_cell_properties(f_cell_prop_container_t *cont)
{
    f_cell_prop_container_t *result = create_cell_prop_container();
    if (result == NULL)
        return NULL;

    size_t i = 0;
    size_t sz = vector_size(cont);
    for (i = 0; i < sz; ++i) {
        f_cell_props_t *opt = (f_cell_props_t *)vector_at(cont, i);
        if (FT_IS_ERROR(vector_push(result, opt))) {
            destroy_cell_prop_container(result);
            return NULL;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x161d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e2c6
movq $0x0, -0x8(%rbp)
jmp 0x1e33b
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x132b0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1e333
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13350
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13720
cmpl $0x0, %eax
jge 0x1e323
movq -0x18(%rbp), %rdi
callq 0x1e270
movq $0x0, -0x8(%rbp)
jmp 0x1e33b
jmp 0x1e325
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1e2e3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: copy_cell
FT_INTERNAL
f_cell_t *copy_cell(f_cell_t *cell)
{
    assert(cell);

    f_cell_t *result = create_cell();
    if (result == NULL)
        return NULL;
    destroy_string_buffer(result->str_buffer);
    result->str_buffer = copy_string_buffer(cell->str_buffer);
    if (result->str_buffer == NULL) {
        destroy_cell(result);
        return NULL;
    }
    result->cell_type = cell->cell_type;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e365
jmp 0x1e384
leaq 0x52e7(%rip), %rdi      # 0x23653
leaq 0x4823(%rip), %rsi      # 0x22b96
movl $0x919, %edx            # imm = 0x919
leaq 0x6241(%rip), %rcx      # 0x245c0
callq 0x7120
callq 0x18140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e39e
movq $0x0, -0x8(%rbp)
jmp 0x1e3f3
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x13410
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1e400
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1e3dd
movq -0x18(%rbp), %rdi
callq 0x17010
movq $0x0, -0x8(%rbp)
jmp 0x1e3f3
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: copy_string_buffer
FT_INTERNAL
f_string_buffer_t *copy_string_buffer(const f_string_buffer_t *buffer)
{
    assert(buffer);
    f_string_buffer_t *result = create_string_buffer(buffer->data_sz, buffer->type);
    if (result == NULL)
        return NULL;
    switch (buffer->type) {
        case CHAR_BUF:
            if (FT_IS_ERROR(fill_buffer_from_string(result, buffer->str.cstr))) {
                destroy_string_buffer(result);
                return NULL;
            }
            break;
#ifdef FT_HAVE_WCHAR
        case W_CHAR_BUF:
            if (FT_IS_ERROR(fill_buffer_from_wstring(result, buffer->str.wstr))) {
                destroy_string_buffer(result);
                return NULL;
            }
            break;
#endif /* FT_HAVE_WCHAR */
        default:
            destroy_string_buffer(result);
            return NULL;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e415
jmp 0x1e434
leaq 0x565d(%rip), %rdi      # 0x23a79
leaq 0x4773(%rip), %rsi      # 0x22b96
movl $0x1962, %edx           # imm = 0x1962
leaq 0x61b1(%rip), %rcx      # 0x245e0
callq 0x7120
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x17450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e460
movq $0x0, -0x8(%rbp)
jmp 0x1e4e9
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x1e47a
jmp 0x1e470
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x1e4a4
jmp 0x1e4ce
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x181d0
cmpl $0x0, %eax
jge 0x1e4a2
movq -0x18(%rbp), %rdi
callq 0x13410
movq $0x0, -0x8(%rbp)
jmp 0x1e4e9
jmp 0x1e4e1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x18390
cmpl $0x0, %eax
jge 0x1e4cc
movq -0x18(%rbp), %rdi
callq 0x13410
movq $0x0, -0x8(%rbp)
jmp 0x1e4e9
jmp 0x1e4e1
movq -0x18(%rbp), %rdi
callq 0x13410
movq $0x0, -0x8(%rbp)
jmp 0x1e4e9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0xeb4(%rip), %rax       # 0x2010
movq %rax, 0x10(%rsp)
movq 0xeb0(%rip), %rax       # 0x2018
movq %rax, 0x18(%rsp)
movq 0xeac(%rip), %rax       # 0x2020
movq %rax, 0x20(%rsp)
movq $0x6, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x11bf
movq (%rsp), %rax
movss 0x10(%rsp,%rax,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe7e(%rip), %rdi       # 0x2028
movb $0x1, %al
callq 0x1030
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x118a
leaq 0xe69(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1230
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x1219
movq (%rsp), %rax
movss 0x10(%rsp,%rax,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe24(%rip), %rdi       # 0x2028
movb $0x1, %al
callq 0x1030
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x11e4
leaq 0xe0f(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x2e2d(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe2f(%rip), %rdi       # 0x2004
callq 0x1040
movq 0x2e17(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe42(%rip), %rdi       # 0x202d
callq 0x1040
movq 0x2e01(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe4f(%rip), %rdi       # 0x2050
callq 0x1040
movq 0x2deb(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe5b(%rip), %rdi       # 0x2072
callq 0x1040
movq 0x2dd5(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe66(%rip), %rdi       # 0x2093
callq 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x126b
callq 0x11c0
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1060
movq %rax, -0x18(%rbp)
callq 0x1030
cmpl $0x0, (%rax)
je 0x12c8
movq 0x2d62(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x10a0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xe06(%rip), %rsi       # 0x20bd
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x1090
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x1386
callq 0x10b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1313
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1080
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
movl -0x24(%rbp), %edi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x1070
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jle 0x1354
movl -0x28(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x1352
movl -0x28(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x1352
movl -0x28(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1376
movq 0x2c9d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd63(%rip), %rsi       # 0x20c8
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x1090
jmp 0x1378
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12d6
movl -0x1c(%rbp), %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe3d(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1229
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x1070
shrq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x2e6f(%rip), %rdi      # 0x4080
movl $0x4, %esi
callq 0x1030
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
jmp 0x1241
leaq 0xdd7(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x10a0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xdc3(%rip), %rdi       # 0x2025
movb $0x0, %al
callq 0x1050
leaq 0xdca(%rip), %rdi       # 0x203a
movb $0x0, %al
callq 0x1050
leaq 0xdca(%rip), %rdi       # 0x2048
movb $0x0, %al
callq 0x1050
leaq 0xdcb(%rip), %rdi       # 0x2057
movb $0x0, %al
callq 0x1050
leaq 0xdd3(%rip), %rdi       # 0x206d
movb $0x0, %al
callq 0x1050
leaq 0xde3(%rip), %rdi       # 0x208b
movb $0x0, %al
callq 0x1050
leaq 0xdf3(%rip), %rdi       # 0x20a9
movb $0x0, %al
callq 0x1050
leaq 0xdec(%rip), %rdi       # 0x20b0
movb $0x0, %al
callq 0x1050
leaq 0xdf4(%rip), %rdi       # 0x20c6
movb $0x0, %al
callq 0x1050
leaq 0xe06(%rip), %rdi       # 0x20e6
movb $0x0, %al
callq 0x1050
leaq 0xe18(%rip), %rdi       # 0x2106
movb $0x0, %al
callq 0x1050
leaq 0xe0a(%rip), %rdi       # 0x2106
movb $0x0, %al
callq 0x1050
movslq -0x4(%rbp), %rsi
leaq 0xe00(%rip), %rdi       # 0x210e
movb $0x0, %al
callq 0x1050
leaq 0xe0e(%rip), %rdi       # 0x212a
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x1365
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11b0
movl %eax, -0x14(%rbp)
jmp 0x1374
leaq 0xdd3(%rip), %rdi       # 0x213f
callq 0x11b0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1250
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1408
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
jne 0x13b6
leaq 0xda0(%rip), %rdi       # 0x2148
movb $0x0, %al
callq 0x1050
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jge 0x13e0
movslq -0x18(%rbp), %rcx
leaq 0x2cb4(%rip), %rax      # 0x4080
movslq (%rax,%rcx,4), %rsi
leaq 0xd8a(%rip), %rdi       # 0x2161
movb $0x0, %al
callq 0x1050
jmp 0x13fd
movslq -0x18(%rbp), %rcx
leaq 0x2c95(%rip), %rax      # 0x4080
movslq (%rax,%rcx,4), %rsi
leaq 0xd71(%rip), %rdi       # 0x2167
movb $0x0, %al
callq 0x1050
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x138a
xorl %edi, %edi
callq 0x10a0