LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/worksheet.c
// Function: worksheet_write_x14_cf_rule
STATIC void
_worksheet_write_x14_cf_rule(lxw_worksheet *self,
                             lxw_cond_format_obj *cond_format)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("type", "dataBar");
    LXW_PUSH_ATTRIBUTES_STR("id", cond_format->guid);

    lxw_xml_start_tag(self->file, "x14:cfRule", &attributes);

    /* Write the x14:dataBar element. */
    _worksheet_write_x14_data_bar(self, cond_format);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x62e92
leaq 0x5517(%rip), %rdi      # 0x683b0
leaq 0xc085(%rip), %rsi      # 0x6ef25
callq 0xc030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x1040(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1040, %rax           # imm = 0x1040
movq %rax, -0x18(%rbp)
jmp 0x62ed3
jmp 0x62ed5
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rsi
leaq 0xbc9e(%rip), %rdi      # 0x6eb85
callq 0xc030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x1040(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1040, %rax           # imm = 0x1040
movq %rax, -0x18(%rbp)
jmp 0x62f1a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xc005(%rip), %rsi      # 0x6ef2d
leaq -0x20(%rbp), %rdx
callq 0xc390
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x62fd0
jmp 0x62f40
cmpq $0x0, -0x20(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x62f50
jmp 0x62f82
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x1040(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x62f75
leaq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x62f77
movq -0x28(%rbp), %rdi
callq 0xc0d0
jmp 0x62f40
jmp 0x62f84
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/worksheet.c
// Function: worksheet_write_x14_color
STATIC void
_worksheet_write_x14_color(lxw_worksheet *self, char *type, lxw_color_t color)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;
    char rgb[LXW_ATTR_32];

    lxw_snprintf(rgb, LXW_ATTR_32, "FF%06X", color & LXW_COLOR_MASK);

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("rgb", rgb);
    lxw_xml_empty_tag(self->file, type, &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
movl -0x14(%rbp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movl $0x20, %esi
leaq 0x595d(%rip), %rdx      # 0x691e9
movb $0x0, %al
callq 0xc5d0
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x638a5
leaq -0x50(%rbp), %rsi
leaq 0x5940(%rip), %rdi      # 0x691f0
callq 0xc030
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x1040(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1040, %rax           # imm = 0x1040
movq %rax, -0x20(%rbp)
jmp 0x638e3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xcca0
jmp 0x638f9
cmpq $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x63909
jmp 0x6393b
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x1040(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6392e
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x63930
movq -0x30(%rbp), %rdi
callq 0xc0d0
jmp 0x638f9
jmp 0x6393d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/worksheet.c
// Function: insert_cell_list
STATIC void
_insert_cell_list(struct lxw_table_cells *cell_list,
                  lxw_cell *cell, lxw_col_t col_num)
{
    lxw_cell *existing_cell;

    cell->col_num = col_num;

    existing_cell = RB_INSERT(lxw_table_cells, cell_list, cell);

    /* If existing_cell is not NULL, then that cell already existed. */
    /* Remove existing_cell and add new one in again. */
    if (existing_cell) {
        RB_REMOVE(lxw_table_cells, cell_list, existing_cell);

        /* Add it in again. */
        RB_INSERT(lxw_table_cells, cell_list, cell);
        _free_cell(existing_cell);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x639c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x639ae
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x57830
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x639c0
movq -0x20(%rbp), %rdi
callq 0x47410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/worksheet.c
// Function: get_row_list
STATIC lxw_row *
_get_row_list(struct lxw_table_rows *table, lxw_row_t row_num)
{
    lxw_row *row;
    lxw_row *existing_row;

    if (table->cached_row_num == row_num)
        return table->cached_row;

    /* Create a new row and try and insert it. */
    row = _new_row(row_num);
    existing_row = RB_INSERT(lxw_table_rows, table, row);

    /* If existing_row is not NULL, then it already existed. Free new row */
    /* and return existing_row. */
    if (existing_row) {
        _free_row(row);
        row = existing_row;
    }

    table->cached_row = row;
    table->cached_row_num = row_num;

    return row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x63f89
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x63fdc
movl -0x14(%rbp), %edi
callq 0x63ff0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x640c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x63fbe
movq -0x20(%rbp), %rdi
callq 0x464d0
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%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/Paxa[P]fast_excel/libxlsxwriter/src/worksheet.c
// Function: new_row
STATIC lxw_row *
_new_row(lxw_row_t row_num)
{
    lxw_row *row = calloc(1, sizeof(lxw_row));

    if (row) {
        row->row_num = row_num;
        row->cells = calloc(1, sizeof(struct lxw_table_cells));
        row->height = LXW_DEF_ROW_HEIGHT;

        if (row->cells)
            RB_INIT(row->cells);
        else
            LXW_MEM_ERROR();
    }
    else {
        LXW_MEM_ERROR();
    }

    return row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x48, %esi
callq 0xc870
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6408d
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0xc870
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movsd 0x827c(%rip), %xmm0     # 0x6c2c0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x64067
jmp 0x64056
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, (%rax)
jmp 0x6408b
movq 0x18f8a(%rip), %rax     # 0x7cff8
movq (%rax), %rdi
leaq 0x2058(%rip), %rsi      # 0x660d0
leaq 0x8375(%rip), %rdx      # 0x6c3f4
movl $0x33a, %ecx            # imm = 0x33A
movb $0x0, %al
callq 0xc8f0
jmp 0x640b1
movq 0x18f64(%rip), %rax     # 0x7cff8
movq (%rax), %rdi
leaq 0x2032(%rip), %rsi      # 0x660d0
leaq 0x834f(%rip), %rdx      # 0x6c3f4
movl $0x33d, %ecx            # imm = 0x33D
movb $0x0, %al
callq 0xc8f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: fprint_escaped_attributes
STATIC void
_fprint_escaped_attributes(FILE * xmlfile,
                           struct xml_attribute_list *attributes)
{
    struct xml_attribute *attribute;

    if (attributes) {
        STAILQ_FOREACH(attribute, attributes, list_entries) {
            fprintf(xmlfile, " %s=", attribute->key);

            if (!strpbrk(attribute->value, "&<>\"\n")) {
                fprintf(xmlfile, "\"%s\"", attribute->value);
            }
            else {
                char *encoded = _escape_attributes(attribute);

                if (encoded) {
                    fprintf(xmlfile, "\"%s\"", encoded);

                    free(encoded);
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x647b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x647ae
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xab89(%rip), %rsi      # 0x6f2a9
movb $0x0, %al
callq 0xc8f0
movq -0x18(%rbp), %rdi
addq $0x820, %rdi            # imm = 0x820
leaq 0xab75(%rip), %rsi      # 0x6f2ae
callq 0xcbb0
cmpq $0x0, %rax
jne 0x64763
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x820, %rdx            # imm = 0x820
leaq 0xa071(%rip), %rsi      # 0x6e7cb
movb $0x0, %al
callq 0xc8f0
jmp 0x64798
movq -0x18(%rbp), %rdi
callq 0x64fe0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x64796
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xa045(%rip), %rsi      # 0x6e7cb
movb $0x0, %al
callq 0xc8f0
movq -0x20(%rbp), %rdi
callq 0xc0d0
jmp 0x64798
jmp 0x6479a
movq -0x18(%rbp), %rax
movq 0x1040(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x64706
jmp 0x647b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_xml_start_tag_unencoded
void
lxw_xml_start_tag_unencoded(FILE * xmlfile,
                            const char *tag,
                            struct xml_attribute_list *attributes)
{
    struct xml_attribute *attribute;

    fprintf(xmlfile, "<%s", tag);

    if (attributes) {
        STAILQ_FOREACH(attribute, attributes, list_entries) {
            fprintf(xmlfile, " %s=\"%s\"", attribute->key, attribute->value);
        }
    }

    fprintf(xmlfile, ">");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xaa85(%rip), %rsi      # 0x6f268
movb $0x0, %al
callq 0xc8f0
cmpq $0x0, -0x18(%rbp)
je 0x64837
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x64835
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x820, %rcx            # imm = 0x820
leaq 0xaa4f(%rip), %rsi      # 0x6f26c
movb $0x0, %al
callq 0xc8f0
movq -0x20(%rbp), %rax
movq 0x1040(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x647fc
jmp 0x64837
movq -0x8(%rbp), %rdi
leaq 0x5e53(%rip), %rsi      # 0x6a695
movb $0x0, %al
callq 0xc8f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_xml_data_element
void
lxw_xml_data_element(FILE * xmlfile,
                     const char *tag,
                     const char *data, struct xml_attribute_list *attributes)
{
    fprintf(xmlfile, "<%s", tag);

    _fprint_escaped_attributes(xmlfile, attributes);

    fprintf(xmlfile, ">");

    _fprint_escaped_data(xmlfile, data);

    fprintf(xmlfile, "</%s>", tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa8e1(%rip), %rsi      # 0x6f268
movb $0x0, %al
callq 0xc8f0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x646e0
movq -0x8(%rbp), %rdi
leaq 0x5cef(%rip), %rsi      # 0x6a695
movb $0x0, %al
callq 0xc8f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x649e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa8ac(%rip), %rsi      # 0x6f275
movb $0x0, %al
callq 0xc8f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: fprint_escaped_data
STATIC void
_fprint_escaped_data(FILE * xmlfile, const char *data)
{
    /* Escape the data section of the XML element. */
    if (!strpbrk(data, "&<>")) {
        fprintf(xmlfile, "%s", data);
    }
    else {
        char *encoded = lxw_escape_data(data);
        if (encoded) {
            fprintf(xmlfile, "%s", encoded);
            free(encoded);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa8c6(%rip), %rsi      # 0x6f2c1
callq 0xcbb0
cmpq $0x0, %rax
jne 0x64a1e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x7e8f(%rip), %rsi      # 0x6c8a4
movb $0x0, %al
callq 0xc8f0
jmp 0x64a53
movq -0x10(%rbp), %rdi
callq 0xc590
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x64a51
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7e63(%rip), %rsi      # 0x6c8a4
movb $0x0, %al
callq 0xc8f0
movq -0x18(%rbp), %rdi
callq 0xc0d0
jmp 0x64a53
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_escape_data
char *
lxw_escape_data(const char *data)
{
    size_t encoded_len = (strlen(data) * 5 + 1);

    char *encoded = (char *) calloc(encoded_len, 1);
    char *p_encoded = encoded;

    while (*data) {
        switch (*data) {
            case '&':
                memcpy(p_encoded, LXW_AMP, sizeof(LXW_AMP) - 1);
                p_encoded += sizeof(LXW_AMP) - 1;
                break;
            case '<':
                memcpy(p_encoded, LXW_LT, sizeof(LXW_LT) - 1);
                p_encoded += sizeof(LXW_LT) - 1;
                break;
            case '>':
                memcpy(p_encoded, LXW_GT, sizeof(LXW_GT) - 1);
                p_encoded += sizeof(LXW_GT) - 1;
                break;
            default:
                *p_encoded = *data;
                p_encoded++;
                break;
        }
        data++;
    }

    return encoded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc4e0
imulq $0x5, %rax, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xc870
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x64b7d
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x26, %eax
je 0x64afd
jmp 0x64ae9
movl -0x24(%rbp), %eax
subl $0x3c, %eax
je 0x64b20
jmp 0x64af3
movl -0x24(%rbp), %eax
subl $0x3e, %eax
je 0x64b3a
jmp 0x64b54
movq -0x20(%rbp), %rax
movl 0xa780(%rip), %ecx      # 0x6f287
movl %ecx, (%rax)
movb 0xa77c(%rip), %cl       # 0x6f28b
movb %cl, 0x4(%rax)
movq -0x20(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x20(%rbp)
jmp 0x64b6c
movq -0x20(%rbp), %rax
movl 0xa763(%rip), %ecx      # 0x6f28d
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x64b6c
movq -0x20(%rbp), %rax
movl 0xa74e(%rip), %ecx      # 0x6f292
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x64b6c
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x64acb
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_has_control_characters
uint8_t
lxw_has_control_characters(const char *string)
{
    while (string) {
        /* 0xE0 == 0b11100000 masks values > 0x19 == 0b00011111. */
        if (!(*string & 0xE0) && *string != 0x0A && *string != 0x09)
            return LXW_TRUE;

        string++;
    }

    return LXW_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x64bdc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xe0, %eax
cmpl $0x0, %eax
jne 0x64bce
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x64bce
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x64bce
movb $0x1, -0x1(%rbp)
jmp 0x64be0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x64b98
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_escape_control_characters
char *
lxw_escape_control_characters(const char *string)
{
    size_t escape_len = sizeof("_xHHHH_") - 1;
    size_t encoded_len = (strlen(string) * escape_len + 1);

    char *encoded = (char *) calloc(encoded_len, 1);
    char *p_encoded = encoded;

    while (*string) {
        switch (*string) {
            case '\x01':
            case '\x02':
            case '\x03':
            case '\x04':
            case '\x05':
            case '\x06':
            case '\x07':
            case '\x08':
            case '\x0B':
            case '\x0C':
            case '\x0D':
            case '\x0E':
            case '\x0F':
            case '\x10':
            case '\x11':
            case '\x12':
            case '\x13':
            case '\x14':
            case '\x15':
            case '\x16':
            case '\x17':
            case '\x18':
            case '\x19':
            case '\x1A':
            case '\x1B':
            case '\x1C':
            case '\x1D':
            case '\x1E':
            case '\x1F':
                lxw_snprintf(p_encoded, escape_len + 1, "_x%04X_", *string);
                p_encoded += escape_len;
                break;
            default:
                *p_encoded = *string;
                p_encoded++;
                break;
        }
        string++;
    }

    return encoded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x7, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc4e0
imulq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xc870
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x64cb2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
decl %eax
subl $0x8, %eax
jb 0x64c5d
jmp 0x64c50
movl -0x2c(%rbp), %eax
addl $-0xb, %eax
subl $0x14, %eax
ja 0x64c8c
jmp 0x64c5d
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
leaq 0xa620(%rip), %rdx      # 0x6f297
movb $0x0, %al
callq 0xc5d0
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x64ca4
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x64c34
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_new_attribute_str
struct xml_attribute *
lxw_new_attribute_str(const char *key, const char *value)
{
    struct xml_attribute *attribute = malloc(sizeof(struct xml_attribute));

    LXW_ATTRIBUTE_COPY(attribute->key, key);
    LXW_ATTRIBUTE_COPY(attribute->value, value);

    return attribute;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1048, %edi           # imm = 0x1048
callq 0xcaf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x81f, %edx            # imm = 0x81F
callq 0xc1a0
movq -0x18(%rbp), %rax
movb $0x0, 0x81f(%rax)
jmp 0x64ecd
movq -0x18(%rbp), %rdi
addq $0x820, %rdi            # imm = 0x820
movq -0x10(%rbp), %rsi
movl $0x81f, %edx            # imm = 0x81F
callq 0xc1a0
movq -0x18(%rbp), %rax
movb $0x0, 0x103f(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_new_attribute_int
struct xml_attribute *
lxw_new_attribute_int(const char *key, uint64_t value)
{
    struct xml_attribute *attribute = malloc(sizeof(struct xml_attribute));

    LXW_ATTRIBUTE_COPY(attribute->key, key);

#if defined(_MSC_VER)
    lxw_snprintf(attribute->value, LXW_MAX_ATTRIBUTE_LENGTH, "%lld", value);
#else
    lxw_snprintf(attribute->value, LXW_MAX_ATTRIBUTE_LENGTH, "%ld",
                 (long) value);
#endif

    return attribute;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1048, %edi           # imm = 0x1048
callq 0xcaf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x81f, %edx            # imm = 0x81F
callq 0xc1a0
movq -0x18(%rbp), %rax
movb $0x0, 0x81f(%rax)
movq -0x18(%rbp), %rdi
addq $0x820, %rdi            # imm = 0x820
movq -0x10(%rbp), %rcx
movl $0x820, %esi            # imm = 0x820
leaq 0xa34f(%rip), %rdx      # 0x6f2a5
movb $0x0, %al
callq 0xc5d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/src/xmlwriter.c
// Function: lxw_new_attribute_dbl
struct xml_attribute *
lxw_new_attribute_dbl(const char *key, double value)
{
    struct xml_attribute *attribute = malloc(sizeof(struct xml_attribute));

    LXW_ATTRIBUTE_COPY(attribute->key, key);
    lxw_sprintf_dbl(attribute->value, value);

    return attribute;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x1048, %edi           # imm = 0x1048
callq 0xcaf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x81f, %edx            # imm = 0x81F
callq 0xc1a0
movq -0x18(%rbp), %rax
movb $0x0, 0x81f(%rax)
movq -0x18(%rbp), %rdi
addq $0x820, %rdi            # imm = 0x820
movsd -0x10(%rbp), %xmm0
movl $0x20, %esi
leaq 0x1fc1(%rip), %rdx      # 0x66f89
movb $0x1, %al
callq 0xc5d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: main
int main(int argc, char **argv)
{
    struct Config conf;
    struct Options opts;

    if (parse_args(argc, argv, &opts)) {
        return -1;
    }

    if (read_config(&conf)) {
        free_config(&conf);
        return -1;
    }

    while (optind < argc) {
printf("generating code from %s to %s\n", argv[optind], opts.outfile);

        struct TestFile *tf = generate_code(argv[optind], opts.outfile, &conf);
        if (tf) {
            if (opts.just_output_fortran) goto pass;
printf("building test for %s\n", opts.outfile);
            build_test(tf, &conf);

            if (opts.stop_after_build) goto pass;
printf("running test %s\n", tf->exe);
            run_test(tf->exe);

 pass:
            close_testfile(tf);
        } // XXX what does it mean if tf == NULL?

        optind++;
    }

    free_config(&conf);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x2500
cmpl $0x0, %eax
je 0x23e7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x24f1
leaq -0x48(%rbp), %rdi
callq 0x3a50
cmpl $0x0, %eax
je 0x240a
leaq -0x48(%rbp), %rdi
callq 0x3e30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x24f1
jmp 0x240c
movq 0xcbbd(%rip), %rax      # 0xefd0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x24e1
movq -0x10(%rbp), %rax
movq 0xcba7(%rip), %rcx      # 0xefd0
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x50(%rbp), %rdx
leaq 0x7e59(%rip), %rdi      # 0xa294
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rax
movq 0xcb83(%rip), %rcx      # 0xefd0
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x2710
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x24c7
cmpl $0x0, -0x58(%rbp)
je 0x2474
jmp 0x24be
movq -0x50(%rbp), %rsi
leaq 0x7e34(%rip), %rdi      # 0xa2b3
movb $0x0, %al
callq 0x2100
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x28a0
cmpl $0x0, -0x54(%rbp)
je 0x249b
jmp 0x24be
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7e1f(%rip), %rdi      # 0xa2c9
movb $0x0, %al
callq 0x2100
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28f0
movq -0x60(%rbp), %rdi
callq 0x6de0
movq 0xcb02(%rip), %rax      # 0xefd0
movl (%rax), %ecx
addl $0x1, %ecx
movq 0xcaf6(%rip), %rax      # 0xefd0
movl %ecx, (%rax)
jmp 0x240c
leaq -0x48(%rbp), %rdi
callq 0x3e30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: generate_code
static struct TestFile *
generate_code(char *infile, char *outfile, const struct Config *conf)
{
    struct TestFile *tf;
    FILE *fout;
    int dep_added;

    tf = parse_test_file(infile);
    if (!tf) return NULL;
    if (!tf->sets) {
        close_testfile(tf);
        return NULL;
    }

    dep_added = file_dependency(infile, tf->sets, conf);

    // XXX if we're generating code just to run a test, use a mkstemp
    if (!outfile) {
        outfile = make_fortran_name(infile, conf);
    }
    tf->exe = outfile;

    fout = fopen(outfile, "w");
    if (!fout) {
        fprintf(stderr, "FUnit: could not open %s for writing\n", outfile);
        return NULL;
    }

    if (generate_code_file(tf->sets, fout)) {
        close_testfile(tf);
        return NULL;
    }

    if (fclose(fout)) {
        fprintf(stderr, "FUnit: error closing %s\n", outfile);
        close_testfile(tf);
        return NULL;
    }

    if (dep_added) { // XXX wtf is this doing?
        struct TestSet *set = tf->sets;
        while (set) {
            set->deps = set->deps->next;
            set = set->next;
        }
    }

    return tf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f10
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2745
movq $0x0, -0x8(%rbp)
jmp 0x2892
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2766
movq -0x28(%rbp), %rdi
callq 0x6de0
movq $0x0, -0x8(%rbp)
jmp 0x2892
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2950
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2796
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2a80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
leaq 0x7be7(%rip), %rsi      # 0xa394
callq 0x2230
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x27e6
movq 0xc834(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7bc4(%rip), %rsi      # 0xa396
movb $0x0, %al
callq 0x21a0
movq $0x0, -0x8(%rbp)
jmp 0x2892
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x4590
cmpl $0x0, %eax
je 0x2812
movq -0x28(%rbp), %rdi
callq 0x6de0
movq $0x0, -0x8(%rbp)
jmp 0x2892
movq -0x30(%rbp), %rdi
callq 0x20c0
cmpl $0x0, %eax
je 0x284f
movq 0xc7d1(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7b87(%rip), %rsi      # 0xa3bc
movb $0x0, %al
callq 0x21a0
movq -0x28(%rbp), %rdi
callq 0x6de0
movq $0x0, -0x8(%rbp)
jmp 0x2892
cmpl $0x0, -0x34(%rbp)
je 0x288a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2888
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2861
jmp 0x288a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: build_test
static int build_test(struct TestFile *tf, struct Config *conf)
{
    struct StringBuffer sb;
    sb_init(&sb, 128);

    make_build_command(&sb, tf, conf);

    int ret = checked_system(sb.s);

    sb_free(&sb);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x80, %esi
callq 0x92d0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3190
movq -0x28(%rbp), %rdi
callq 0x2b90
movl %eax, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9320
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: run_test
static int run_test(const char *testfile)
{
    if (!fu_file_exists(testfile)) {
        fprintf(stderr, "Test executable '%s' not found\n", testfile);
        return -1;
    }

    return checked_system(testfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90f0
cmpl $0x0, %eax
jne 0x292f
movq 0xc6e7(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x7b09(%rip), %rsi      # 0xa428
movb $0x0, %al
callq 0x21a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x293b
movq -0x10(%rbp), %rdi
callq 0x2b90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: file_dependency
static int file_dependency(char *infile, struct TestSet *set,
                           const struct Config *conf)
{
    static struct TestDependency dep;
    static char buf[PATH_MAX], *test, *dot;

    test = strstr(infile, "test_");
    dot = strrchr(buf, '.');
    if (test && (!dot || dot > test + 5)) { // extract name after 'test_'
        strcpy(buf, test + 5);
        if (dot) {
            if (!strcmp(dot, conf->template_ext)) { // .fun -> .F90
                strcpy(dot, conf->fortran_ext);
            } // else assume correct extension already
        } else { // append fortran extension
            strcat(buf, conf->fortran_ext);
        }

        // add this dependency to the dep list of each set
        while (set) {
            dep.next = set->deps;
            set->deps = &dep;
            set = set->next;
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x7a66(%rip), %rsi      # 0xa3d5
callq 0x22a0
movq %rax, 0xd8f5(%rip)      # 0x10270
leaq 0xc8ee(%rip), %rdi      # 0xf270
movl $0x2e, %esi
callq 0x2110
movq %rax, 0xd8e5(%rip)      # 0x10278
cmpq $0x0, 0xd8d5(%rip)      # 0x10270
je 0x2a67
cmpq $0x0, 0xd8cf(%rip)      # 0x10278
je 0x29c6
movq 0xd8c6(%rip), %rax      # 0x10278
movq 0xd8b7(%rip), %rcx      # 0x10270
addq $0x5, %rcx
cmpq %rcx, %rax
jbe 0x2a67
movq 0xd8a3(%rip), %rsi      # 0x10270
addq $0x5, %rsi
leaq 0xc898(%rip), %rdi      # 0xf270
callq 0x2090
cmpq $0x0, 0xd893(%rip)      # 0x10278
je 0x2a16
movq 0xd88a(%rip), %rdi      # 0x10278
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x2a14
movq 0xd871(%rip), %rdi      # 0x10278
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2090
jmp 0x2a2a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xc84b(%rip), %rdi      # 0xf270
callq 0x2250
jmp 0x2a2c
cmpq $0x0, -0x18(%rbp)
je 0x2a5e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc80e(%rip)      # 0xf250
movq -0x18(%rbp), %rax
leaq 0xc803(%rip), %rcx      # 0xf250
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a2c
movl $0x1, -0x4(%rbp)
jmp 0x2a6e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: make_fortran_name
static char *make_fortran_name(char *infile, const struct Config *conf)
{
    static char buf[PATH_MAX + 1], *dot;

    if (strlen(infile) > PATH_MAX - strlen(conf->fortran_ext)) {
        fprintf(stderr, "FUnit: the input file name '%s' is too long\n",
                infile);
        abort();
    }

    dot = strrchr(infile, '.');
    if (dot && !strcmp(dot, conf->template_ext)) {
        strncpy(buf, infile, dot - infile);
        strcpy(buf + (dot - infile), conf->fortran_ext);
    } else { // unrecognized or missing extension, just append extension
        strcpy(buf, infile);
        strcat(buf, conf->fortran_ext);
    }
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x20d0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movl $0x1000, %ecx           # imm = 0x1000
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x2adf
movq 0xc533(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x7908(%rip), %rsi      # 0xa3db
movb $0x0, %al
callq 0x21a0
callq 0x2050
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, 0xe794(%rip)      # 0x11288
cmpq $0x0, 0xe78c(%rip)      # 0x11288
je 0x2b5c
movq 0xe783(%rip), %rdi      # 0x11288
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x2b5c
movq -0x8(%rbp), %rsi
movq 0xe766(%rip), %rdx      # 0x11288
movq -0x8(%rbp), %rax
subq %rax, %rdx
leaq 0xd750(%rip), %rdi      # 0x10280
callq 0x2070
movq 0xe74c(%rip), %rax      # 0x11288
movq -0x8(%rbp), %rcx
subq %rcx, %rax
leaq 0xd736(%rip), %rdi      # 0x10280
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2090
jmp 0x2b80
movq -0x8(%rbp), %rsi
leaq 0xd719(%rip), %rdi      # 0x10280
callq 0x2090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xd705(%rip), %rdi      # 0x10280
callq 0x2250
leaq 0xd6f9(%rip), %rax      # 0x10280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/funit.c
// Function: checked_system
static int checked_system(const char *command)
{
    int ret = system(command);

    if (ret == 127) {
        ret = -1;
        goto report_err;
    } else if (ret < 0) {
 report_err:
        fprintf(stderr, "system(): error executing '%s'\n", command);
    } // else success

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movl %eax, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
jne 0x2bb7
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x2bbf
cmpl $0x0, -0xc(%rbp)
jge 0x2bdb
jmp 0x2bbf
movq 0xc432(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x7834(%rip), %rsi      # 0xa408
movb $0x0, %al
callq 0x21a0
jmp 0x2bdd
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: parse_build_rule
void *parse_build_rule(char *build)
{
    struct BRFragments *f = NEW0(struct BRFragments);
    struct StringBuffer sb;
    sb_init(&sb, 128);

    // parse one character at a time, handling special forms as they appear
    size_t i = 0;
    while (build[i] != '\0') {
        switch (build[i]) {
        case '$':
            if (build[i + 1] != '{') goto just_copy;
            i = parse_env_var(&sb, build, i);
            break;
        case '{':
            if (build[i + 1] != '{') goto just_copy;
            i = parse_internal_var(f, &sb, build, i);
            break;
        case '\\':
            switch (build[i + 1]) {
            case '$':
            case '{':
            case '}':
            case '\\':
                i++; // skip the escaping backslash
                goto just_copy;
            default:
                break; // unknown sequence - no escape - fall through
            }
            // FALL THROUGH
        default:
 just_copy:
            sb_add_char(&sb, build[i++]);
            break;
        }
    }

    if (sb.len > 0) { // one last string to add
        close_string_fragment(f, &sb);
    }

    sb_free(&sb);

    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2180
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x80, %esi
callq 0x92d0
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2d35
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
subl $0x24, %eax
je 0x2c67
jmp 0x2c50
movl -0x34(%rbp), %eax
subl $0x5c, %eax
je 0x2cc7
jmp 0x2c5a
movl -0x34(%rbp), %eax
subl $0x7b, %eax
je 0x2c98
jmp 0x2d0e
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x7b, %eax
je 0x2c7e
jmp 0x2d10
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x2d60
movq %rax, -0x30(%rbp)
jmp 0x2d30
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x7b, %eax
je 0x2cac
jmp 0x2d10
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x28(%rbp), %rsi
callq 0x2ef0
movq %rax, -0x30(%rbp)
jmp 0x2d30
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movsbl 0x1(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
subl $0x24, %eax
je 0x2cfc
jmp 0x2cde
movl -0x38(%rbp), %eax
subl $0x5c, %eax
je 0x2cfc
jmp 0x2ce8
movl -0x38(%rbp), %eax
subl $0x7b, %eax
je 0x2cfc
jmp 0x2cf2
movl -0x38(%rbp), %eax
subl $0x7d, %eax
jne 0x2d0a
jmp 0x2cfc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2d10
jmp 0x2d0c
jmp 0x2d0e
jmp 0x2d10
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movsbl (%rax,%rcx), %esi
callq 0x93d0
jmp 0x2c25
cmpq $0x0, -0x18(%rbp)
jbe 0x2d49
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3100
leaq -0x28(%rbp), %rdi
callq 0x9320
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: close_string_fragment
static void close_string_fragment(struct BRFragments *f,
                                  struct StringBuffer *sb)
{
    ensure_fragments(f);
    f->frags[f->n].type = BR_STRING;
    f->frags[f->n].frag.s = fu_strndup(sb->s, sb->len);
    f->n++;

    sb->len = 0; // re-use buffer
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39e0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x9070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: make_build_command
void make_build_command(struct StringBuffer *sb,
                        const struct TestFile *tf,
                        const struct Config *conf)
{
    struct BRFragments *f = (struct BRFragments *)conf->build_fragments;
    struct BRFragment *frags = f->frags;

    for (size_t i = 0; i < f->n; i++) {
        switch (frags[i].type) {
        case BR_STRING:
            sb_add_str(sb, frags[i].frag.s);
            break;
        case BR_IVAR:
            (frags[i].frag.expandcb)(sb, tf, conf);
            break;
        }
    }
    sb_add_char(sb, '\0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3242
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x31f3
jmp 0x31e9
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x3211
jmp 0x3232
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x9480
jmp 0x3232
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
jmp 0x3234
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x31c3
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x93d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: free_build_fragments
void free_build_fragments(void *p)
{
    struct BRFragments *f = (struct BRFragments *)p;

    for (size_t i = 0; i < f->n; i++) {
        if (f->frags[i].type == BR_STRING) {
            free(f->frags[i].frag.s);
        }
    }

    free(f->frags);

    free(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x32cc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x32bc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2040
jmp 0x32be
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x327c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: add_ivar_fragment
static void add_ivar_fragment(struct BRFragments *f, struct IVar *ivar)
{
    ensure_fragments(f);
    f->frags[f->n].type = BR_IVAR;
    f->frags[f->n].frag.expandcb = ivar->expandcb;
    f->n++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39e0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: expand_deps
static void expand_deps(struct StringBuffer *sb,
                        const struct TestFile *tf,
                        const struct Config *conf)
{
    // count deps and allocate array to keep track of already appended deps
    size_t n_deps = 0;
    struct TestSet *set = tf->sets;
    while (set) {
        n_deps += set->n_deps;
        set = set->next;
    }

    if (n_deps == 0) return; // nothing to add? done!

    char **deps = NEWA(char *, n_deps);

    n_deps = 0; // haven't added any deps yet
    for (set = tf->sets; set; set = set->next) {
        for (struct TestDependency *dep = set->deps; dep; dep = dep->next) {
            if (!have_thing(deps, n_deps, dep->filename)) {
                deps[n_deps++] = dep->filename;
                sb_add_nstr(sb, dep->filename, dep->len);
                sb_add_char(sb, ' ');
            }
        }
    }
    sb->len--; // remove trailing space

    free(deps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x33ec
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x33c8
cmpq $0x0, -0x20(%rbp)
jne 0x33f8
jmp 0x34d5
movq -0x20(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21e0
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x34bc
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x34aa
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x3780
cmpl $0x0, %eax
jne 0x349b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x9420
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x93d0
jmp 0x349d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3434
jmp 0x34ac
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x341d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rdi
callq 0x2040
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: expand_prereqs
static void expand_prereqs(struct StringBuffer *sb,
                           const struct TestFile *tf,
                           const struct Config *conf)
{
    expand_src_f(sb, tf, conf);
    sb_add_char(sb, ' ');
    expand_deps(sb, tf, conf);
    sb_add_char(sb, ' ');
    expand_mods_f(sb, tf, conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3730
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x93d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x33a0
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x93d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3540
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: expand_sets
static void expand_sets(struct StringBuffer *sb,
                        const struct TestFile *tf,
                        const struct Config *conf)
{
    struct TestSet *set = tf->sets;
    while (set) {
        sb_add_nstr(sb, set->name, set->namelen);
        sb_add_char(sb, ' ');
        set = set->next;
    }
    sb->len--; // remove trailing space
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x36ab
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdx
callq 0x9420
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x93d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3670
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: expand_src
static void expand_src(struct StringBuffer *sb,
                       const struct TestFile *tf,
                       const struct Config *conf)
{
    size_t srclen = len_without_ext(tf->path, conf->template_ext,
                                    conf->template_ext_len,
                                    "test file", "template");
    sb_add_nstr(sb, tf->path, srclen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x7065(%rip), %rcx      # 0xa767
leaq 0x7068(%rip), %r8       # 0xa771
callq 0x3950
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x9420
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)