LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbx
movq %r12, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1b8ed(%rip), %rdi     # 0x41367
callq 0xc030
movl $0x1040, %r13d          # imm = 0x1040
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movl %r15d, %esi
leaq 0x1e05f(%rip), %rdi     # 0x43b04
callq 0xc180
leaq (%rax,%r13), %rcx
movq %r12, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movl %ebp, %esi
leaq 0x1de24(%rip), %rdi     # 0x438ed
callq 0xc180
addq %rax, %r13
movq %r12, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r13, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1de0a(%rip), %rsi     # 0x438f7
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x25b1f
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x25b13
movq %rbx, 0x10(%rsp)
callq 0xc0c0
movq 0x8(%rsp), %rdi
jmp 0x25af8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
incw %si
jne 0x2640c
xorl %edi, %edi
jmp 0x26464
xorl %eax, %eax
movl $0x5a, %ecx
movzwl %si, %esi
imulq $0x9d89d8a, %rsi, %rdi  # imm = 0x9D89D8A
shrq $0x20, %rdi
leal (%rdi,%rdi,4), %r8d
leal (%r8,%r8,4), %r8d
addl %edi, %r8d
movl %esi, %edi
subl %r8d, %edi
movl %edi, %r8d
orb $0x40, %r8b
testl %edi, %edi
movzbl %r8b, %edi
cmovel %ecx, %edi
movzbl %al, %r8d
incb %al
movb %dil, (%rbx,%r8)
movzbl %al, %edi
movb $0x0, (%rbx,%rdi)
decl %esi
imulq $0x4ec4ec4f, %rsi, %rsi # imm = 0x4EC4EC4F
shrq $0x23, %rsi
testw %si, %si
jne 0x26413
testb %dl, %dl
je 0x2646e
movw $0x24, (%rbx,%rdi)
movq %rbx, %rdi
callq 0xc480
cmpq $0x2, %rax
jb 0x264a4
leaq (%rax,%rbx), %rcx
decq %rcx
shrq %rax
negq %rax
xorl %edx, %edx
movb (%rbx), %sil
movb (%rcx,%rdx), %dil
movb %dil, (%rbx)
movb %sil, (%rcx,%rdx)
decq %rdx
incq %rbx
cmpq %rdx, %rax
jne 0x2648b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc580
movq %r14, %rdi
callq 0xc480
testl %ebp, %ebp
je 0x2650d
movb $0x24, (%r14,%rax)
incq %rax
addq %rax, %r14
incl %ebx
leaq 0x1f027(%rip), %rdx     # 0x45540
movl $0x9, %esi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xc570
// File: /workspace/github_c_makefile_star2_O1/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 0xca00
cmpl %ebx, %r12d
sete %al
cmpw %bp, %r15w
sete %cl
testb %cl, %al
je 0x26563
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc480
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 0xca00
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ecx
movl $0x1, %r8d
callq 0xc5e0
cmpl %ebx, %r12d
sete %al
cmpw %bp, %r15w
sete %cl
testb %cl, %al
je 0x265c8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc480
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x3a, -0x1(%rdi)
movzwl %bp, %edx
movl %ebx, %esi
movl $0x1, %ecx
movl $0x1, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc5e0
// File: /workspace/github_c_makefile_star2_O1/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 0xc380
movq %rax, %r13
movl $0x9a, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xc170
movq %r13, %rdi
callq 0xc0c0
movq %r14, %rdi
callq 0xc480
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x21, -0x1(%rdi)
movl %r12d, %esi
movl %r15d, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0xc5e0
cmpl %ebx, %r12d
sete %al
cmpw %bp, %r15w
sete %cl
testb %cl, %al
je 0x2667e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc480
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x3a, -0x1(%rdi)
movzwl %bp, %edx
movl %ebx, %esi
movl $0x1, %ecx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc5e0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xc480
cmpb $0x27, (%rbx)
je 0x26736
movq %rax, %r14
testq %rax, %rax
je 0x2672b
callq 0xd0f0
movq (%rax), %rcx
movl $0x2, %eax
xorl %edx, %edx
movl $0x1, %esi
xorl %edi, %edi
movzbl (%rbx,%rdi), %r8d
testb $0x8, (%rcx,%r8,2)
movzbl %dl, %r9d
movl $0x1, %edx
cmovnel %r9d, %edx
cmpl $0x5f, %r8d
cmovel %r9d, %edx
cmpl $0x2e, %r8d
cmovel %r9d, %edx
xorl %r9d, %r9d
cmpl $0x27, %r8d
cmovel %esi, %edx
sete %r9b
addq %r9, %rax
incq %rdi
cmpq %rdi, %r14
jne 0x266e4
testb %dl, %dl
sete %cl
jmp 0x26732
movb $0x1, %cl
movl $0x2, %eax
testb %cl, %cl
je 0x26743
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xcce0
leaq (%r14,%rax), %rsi
incq %rsi
movl $0x1, %r15d
movl $0x1, %edi
callq 0xc7f0
testq %rax, %rax
je 0x2679c
movb $0x27, (%rax)
testq %r14, %r14
je 0x2678f
movl $0x1, %r15d
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%r15)
cmpb $0x27, %dl
jne 0x26784
movb $0x27, 0x1(%rax,%r15)
incq %r15
incq %rcx
incq %r15
cmpq %rcx, %r14
jne 0x2676f
movw $0x27, (%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
callq 0xde6c
xorl %eax, %eax
jmp 0x26796
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdi, %rdi
je 0x267d8
movq %rdi, %rbx
callq 0xd0f0
movq (%rax), %rax
decq %rbx
movzbl 0x1(%rbx), %ecx
incq %rbx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x267c2
movq %rbx, %rdi
callq 0xce80
subl $0x1, %eax
cmovbl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movw $0xffff, %bx            # imm = 0xFFFF
testq %rdi, %rdi
je 0x2684f
movq %rdi, %r14
callq 0xd0f0
movq (%rax), %rax
movzbl (%r14), %edx
cmpl $0x24, %edx
sete %cl
je 0x26815
movzwl (%rax,%rdx,2), %esi
andl $0x100, %esi            # imm = 0x100
je 0x2684f
incq %r14
xorl %ebx, %ebx
movsbl %dl, %edx
leal (%rbx,%rbx,4), %esi
leal (%rsi,%rsi,4), %esi
addl %ebx, %esi
addl %esi, %edx
addl $-0x40, %edx
testb $0x1, %cl
cmovnel %ebx, %edx
movl %edx, %ebx
movzbl (%r14), %edx
incq %r14
cmpl $0x24, %edx
sete %cl
je 0x2681a
movzwl (%rax,%rdx,2), %esi
andl $0x100, %esi            # imm = 0x100
jne 0x2681a
decl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e240(%rip), %xmm0    # 0x44d18
testl %esi, %esi
sete %al
leaq 0x1e24c(%rip), %rcx     # 0x44d30
addsd (%rcx,%rax,8), %xmm0
jne 0x26b14
movsd 0x1bf4d(%rip), %xmm1    # 0x42a40
addsd %xmm0, %xmm1
movsd 0x1e221(%rip), %xmm2    # 0x44d20
cmplesd %xmm0, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26b4e
movq %rdi, %rbx
callq 0xc480
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0xca50
testq %rax, %rax
je 0x26b50
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc900
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/utility.c
// Function: lxw_utf8_strlen
size_t
lxw_utf8_strlen(const char *str)
{
    size_t byte_count = 0;
    size_t char_count = 0;

    while (str[byte_count]) {
        if ((str[byte_count] & 0xc0) != 0x80)
            char_count++;

        byte_count++;
    }

    return char_count;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x26b95
incq %rdi
xorl %eax, %eax
andb $-0x40, %cl
xorl %edx, %edx
negb %cl
setno %dl
addq %rdx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x26b7e
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc480
movq %rax, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
je 0x26c5b
xorl %esi, %esi
movl %esi, %edx
shrl $0xe, %esi
andl $0x1, %esi
addl %edx, %edx
movl %edx, %edi
andl $0x7ffe, %edi           # imm = 0x7FFE
orl %esi, %edi
movzbl -0x1(%rbx,%rcx), %esi
xorl %edi, %esi
decq %rcx
jne 0x26c20
shrl $0xe, %edx
andl $0x1, %edx
movzwl %si, %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
leal (%rdx,%rcx,2), %ecx
xorl %ecx, %eax
xorl $0xce4b, %eax           # imm = 0xCE4B
jmp 0x26c5d
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1c792(%rip), %rdi     # 0x45375
leaq 0x1c795(%rip), %rsi     # 0x4537f
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1c773(%rip), %rsi     # 0x45385
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28c42
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x28c37
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x28c1d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x8(%rsp), %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1c6ae(%rip), %rdi     # 0x4531e
leaq 0x1c6ad(%rip), %rsi     # 0x45324
callq 0xc030
movl $0x1040, %r12d          # imm = 0x1040
leaq (%rax,%r12), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
leaq 0x1c80c(%rip), %rdi     # 0x454ab
leaq 0x185eb(%rip), %rsi     # 0x41291
callq 0xc030
addq %rax, %r12
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %r12, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1c700(%rip), %rsi     # 0x453ca
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28cfc
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x28cf0
movq %rbx, 0x10(%rsp)
callq 0xc0c0
movq 0x8(%rsp), %rdi
jmp 0x28cd5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/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 0x1c7d4(%rip), %rdx     # 0x45524
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 0xc570
addq $0x30, %rsp
movq (%rbx), %rdi
leaq 0x1c7c7(%rip), %rsi     # 0x45543
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xcb30
addq $0x820, %rsp            # imm = 0x820
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
testl %esi, %esi
je 0x28dea
leaq 0x1c7d9(%rip), %rdi     # 0x45598
leaq 0x184cb(%rip), %rsi     # 0x41291
callq 0xc030
leaq 0x1040(%rax), %rcx
movq $0x0, 0x1040(%rax)
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x10(%rsp)
leaq 0x1c5c4(%rip), %rdi     # 0x453b5
movq %rbx, %rsi
callq 0xc030
leaq 0x1040(%rax), %rcx
movq $0x0, 0x1040(%rax)
leaq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1c59e(%rip), %rsi     # 0x453c3
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28e57
movq 0x1040(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x28e4b
movq %rbx, 0x10(%rsp)
callq 0xc0c0
movq 0x8(%rsp), %rdi
jmp 0x28e30
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %rbx
movq %r15, (%rbx)
movq %rbx, 0x8(%rbx)
leaq 0x1c919(%rip), %rdi     # 0x45798
callq 0xc030
leaq 0x1040(%rax), %rcx
movq %r15, 0x1040(%rax)
movq 0x8(%rbx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rbx)
movq (%r14), %rdi
leaq 0x1c8f5(%rip), %rsi     # 0x4579c
movq %rbx, %rdx
callq 0xcc00
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28ed7
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x28ecc
movq %rbx, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x28eb2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x29adb
movq (%rbx), %rdi
callq 0xc0c0
movq 0x8(%rbx), %rdi
callq 0xc0c0
movq 0x10(%rbx), %rdi
callq 0xc0c0
movq 0x18(%rbx), %rdi
callq 0xc0c0
movq 0x20(%rbx), %rdi
callq 0xc0c0
movq 0x28(%rbx), %rdi
callq 0xc0c0
movq 0x30(%rbx), %rdi
callq 0xc0c0
movq 0x38(%rbx), %rdi
callq 0xc0c0
movq 0x40(%rbx), %rdi
callq 0xc0c0
movq 0x48(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
jmp 0xc0c0
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x29f1f
movl $0x1, %ebp
subl $0x1, %ebp
jb 0x29f13
movq %rbx, %rdi
callq 0xc9c0
movq 0x230(%rbx), %rbx
testq %rbx, %rbx
jne 0x29f06
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcd40
testq %rax, %rax
je 0x2b20f
movq %rax, %rbx
movq 0x58(%r14), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2b1bc
movl $0x238, %edx            # imm = 0x238
movq %rbx, %rdi
callq 0xc900
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x230(%rbx)
movq $-0x1, 0x28(%rbx)
movq 0xd8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0xe0(%r14), %rax
movq %rax, 0x10(%rbx)
leaq 0xba(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x230, %rax            # imm = 0x230
movq $0x0, 0x230(%rbx)
movq 0x58(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, (%rcx)
movq 0x58(%r14), %rcx
movq %rax, 0x8(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xdf41
xorl %ebx, %ebx
jmp 0x2b204
// File: /workspace/github_c_makefile_star2_O1/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 0xd0d0
movl $0xe, %ebp
cmpq $0x1f, %rax
ja 0x2b6e0
leaq 0x1ab3e(%rip), %rsi     # 0x461c6
movq %rbx, %rdi
callq 0xcb10
movl $0xf, %ebp
testq %rax, %rax
jne 0x2b6e0
movl $0x10, %ebp
cmpb $0x27, (%rbx)
je 0x2b6e0
movq %rbx, %rdi
callq 0xc480
cmpb $0x27, -0x1(%rbx,%rax)
je 0x2b6e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xca20
movl $0x11, %ebp
testq %rax, %rax
jne 0x2b6e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xce70
xorl %ecx, %ecx
testq %rax, %rax
movl $0x11, %ebp
cmovel %ecx, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc790
testq %rax, %rax
je 0x2bb52
movq %rax, %rcx
addq $0x178, %rcx            # imm = 0x178
movq $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_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_set_custom_property_string
lxw_error
workbook_set_custom_property_string(lxw_workbook *self, const char *name,
                                    const char *value)
{
    lxw_custom_property *custom_property;

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

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

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

    if (lxw_utf8_strlen(value) > 255) {
        LXW_WARN_FORMAT("workbook_set_custom_property_string(): parameter "
                        "'value' 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.string = lxw_strdup(value);
    custom_property->type = LXW_CUSTOM_STRING;

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

    return LXW_NO_ERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2cd76
movq %rdx, %r14
testq %rdx, %rdx
je 0x2cd7d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd0d0
cmpq $0x100, %rax            # imm = 0x100
jae 0x2cd89
movq %r14, %rdi
callq 0xd0d0
cmpq $0x100, %rax            # imm = 0x100
jae 0x2cd90
movl $0x1, %edi
movl $0x38, %esi
callq 0xc7f0
testq %rax, %rax
je 0x2cd9c
movq %rax, %r12
movq %r15, %rdi
callq 0xcce0
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0xcce0
movq %rax, 0x10(%r12)
movl $0x1, (%r12)
movq %r12, %rax
addq $0x30, %rax
movq $0x0, 0x30(%r12)
movq 0x78(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r12, (%rcx)
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xe39f
jmp 0x2cd82
callq 0xe383
movl $0xc, %eax
jmp 0x2cd6a
callq 0xe367
jmp 0x2cd95
callq 0xe34b
movl $0x14, %eax
jmp 0x2cd6a
callq 0xe327
movl $0x1, %eax
jmp 0x2cd6a
// File: /workspace/github_c_makefile_star2_O1/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 0x2ce3a
movq %rsi, %r14
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdi
callq 0xd0d0
cmpq $0x100, %rax            # imm = 0x100
jae 0x2ce46
movl $0x1, %edi
movl $0x38, %esi
callq 0xc7f0
testq %rax, %rax
je 0x2ce52
movq %rax, %r15
movq %r14, %rdi
callq 0xcce0
movq %rax, 0x8(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%r15)
movl $0x2, (%r15)
movq %r15, %rax
addq $0x30, %rax
movq $0x0, 0x30(%r15)
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
callq 0xe3fb
movl $0xc, %eax
jmp 0x2ce30
callq 0xe3df
movl $0x14, %eax
jmp 0x2ce30
callq 0xe3bb
movl $0x1, %eax
jmp 0x2ce30
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_set_custom_property_integer
lxw_error
workbook_set_custom_property_integer(lxw_workbook *self, const char *name,
                                     int32_t value)
{
    lxw_custom_property *custom_property;

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

    if (strlen(name) > 255) {
        LXW_WARN_FORMAT("workbook_set_custom_property_integer(): 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.integer = value;
    custom_property->type = LXW_CUSTOM_INTEGER;

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

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2cedf
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc480
cmpq $0x100, %rax            # imm = 0x100
jae 0x2ceeb
movl $0x1, %edi
movl $0x38, %esi
callq 0xc7f0
testq %rax, %rax
je 0x2cef7
movq %rax, %r15
movq %r14, %rdi
callq 0xcce0
movq %rax, 0x8(%r15)
movl %ebp, 0x10(%r15)
movl $0x3, (%r15)
movq %r15, %rax
addq $0x30, %rax
movq $0x0, 0x30(%r15)
movq 0x78(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r15, (%rcx)
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xe457
movl $0xc, %eax
jmp 0x2ced4
callq 0xe43b
movl $0x14, %eax
jmp 0x2ced4
callq 0xe417
movl $0x1, %eax
jmp 0x2ced4
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_set_custom_property_boolean
lxw_error
workbook_set_custom_property_boolean(lxw_workbook *self, const char *name,
                                     uint8_t value)
{
    lxw_custom_property *custom_property;

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

    if (lxw_utf8_strlen(name) > 255) {
        LXW_WARN_FORMAT("workbook_set_custom_property_boolean(): 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.boolean = value;
    custom_property->type = LXW_CUSTOM_BOOLEAN;

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

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2cf84
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd0d0
cmpq $0x100, %rax            # imm = 0x100
jae 0x2cf90
movl $0x1, %edi
movl $0x38, %esi
callq 0xc7f0
testq %rax, %rax
je 0x2cf9c
movq %rax, %r15
movq %r14, %rdi
callq 0xcce0
movq %rax, 0x8(%r15)
movb %bpl, 0x10(%r15)
movl $0x4, (%r15)
movq %r15, %rax
addq $0x30, %rax
movq $0x0, 0x30(%r15)
movq 0x78(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r15, (%rcx)
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xe4b3
movl $0xc, %eax
jmp 0x2cf79
callq 0xe497
movl $0x14, %eax
jmp 0x2cf79
callq 0xe473
movl $0x1, %eax
jmp 0x2cf79
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_set_custom_property_datetime
lxw_error
workbook_set_custom_property_datetime(lxw_workbook *self, const char *name,
                                      lxw_datetime *datetime)
{
    lxw_custom_property *custom_property;

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

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

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

    /* 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);

    memcpy(&custom_property->u.datetime, datetime, sizeof(lxw_datetime));
    custom_property->type = LXW_CUSTOM_DATETIME;

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

    return LXW_NO_ERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2d051
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd0d0
cmpq $0x100, %rax            # imm = 0x100
jae 0x2d058
testq %r14, %r14
je 0x2d05f
movl $0x1, %edi
movl $0x38, %esi
callq 0xc7f0
testq %rax, %rax
je 0x2d06b
movq %rax, %r12
movq %r15, %rdi
callq 0xcce0
movq %rax, 0x8(%r12)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x10(%r12)
movups %xmm1, 0x20(%r12)
movl $0x5, (%r12)
movq %r12, %rax
addq $0x30, %rax
movq $0x0, 0x30(%r12)
movq 0x78(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r12, (%rcx)
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xe52b
jmp 0x2d064
callq 0xe50f
jmp 0x2d064
callq 0xe4f3
movl $0xc, %eax
jmp 0x2d045
callq 0xe4cf
movl $0x1, %eax
jmp 0x2d045
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_get_worksheet_by_name
lxw_worksheet *
workbook_get_worksheet_by_name(lxw_workbook *self, const char *name)
{
    lxw_worksheet_name worksheet_name;
    lxw_worksheet_name *found;

    if (!name)
        return NULL;

    worksheet_name.name = name;
    found = RB_FIND(lxw_worksheet_names,
                    self->worksheet_names, &worksheet_name);

    if (found)
        return found->worksheet;
    else
        return NULL;
}

// Assembly:
testq %rsi, %rsi
je 0x2d0c1
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x2d0b3
movq %rsi, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xc130
movl $0x10, %ecx
testl %eax, %eax
js 0x2d0aa
movl $0x18, %ecx
je 0x2d0b6
movq (%r14,%rcx), %r14
testq %r14, %r14
jne 0x2d08f
xorl %r14d, %r14d
testq %r14, %r14
je 0x2d0c4
movq 0x8(%r14), %rax
jmp 0x2d0c6
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_get_chartsheet_by_name
lxw_chartsheet *
workbook_get_chartsheet_by_name(lxw_workbook *self, const char *name)
{
    lxw_chartsheet_name chartsheet_name;
    lxw_chartsheet_name *found;

    if (!name)
        return NULL;

    chartsheet_name.name = name;
    found = RB_FIND(lxw_chartsheet_names,
                    self->chartsheet_names, &chartsheet_name);

    if (found)
        return found->chartsheet;
    else
        return NULL;
}

// Assembly:
testq %rsi, %rsi
je 0x2d118
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x2d10a
movq %rsi, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xc130
movl $0x10, %ecx
testl %eax, %eax
js 0x2d101
movl $0x18, %ecx
je 0x2d10d
movq (%r14,%rcx), %r14
testq %r14, %r14
jne 0x2d0e6
xorl %r14d, %r14d
testq %r14, %r14
je 0x2d11b
movq 0x8(%r14), %rax
jmp 0x2d11d
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_add_vba_project
lxw_error
workbook_add_vba_project(lxw_workbook *self, const char *filename)
{
    FILE *filehandle;

    if (!filename) {
        LXW_WARN("workbook_add_vba_project(): "
                 "project filename must be specified.");
        return LXW_ERROR_NULL_PARAMETER_IGNORED;
    }

    /* Check that the vbaProject file exists and can be opened. */
    filehandle = lxw_fopen(filename, "rb");
    if (!filehandle) {
        LXW_WARN_FORMAT1("workbook_add_vba_project(): "
                         "project file doesn't exist or can't be opened: %s.",
                         filename);
        return LXW_ERROR_PARAMETER_VALIDATION;
    }
    fclose(filehandle);

    self->vba_project = lxw_strdup(filename);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2d190
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12e9e(%rip), %rsi     # 0x40000
movq %rbx, %rdi
callq 0xc250
testq %rax, %rax
je 0x2d19c
movq %rax, %rdi
callq 0xc420
movq %rbx, %rdi
callq 0xcce0
movq %rax, 0xe8(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xe547
movl $0xc, %eax
jmp 0x2d188
movq 0x28e55(%rip), %rax     # 0x55ff8
movq (%rax), %rdi
leaq 0x1906d(%rip), %rsi     # 0x4621a
movq %rbx, %rdx
xorl %eax, %eax
callq 0xc870
movl $0xd, %eax
jmp 0x2d188
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: workbook_add_signed_vba_project
lxw_error
workbook_add_signed_vba_project(lxw_workbook *self,
                                const char *vba_project,
                                const char *signature)
{
    FILE *filehandle;

    lxw_error error = workbook_add_vba_project(self, vba_project);
    if (error != LXW_NO_ERROR)
        return error;

    if (!signature) {
        LXW_WARN("workbook_add_signed_vba_project(): "
                 "signature filename must be specified.");
        return LXW_ERROR_NULL_PARAMETER_IGNORED;
    }

    /* Check that the vbaProjectSignature file exists and can be opened. */
    filehandle = lxw_fopen(signature, "rb");
    if (!filehandle) {
        LXW_WARN_FORMAT1("workbook_add_signed_vba_project(): "
                         "signature file doesn't exist or can't be opened: %s.",
                         signature);
        return LXW_ERROR_PARAMETER_VALIDATION;
    }
    fclose(filehandle);

    self->vba_project_signature = lxw_strdup(signature);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0xc990
testl %eax, %eax
jne 0x2d203
testq %rbx, %rbx
je 0x2d20b
leaq 0x12e23(%rip), %rsi     # 0x40000
movq %rbx, %rdi
callq 0xc250
testq %rax, %rax
je 0x2d217
movq %rax, %rdi
callq 0xc420
movq %rbx, %rdi
callq 0xcce0
movq %rax, 0xf0(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xe563
movl $0xc, %eax
jmp 0x2d203
movq 0x28dda(%rip), %rax     # 0x55ff8
movq (%rax), %rdi
leaq 0x190a2(%rip), %rsi     # 0x462ca
movq %rbx, %rdx
xorl %eax, %eax
callq 0xc870
movl $0xd, %eax
jmp 0x2d203
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/workbook.c
// Function: write_sheet
STATIC void
_write_sheet(lxw_workbook *self, const char *name, uint32_t sheet_id,
             uint8_t hidden)
{
    struct xml_attribute_list attributes;
    struct xml_attribute *attribute;
    char r_id[LXW_MAX_ATTRIBUTE_LENGTH] = "rId1";

    lxw_snprintf(r_id, LXW_ATTR_32, "rId%d", sheet_id);

    LXW_INIT_ATTRIBUTES();
    LXW_PUSH_ATTRIBUTES_STR("name", name);
    LXW_PUSH_ATTRIBUTES_INT("sheetId", sheet_id);

    if (hidden)
        LXW_PUSH_ATTRIBUTES_STR("state", "hidden");

    LXW_PUSH_ATTRIBUTES_STR("r:id", r_id);

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

    LXW_FREE_ATTRIBUTES();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
xorl %r13d, %r13d
movl $0x820, %edx            # imm = 0x820
movq %r12, %rdi
xorl %esi, %esi
callq 0xc640
movl $0x31644972, (%r12)     # imm = 0x31644972
leaq 0x154e6(%rip), %rdx     # 0x42769
movl $0x20, %esi
movq %r12, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0xc570
movq %rsp, %r12
movq %r13, (%r12)
movq %r12, 0x8(%r12)
leaq 0x140bf(%rip), %rdi     # 0x41367
movq %r15, %rsi
callq 0xc030
movl $0x1040, %r15d          # imm = 0x1040
leaq (%rax,%r15), %rcx
movq %r13, 0x1040(%rax)
movq 0x8(%r12), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r12)
movl %r14d, %esi
leaq 0x191ad(%rip), %rdi     # 0x46485
callq 0xc180
addq %rax, %r15
movq %r13, 0x1040(%rax)
movq 0x8(%r12), %rcx
movq %rax, (%rcx)
movq %r15, 0x8(%r12)
testl %ebp, %ebp
je 0x2d32a
leaq 0x1918e(%rip), %rdi     # 0x4648d
leaq 0x165cb(%rip), %rsi     # 0x438d1
callq 0xc030
leaq 0x1040(%rax), %rcx
movq $0x0, 0x1040(%rax)
movq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rsp)
leaq 0x1543e(%rip), %rdi     # 0x4276f
leaq 0x10(%rsp), %rsi
callq 0xc030
leaq 0x1040(%rax), %rcx
movq $0x0, 0x1040(%rax)
movq %rsp, %r14
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
movq (%rbx), %rdi
leaq 0x15beb(%rip), %rsi     # 0x42f50
movq %r14, %rdx
callq 0xcc00
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2d395
movq 0x1040(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x2d38a
movq %r14, 0x8(%rsp)
callq 0xc0c0
movq (%rsp), %rdi
jmp 0x2d370
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq