LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x19c01
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x19c05
movq %rax, 0x8(%rax)
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x19c09
movq %rax, 0x8(%rax)
leaq 0x263cb(%rip), %rsi     # 0x3ff4a
leaq 0x2531e(%rip), %rdx     # 0x3eea4
movq %rbx, %rdi
callq 0xc4d0
leaq 0x257ee(%rip), %rsi     # 0x3f383
leaq 0x25341(%rip), %rdx     # 0x3eedd
movq %rbx, %rdi
callq 0xc4d0
leaq 0x25342(%rip), %rsi     # 0x3eeed
leaq 0x2534d(%rip), %rdx     # 0x3eeff
movq %rbx, %rdi
callq 0xcd10
leaq 0x25384(%rip), %rsi     # 0x3ef45
leaq 0x25390(%rip), %rdx     # 0x3ef58
movq %rbx, %rdi
callq 0xcd10
leaq 0x253bc(%rip), %rsi     # 0x3ef93
leaq 0x253c4(%rip), %rdx     # 0x3efa2
movq %rbx, %rdi
callq 0xcd10
leaq 0x253fc(%rip), %rsi     # 0x3efe9
leaq 0x2540a(%rip), %rdx     # 0x3effe
movq %rbx, %rdi
callq 0xcd10
movq %rbx, %rax
popq %rbx
retq
pushq $0x1f
jmp 0x19c0b
pushq $0x22
jmp 0x19c0b
pushq $0x26
popq %rcx
movq 0x393e5(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x234c3(%rip), %rsi     # 0x3d0e0
leaq 0x25270(%rip), %rdx     # 0x3ee94
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xcde0
xorl %ebx, %ebx
jmp 0x19bfc
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x19ca9
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x19cb5
movq %rax, %rbx
movq %r15, %rdi
callq 0xcd50
movq %rax, %r15
movq %rax, (%rbx)
testq %rax, %rax
je 0x19ce4
movq %r12, %rdi
callq 0xcd50
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x19ceb
movq %rbx, %rax
addq $0x10, %rax
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
movq 0x3933c(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2341a(%rip), %rsi     # 0x3d0e0
leaq 0x251c7(%rip), %rdx     # 0x3ee94
movl $0xea, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc8d0
movl $0xed, %ecx
jmp 0x19cf0
movl $0xf0, %ecx
movq 0x39301(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x233df(%rip), %rsi     # 0x3d0e0
leaq 0x2518c(%rip), %rdx     # 0x3ee94
xorl %eax, %eax
callq 0xc8d0
movq %r15, %rdi
callq 0xc0d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc0d0
// File: /workspace/github_c_makefile_star2_O2/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 0x19ec6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x19e65
jmp 0x19e72
movq 0x10(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x19e48
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0d0
movq 0x8(%r14), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq 0x8(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x19e38
callq 0xc0d0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x19eaa
jmp 0x19eb7
movq 0x10(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x19e8d
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0d0
movq 0x8(%r14), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq 0x10(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x19e7d
callq 0xc0d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc0d0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcfb0
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %r14, 0x8(%r14)
leaq 0x2321d(%rip), %rdi     # 0x3d111
leaq 0x2548c(%rip), %rsi     # 0x3f387
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
movq (%rbx), %rdi
leaq 0x25bbf(%rip), %rsi     # 0x3fae3
movq %r14, %rdx
callq 0xc380
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19f53
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x19f4c
movq %r14, 0x10(%rsp)
callq 0xc0d0
jmp 0x19f2c
movq 0x8(%rbx), %r15
movl $0x1040, %r12d          # imm = 0x1040
leaq 0x25476(%rip), %r13     # 0x3f3da
movq (%r15), %r15
testq %r15, %r15
je 0x1a00d
movq (%r15), %rsi
movq 0x8(%r15), %rbp
andq $0x0, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x2543b(%rip), %rdi     # 0x3f3c4
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq (%rax,%r12), %rcx
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x25420(%rip), %rdi     # 0x3f3ce
movq %rbp, %rsi
callq 0xc030
leaq (%rax,%r12), %rcx
andq $0x0, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
movq (%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a004
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x19ffd
movq %r14, 0x10(%rsp)
callq 0xc0d0
jmp 0x19fdd
addq $0x10, %r15
jmp 0x19f64
movq 0x10(%rbx), %r15
movl $0x1040, %r12d          # imm = 0x1040
leaq 0x253cd(%rip), %r13     # 0x3f3eb
movq (%r15), %r15
testq %r15, %r15
je 0x1a0c7
movq (%r15), %rsi
movq 0x8(%r15), %rbp
andq $0x0, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x2539f(%rip), %rdi     # 0x3f3e2
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq (%rax,%r12), %rcx
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x25366(%rip), %rdi     # 0x3f3ce
movq %rbp, %rsi
callq 0xc030
leaq (%rax,%r12), %rcx
andq $0x0, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
movq (%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a0be
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1a0b7
movq %r14, 0x10(%rsp)
callq 0xc0d0
jmp 0x1a097
addq $0x10, %r15
jmp 0x1a01e
movq (%rbx), %rdi
leaq 0x25a12(%rip), %rsi     # 0x3fae3
callq 0xc060
addq $0x18, %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/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 0xca10
movq %rax, (%rsp)
cmpq $0x0, (%r14)
je 0x1a544
movq %r14, %rdi
jmp 0x1a547
movq %rsp, %rdi
callq 0xce90
leaq 0x25031(%rip), %rdx     # 0x3f584
pushq $0x1f
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
callq 0xcd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x1a901
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1a905
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
pushq $0x22
jmp 0x1a907
pushq $0x25
popq %rcx
movq 0x386e9(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x227c7(%rip), %rsi     # 0x3d0e0
leaq 0x24d97(%rip), %rdx     # 0x3f6b7
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xc6d0
xorl %ebx, %ebx
jmp 0x1a8fc
// File: /workspace/github_c_makefile_star2_O2/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 0x1a979
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x1a963
jmp 0x1a970
movq 0x78(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x1a957
movq %rdi, 0x8(%rdi)
movq %rax, %rdi
callq 0xcd30
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
jne 0x1a947
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
jmp 0xc0d0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a99e
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xc0d0
movq 0x68(%rbx), %rdi
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
jmp 0xc0d0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl (%rsi), %ecx
leaq 0x24099(%rip), %r15     # 0x3f707
leaq 0x5(%rsp), %r14
pushq $0xb
popq %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc5b0
movq (%rbx), %rdi
leaq 0x24079(%rip), %rsi     # 0x3f70a
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcba0
cvttsd2si 0x8(%r12), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc5b0
movq (%rbx), %rdi
leaq 0x24056(%rip), %rsi     # 0x3f712
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcba0
movl 0x4(%r12), %ecx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc5b0
movq (%rbx), %rdi
leaq 0x24038(%rip), %rsi     # 0x3f71d
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcba0
cvttsd2si 0x10(%r12), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc5b0
movq (%rbx), %rdi
leaq 0x24015(%rip), %rsi     # 0x3f725
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcba0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x23c43(%rip), %rdi     # 0x3f7f6
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 0x23bed(%rip), %rsi     # 0x3f7c9
movq %rbx, %rdx
callq 0xc380
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc0b
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1bc04
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x1bbe4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x2aae3(%rip), %rdi     # 0x46719
xorl %esi, %esi
callq 0xc1a0
movl $0x1040, %r15d          # imm = 0x1040
leaq (%rax,%r15), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movslq %ebp, %rsi
leaq 0x238f6(%rip), %rdi     # 0x3f55a
callq 0xc1a0
addq %rax, %r15
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r15, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x23ce7(%rip), %rsi     # 0x3f970
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1bcb8
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1bcb1
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x1bc91
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movl %edx, %ebp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
movq %rbx, 0x8(%rbx)
movl %esi, %esi
leaq 0x23bac(%rip), %rdi     # 0x3f894
callq 0xc1a0
movl $0x1040, %r15d          # imm = 0x1040
leaq (%rax,%r15), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movl %ebp, %esi
leaq 0x23b84(%rip), %rdi     # 0x3f897
callq 0xc1a0
addq %rax, %r15
andq $0x0, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r15, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x23c40(%rip), %rsi     # 0x3f978
movq %rbx, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd67
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1bd60
movq %rbx, 0x10(%rsp)
callq 0xc0d0
jmp 0x1bd40
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
movl $0x98, %esi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x1be75
leaq 0xb4(%r14), %rsi
pushq $0x7f
popq %rdx
movq %rbx, %rdi
callq 0xc190
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)
movq 0x1d1(%r14), %rax
movq %rax, 0x8c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3717c(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2125a(%rip), %rsi     # 0x3d0e0
leaq 0x23bd3(%rip), %rdx     # 0x3fa60
movl $0xad, %ecx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1be6a
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x1c
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x1bef3
movb 0x210(%r14), %al
movb %al, 0x4(%rbx)
movb 0x211(%r14), %al
movb %al, 0x5(%rbx)
movl 0x20c(%r14), %eax
movl %eax, (%rbx)
movl 0x224(%r14), %eax
movl %eax, 0x18(%rbx)
movups 0x214(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x370fe(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x211dc(%rip), %rsi     # 0x3d0e0
leaq 0x23b55(%rip), %rdx     # 0x3fa60
movl $0xcc, %ecx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1bee8
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0xc
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x1bf52
movq 0x1e4(%r14), %rax
movq %rax, (%rbx)
movb 0x1f4(%r14), %al
movb %al, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3709f(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2117d(%rip), %rsi     # 0x3d0e0
leaq 0x23af6(%rip), %rdx     # 0x3fa60
movl $0xe7, %ecx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1bf47
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
movl $0x238, %esi            # imm = 0x238
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x1c03b
movl $0x230, %edx            # imm = 0x230
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc960
andq $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
movq 0x36fb6(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x21094(%rip), %rsi     # 0x3d0e0
leaq 0x23a0d(%rip), %rdx     # 0x3fa60
movl $0x95, %ecx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1c030
// File: /workspace/github_c_makefile_star2_O2/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
cmpw $0x10e, %si             # imm = 0x10E
je 0x1c1ed
leal 0x5a(%rsi), %eax
cmpw $0xb4, %ax
ja 0x1c1f6
pushq $0x5a
popq %rax
subl %esi, %eax
testw %si, %si
cmovnsl %esi, %eax
movw %ax, 0x1e2(%rbx)
popq %rbx
retq
movq 0x36dfb(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x23862(%rip), %rdi     # 0x3fa69
pushq $0x40
popq %rsi
pushq $0x1
popq %rdx
callq 0xd000
xorl %eax, %eax
jmp 0x1c1ed
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r15
movl (%rdi), %edx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x1c3e0
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x1c3d4
movq (%r15), %r15
testq %r15, %r15
je 0x1c3d4
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcb60
testl %eax, %eax
je 0x1c3d7
addq $0x18, %r15
jmp 0x1c3b4
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/hash_table.c
// Function: generate_hash_key
STATIC size_t
_generate_hash_key(void *data, size_t data_len, size_t num_buckets)
{
    unsigned char *p = data;
    size_t hash = 2166136261U;
    size_t i;

    for (i = 0; i < data_len; i++)
        hash = (hash * 16777619) ^ p[i];

    return hash % num_buckets;
}

// Assembly:
movq %rdx, %rcx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x1c402
imulq $0x1000193, %rax, %r8   # imm = 0x1000193
movzbl (%rdi,%rdx), %eax
xorq %r8, %rax
incq %rdx
jmp 0x1c3ea
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x1c60b
movq %rax, %rbx
movb %r15b, 0xc(%rax)
movb %r14b, 0xd(%rax)
movl %ebp, %edi
pushq $0x8
popq %rsi
callq 0xc850
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1c633
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1c63a
movq %rax, 0x8(%rax)
movl %ebp, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x369e6(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x20ac4(%rip), %rsi     # 0x3d0e0
leaq 0x23487(%rip), %rdx     # 0x3faaa
xorl %ebx, %ebx
movl $0xa3, %ecx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1c5fd
movl $0xab, %ecx
jmp 0x1c63f
movl $0xaf, %ecx
movq 0x369b2(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x20a90(%rip), %rsi     # 0x3d0e0
leaq 0x23453(%rip), %rdx     # 0x3faaa
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xd0b0
xorl %ebx, %ebx
jmp 0x1c5fd
// File: /workspace/github_c_makefile_star2_O2/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 0x1c6f5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1c6ba
movq (%rax), %r14
testq %r14, %r14
je 0x1c6ba
movq 0x10(%r14), %r15
cmpb $0x0, 0xc(%rbx)
je 0x1c69e
movq (%r14), %rdi
callq 0xc0d0
cmpb $0x0, 0xd(%rbx)
je 0x1c6ad
movq 0x8(%r14), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq %r15, %r14
jmp 0x1c687
xorl %r14d, %r14d
movl (%rbx), %eax
cmpq %rax, %r14
jae 0x1c6d6
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xc0d0
incq %r14
jmp 0x1c6bd
movq 0x10(%rbx), %rdi
callq 0xc0d0
movq 0x18(%rbx), %rdi
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc0d0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xcac0
testl %eax, %eax
je 0x1cfe7
movq %rbx, %rdi
callq 0xc450
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x68(%r14)
je 0x1cffb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc450
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcbb0
testl %eax, %eax
jne 0x1cfd6
movq %rbx, %rdi
callq 0xc8e0
cmpq $-0x1, %rax
je 0x1cfd6
movq %rax, %r15
movq %rax, %rdi
callq 0xcab0
movq %rax, 0x68(%r14)
testq %rax, %rax
je 0x1d053
movq %rbx, %rdi
callq 0xc540
movq 0x68(%r14), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq 0xc310
testq %rax, %rax
je 0x1cfd6
movq %r15, 0x18(%r14)
jmp 0x1cfee
movq 0x35f9e(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2007c(%rip), %rsi     # 0x3d0e0
leaq 0x22bf5(%rip), %rdx     # 0x3fc60
movl $0x99, %ecx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1cfd6
// File: /workspace/github_c_makefile_star2_O2/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 0x1d0a0
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xc0d0
movq 0x58(%rbx), %rdi
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
jmp 0xc0d0
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/packager.c
// Function: add_to_zip
STATIC lxw_error
_add_to_zip(lxw_packager *self, FILE * file, char **buffer,
            size_t *buffer_size, const char *filename)
{
    /* Flush to ensure buffer is updated when using a memory-backed file. */
    fflush(file);
    return *buffer ?
        _add_buffer_to_zip(self, *buffer, *buffer_size, filename) :
        _add_file_to_zip(self, file, filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
callq 0xcac0
movq (%r13), %rsi
testq %rsi, %rsi
je 0x1f31a
movq (%r14), %rdx
movq %r15, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f331
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f4a1
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/relationships.c
// Function: lxw_relationships_new
lxw_relationships *
lxw_relationships_new(void)
{
    lxw_relationships *rels = calloc(1, sizeof(lxw_relationships));
    GOTO_LABEL_ON_MEM_ERROR(rels, mem_error);

    rels->relationships = calloc(1, sizeof(struct lxw_rel_tuples));
    GOTO_LABEL_ON_MEM_ERROR(rels->relationships, mem_error);
    STAILQ_INIT(rels->relationships);

    return rels;

mem_error:
    lxw_free_relationships(rels);
    return NULL;
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x1f739
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1f73d
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
pushq $0x20
jmp 0x1f73f
pushq $0x23
popq %rcx
movq 0x338b1(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1d98f(%rip), %rsi     # 0x3d0e0
leaq 0x20ab1(%rip), %rdx     # 0x40209
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xc2b0
xorl %ebx, %ebx
jmp 0x1f734
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/relationships.c
// Function: lxw_free_relationships
void
lxw_free_relationships(lxw_relationships *rels)
{
    lxw_rel_tuple *relationship;

    if (!rels)
        return;

    if (rels->relationships) {
        while (!STAILQ_EMPTY(rels->relationships)) {
            relationship = STAILQ_FIRST(rels->relationships);
            STAILQ_REMOVE_HEAD(rels->relationships, list_pointers);
            free(relationship->type);
            free(relationship->target);
            free(relationship->target_mode);
            free(relationship);
        }

        free(rels->relationships);
    }

    free(rels);
}

// Assembly:
testq %rdi, %rdi
je 0x1f7d4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x1f7b8
jmp 0x1f7c5
movq 0x18(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x1f792
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0d0
movq 0x8(%r14), %rdi
callq 0xc0d0
movq 0x10(%r14), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq 0x10(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x1f782
callq 0xc0d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc0d0
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/relationships.c
// Function: lxw_relationships_assemble_xml_file
void
lxw_relationships_assemble_xml_file(lxw_relationships *self)
{
    /* Write the XML declaration. */
    _relationships_xml_declaration(self);

    _write_relationships(self);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x858, %rsp            # imm = 0x858
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xcfb0
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
movq %r14, 0x8(%r14)
leaq 0x1d90c(%rip), %rdi     # 0x3d111
leaq 0x20a5f(%rip), %rsi     # 0x4026b
callq 0xc030
leaq 0x1040(%rax), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
movq (%rbx), %rdi
leaq 0x209e4(%rip), %rsi     # 0x40219
movq %r14, %rdx
callq 0xc380
movq %rbx, 0x18(%rsp)
movq 0x10(%rbx), %r15
leaq 0x8(%rsp), %rbp
movq (%r15), %r15
testq %r15, %r15
je 0x1f996
movq (%r15), %r14
movq 0x8(%r15), %r13
movq 0x10(%r15), %r12
movl $0x820, %edx            # imm = 0x820
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc690
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
incl %ecx
movl %ecx, 0x8(%rax)
movq %rbx, %rdi
pushq $0x20
popq %rsi
leaq 0x1fee9(%rip), %rdx     # 0x3f779
xorl %eax, %eax
callq 0xc5b0
andq $0x0, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
leaq 0x23c04(%rip), %rdi     # 0x434ad
movq %rbx, %rsi
callq 0xc030
andq $0x0, 0x1040(%rax)
movl $0x1040, %ebx           # imm = 0x1040
leaq (%rax,%rbx), %rcx
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x2029f(%rip), %rdi     # 0x3fb75
movq %r14, %rsi
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq (%rax,%rbx), %rcx
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x209e1(%rip), %rdi     # 0x402df
movq %r13, %rsi
callq 0xc030
leaq (%rax,%rbx), %rcx
andq $0x0, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
testq %r12, %r12
je 0x1f94f
leaq 0x209bb(%rip), %rdi     # 0x402e6
movq %r12, %rsi
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq 0x1040(%rax), %rcx
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x20993(%rip), %rsi     # 0x402f1
movq %rbp, %rdx
callq 0xcc70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1f98d
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1f986
movq %rbp, 0x10(%rsp)
callq 0xc0d0
jmp 0x1f966
addq $0x18, %r15
jmp 0x1f84b
leaq 0x20(%rsp), %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1f9c2
movq 0x1040(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
jne 0x1f9bb
movq %r14, 0x28(%rsp)
callq 0xc0d0
jmp 0x1f99b
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x20848(%rip), %rsi     # 0x40219
callq 0xc060
addq $0x858, %rsp            # imm = 0x858
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/relationships.c
// Function: add_relationship
STATIC void
_add_relationship(lxw_relationships *self, const char *schema,
                  const char *type, const char *target,
                  const char *target_mode)
{
    lxw_rel_tuple *relationship;

    if (!schema || !type || !target)
        return;

    relationship = calloc(1, sizeof(lxw_rel_tuple));
    GOTO_LABEL_ON_MEM_ERROR(relationship, mem_error);

    relationship->type = calloc(1, LXW_MAX_ATTRIBUTE_LENGTH);
    GOTO_LABEL_ON_MEM_ERROR(relationship->type, mem_error);

    /* Add the schema to the relationship type. */
    lxw_snprintf(relationship->type, LXW_MAX_ATTRIBUTE_LENGTH, "%s%s",
                 schema, type);

    relationship->target = lxw_strdup(target);
    GOTO_LABEL_ON_MEM_ERROR(relationship->target, mem_error);

    if (target_mode) {
        relationship->target_mode = lxw_strdup(target_mode);
        GOTO_LABEL_ON_MEM_ERROR(relationship->target_mode, mem_error);
    }

    STAILQ_INSERT_TAIL(self->relationships, relationship, list_pointers);

    return;

mem_error:
    if (relationship) {
        free(relationship->type);
        free(relationship->target);
        free(relationship->target_mode);
        free(relationship);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
testq %r13, %r13
sete %al
orb %cl, %al
jne 0x1facb
movq %r8, %r12
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x1fada
movq %rax, %rbx
movq %r15, (%rsp)
pushq $0x1
popq %rdi
movl $0x820, %esi            # imm = 0x820
callq 0xc850
movq %rax, %r15
movq %rax, (%rbx)
testq %rax, %rax
je 0x1fb0c
leaq 0x1d61a(%rip), %rdx     # 0x3d088
movl $0x820, %esi            # imm = 0x820
movq %r15, %rdi
movq %r14, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0xc5b0
movq %r13, %rdi
callq 0xcd50
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1fb13
testq %r12, %r12
je 0x1faad
movq %rax, %r14
movq %r12, %rdi
callq 0xcd50
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1fb1d
movq %rbx, %rax
addq $0x18, %rax
movq (%rsp), %rdx
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, (%rcx)
movq 0x10(%rdx), %rcx
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x33517(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1d5f5(%rip), %rsi     # 0x3d0e0
leaq 0x20717(%rip), %rdx     # 0x40209
movl $0xab, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc8d0
movl $0xae, %ecx
jmp 0x1fb18
movl $0xb5, %ecx
xorl %r14d, %r14d
jmp 0x1fb22
movl $0xb9, %ecx
movq 0x334cf(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1d5ad(%rip), %rsi     # 0x3d0e0
leaq 0x206cf(%rip), %rdx     # 0x40209
xorl %eax, %eax
callq 0xc8d0
movq %r15, %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc0d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/shared_strings.c
// Function: lxw_sst_new
lxw_sst *
lxw_sst_new(void)
{
    /* Create the new shared string table. */
    lxw_sst *sst = calloc(1, sizeof(lxw_sst));
    RETURN_ON_MEM_ERROR(sst, NULL);

    /* Add the sst RB tree. */
    sst->rb_tree = calloc(1, sizeof(struct sst_rb_tree));
    GOTO_LABEL_ON_MEM_ERROR(sst->rb_tree, mem_error);

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

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

    /* Initialize the RB tree. */
    RB_INIT(sst->rb_tree);

    return sst;

mem_error:
    lxw_sst_free(sst);
    return NULL;
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x1fbed
movq %rax, %rbx
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0xc850
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1fc13
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1fc17
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
movq 0x33404(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1d4e2(%rip), %rsi     # 0x3d0e0
leaq 0x206f9(%rip), %rdx     # 0x402fe
xorl %ebx, %ebx
pushq $0x29
popq %rcx
xorl %eax, %eax
callq 0xc8d0
jmp 0x1fbe8
pushq $0x2d
jmp 0x1fc19
pushq $0x31
popq %rcx
movq 0x333d7(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x1d4b5(%rip), %rsi     # 0x3d0e0
leaq 0x206cc(%rip), %rdx     # 0x402fe
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xd110
xorl %ebx, %ebx
jmp 0x1fbe8
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/shared_strings.c
// Function: lxw_sst_free
void
lxw_sst_free(lxw_sst *sst)
{
    struct sst_element *sst_element;
    struct sst_element *sst_element_temp;

    if (!sst)
        return;

    /* Free the sst_elements and their data using the ordered linked list. */
    if (sst->order_list) {
        STAILQ_FOREACH_SAFE(sst_element, sst->order_list, sst_order_pointers,
                            sst_element_temp) {

            if (sst_element && sst_element->string)
                free(sst_element->string);
            if (sst_element)
                free(sst_element);
        }
    }

    free(sst->order_list);
    free(sst->rb_tree);
    free(sst);
}

// Assembly:
testq %rdi, %rdi
je 0x1fc83
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1fc84
movq (%rax), %r14
testq %r14, %r14
je 0x1fc7d
movq 0x8(%r14), %rdi
movq 0x18(%r14), %r15
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq %r15, %r14
jmp 0x1fc5e
movq 0x10(%rbx), %rdi
jmp 0x1fc86
retq
xorl %edi, %edi
callq 0xc0d0
movq 0x18(%rbx), %rdi
callq 0xc0d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc0d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/shared_strings.c
// Function: lxw_sst_assemble_xml_file
void
lxw_sst_assemble_xml_file(lxw_sst *self)
{
    /* Write the XML declaration. */
    _sst_xml_declaration(self);

    /* Write the sst element. */
    _write_sst(self);

    /* Write the sst strings. */
    _write_sst_strings(self);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xcfb0
movups 0x1f169(%rip), %xmm0    # 0x3ee2a
leaq 0x10(%rsp), %r14
movups %xmm0, 0x2a(%r14)
movaps 0x1f14e(%rip), %xmm0    # 0x3ee20
movaps %xmm0, 0x20(%r14)
movaps 0x1f132(%rip), %xmm0    # 0x3ee10
movaps %xmm0, 0x10(%r14)
movaps 0x1f116(%rip), %xmm0    # 0x3ee00
movaps %xmm0, (%r14)
movq %rsp, %r15
andq $0x0, (%r15)
movq %r15, 0x8(%r15)
leaq 0x1d411(%rip), %rdi     # 0x3d111
movq %r14, %rsi
callq 0xc030
movl $0x1040, %r12d          # imm = 0x1040
leaq (%rax,%r12), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%r15), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r15)
movl 0x8(%rbx), %esi
leaq 0x1fda6(%rip), %rdi     # 0x3fad5
callq 0xc1a0
leaq (%rax,%r12), %rcx
andq $0x0, 0x1040(%rax)
movq 0x8(%r15), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r15)
movl 0xc(%rbx), %esi
leaq 0x205be(%rip), %rdi     # 0x40313
callq 0xc1a0
addq %rax, %r12
andq $0x0, 0x1040(%rax)
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movq %r12, 0x8(%r15)
movq (%rbx), %rdi
leaq 0x20595(%rip), %rsi     # 0x4030f
movq %r15, %rdx
callq 0xc380
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fda7
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1fda0
movq %r15, 0x8(%rsp)
callq 0xc0d0
jmp 0x1fd82
movq 0x10(%rbx), %r12
leaq 0x1f731(%rip), %r15     # 0x3f4e3
movq (%r12), %r12
testq %r12, %r12
je 0x1fec8
cmpb $0x0, 0x10(%r12)
movq 0x8(%r12), %r13
movq (%rbx), %rdi
je 0x1fddc
movq %r13, %rsi
callq 0xcc00
jmp 0x1febf
movq %r15, %rsi
xorl %edx, %edx
callq 0xc380
movq %r13, %rdi
callq 0xc980
movl %eax, %ebp
testb %al, %al
je 0x1fdff
movq %r13, %rdi
callq 0xca00
movq %rax, %r13
andq $0x0, 0x10(%rsp)
movq %r14, 0x18(%rsp)
callq 0xd170
movq (%rax), %r15
movzbl (%r13), %eax
testb $0x20, 0x1(%r15,%rax,2)
jne 0x1fe35
movq %r13, %rdi
callq 0xc4c0
movzbl -0x1(%r13,%rax), %eax
testb $0x20, 0x1(%r15,%rax,2)
je 0x1fe64
leaq 0x204e3(%rip), %rdi     # 0x4031f
leaq 0x204e6(%rip), %rsi     # 0x40329
callq 0xc030
andq $0x0, 0x1040(%rax)
leaq 0x1040(%rax), %rcx
movq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x18(%rsp)
movq (%rbx), %rdi
leaq 0x1e41b(%rip), %rsi     # 0x3e289
movq %r13, %rdx
movq %r14, %rcx
callq 0xcba0
leaq 0x1f663(%rip), %r15     # 0x3f4e3
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1fea7
movq 0x1040(%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x1fea0
movq %r14, 0x18(%rsp)
callq 0xc0d0
jmp 0x1fe80
movq (%rbx), %rdi
movq %r15, %rsi
callq 0xc060
testb %bpl, %bpl
je 0x1febf
movq %r13, %rdi
callq 0xc0d0
addq $0x18, %r12
jmp 0x1fdb2
movq (%rbx), %rdi
leaq 0x2043d(%rip), %rsi     # 0x4030f
callq 0xc060
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq