LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: lxw_styles_new
lxw_styles *
lxw_styles_new(void)
{
    lxw_styles *styles = calloc(1, sizeof(lxw_styles));
    GOTO_LABEL_ON_MEM_ERROR(styles, mem_error);

    styles->xf_formats = calloc(1, sizeof(struct lxw_formats));
    GOTO_LABEL_ON_MEM_ERROR(styles->xf_formats, mem_error);
    STAILQ_INIT(styles->xf_formats);

    styles->dxf_formats = calloc(1, sizeof(struct lxw_formats));
    GOTO_LABEL_ON_MEM_ERROR(styles->dxf_formats, mem_error);
    STAILQ_INIT(styles->dxf_formats);

    return styles;

mem_error:
    lxw_styles_free(styles);
    return NULL;
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x20225
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x20229
movq %rax, 0x8(%rax)
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x2022d
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
pushq $0x21
jmp 0x2022f
pushq $0x24
jmp 0x2022f
pushq $0x28
popq %rcx
movq 0x32dc1(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1ce9f(%rip), %rsi     # 0x3d0e0
leaq 0x200f8(%rip), %rdx     # 0x40340
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xc5e0
xorl %ebx, %ebx
jmp 0x20220
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: lxw_styles_free
void
lxw_styles_free(lxw_styles *styles)
{
    lxw_format *format;

    if (!styles)
        return;

    /* Free the xf formats in the styles. */
    if (styles->xf_formats) {
        while (!STAILQ_EMPTY(styles->xf_formats)) {
            format = STAILQ_FIRST(styles->xf_formats);
            STAILQ_REMOVE_HEAD(styles->xf_formats, list_pointers);
            free(format);
        }
        free(styles->xf_formats);
    }

    /* Free the dxf formats in the styles. */
    if (styles->dxf_formats) {
        while (!STAILQ_EMPTY(styles->dxf_formats)) {
            format = STAILQ_FIRST(styles->dxf_formats);
            STAILQ_REMOVE_HEAD(styles->dxf_formats, list_pointers);
            free(format);
        }
        free(styles->dxf_formats);
    }

    free(styles);
}

// Assembly:
testq %rdi, %rdi
je 0x202db
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x2028e
jmp 0x2029b
movq 0x230(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x20282
movq %rdi, 0x8(%rdi)
movq %rax, %rdi
callq 0xc0d0
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
jne 0x2026f
callq 0xc0d0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
jne 0x202c5
jmp 0x202d2
movq 0x230(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x202b9
movq %rdi, 0x8(%rdi)
movq %rax, %rdi
callq 0xc0d0
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
jne 0x202a6
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
jmp 0xc0d0
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: lxw_styles_write_string_fragment
void
lxw_styles_write_string_fragment(lxw_styles *self, const char *string)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();

    /* Add attribute to preserve leading or trailing whitespace. */
    if (isspace((unsigned char) string[0])
        || isspace((unsigned char) string[strlen(string) - 1]))
        LXW_PUSH_ATTRIBUTES_STR("xml:space", "preserve");

    lxw_xml_data_element(self->file, "t", string, &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
callq 0xd170
movq (%rax), %r12
movzbl (%r14), %eax
testb $0x20, 0x1(%r12,%rax,2)
jne 0x20324
movq %r14, %rdi
callq 0xc4c0
movzbl -0x1(%r14,%rax), %eax
testb $0x20, 0x1(%r12,%rax,2)
je 0x20353
leaq 0x1fff4(%rip), %rdi     # 0x4031f
leaq 0x1fff7(%rip), %rsi     # 0x40329
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq 0x1040(%rax), %rcx
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
movq (%r15), %rdi
leaq 0x1df2c(%rip), %rsi     # 0x3e289
movq %r14, %rdx
movq %rbx, %rcx
callq 0xcba0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2038f
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x20388
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x20368
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_font_vert_align
STATIC void
_write_font_vert_align(lxw_styles *self, const char *align)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

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

    lxw_xml_empty_tag(self->file, "vertAlign", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1ca28(%rip), %rdi     # 0x3e44c
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1e972(%rip), %rsi     # 0x403bf
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21a7c
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x21a75
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x21a55
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_font_size
STATIC void
_write_font_size(lxw_styles *self, double font_size)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_DBL("val", font_size);

    lxw_xml_empty_tag(self->file, "sz", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1c9aa(%rip), %rdi     # 0x3e44c
callq 0xccf0
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1c750(%rip), %rsi     # 0x3e21b
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21afa
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x21af3
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x21ad3
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_font_color_theme
STATIC void
_write_font_color_theme(lxw_styles *self, uint8_t theme)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_INT("theme", theme);

    lxw_xml_empty_tag(self->file, "color", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
movq %rbx, 0x8(%rbx)
movl %esi, %esi
leaq 0x1e445(%rip), %rdi     # 0x3ff67
callq 0xc1a0
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x20935(%rip), %rsi     # 0x42480
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21b7a
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x21b73
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x21b53
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_font_color_indexed
STATIC void
_write_font_color_indexed(lxw_styles *self, uint8_t index)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_INT("indexed", index);

    lxw_xml_empty_tag(self->file, "color", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
movq %rbx, 0x8(%rbx)
movl %esi, %esi
leaq 0x1d2d6(%rip), %rdi     # 0x3ee78
callq 0xc1a0
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x208b5(%rip), %rsi     # 0x42480
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21bfa
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x21bf3
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x21bd3
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_font_name
STATIC void
_write_font_name(lxw_styles *self, const char *font_name,
                 uint8_t is_rich_string)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();

    if (*font_name)
        LXW_PUSH_ATTRIBUTES_STR("val", font_name);
    else
        LXW_PUSH_ATTRIBUTES_STR("val", LXW_DEFAULT_FONT_NAME);

    if (is_rich_string)
        lxw_xml_empty_tag(self->file, "rFont", &attributes);
    else
        lxw_xml_empty_tag(self->file, "name", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsp, %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
cmpb $0x0, (%rsi)
movq %rdi, %r14
leaq 0x1e75a(%rip), %rax     # 0x4037e
cmoveq %rax, %rsi
leaq 0x1c81d(%rip), %rdi     # 0x3e44c
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
testl %ebp, %ebp
leaq 0x1c708(%rip), %rax     # 0x3e35f
leaq 0x1d229(%rip), %rsi     # 0x3ee87
cmoveq %rax, %rsi
movq (%r14), %rdi
movq %rbx, %rdx
callq 0xcc70
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x21c92
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x21c8b
movq %rbx, 0x8(%rsp)
callq 0xc0d0
jmp 0x21c6d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_font_family
STATIC void
_write_font_family(lxw_styles *self, uint8_t font_family)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_INT("val", font_family);

    lxw_xml_empty_tag(self->file, "family", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
movq %rbx, 0x8(%rbx)
movl %esi, %esi
leaq 0x1c791(%rip), %rdi     # 0x3e44c
callq 0xc1a0
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1d1a9(%rip), %rsi     # 0x3ee8d
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21d13
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x21d0c
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x21cec
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_default_fill
STATIC void
_write_default_fill(lxw_styles *self, const char *pattern)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("patternType", pattern);

    lxw_xml_start_tag(self->file, "fill", NULL);
    lxw_xml_empty_tag(self->file, "patternFill", &attributes);
    lxw_xml_end_tag(self->file, "fill");

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsp, %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1e81e(%rip), %rdi     # 0x4063e
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x2066d(%rip), %r15     # 0x424b6
movq %r15, %rsi
xorl %edx, %edx
callq 0xc380
movq (%r14), %rdi
leaq 0x1e7ed(%rip), %rsi     # 0x4064a
movq %rbx, %rdx
callq 0xcc70
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc060
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x21e95
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x21e8e
movq %rbx, 0x8(%rsp)
callq 0xc0d0
jmp 0x21e70
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_sub_border
STATIC void
_write_sub_border(lxw_styles *self, const char *type, uint8_t style,
                  lxw_color_t color)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    char *border_styles[] = {
        "none",
        "thin",
        "medium",
        "dashed",
        "dotted",
        "thick",
        "double",
        "hair",
        "mediumDashed",
        "dashDot",
        "mediumDashDot",
        "dashDotDot",
        "mediumDashDotDot",
        "slantDashDot",
    };

    if (!style) {
        lxw_xml_empty_tag(self->file, type, NULL);
        return;
    }

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("style", border_styles[style]);

    lxw_xml_start_tag(self->file, type, &attributes);

    _write_border_color(self, color);

    lxw_xml_end_tag(self->file, type);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
je 0x223bd
movl %ecx, %ebp
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
movzbl %dl, %eax
leaq 0x1e6f4(%rip), %rcx     # 0x40a38
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x1c4a4(%rip), %rdi     # 0x3e7f6
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc380
movq %rsp, %r12
andq $0x0, (%r12)
movq %r12, 0x8(%r12)
testl %ebp, %ebp
je 0x223d8
andl $0xffffff, %ebp         # imm = 0xFFFFFF
leaq 0x1e02c(%rip), %rdx     # 0x403c9
leaq 0x20(%rsp), %r13
pushq $0x20
popq %rsi
movq %r13, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0xc5b0
leaq 0x1e018(%rip), %rdi     # 0x403d0
movq %r13, %rsi
jmp 0x223e6
movq (%r15), %rdi
movq %r14, %rsi
xorl %edx, %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcc70
leaq 0x1c197(%rip), %rdi     # 0x3e576
leaq 0x20362(%rip), %rsi     # 0x42748
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rsp)
movq (%r15), %rdi
leaq 0x2006f(%rip), %rsi     # 0x42480
movq %r12, %rdx
callq 0xcc70
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2243e
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x22437
movq %r12, 0x8(%rsp)
callq 0xc0d0
jmp 0x22419
movq (%r15), %rdi
movq %r14, %rsi
callq 0xc060
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x22470
movq 0x1040(%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x22469
movq %rbx, 0x18(%rsp)
callq 0xc0d0
jmp 0x22449
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/styles.c
// Function: write_cell_style
STATIC void
_write_cell_style(lxw_styles *self, char *name, uint8_t xf_id,
                  uint8_t builtin_id)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("name", name);
    LXW_PUSH_ATTRIBUTES_INT("xfId", xf_id);
    LXW_PUSH_ATTRIBUTES_INT("builtinId", builtin_id);

    lxw_xml_empty_tag(self->file, "cellStyle", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movq %rsp, %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1bbc7(%rip), %rdi     # 0x3e35f
callq 0xc030
movl $0x1040, %r12d          # imm = 0x1040
leaq (%rax,%r12), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movl %r15d, %esi
leaq 0x1e350(%rip), %rdi     # 0x40b14
callq 0xc1a0
leaq (%rax,%r12), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movl %ebp, %esi
leaq 0x1e114(%rip), %rdi     # 0x408fd
callq 0xc1a0
addq %rax, %r12
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r12, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1e0f9(%rip), %rsi     # 0x40907
movq %rbx, %rdx
callq 0xcc70
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2283b
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x22834
movq %rbx, 0x8(%rsp)
callq 0xc0d0
jmp 0x22816
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_col_to_name
void
lxw_col_to_name(char *col_name, lxw_col_t col_num, uint8_t absolute)
{
    uint8_t pos = 0;
    size_t len;
    size_t i;

    /* Change from 0 index to 1 index. */
    col_num++;

    /* Convert the column number to a string in reverse order. */
    while (col_num) {

        /* Get the remainder in base 26. */
        int remainder = col_num % 26;

        if (remainder == 0)
            remainder = 26;

        /* Convert the remainder value to a character. */
        col_name[pos++] = 'A' + remainder - 1;
        col_name[pos] = '\0';

        /* Get the next order of magnitude. */
        col_num = (col_num - 1) / 26;
    }

    if (absolute) {
        col_name[pos] = '$';
        col_name[pos + 1] = '\0';
    }

    /* Reverse the column name string. */
    len = strlen(col_name);
    for (i = 0; i < (len / 2); i++) {
        char tmp = col_name[i];
        col_name[i] = col_name[len - i - 1];
        col_name[len - i - 1] = tmp;
    }
}

// Assembly:
pushq %rbx
movl %edx, %ecx
movq %rdi, %rbx
incl %esi
movw $0x1a, %di
pushq $0x5a
popq %r8
xorl %r10d, %r10d
movzbl %r10b, %r9d
testw %si, %si
je 0x23123
movl %esi, %eax
xorl %edx, %edx
divw %di
movl %edx, %eax
orb $0x40, %al
testw %dx, %dx
movzbl %al, %eax
cmovel %r8d, %eax
leal 0x1(%r9), %r10d
movb %al, (%rbx,%r9)
movzbl %r10b, %eax
movb $0x0, (%rbx,%rax)
decl %esi
movl %esi, %eax
xorl %edx, %edx
divw %di
movl %eax, %esi
jmp 0x230e8
testb %cl, %cl
je 0x2312e
movw $0x24, (%rbx,%r9)
movq %rbx, %rdi
callq 0xc4c0
leaq (%rax,%rbx), %rcx
decq %rcx
shrq %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x2315d
movb (%rbx,%rdx), %sil
movb (%rcx), %dil
movb %dil, (%rbx,%rdx)
movb %sil, (%rcx)
incq %rdx
decq %rcx
jmp 0x23142
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_rowcol_to_cell_abs
void
lxw_rowcol_to_cell_abs(char *cell_name, lxw_row_t row, lxw_col_t col,
                       uint8_t abs_row, uint8_t abs_col)
{
    size_t pos;

    /* Add the column to the cell. */
    lxw_col_to_name(cell_name, col, abs_col);

    /* Get the end of the cell. */
    pos = strlen(cell_name);

    if (abs_row)
        cell_name[pos++] = '$';

    /* Add the row to the cell. */
    lxw_snprintf(&cell_name[pos], LXW_MAX_ROW_NAME_LENGTH, "%d", ++row);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %edx, %esi
movl %r8d, %edx
callq 0xc5c0
movq %r14, %rdi
callq 0xc4c0
testl %ebp, %ebp
je 0x231c4
movb $0x24, (%r14,%rax)
incq %rax
addq %rax, %r14
incl %ebx
leaq 0x1f380(%rip), %rdx     # 0x42550
pushq $0x9
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xc5b0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_rowcol_to_range
void
lxw_rowcol_to_range(char *range,
                    lxw_row_t first_row, lxw_col_t first_col,
                    lxw_row_t last_row, lxw_col_t last_col)
{
    size_t pos;

    /* Add the first cell to the range. */
    lxw_rowcol_to_cell(range, first_row, first_col);

    /* If the start and end cells are the same just return a single cell. */
    if (first_row == last_row && first_col == last_col)
        return;

    /* Get the end of the cell. */
    pos = strlen(range);

    /* Add the range separator. */
    range[pos++] = ':';

    /* Add the first cell to the range. */
    lxw_rowcol_to_cell(&range[pos], last_row, last_col);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %ebx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0xca60
cmpl %ebx, %r12d
sete %al
cmpw %bp, %r15w
sete %cl
testb %cl, %al
je 0x23218
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc4c0
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x3a, -0x1(%rdi)
movzwl %bp, %edx
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xca60
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_rowcol_to_range_abs
void
lxw_rowcol_to_range_abs(char *range,
                        lxw_row_t first_row, lxw_col_t first_col,
                        lxw_row_t last_row, lxw_col_t last_col)
{
    size_t pos;

    /* Add the first cell to the range. */
    lxw_rowcol_to_cell_abs(range, first_row, first_col, 1, 1);

    /* If the start and end cells are the same just return a single cell. */
    if (first_row == last_row && first_col == last_col)
        return;

    /* Get the end of the cell. */
    pos = strlen(range);

    /* Add the range separator. */
    range[pos++] = ':';

    /* Add the first cell to the range. */
    lxw_rowcol_to_cell_abs(&range[pos], last_row, last_col, 1, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %ebx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
pushq $0x1
popq %rcx
movl %ecx, %r8d
callq 0xc620
cmpl %ebx, %r12d
sete %al
cmpw %bp, %r15w
sete %cl
testb %cl, %al
je 0x23278
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc4c0
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x3a, -0x1(%rdi)
movzwl %bp, %edx
pushq $0x1
popq %rcx
movl %ebx, %esi
movl %ecx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc620
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_rowcol_to_formula_abs
void
lxw_rowcol_to_formula_abs(char *formula, const char *sheetname,
                          lxw_row_t first_row, lxw_col_t first_col,
                          lxw_row_t last_row, lxw_col_t last_col)
{
    size_t pos;
    char *quoted_name = lxw_quote_sheetname(sheetname);

    strncpy(formula, quoted_name, LXW_MAX_FORMULA_RANGE_LENGTH - 1);
    free(quoted_name);

    /* Get the end of the sheetname. */
    pos = strlen(formula);

    /* Add the range separator. */
    formula[pos++] = '!';

    /* Add the first cell to the range. */
    lxw_rowcol_to_cell_abs(&formula[pos], first_row, first_col, 1, 1);

    /* If the start and end cells are the same just return a single cell. */
    if (first_row == last_row && first_col == last_col)
        return;

    /* Get the end of the cell. */
    pos = strlen(formula);

    /* Add the range separator. */
    formula[pos++] = ':';

    /* Add the first cell to the range. */
    lxw_rowcol_to_cell_abs(&formula[pos], last_row, last_col, 1, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %ebx
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
movq %rsi, %rdi
callq 0xc3b0
movq %rax, %r13
movl $0x9a, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xc190
movq %r13, %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc4c0
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x21, -0x1(%rdi)
pushq $0x1
popq %rcx
movl %r12d, %esi
movl %r15d, %edx
movl %ecx, %r8d
callq 0xc620
cmpl %ebx, %r12d
sete %al
cmpw %bp, %r15w
sete %cl
testb %cl, %al
je 0x23324
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc4c0
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x3a, -0x1(%rdi)
movzwl %bp, %edx
pushq $0x1
popq %rcx
movl %ebx, %esi
movl %ecx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc620
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_quote_sheetname
char *
lxw_quote_sheetname(const char *str)
{

    uint8_t needs_quoting = 0;
    size_t number_of_quotes = 2;
    size_t i, j;
    size_t len = strlen(str);

    /* Don't quote the sheetname if it is already quoted. */
    if (str[0] == '\'')
        return lxw_strdup(str);

    /* Check if the sheetname contains any characters that require it
     * to be quoted. Also check for single quotes within the string. */
    for (i = 0; i < len; i++) {
        if (!isalnum((unsigned char) str[i]) && str[i] != '_'
            && str[i] != '.')
            needs_quoting = 1;

        if (str[i] == '\'') {
            needs_quoting = 1;
            number_of_quotes++;
        }
    }

    if (!needs_quoting) {
        return lxw_strdup(str);
    }
    else {
        /* Add single quotes to the start and end of the string. */
        char *quoted_name = calloc(1, len + number_of_quotes + 1);
        RETURN_ON_MEM_ERROR(quoted_name, NULL);

        quoted_name[0] = '\'';

        for (i = 0, j = 1; i < len; i++, j++) {
            quoted_name[j] = str[i];

            /* Double quote inline single quotes. */
            if (str[i] == '\'') {
                quoted_name[++j] = '\'';
            }
        }
        quoted_name[j++] = '\'';
        quoted_name[j++] = '\0';

        return quoted_name;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xc4c0
cmpb $0x27, (%rbx)
je 0x2340b
movq %rax, %r14
pushq $0x2
popq %r15
xorl %r12d, %r12d
pushq $0x1
popq %rbp
xorl %r13d, %r13d
cmpq %r12, %r14
je 0x233c4
callq 0xd170
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
testb $0x8, (%rax,%rcx,2)
movzbl %r13b, %eax
movl %ebp, %r13d
cmovnel %eax, %r13d
cmpl $0x5f, %ecx
cmovel %eax, %r13d
cmpl $0x2e, %ecx
cmovel %eax, %r13d
xorl %eax, %eax
cmpl $0x27, %ecx
sete %al
cmovel %ebp, %r13d
addq %rax, %r15
incq %r12
jmp 0x23381
testb %r13b, %r13b
je 0x2340b
leaq (%r14,%r15), %rsi
incq %rsi
pushq $0x1
popq %r12
movq %r12, %rdi
callq 0xc850
testq %rax, %rax
je 0x2343a
movq %rax, %r15
movb $0x27, (%rax)
xorl %eax, %eax
cmpq %rax, %r14
je 0x23421
movb (%rbx,%rax), %cl
movb %cl, (%r15,%r12)
cmpb $0x27, %cl
jne 0x23403
movb $0x27, 0x1(%r15,%r12)
incq %r12
incq %rax
incq %r12
jmp 0x233e9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd50
movw $0x27, (%r15,%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2fbb7(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x19c95(%rip), %rsi     # 0x3d0e0
leaq 0x1ee2e(%rip), %rdx     # 0x42280
xorl %r15d, %r15d
movl $0x227, %ecx            # imm = 0x227
xorl %eax, %eax
callq 0xc8d0
jmp 0x23428
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_name_to_row
lxw_row_t
lxw_name_to_row(const char *row_str)
{
    lxw_row_t row_num = 0;
    const char *p = row_str;

    /* Skip the column letters and absolute symbol of the A1 cell. */
    while (p && !isdigit((unsigned char) *p))
        p++;

    /* Convert the row part of the A1 cell to a number. */
    if (p)
        row_num = atoi(p);

    if (row_num)
        return row_num - 1;
    else
        return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x23490
callq 0xd170
movq (%rax), %rax
movzbl (%rbx), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x23483
incq %rbx
jmp 0x23467
movq %rbx, %rdi
callq 0xcf00
subl $0x1, %eax
jae 0x23492
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_name_to_col
lxw_col_t
lxw_name_to_col(const char *col_str)
{
    lxw_col_t col_num = 0;
    const char *p = col_str;

    /* Convert leading column letters of A1 cell. Ignore absolute $ marker. */
    while (p && (isupper((unsigned char) *p) || *p == '$')) {
        if (*p != '$')
            col_num = (col_num * 26) + (*p - 'A' + 1);
        p++;
    }

    return col_num - 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x234d5
callq 0xd170
movzbl (%r14), %ecx
cmpl $0x24, %ecx
je 0x234be
movq (%rax), %rax
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
je 0x234d5
movsbl %cl, %eax
cwtl
imull $0x1a, %ebx, %ecx
cmpb $0x24, %al
leal -0x40(%rcx,%rax), %eax
cmovel %ebx, %eax
incq %r14
movl %eax, %ebx
jmp 0x2349d
decl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_unixtime_to_excel_date_epoch
double
lxw_unixtime_to_excel_date_epoch(int64_t unixtime, uint8_t date_1904)
{
    double excel_datetime = 0.0;
    double epoch = date_1904 ? 24107.0 : 25568.0;

    excel_datetime = epoch + (unixtime / (24 * 60 * 60.0));

    if (!date_1904 && excel_datetime >= 60.0)
        excel_datetime = excel_datetime + 1.0;

    return excel_datetime;
}

// Assembly:
cvtsi2sd %rdi, %xmm0
xorl %eax, %eax
divsd 0x1e609(%rip), %xmm0    # 0x41d28
testl %esi, %esi
sete %al
leaq 0x1e615(%rip), %rcx     # 0x41d40
addsd (%rcx,%rax,8), %xmm0
jne 0x2375b
movsd 0x1c316(%rip), %xmm1    # 0x3fa50
addsd %xmm0, %xmm1
movsd 0x1e5ea(%rip), %xmm2    # 0x41d30
cmplesd %xmm0, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_strdup
char *
lxw_strdup(const char *str)
{
    size_t len;
    char *copy;

    if (!str)
        return NULL;

    len = strlen(str) + 1;
    copy = malloc(len);

    if (copy)
        memcpy(copy, str, len);

    return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x23795
movq %rdi, %rbx
callq 0xc4c0
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0xcab0
testq %rax, %rax
je 0x23795
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc960
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_hash_password
uint16_t
lxw_hash_password(const char *password)
{
    uint16_t byte_count = (uint16_t) strlen(password);
    uint16_t hash = 0;
    const char *p = &password[byte_count];

    if (!byte_count)
        return hash;

    while (p-- != password) {
        hash = ((hash >> 14) & 0x01) | ((hash << 1) & 0x7fff);
        hash ^= *p & 0xFF;
    }

    hash = ((hash >> 14) & 0x01) | ((hash << 1) & 0x7fff);
    hash ^= byte_count;
    hash ^= 0xCE4B;

    return hash;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xc4c0
movq %rax, %rdx
andq $0xffff, %rdx           # imm = 0xFFFF
je 0x23888
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x2386f
movl %ecx, %esi
shrl $0xe, %esi
andl $0x1, %esi
andl $0x3fff, %ecx           # imm = 0x3FFF
leal (%rsi,%rcx,2), %esi
movzbl -0x1(%rbx,%rdx), %ecx
xorl %esi, %ecx
decq %rdx
jmp 0x2384d
movzwl %cx, %edx
shrl $0xe, %edx
addl %ecx, %ecx
andl $0x7ffe, %ecx           # imm = 0x7FFE
orl %edx, %ecx
xorl %ecx, %eax
xorl $0xce4b, %eax           # imm = 0xCE4B
jmp 0x2388a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/vml.c
// Function: vml_write_stroke
STATIC void
_vml_write_stroke(lxw_vml *self)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("joinstyle", "miter");

    lxw_xml_empty_tag(self->file, "v:stroke", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1cc53(%rip), %rdi     # 0x42385
leaq 0x1cc56(%rip), %rsi     # 0x4238f
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1cc33(%rip), %rsi     # 0x42395
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25791
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x2578a
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x2576a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/vml.c
// Function: vml_write_rotation_lock
STATIC void
_vml_write_rotation_lock(lxw_vml *self)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("v:ext", "edit");
    LXW_PUSH_ATTRIBUTES_STR("rotation", "t");

    lxw_xml_empty_tag(self->file, "o:lock", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsp, %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1cb77(%rip), %rdi     # 0x4232e
leaq 0x1cb76(%rip), %rsi     # 0x42334
callq 0xc030
movl $0x1040, %r15d          # imm = 0x1040
andq $0x0, 0x1040(%rax)
leaq (%rax,%r15), %rcx
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
leaq 0x1ccd4(%rip), %rdi     # 0x424bb
leaq 0x18a9b(%rip), %rsi     # 0x3e289
callq 0xc030
addq %rax, %r15
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r15, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1cbc7(%rip), %rsi     # 0x423da
movq %rbx, %rdx
callq 0xcc70
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25840
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x25839
movq %rbx, 0x8(%rsp)
callq 0xc0d0
jmp 0x2581b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/vml.c
// Function: vml_write_anchor
STATIC void
_vml_write_anchor(lxw_vml *self, lxw_vml_obj *vml_obj)
{
    char anchor_data[LXW_MAX_ATTRIBUTE_LENGTH];

    lxw_snprintf(anchor_data,
                 LXW_MAX_ATTRIBUTE_LENGTH,
                 "%d, %d, %d, %d, %d, %d, %d, %d",
                 vml_obj->from.col,
                 (uint32_t) vml_obj->from.col_offset,
                 vml_obj->from.row,
                 (uint32_t) vml_obj->from.row_offset,
                 vml_obj->to.col,
                 (uint32_t) vml_obj->to.col_offset,
                 vml_obj->to.row, (uint32_t) vml_obj->to.row_offset);

    lxw_xml_data_element(self->file, "x:Anchor", anchor_data, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x820, %rsp            # imm = 0x820
movq %rdi, %rbx
cvttsd2si 0x60(%rsi), %r8
movl 0x58(%rsi), %ecx
movl 0x5c(%rsi), %r9d
cvttsd2si 0x68(%rsi), %r10
movl 0x70(%rsi), %r11d
cvttsd2si 0x78(%rsi), %r15
movl 0x74(%rsi), %r12d
cvttsd2si 0x80(%rsi), %r13
subq $0x8, %rsp
leaq 0x1cca2(%rip), %rdx     # 0x42534
leaq 0x8(%rsp), %r14
movl $0x820, %esi            # imm = 0x820
movq %r14, %rdi
xorl %eax, %eax
pushq %r13
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0xc5b0
addq $0x30, %rsp
movq (%rbx), %rdi
leaq 0x1cc95(%rip), %rsi     # 0x42553
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcba0
addq $0x820, %rsp            # imm = 0x820
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/vml.c
// Function: vml_write_comment_path
STATIC void
_vml_write_comment_path(lxw_vml *self, uint8_t has_gradient, char *type)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();

    if (has_gradient)
        LXW_PUSH_ATTRIBUTES_STR("gradientshapeok", "t");

    LXW_PUSH_ATTRIBUTES_STR("o:connecttype", type);

    lxw_xml_empty_tag(self->file, "v:path", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsp, %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
movq %rbx, 0x8(%rbx)
testl %esi, %esi
je 0x2593e
leaq 0x1cc92(%rip), %rdi     # 0x425a8
leaq 0x1896c(%rip), %rsi     # 0x3e289
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq 0x1040(%rax), %rcx
movq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rsp)
leaq 0x1ca80(%rip), %rdi     # 0x423c5
movq %r15, %rsi
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rsp)
movq (%r14), %rdi
leaq 0x1ca60(%rip), %rsi     # 0x423d3
movq %rbx, %rdx
callq 0xcc70
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x259a0
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x25999
movq %rbx, 0x8(%rsp)
callq 0xc0d0
jmp 0x2597b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/vml.c
// Function: vml_write_formula
STATIC void
_vml_write_formula(lxw_vml *self, char *equation)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("eqn", equation);

    lxw_xml_empty_tag(self->file, "v:f", &attributes);

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1cde0(%rip), %rdi     # 0x427a8
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1cdbb(%rip), %rsi     # 0x427ac
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25a20
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x25a19
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x259f9
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: free_doc_properties
STATIC void
_free_doc_properties(lxw_doc_properties *properties)
{
    if (properties) {
        free((void *) properties->title);
        free((void *) properties->subject);
        free((void *) properties->author);
        free((void *) properties->manager);
        free((void *) properties->company);
        free((void *) properties->category);
        free((void *) properties->keywords);
        free((void *) properties->comments);
        free((void *) properties->status);
        free((void *) properties->hyperlink_base);
    }

    free(properties);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x26651
movq (%rbx), %rdi
callq 0xc0d0
movq 0x8(%rbx), %rdi
callq 0xc0d0
movq 0x10(%rbx), %rdi
callq 0xc0d0
movq 0x18(%rbx), %rdi
callq 0xc0d0
movq 0x20(%rbx), %rdi
callq 0xc0d0
movq 0x28(%rbx), %rdi
callq 0xc0d0
movq 0x30(%rbx), %rdi
callq 0xc0d0
movq 0x38(%rbx), %rdi
callq 0xc0d0
movq 0x40(%rbx), %rdi
callq 0xc0d0
movq 0x48(%rbx), %rdi
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
jmp 0xc0d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: lxw_workbook_set_default_xf_indices
void
lxw_workbook_set_default_xf_indices(lxw_workbook *self)
{
    lxw_format *format;
    int32_t index = 0;

    STAILQ_FOREACH(format, self->formats, list_pointers) {

        /* Skip the hyperlink format. */
        if (index != 1)
            lxw_format_get_xf_index(format);

        index++;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x58(%rdi), %rbx
pushq $0x1
popq %rbp
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x26a82
subl $0x1, %ebp
jb 0x26a79
movq %rbx, %rdi
callq 0xca20
addq $0x230, %rbx            # imm = 0x230
jmp 0x26a64
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_add_format
lxw_format *
workbook_add_format(lxw_workbook *self)
{
    /* Create a new format object. */
    lxw_format *format = lxw_format_new();
    RETURN_ON_MEM_ERROR(format, NULL);

    if (!STAILQ_EMPTY(self->formats)) {
        memcpy(format, STAILQ_FIRST(self->formats), sizeof(lxw_format));
        format->xf_format_indices = NULL;
        format->num_xf_formats = NULL;
        format->list_pointers.stqe_next = NULL;
        format->xf_index = LXW_PROPERTY_UNSET;
        format->dxf_index = LXW_PROPERTY_UNSET;
    }

    format->xf_format_indices = self->used_xf_formats;
    format->dxf_format_indices = self->used_dxf_formats;
    format->num_xf_formats = &self->num_xf_formats;

    STAILQ_INSERT_TAIL(self->formats, format, list_pointers);

    return format;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xcdc0
movq %rax, %rbx
testq %rax, %rax
je 0x27dcd
movq 0x58(%r14), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x27d8a
movl $0x238, %edx            # imm = 0x238
movq %rbx, %rdi
callq 0xc960
orq $-0x1, 0x28(%rbx)
movq 0x58(%r14), %rax
movups 0xd8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0xba(%r14), %rcx
movq %rcx, 0x18(%rbx)
movq %rbx, %rcx
addq $0x230, %rcx            # imm = 0x230
andq $0x0, 0x230(%rbx)
movq 0x8(%rax), %rax
movq %rbx, (%rax)
movq 0x58(%r14), %rax
movq %rcx, 0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2b224(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x15302(%rip), %rsi     # 0x3d0e0
leaq 0x1ab6c(%rip), %rdx     # 0x42951
movl $0x82b, %ecx            # imm = 0x82B
xorl %eax, %eax
callq 0xc8d0
jmp 0x27dc2
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_validate_sheet_name
lxw_error
workbook_validate_sheet_name(lxw_workbook *self, const char *sheetname)
{
    /* Check the UTF-8 length of the worksheet name. */
    if (lxw_utf8_strlen(sheetname) > LXW_SHEETNAME_MAX)
        return LXW_ERROR_SHEETNAME_LENGTH_EXCEEDED;

    /* Check that the worksheet name doesn't contain invalid characters. */
    if (strpbrk(sheetname, "[]:*?/\\"))
        return LXW_ERROR_INVALID_SHEETNAME_CHARACTER;

    /* Check that the worksheet doesn't start or end with an apostrophe. */
    if (sheetname[0] == '\'' || sheetname[strlen(sheetname) - 1] == '\'')
        return LXW_ERROR_SHEETNAME_START_END_APOSTROPHE;

    /* Check if the worksheet name is already in use. */
    if (workbook_get_worksheet_by_name(self, sheetname))
        return LXW_ERROR_SHEETNAME_ALREADY_USED;

    /* Check if the chartsheet name is already in use. */
    if (workbook_get_chartsheet_by_name(self, sheetname))
        return LXW_ERROR_SHEETNAME_ALREADY_USED;

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xd150
cmpq $0x1f, %rax
jbe 0x282c7
pushq $0xe
jmp 0x282dd
leaq 0x1aee8(%rip), %rsi     # 0x431b6
movq %rbx, %rdi
callq 0xcb80
testq %rax, %rax
je 0x282e5
pushq $0xf
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rbp
cmpb $0x27, (%rbx)
je 0x282de
movq %rbx, %rdi
callq 0xc4c0
cmpb $0x27, -0x1(%rbx,%rax)
je 0x282de
movq %r14, %rdi
movq %rbx, %rsi
callq 0xca80
testq %rax, %rax
je 0x28310
pushq $0x11
jmp 0x282dd
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcef0
xorl %ecx, %ecx
testq %rax, %rax
pushq $0x11
popq %rbp
cmovel %ecx, %ebp
jmp 0x282de
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_add_chart
lxw_chart *
workbook_add_chart(lxw_workbook *self, uint8_t type)
{
    lxw_chart *chart;

    /* Create a new chart object. */
    chart = lxw_chart_new(type);

    if (chart)
        STAILQ_INSERT_TAIL(self->charts, chart, list_pointers);

    return chart;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
callq 0xc7f0
testq %rax, %rax
je 0x287fc
movq %rax, %rcx
addq $0x178, %rcx            # imm = 0x178
andq $0x0, 0x178(%rax)
movq 0x48(%rbx), %rdx
movq 0x8(%rdx), %rdx
movq %rax, (%rdx)
movq 0x48(%rbx), %rdx
movq %rcx, 0x8(%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_set_vba_name
lxw_error
workbook_set_vba_name(lxw_workbook *self, const char *name)
{
    if (!name) {
        LXW_WARN("workbook_set_vba_name(): " "name must be specified.");
        return LXW_ERROR_NULL_PARAMETER_IGNORED;
    }

    self->vba_codename = lxw_strdup(name);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x294f8
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xcd50
movq %rax, 0xf8(%rbx)
xorl %eax, %eax
popq %rbx
retq
movq 0x29af9(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x19e15(%rip), %rdi     # 0x4331e
pushq $0x3c
popq %rsi
pushq $0x1
popq %rdx
callq 0xd000
pushq $0xc
popq %rax
jmp 0x294f6
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_set_custom_property_number
lxw_error
workbook_set_custom_property_number(lxw_workbook *self, const char *name,
                                    double value)
{
    lxw_custom_property *custom_property;

    if (!name) {
        LXW_WARN_FORMAT("workbook_set_custom_property_number(): parameter "
                        "'name' cannot be NULL.");
        return LXW_ERROR_NULL_PARAMETER_IGNORED;
    }

    if (lxw_utf8_strlen(name) > 255) {
        LXW_WARN_FORMAT("workbook_set_custom_property_number(): parameter "
                        "'name' exceeds Excel length limit of 255.");
        return LXW_ERROR_255_STRING_LENGTH_EXCEEDED;
    }

    /* Create a struct to hold the custom property. */
    custom_property = calloc(1, sizeof(struct lxw_custom_property));
    RETURN_ON_MEM_ERROR(custom_property, LXW_ERROR_MEMORY_MALLOC_FAILED);

    custom_property->name = lxw_strdup(name);
    custom_property->u.number = value;
    custom_property->type = LXW_CUSTOM_DOUBLE;

    STAILQ_INSERT_TAIL(self->custom_properties, custom_property,
                       list_pointers);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x29c10
movq %rsi, %r14
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdi
callq 0xd150
cmpq $0x100, %rax            # imm = 0x100
jae 0x29c30
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x29c50
movq %rax, %r15
movq %r14, %rdi
callq 0xcd50
movq %rax, 0x8(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%r15)
movl $0x2, (%r15)
movq %r15, %rax
addq $0x30, %rax
movq 0x78(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r15, (%rcx)
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x293e1(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x19247(%rip), %rdi     # 0x42e68
pushq $0x53
popq %rsi
pushq $0x1
popq %rdx
callq 0xd000
pushq $0xc
jmp 0x29c76
movq 0x293c1(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x1927b(%rip), %rdi     # 0x42ebc
pushq $0x66
popq %rsi
pushq $0x1
popq %rdx
callq 0xd000
pushq $0x14
jmp 0x29c76
movq 0x293a1(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1347f(%rip), %rsi     # 0x3d0e0
leaq 0x18ce9(%rip), %rdx     # 0x42951
movl $0x981, %ecx            # imm = 0x981
xorl %eax, %eax
callq 0xc8d0
pushq $0x1
popq %rax
jmp 0x29c06