LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_write_pie_chart
STATIC void
_chart_write_pie_chart(lxw_chart *self)
{
    lxw_chart_series *series;

    lxw_xml_start_tag(self->file, "c:pieChart", NULL);

    /* Write the c:varyColors element. */
    _chart_write_vary_colors(self);

    STAILQ_FOREACH(series, self->series_list, list_pointers) {
        /* Write the c:ser element. */
        _chart_write_ser(self, series);
    }

    /* Write the c:firstSliceAng element. */
    _chart_write_first_slice_ang(self);

    lxw_xml_end_tag(self->file, "c:pieChart");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x266db(%rip), %rsi     # 0x4176d
xorl %edx, %edx
callq 0xc350
movq %rbx, %rdi
callq 0x1acf9
movq 0x128(%rbx), %rax
movq (%rax), %r14
movq %rbx, %rdi
testq %r14, %r14
je 0x1b0c4
movq %r14, %rsi
callq 0x1730e
movq 0x110(%r14), %r14
jmp 0x1b0ab
callq 0x1ad82
movq (%rbx), %rdi
leaq 0x2669a(%rip), %rsi     # 0x4176d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc060
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_write_radar_chart
STATIC void
_chart_write_radar_chart(lxw_chart *self)
{
    lxw_chart_series *series;

    lxw_xml_start_tag(self->file, "c:radarChart", NULL);

    /* Write the c:radarStyle element. */
    _chart_write_radar_style(self);

    STAILQ_FOREACH(series, self->series_list, list_pointers) {
        /* Write the c:ser element. */
        _chart_write_ser(self, series);
    }

    /* Write the c:axId elements. */
    _chart_write_axis_ids(self);

    lxw_xml_end_tag(self->file, "c:radarChart");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x26259(%rip), %rsi     # 0x417bc
xorl %r15d, %r15d
xorl %edx, %edx
callq 0xc350
movq %rsp, %r14
movq %r15, (%r14)
movq %r14, 0x8(%r14)
cmpb $0x16, 0x8(%rbx)
leaq 0x26247(%rip), %rax     # 0x417c9
leaq 0x25bc0(%rip), %rsi     # 0x41149
cmoveq %rax, %rsi
leaq 0x25ec0(%rip), %rdi     # 0x41454
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
movq (%rbx), %rdi
leaq 0x26214(%rip), %rsi     # 0x417d0
movq %r14, %rdx
callq 0xcc00
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b5ec
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1b5e1
movq %r14, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1b5c7
movq 0x128(%rbx), %rax
movq (%rax), %r14
movq %rbx, %rdi
testq %r14, %r14
je 0x1b60f
movq %r14, %rsi
callq 0x1730e
movq 0x110(%r14), %r14
jmp 0x1b5f6
callq 0x17555
movq (%rbx), %rdi
leaq 0x2619e(%rip), %rsi     # 0x417bc
callq 0xc060
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_write_legend_pos
STATIC void
_chart_write_legend_pos(lxw_chart *self, char *position)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();

    LXW_PUSH_ATTRIBUTES_STR("val", position);

    lxw_xml_empty_tag(self->file, "c:legendPos", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x25e07(%rip), %rdi     # 0x41454
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x261c0(%rip), %rsi     # 0x41835
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b6a5
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1b69a
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1b680
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_write_overlay
STATIC void
_chart_write_overlay(lxw_chart *self)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("val", "1");

    lxw_xml_empty_tag(self->file, "c:overlay", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x25d85(%rip), %rdi     # 0x41454
leaq 0x2a062(%rip), %rsi     # 0x45738
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x26151(%rip), %rsi     # 0x4184f
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b72e
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1b723
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1b709
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chartsheet.c
// Function: lxw_chartsheet_new
lxw_chartsheet *
lxw_chartsheet_new(lxw_worksheet_init_data *init_data)
{
    lxw_chartsheet *chartsheet = calloc(1, sizeof(lxw_chartsheet));
    GOTO_LABEL_ON_MEM_ERROR(chartsheet, mem_error);

    /* Use an embedded worksheet instance to write XML records that are
     * shared with worksheet.c. */
    chartsheet->worksheet = lxw_worksheet_new(NULL);
    GOTO_LABEL_ON_MEM_ERROR(chartsheet->worksheet, mem_error);

    if (init_data) {
        chartsheet->name = init_data->name;
        chartsheet->quoted_name = init_data->quoted_name;
        chartsheet->tmpdir = init_data->tmpdir;
        chartsheet->index = init_data->index;
        chartsheet->hidden = init_data->hidden;
        chartsheet->active_sheet = init_data->active_sheet;
        chartsheet->first_sheet = init_data->first_sheet;
    }

    chartsheet->worksheet->is_chartsheet = LXW_TRUE;
    chartsheet->worksheet->zoom_scale_normal = LXW_FALSE;
    chartsheet->worksheet->orientation = LXW_LANDSCAPE;

    return chartsheet;

mem_error:
    lxw_chartsheet_free(chartsheet);
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x78, %esi
callq 0xc7f0
movq %rax, %rbx
testq %rax, %rax
je 0x1b7c2
xorl %edi, %edi
callq 0xc9e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1b7c9
testq %r14, %r14
je 0x1b7a2
movq 0x20(%r14), %rcx
movq %rcx, 0x38(%rbx)
movq 0x28(%r14), %rcx
movq %rcx, 0x40(%rbx)
movq 0x30(%r14), %rcx
movq %rcx, 0x48(%rbx)
movzwl (%r14), %ecx
movw %cx, 0x50(%rbx)
movb 0x2(%r14), %cl
movb %cl, 0x54(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x58(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x60(%rbx)
movb $0x1, 0xe8(%rax)
xorl %ecx, %ecx
movb %cl, 0x14e(%rax)
movb %cl, 0x13d(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1f, %edi
jmp 0x1b7ce
movl $0x24, %edi
movq %rbx, %rsi
callq 0xd820
xorl %ebx, %ebx
jmp 0x1b7b7
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chartsheet.c
// Function: lxw_chartsheet_free
void
lxw_chartsheet_free(lxw_chartsheet *chartsheet)
{
    if (!chartsheet)
        return;

    lxw_worksheet_free(chartsheet->worksheet);
    free((void *) chartsheet->name);
    free((void *) chartsheet->quoted_name);
    free(chartsheet);
}

// Assembly:
testq %rdi, %rdi
je 0x1b807
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcdb0
movq 0x38(%rbx), %rdi
callq 0xc0c0
movq 0x40(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chartsheet.c
// Function: lxw_chartsheet_assemble_xml_file
void
lxw_chartsheet_assemble_xml_file(lxw_chartsheet *self)
{
    /* Set the embedded worksheet filehandle to the same as the chartsheet. */
    self->worksheet->file = self->file;

    /* Write the XML declaration. */
    _chartsheet_xml_declaration(self);

    /* Write the chartsheet element. */
    _chartsheet_write_chartsheet(self);

    /* Write the sheetPr element. */
    _chartsheet_write_sheet_pr(self);

    /* Write the sheetViews element. */
    _chartsheet_write_sheet_views(self);

    /* Write the sheetProtection element. */
    _chartsheet_write_sheet_protection(self);

    /* Write the pageMargins element. */
    _chartsheet_write_page_margins(self);

    /* Write the chartsheet page setup. */
    _chartsheet_write_page_setup(self);

    /* Write the headerFooter element. */
    _chartsheet_write_header_footer(self);

    /* Write the drawing element. */
    _chartsheet_write_drawings(self);

    lxw_xml_end_tag(self->file, "chartsheet");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
movq %rdi, (%rax)
callq 0xcf30
movups 0x265e9(%rip), %xmm0    # 0x41e1a
leaq 0x10(%rsp), %rax
movups %xmm0, 0x2a(%rax)
movaps 0x265cf(%rip), %xmm0    # 0x41e10
movaps %xmm0, 0x20(%rax)
movaps 0x265b4(%rip), %xmm0    # 0x41e00
movaps %xmm0, 0x10(%rax)
movaps 0x26599(%rip), %xmm0    # 0x41df0
movaps %xmm0, (%rax)
leaq 0x2638f(%rip), %rsi     # 0x41bf0
leaq 0x50(%rsp), %r15
movl $0x8, %ecx
movq %r15, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x737069, 0x40(%r15)   # imm = 0x737069
xorl %r12d, %r12d
movq %rsp, %r14
movq %r12, (%r14)
movq %r14, 0x8(%r14)
leaq 0x24884(%rip), %rdi     # 0x40111
movq %rax, %rsi
callq 0xc030
movl $0x1040, %r13d          # imm = 0x1040
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
leaq 0x25f35(%rip), %rdi     # 0x417ed
movq %r15, %rsi
callq 0xc030
addq %rax, %r13
movq %r12, 0x1040(%rax)
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq %r13, 0x8(%r14)
movq (%rbx), %rdi
leaq 0x27661(%rip), %rsi     # 0x42f40
movq %r14, %rdx
callq 0xc350
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b90f
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1b904
movq %r14, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1b8ea
movq 0x8(%rbx), %rdi
callq 0xc270
movq 0x8(%rbx), %rdi
callq 0xc540
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rsi
callq 0xc810
movq 0x8(%rbx), %rdi
callq 0xc140
movq 0x8(%rbx), %rdi
callq 0xc4f0
movq 0x8(%rbx), %rdi
callq 0xcbb0
movq 0x8(%rbx), %rdi
callq 0xd040
movq (%rbx), %rdi
leaq 0x275e4(%rip), %rsi     # 0x42f40
callq 0xc060
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chartsheet.c
// Function: chartsheet_protect
void
chartsheet_protect(lxw_chartsheet *self, const char *password,
                   lxw_protection *options)
{
    struct lxw_protection_obj *protect = &self->protection;

    /* Copy any user parameters to the internal structure. */
    if (options) {
        protect->objects = options->no_objects;
        protect->no_content = options->no_content;
    }
    else {
        protect->objects = LXW_FALSE;
        protect->no_content = LXW_FALSE;
    }

    if (password) {
        uint16_t hash = lxw_hash_password(password);
        lxw_snprintf(protect->hash, 5, "%X", hash);
    }
    else {
        if (protect->objects && protect->no_content)
            return;
    }

    protect->no_sheet = LXW_TRUE;
    protect->scenarios = LXW_TRUE;
    protect->is_configured = LXW_TRUE;

    if (self->chart)
        self->chart->is_protected = LXW_TRUE;
    else
        self->is_protected = LXW_TRUE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1bb6a
movb 0x10(%rdx), %al
movb %al, 0x26(%rbx)
movb 0xf(%rdx), %al
jmp 0x1bb70
movb $0x0, 0x26(%rbx)
xorl %eax, %eax
movb %al, 0x27(%rbx)
testq %rsi, %rsi
je 0x1bbb6
movq %rsi, %rdi
callq 0xc840
leaq 0x2b(%rbx), %rdi
movzwl %ax, %ecx
leaq 0x261f9(%rip), %rdx     # 0x41d87
movl $0x5, %esi
xorl %eax, %eax
callq 0xc570
movw $0x101, 0x29(%rbx)      # imm = 0x101
movb $0x1, 0x25(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1bbc4
movb $0x1, 0x169(%rax)
jmp 0x1bbc8
cmpb $0x0, 0x26(%rbx)
je 0x1bb9a
cmpb $0x0, 0x27(%rbx)
jne 0x1bbc8
jmp 0x1bb9a
movb $0x1, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/comment.c
// Function: lxw_comment_new
lxw_comment *
lxw_comment_new(void)
{
    lxw_comment *comment = calloc(1, sizeof(lxw_comment));
    GOTO_LABEL_ON_MEM_ERROR(comment, mem_error);

    comment->author_ids = calloc(1, sizeof(struct lxw_author_ids));
    GOTO_LABEL_ON_MEM_ERROR(comment->author_ids, mem_error);
    RB_INIT(comment->author_ids);

    return comment;

mem_error:
    lxw_comment_free(comment);
    return NULL;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0xc7f0
movq %rax, %rbx
testq %rax, %rax
je 0x1bc7c
movl $0x1, %edi
movl $0x8, %esi
callq 0xc7f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1bc83
movq $0x0, (%rax)
movq %rbx, %rax
popq %rbx
retq
movl $0x6b, %edi
jmp 0x1bc88
movl $0x6e, %edi
movq %rbx, %rsi
callq 0xd8fe
xorl %ebx, %ebx
jmp 0x1bc77
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/content_types.c
// Function: lxw_content_types_new
lxw_content_types *
lxw_content_types_new(void)
{
    lxw_content_types *content_types = calloc(1, sizeof(lxw_content_types));
    GOTO_LABEL_ON_MEM_ERROR(content_types, mem_error);

    content_types->default_types = calloc(1, sizeof(struct lxw_tuples));
    GOTO_LABEL_ON_MEM_ERROR(content_types->default_types, mem_error);
    STAILQ_INIT(content_types->default_types);

    content_types->overrides = calloc(1, sizeof(struct lxw_tuples));
    GOTO_LABEL_ON_MEM_ERROR(content_types->overrides, mem_error);
    STAILQ_INIT(content_types->overrides);

    lxw_ct_add_default(content_types, "rels",
                       LXW_APP_PACKAGE "relationships+xml");
    lxw_ct_add_default(content_types, "xml", "application/xml");

    lxw_ct_add_override(content_types, "/docProps/app.xml",
                        LXW_APP_DOCUMENT "extended-properties+xml");
    lxw_ct_add_override(content_types, "/docProps/core.xml",
                        LXW_APP_PACKAGE "core-properties+xml");
    lxw_ct_add_override(content_types, "/xl/styles.xml",
                        LXW_APP_DOCUMENT "spreadsheetml.styles+xml");
    lxw_ct_add_override(content_types, "/xl/theme/theme1.xml",
                        LXW_APP_DOCUMENT "theme+xml");

    return content_types;

mem_error:
    lxw_content_types_free(content_types);
    return NULL;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0xc7f0
movq %rax, %rbx
testq %rax, %rax
je 0x1ca37
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1ca3e
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1ca45
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
leaq 0x26585(%rip), %rsi     # 0x42f3a
leaq 0x254d8(%rip), %rdx     # 0x41e94
movq %rbx, %rdi
callq 0xc490
leaq 0x259a8(%rip), %rsi     # 0x42373
leaq 0x254fb(%rip), %rdx     # 0x41ecd
movq %rbx, %rdi
callq 0xc490
leaq 0x254fc(%rip), %rsi     # 0x41edd
leaq 0x25507(%rip), %rdx     # 0x41eef
movq %rbx, %rdi
callq 0xcca0
leaq 0x2553e(%rip), %rsi     # 0x41f35
leaq 0x2554a(%rip), %rdx     # 0x41f48
movq %rbx, %rdi
callq 0xcca0
leaq 0x25576(%rip), %rsi     # 0x41f83
leaq 0x2557e(%rip), %rdx     # 0x41f92
movq %rbx, %rdi
callq 0xcca0
leaq 0x255b6(%rip), %rsi     # 0x41fd9
leaq 0x255c4(%rip), %rdx     # 0x41fee
movq %rbx, %rdi
callq 0xcca0
movq %rbx, %rax
popq %rbx
retq
movl $0x1f, %edi
jmp 0x1ca4a
movl $0x22, %edi
jmp 0x1ca4a
movl $0x26, %edi
movq %rbx, %rsi
callq 0xd92c
xorl %ebx, %ebx
jmp 0x1ca32
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/content_types.c
// Function: lxw_ct_add_default
void
lxw_ct_add_default(lxw_content_types *self, const char *key,
                   const char *value)
{
    lxw_tuple *tuple;

    if (!key || !value)
        return;

    tuple = calloc(1, sizeof(lxw_tuple));
    GOTO_LABEL_ON_MEM_ERROR(tuple, mem_error);

    tuple->key = lxw_strdup(key);
    GOTO_LABEL_ON_MEM_ERROR(tuple->key, mem_error);

    tuple->value = lxw_strdup(value);
    GOTO_LABEL_ON_MEM_ERROR(tuple->value, mem_error);

    STAILQ_INSERT_TAIL(self->default_types, tuple, list_pointers);

    return;

mem_error:
    if (tuple) {
        free(tuple->key);
        free(tuple->value);
        free(tuple);
    }
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x1cadc
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0xc7f0
testq %rax, %rax
je 0x1cadd
movq %rax, %rbx
movq %r12, %rdi
callq 0xcce0
movq %rax, (%rbx)
testq %rax, %rax
je 0x1cae4
movq %r15, %rdi
callq 0xcce0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1caeb
movq %rbx, %rax
addq $0x10, %rax
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, (%rcx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xd9af
jmp 0x1cad1
movl $0xed, %esi
jmp 0x1caf0
movl $0xf0, %esi
xorl %edx, %edx
testq %rbx, %rbx
sete %dl
movq %rbx, %rdi
callq 0xd95a
jmp 0x1cad1
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/content_types.c
// Function: lxw_content_types_free
void
lxw_content_types_free(lxw_content_types *content_types)
{
    lxw_tuple *default_type;
    lxw_tuple *override;

    if (!content_types)
        return;

    if (content_types->default_types) {
        while (!STAILQ_EMPTY(content_types->default_types)) {
            default_type = STAILQ_FIRST(content_types->default_types);
            STAILQ_REMOVE_HEAD(content_types->default_types, list_pointers);
            free(default_type->key);
            free(default_type->value);
            free(default_type);
        }
        free(content_types->default_types);
    }

    if (content_types->overrides) {
        while (!STAILQ_EMPTY(content_types->overrides)) {
            override = STAILQ_FIRST(content_types->overrides);
            STAILQ_REMOVE_HEAD(content_types->overrides, list_pointers);
            free(override->key);
            free(override->value);
            free(override);
        }
        free(content_types->overrides);
    }

    free(content_types);
}

// Assembly:
testq %rdi, %rdi
je 0x1cc53
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x1cbf0
jmp 0x1cc01
movq 0x10(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x1cbd7
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0c0
movq 0x8(%r14), %rdi
callq 0xc0c0
movq %r14, %rdi
callq 0xc0c0
movq 0x8(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x1cbc7
callq 0xc0c0
cmpq $0x0, 0x10(%rbx)
jne 0x1cc33
jmp 0x1cc44
movq 0x10(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x1cc1a
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0c0
movq 0x8(%r14), %rdi
callq 0xc0c0
movq %r14, %rdi
callq 0xc0c0
movq 0x10(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x1cc0a
callq 0xc0c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/content_types.c
// Function: lxw_content_types_assemble_xml_file
void
lxw_content_types_assemble_xml_file(lxw_content_types *self)
{
    /* Write the XML declaration. */
    _content_types_xml_declaration(self);

    _write_types(self);
    _write_defaults(self);
    _write_overrides(self);

    /* Close the content_types tag. */
    lxw_xml_end_tag(self->file, "Types");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xcf30
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %r14, 0x8(%r14)
leaq 0x2348e(%rip), %rdi     # 0x40111
leaq 0x256ed(%rip), %rsi     # 0x42377
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
movq (%rbx), %rdi
leaq 0x25e21(%rip), %rsi     # 0x42ad3
movq %r14, %rdx
callq 0xc350
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1cce4
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1ccd8
movq %r14, 0x10(%rsp)
callq 0xc0c0
movq 0x8(%rsp), %rdi
jmp 0x1ccbd
movq 0x8(%rbx), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x1cd9f
xorl %r12d, %r12d
movl $0x1040, %r13d          # imm = 0x1040
movq (%r15), %rsi
movq 0x8(%r15), %rbp
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x2569f(%rip), %rdi     # 0x423b4
callq 0xc030
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x25685(%rip), %rdi     # 0x423be
movq %rbp, %rsi
callq 0xc030
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
movq (%rbx), %rdi
leaq 0x25667(%rip), %rsi     # 0x423ca
movq %r14, %rdx
callq 0xcc00
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd92
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1cd8b
movq %r14, 0x10(%rsp)
callq 0xc0c0
jmp 0x1cd6b
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1ccfd
movq 0x10(%rbx), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x1ce5a
xorl %r12d, %r12d
movl $0x1040, %r13d          # imm = 0x1040
movq (%r15), %rsi
movq 0x8(%r15), %rbp
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x25602(%rip), %rdi     # 0x423d2
callq 0xc030
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x255ca(%rip), %rdi     # 0x423be
movq %rbp, %rsi
callq 0xc030
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
movq (%rbx), %rdi
leaq 0x255bd(%rip), %rsi     # 0x423db
movq %r14, %rdx
callq 0xcc00
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ce4d
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1ce46
movq %r14, 0x10(%rsp)
callq 0xc0c0
jmp 0x1ce26
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1cdb8
movq (%rbx), %rdi
leaq 0x25c6f(%rip), %rsi     # 0x42ad3
callq 0xc060
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/core.c
// Function: datetime_to_iso8601_date
static void
_datetime_to_iso8601_date(time_t *timer, char *str, size_t size)
{
    struct tm *tmp_datetime;
    time_t current_time = time(NULL);

    if (*timer)
        tmp_datetime = gmtime(timer);
    else
        tmp_datetime = gmtime(&current_time);

    strftime(str, size - 1, "%Y-%m-%dT%H:%M:%SZ", tmp_datetime);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0xc9b0
movq %rsp, %rcx
movq %rax, (%rcx)
cmpq $0x0, (%r14)
cmoveq %rcx, %r14
movq %r14, %rdi
callq 0xce10
leaq 0x2529d(%rip), %rdx     # 0x42574
movl $0x1f, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0xccb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: lxw_drawing_new
lxw_drawing *
lxw_drawing_new(void)
{
    lxw_drawing *drawing = calloc(1, sizeof(lxw_drawing));
    GOTO_LABEL_ON_MEM_ERROR(drawing, mem_error);

    drawing->drawing_objects = calloc(1, sizeof(struct lxw_drawing_objects));
    GOTO_LABEL_ON_MEM_ERROR(drawing->drawing_objects, mem_error);

    STAILQ_INIT(drawing->drawing_objects);

    return drawing;

mem_error:
    lxw_drawing_free(drawing);
    return NULL;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0xc7f0
movq %rax, %rbx
testq %rax, %rax
je 0x1d6a8
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1d6af
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
movl $0x22, %edi
jmp 0x1d6b4
movl $0x25, %edi
movq %rbx, %rsi
callq 0xda90
xorl %ebx, %ebx
jmp 0x1d6a3
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: lxw_drawing_free
void
lxw_drawing_free(lxw_drawing *drawing)
{
    lxw_drawing_object *drawing_object;

    if (!drawing)
        return;

    if (drawing->drawing_objects) {
        while (!STAILQ_EMPTY(drawing->drawing_objects)) {
            drawing_object = STAILQ_FIRST(drawing->drawing_objects);
            STAILQ_REMOVE_HEAD(drawing->drawing_objects, list_pointers);
            lxw_free_drawing_object(drawing_object);
        }

        free(drawing->drawing_objects);
    }

    free(drawing);
}

// Assembly:
testq %rdi, %rdi
je 0x1d704
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x1d6ea
jmp 0x1d6fb
movq 0x78(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x1d6e2
movq %rdi, 0x8(%rdi)
movq %rax, %rdi
callq 0xccc0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
jne 0x1d6d2
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: lxw_free_drawing_object
void
lxw_free_drawing_object(lxw_drawing_object *drawing_object)
{
    if (!drawing_object)
        return;

    free(drawing_object->description);
    free(drawing_object->tip);

    free(drawing_object);
}

// Assembly:
testq %rdi, %rdi
je 0x1d729
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xc0c0
movq 0x68(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: drawing_write_coords
STATIC void
_drawing_write_coords(lxw_drawing *self, lxw_drawing_coords *coords)
{
    char data[LXW_UINT32_T_LENGTH];

    lxw_snprintf(data, LXW_UINT32_T_LENGTH, "%u", coords->col);
    _drawing_write_col(self, data);

    lxw_snprintf(data, LXW_UINT32_T_LENGTH, "%u",
                 (uint32_t) coords->col_offset);
    _drawing_write_col_off(self, data);

    lxw_snprintf(data, LXW_UINT32_T_LENGTH, "%u", coords->row);
    _drawing_write_row(self, data);

    lxw_snprintf(data, LXW_UINT32_T_LENGTH, "%u",
                 (uint32_t) coords->row_offset);
    _drawing_write_row_off(self, data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl (%rsi), %ecx
leaq 0x2428a(%rip), %r15     # 0x426f7
leaq 0xd(%rsp), %r14
movl $0xb, %esi
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc570
movq (%rbx), %rdi
leaq 0x2426c(%rip), %rsi     # 0x426fa
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcb30
cvttsd2si 0x8(%r12), %rcx
movl $0xb, %esi
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc570
movq (%rbx), %rdi
leaq 0x24247(%rip), %rsi     # 0x42702
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcb30
movl 0x4(%r12), %ecx
movl $0xb, %esi
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc570
movq (%rbx), %rdi
leaq 0x24227(%rip), %rsi     # 0x4270d
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcb30
cvttsd2si 0x10(%r12), %rcx
movl $0xb, %esi
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc570
movq (%rbx), %rdi
leaq 0x24202(%rip), %rsi     # 0x42715
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcb30
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: drawing_write_uri_ext
STATIC void
_drawing_write_uri_ext(lxw_drawing *self, char *uri)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("uri", uri);

    lxw_xml_start_tag(self->file, "a:ext", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x23e02(%rip), %rdi     # 0x427e6
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x23dad(%rip), %rsi     # 0x427b9
movq %rbx, %rdx
callq 0xc350
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ea3c
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1ea31
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1ea17
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: drawing_write_pos
STATIC void
_drawing_write_pos(lxw_drawing *self, int32_t x, int32_t y)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_INT("x", x);
    LXW_PUSH_ATTRIBUTES_INT("y", y);

    lxw_xml_empty_tag(self->file, "xdr:pos", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x2abde(%rip), %rdi     # 0x49649
xorl %esi, %esi
callq 0xc180
movl $0x1040, %r12d          # imm = 0x1040
leaq (%rax,%r12), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movslq %ebp, %rsi
leaq 0x23ab2(%rip), %rdi     # 0x4254a
callq 0xc180
addq %rax, %r12
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r12, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x23ea4(%rip), %rsi     # 0x42960
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1eaec
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1eae1
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1eac7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/drawing.c
// Function: drawing_write_ext
STATIC void
_drawing_write_ext(lxw_drawing *self, uint32_t cx, uint32_t cy)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_INT("cx", cx);
    LXW_PUSH_ATTRIBUTES_INT("cy", cy);

    lxw_xml_empty_tag(self->file, "xdr:ext", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
movl %esi, %esi
leaq 0x23d64(%rip), %rdi     # 0x42884
callq 0xc180
movl $0x1040, %r12d          # imm = 0x1040
leaq (%rax,%r12), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movl %ebp, %esi
leaq 0x23d3d(%rip), %rdi     # 0x42887
callq 0xc180
addq %rax, %r12
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r12, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x23dfa(%rip), %rsi     # 0x42968
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1eb9e
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1eb93
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x1eb79
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/format.c
// Function: lxw_format_get_font_key
lxw_font *
lxw_format_get_font_key(lxw_format *self)
{
    lxw_font *key = calloc(1, sizeof(lxw_font));
    GOTO_LABEL_ON_MEM_ERROR(key, mem_error);

    LXW_FORMAT_FIELD_COPY(key->font_name, self->font_name);
    key->font_size = self->font_size;
    key->bold = self->bold;
    key->italic = self->italic;
    key->underline = self->underline;
    key->theme = self->theme;
    key->font_color = self->font_color;
    key->font_strikeout = self->font_strikeout;
    key->font_outline = self->font_outline;
    key->font_shadow = self->font_shadow;
    key->font_script = self->font_script;
    key->font_family = self->font_family;
    key->font_charset = self->font_charset;
    key->font_condense = self->font_condense;
    key->font_extend = self->font_extend;

    return key;

mem_error:
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x98, %esi
callq 0xc7f0
testq %rax, %rax
je 0x1ed90
movq %rax, %rbx
leaq 0xb4(%r14), %rsi
movl $0x7f, %edx
movq %rax, %rdi
callq 0xc170
movb $0x0, 0x7f(%rbx)
movsd 0x1c0(%r14), %xmm0
movsd %xmm0, 0x80(%rbx)
movb 0x1c8(%r14), %al
movb %al, 0x88(%rbx)
movb 0x1c9(%r14), %al
movb %al, 0x89(%rbx)
movb 0x1d0(%r14), %al
movb %al, 0x8a(%rbx)
movb 0x1d9(%r14), %al
movb %al, 0x8b(%rbx)
movl 0x1cc(%r14), %eax
movl %eax, 0x94(%rbx)
movb 0x1d1(%r14), %al
movb %al, 0x8c(%rbx)
movb 0x1d2(%r14), %al
movb %al, 0x8d(%rbx)
movb 0x1d3(%r14), %al
movb %al, 0x8e(%rbx)
movb 0x1d4(%r14), %al
movb %al, 0x8f(%rbx)
movb 0x1d5(%r14), %al
movb %al, 0x90(%rbx)
movb 0x1d6(%r14), %al
movb %al, 0x91(%rbx)
movb 0x1d7(%r14), %al
movb %al, 0x92(%rbx)
movb 0x1d8(%r14), %al
movb %al, 0x93(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xdae0
xorl %ebx, %ebx
jmp 0x1ed85
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/format.c
// Function: lxw_format_get_border_key
lxw_border *
lxw_format_get_border_key(lxw_format *self)
{
    lxw_border *key = calloc(1, sizeof(lxw_border));
    GOTO_LABEL_ON_MEM_ERROR(key, mem_error);

    key->bottom = self->bottom;
    key->left = self->left;
    key->right = self->right;
    key->top = self->top;
    key->diag_border = self->diag_border;
    key->diag_type = self->diag_type;
    key->bottom_color = self->bottom_color;
    key->left_color = self->left_color;
    key->right_color = self->right_color;
    key->top_color = self->top_color;
    key->diag_color = self->diag_color;

    return key;

mem_error:
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x1c, %esi
callq 0xc7f0
testq %rax, %rax
je 0x1ee15
movb 0x20c(%rbx), %cl
movb %cl, (%rax)
movb 0x20f(%rbx), %cl
movb %cl, 0x3(%rax)
movb 0x210(%rbx), %cl
movb %cl, 0x4(%rax)
movb 0x211(%rbx), %cl
movb %cl, 0x5(%rax)
movb 0x20d(%rbx), %cl
movb %cl, 0x1(%rax)
movb 0x20e(%rbx), %cl
movb %cl, 0x2(%rax)
movl 0x214(%rbx), %ecx
movl %ecx, 0x8(%rax)
movl 0x21c(%rbx), %ecx
movl %ecx, 0x10(%rax)
movl 0x220(%rbx), %ecx
movl %ecx, 0x14(%rax)
movl 0x224(%rbx), %ecx
movl %ecx, 0x18(%rax)
movl 0x218(%rbx), %ecx
movl %ecx, 0xc(%rax)
popq %rbx
retq
callq 0xdb04
xorl %eax, %eax
jmp 0x1ee13
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/format.c
// Function: lxw_format_get_fill_key
lxw_fill *
lxw_format_get_fill_key(lxw_format *self)
{
    lxw_fill *key = calloc(1, sizeof(lxw_fill));
    GOTO_LABEL_ON_MEM_ERROR(key, mem_error);

    key->fg_color = self->fg_color;
    key->bg_color = self->bg_color;
    key->pattern = self->pattern;

    return key;

mem_error:
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0xc, %esi
callq 0xc7f0
testq %rax, %rax
je 0x1ee52
movl 0x1e4(%rbx), %ecx
movl %ecx, (%rax)
movl 0x1e8(%rbx), %ecx
movl %ecx, 0x4(%rax)
movb 0x1f4(%rbx), %cl
movb %cl, 0x8(%rax)
popq %rbx
retq
callq 0xdb28
xorl %eax, %eax
jmp 0x1ee50
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/format.c
// Function: get_format_key
STATIC lxw_format *
_get_format_key(lxw_format *self)
{
    lxw_format *key = calloc(1, sizeof(lxw_format));
    GOTO_LABEL_ON_MEM_ERROR(key, mem_error);

    memcpy(key, self, sizeof(lxw_format));

    /* Set pointer members to NULL since they aren't part of the comparison. */
    key->xf_format_indices = NULL;
    key->dxf_format_indices = NULL;
    key->num_xf_formats = NULL;
    key->num_dxf_formats = NULL;
    key->list_pointers.stqe_next = NULL;

    return key;

mem_error:
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x238, %esi            # imm = 0x238
callq 0xc7f0
testq %rax, %rax
je 0x1ef23
movq %rax, %rbx
movl $0x238, %edx            # imm = 0x238
movq %rax, %rdi
movq %r14, %rsi
callq 0xc900
movq $0x0, 0x230(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xdb4c
xorl %ebx, %ebx
jmp 0x1ef18
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/format.c
// Function: format_set_rotation
void
format_set_rotation(lxw_format *self, int16_t angle)
{
    /* Convert user angle to Excel angle. */
    if (angle == 270) {
        self->rotation = 255;
    }
    else if (angle >= -90 && angle <= 90) {
        if (angle < 0)
            angle = -angle + 90;

        self->rotation = angle;
    }
    else {
        LXW_WARN("Rotation rotation outside range: -90 <= angle <= 90.");
        self->rotation = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movw $0xff, %ax
cmpl $0x10e, %esi            # imm = 0x10E
je 0x1f0c4
leal 0x5a(%rsi), %eax
movzwl %ax, %eax
cmpl $0xb4, %eax
ja 0x1f0cd
movl $0x5a, %eax
subl %esi, %eax
testw %si, %si
cmovnsl %esi, %eax
movw %ax, 0x1e2(%rbx)
popq %rbx
retq
callq 0xdb70
xorl %eax, %eax
jmp 0x1f0c4
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/format.c
// Function: format_set_border
void
format_set_border(lxw_format *self, uint8_t style)
{
    style = _check_border(style);
    self->bottom = style;
    self->top = style;
    self->left = style;
    self->right = style;
}

// Assembly:
leal -0x1(%rsi), %eax
xorl %ecx, %ecx
cmpb $0xd, %al
cmovbl %esi, %ecx
movb %cl, 0x20c(%rdi)
movb %cl, 0x211(%rdi)
movb %cl, 0x20f(%rdi)
movb %cl, 0x210(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/hash_table.c
// Function: lxw_hash_key_exists
lxw_hash_element *
lxw_hash_key_exists(lxw_hash_table *lxw_hash, void *key, size_t key_len)
{
    size_t hash_key = _generate_hash_key(key, key_len, lxw_hash->num_buckets);
    struct lxw_hash_bucket_list *list;
    lxw_hash_element *element;

    if (!lxw_hash->buckets[hash_key]) {
        /* The key isn't in the LXW_HASH hash table. */
        return NULL;
    }
    else {
        /* The key is already in the table or there is a hash collision. */
        list = lxw_hash->buckets[hash_key];

        /* Iterate over the keys in the bucket's linked list. */
        SLIST_FOREACH(element, list, lxw_hash_list_pointers) {
            if (memcmp(element->key, key, key_len) == 0) {
                /* The key already exists in the table. */
                return element;
            }
        }

        /* Key doesn't exist in the list so this is a hash collision. */
        return NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
movl (%rdi), %ecx
testq %rdx, %rdx
je 0x1f27c
xorl %edx, %edx
imulq $0x1000193, %rax, %rsi  # imm = 0x1000193
movzbl (%r14,%rdx), %eax
xorq %rsi, %rax
incq %rdx
cmpq %rdx, %rbx
jne 0x1f265
xorl %r15d, %r15d
xorl %edx, %edx
divq %rcx
movq 0x18(%rdi), %rax
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x1f2b4
movq (%rax), %r15
testq %r15, %r15
je 0x1f2b1
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcaf0
testl %eax, %eax
je 0x1f2b4
movq 0x18(%r15), %r15
jmp 0x1f294
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/hash_table.c
// Function: lxw_hash_new
lxw_hash_table *
lxw_hash_new(uint32_t num_buckets, uint8_t free_key, uint8_t free_value)
{
    /* Create the new hash table. */
    lxw_hash_table *lxw_hash = calloc(1, sizeof(lxw_hash_table));
    RETURN_ON_MEM_ERROR(lxw_hash, NULL);

    lxw_hash->free_key = free_key;
    lxw_hash->free_value = free_value;

    /* Add the lxw_hash element buckets. */
    lxw_hash->buckets =
        calloc(num_buckets, sizeof(struct lxw_hash_bucket_list *));
    GOTO_LABEL_ON_MEM_ERROR(lxw_hash->buckets, mem_error);

    /* Add a list for tracking the insertion order. */
    lxw_hash->order_list = calloc(1, sizeof(struct lxw_hash_order_list));
    GOTO_LABEL_ON_MEM_ERROR(lxw_hash->order_list, mem_error);

    /* Initialize the order list. */
    STAILQ_INIT(lxw_hash->order_list);

    /* Store the number of buckets to calculate the load factor. */
    lxw_hash->num_buckets = num_buckets;

    return lxw_hash;

mem_error:
    lxw_hash_free(lxw_hash);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %ebp
movl $0x1, %edi
movl $0x20, %esi
callq 0xc7f0
testq %rax, %rax
je 0x1f4c4
movq %rax, %rbx
movb %r15b, 0xc(%rax)
movb %r14b, 0xd(%rax)
movl %ebp, %edi
movl $0x8, %esi
callq 0xc7f0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1f4cb
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1f4d2
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movl %ebp, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xdc0c
jmp 0x1f4df
movl $0xab, %edi
jmp 0x1f4d7
movl $0xaf, %edi
movq %rbx, %rsi
callq 0xdbde
xorl %ebx, %ebx
jmp 0x1f4b6
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/hash_table.c
// Function: lxw_hash_free
void
lxw_hash_free(lxw_hash_table *lxw_hash)
{
    size_t i;
    lxw_hash_element *element;
    lxw_hash_element *element_temp;

    if (!lxw_hash)
        return;

    /* Free the lxw_hash_elements and data using the ordered linked list. */
    if (lxw_hash->order_list) {
        STAILQ_FOREACH_SAFE(element, lxw_hash->order_list,
                            lxw_hash_order_pointers, element_temp) {
            if (lxw_hash->free_key)
                free(element->key);
            if (lxw_hash->free_value)
                free(element->value);
            free(element);
        }
    }

    /* Free the buckets from the hash table. */
    for (i = 0; i < lxw_hash->num_buckets; i++) {
        free(lxw_hash->buckets[i]);
    }

    free(lxw_hash->order_list);
    free(lxw_hash->buckets);
    free(lxw_hash);
}

// Assembly:
testq %rdi, %rdi
je 0x1f574
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1f536
movq (%rax), %r14
testq %r14, %r14
je 0x1f536
movq 0x10(%r14), %r15
cmpb $0x0, 0xc(%rbx)
je 0x1f517
movq (%r14), %rdi
callq 0xc0c0
cmpb $0x0, 0xd(%rbx)
je 0x1f526
movq 0x8(%r14), %rdi
callq 0xc0c0
movq %r14, %rdi
callq 0xc0c0
movq %r15, %r14
testq %r15, %r15
jne 0x1f505
cmpl $0x0, (%rbx)
je 0x1f555
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xc0c0
incq %r14
movl (%rbx), %eax
cmpq %rax, %r14
jb 0x1f53e
movq 0x10(%rbx), %rdi
callq 0xc0c0
movq 0x18(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc0c0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/packager.c
// Function: fclose_memstream
ZCALLBACK
_fclose_memstream(voidpf opaque, voidpf stream)
{
    lxw_packager *packager = (lxw_packager *) opaque;
    FILE *file = (FILE *) stream;
    long size;

    /* Ensure memstream buffer is updated */
    if (fflush(file))
        goto mem_error;

    /* If the memstream is backed by a temporary file, no buffer is created,
       so create it manually. */
    if (!packager->output_buffer) {
        if (fseek(file, 0L, SEEK_END))
            goto mem_error;

        size = ftell(file);
        if (size == -1)
            goto mem_error;

        packager->output_buffer = malloc(size);
        GOTO_LABEL_ON_MEM_ERROR(packager->output_buffer, mem_error);

        rewind(file);
        if (fread((void *) packager->output_buffer, size, 1, file) < 1)
            goto mem_error;

        packager->output_buffer_size = size;
    }

    return fclose(file);

mem_error:
    fclose(file);
    return EOF;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xca60
testl %eax, %eax
je 0x1fe4e
movq %rbx, %rdi
callq 0xc420
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x68(%r14)
je 0x1fe62
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc420
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xcb40
testl %eax, %eax
jne 0x1fe3b
movq %rbx, %rdi
callq 0xc880
cmpq $-0x1, %rax
je 0x1fe3b
movq %rax, %r15
movq %rax, %rdi
callq 0xca50
movq %rax, 0x68(%r14)
testq %rax, %rax
je 0x1febe
movq %rbx, %rdi
callq 0xc500
movq 0x68(%r14), %rdi
movl $0x1, %edx
movq %r15, %rsi
movq %rbx, %rcx
callq 0xc2f0
testq %rax, %rax
je 0x1fe3b
movq %r15, 0x18(%r14)
jmp 0x1fe55
callq 0xdc73
jmp 0x1fe3b
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/packager.c
// Function: lxw_packager_free
void
lxw_packager_free(lxw_packager *packager)
{
    if (!packager)
        return;

    free((void *) packager->buffer);
    free((void *) packager->filename);
    free(packager);
}

// Assembly:
testq %rdi, %rdi
je 0x1feec
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xc0c0
movq 0x58(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/packager.c
// Function: write_chartsheet_files
STATIC lxw_error
_write_chartsheet_files(lxw_packager *self)
{
    lxw_workbook *workbook = self->workbook;
    lxw_sheet *sheet;
    lxw_chartsheet *chartsheet;
    char sheetname[LXW_FILENAME_LENGTH] = { 0 };
    char *buffer = NULL;
    size_t buffer_size = 0;
    uint32_t index = 1;
    lxw_error err;

    STAILQ_FOREACH(sheet, workbook->sheets, list_pointers) {
        if (sheet->is_chartsheet)
            chartsheet = sheet->u.chartsheet;
        else
            continue;

        lxw_snprintf(sheetname, LXW_FILENAME_LENGTH,
                     "xl/chartsheets/sheet%d.xml", index++);

        chartsheet->file = lxw_get_filehandle(&buffer, &buffer_size,
                                              self->tmpdir);
        if (!chartsheet->file)
            return LXW_ERROR_CREATING_TMPFILE;

        lxw_chartsheet_assemble_xml_file(chartsheet);

        err = _add_to_zip(self, chartsheet->file, &buffer, &buffer_size,
                          sheetname);
        fclose(chartsheet->file);
        free(buffer);
        RETURN_ON_ERROR(err);
    }

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
xorl %r13d, %r13d
movq %r13, 0x8(%rsp)
movq %r13, 0x18(%rsp)
movq 0x8(%rax), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x20aa5
movq %rdi, %rbx
movl $0x1, %ecx
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %rbp
movq %rdi, 0x10(%rsp)
cmpb $0x0, (%r12)
je 0x20a8c
movq 0x8(%r12), %r14
movl $0x80, %esi
movq %r13, %rdi
leaq 0x22368(%rip), %rdx     # 0x42d85
movl %ecx, 0x4(%rsp)
xorl %eax, %eax
callq 0xc570
movq 0x70(%rbx), %rdx
movq %r15, %rdi
movq %rbp, %rsi
callq 0xce00
movq %rax, (%r14)
testq %rax, %rax
je 0x20a9f
movq %r14, %rdi
callq 0xcba0
movq (%r14), %rsi
movq %rbp, %rcx
movq %rbx, %rdi
movq %r15, %rbx
movq %r15, %rdx
movq %r13, %r15
movq %r13, %r8
callq 0x22482
movl %eax, %r13d
movq (%r14), %rdi
callq 0xc420
movq 0x8(%rsp), %rdi
callq 0xc0c0
testl %r13d, %r13d
jne 0x20aa5
movl 0x4(%rsp), %ecx
incl %ecx
movq %r15, %r13
movq %rbx, %r15
movq 0x10(%rsp), %rbx
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x209fe
xorl %r13d, %r13d
jmp 0x20aa5
movl $0x3, %r13d
movl %r13d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/packager.c
// Function: write_workbook_file
STATIC lxw_error
_write_workbook_file(lxw_packager *self)
{
    lxw_workbook *workbook = self->workbook;
    lxw_error err;

    char *buffer = NULL;
    size_t buffer_size = 0;
    workbook->file = lxw_get_filehandle(&buffer, &buffer_size, self->tmpdir);
    if (!workbook->file)
        return LXW_ERROR_CREATING_TMPFILE;

    lxw_workbook_assemble_xml_file(workbook);

    err = _add_to_zip(self, workbook->file, &buffer, &buffer_size,
                      "xl/workbook.xml");
    fclose(workbook->file);
    free(buffer);
    RETURN_ON_ERROR(err);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x70(%r14), %rdx
callq 0xce00
movq %rax, (%rbx)
testq %rax, %rax
je 0x20b29
movq %rbx, %rdi
callq 0xc220
movq (%rbx), %rsi
leaq 0x221aa(%rip), %r8      # 0x42caa
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x22482
movl %eax, %ebp
movq (%rbx), %rdi
callq 0xc420
movq (%r15), %rdi
callq 0xc0c0
jmp 0x20b2e
movl $0x3, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq