LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.c
// Function: tmpfileplus_f
FILE *tmpfileplus_f(const char *dir, const char *prefix, char *pathnamebuf, size_t pathsize, int keep)
{
	char *tmpbuf = NULL;
	FILE *fp;

	/* If no buffer provided, do the normal way */
	if (!pathnamebuf || (int)pathsize <= 0) {
		return tmpfileplus(dir, prefix, NULL, keep);
	}
	/* Call with a temporary buffer */
	fp = tmpfileplus(dir, prefix, &tmpbuf, keep);
	if (fp && strlen(tmpbuf) > pathsize - 1) {
		/* Succeeded but not enough room in output buffer, so clean up and return an error */
		pathnamebuf[0] = 0;
		fclose(fp);
		if (keep) remove(tmpbuf);
		free(tmpbuf);
		errno = E2BIG;
		return NULL;
	}
	/* Copy name into buffer */
	strcpy(pathnamebuf, tmpbuf);
	free(tmpbuf);

	return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movq %rcx, %r12
andq $0x0, 0x8(%rsp)
testq %rdx, %rdx
setne %al
testl %r12d, %r12d
setg %cl
testb %cl, %al
jne 0xfbcb
xorl %edx, %edx
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc0a0
movq %rdx, %r14
leaq 0x8(%rsp), %r13
movq %r13, %rdx
movl %ebx, %ecx
callq 0xc0a0
movq %rax, %r15
movq (%r13), %r13
testq %rax, %rax
je 0xfc2d
movq %r13, %rdi
callq 0xc4c0
decq %r12
cmpq %r12, %rax
jbe 0xfc2d
movb $0x0, (%r14)
movq %r15, %rdi
callq 0xc450
testl %ebx, %ebx
je 0xfc13
movq 0x8(%rsp), %rdi
callq 0xc1b0
movq 0x8(%rsp), %rdi
callq 0xc0d0
callq 0xc170
movl $0x7, (%rax)
xorl %r15d, %r15d
jmp 0xfc40
movq %r14, %rdi
movq %r13, %rsi
callq 0xc250
movq %r13, %rdi
callq 0xc0d0
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/md5/md5.c
// Function: MD5_Update
void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
{
	MD5_u32plus saved_lo;
	unsigned long used, available;

	saved_lo = ctx->lo;
	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
		ctx->hi++;
	ctx->hi += size >> 29;

	used = saved_lo & 0x3f;

	if (used) {
		available = 64 - used;

		if (size < available) {
			memcpy(&ctx->buffer[used], data, size);
			return;
		}

		memcpy(&ctx->buffer[used], data, available);
		data = (const unsigned char *)data + available;
		size -= available;
		body(ctx, ctx->buffer, 64);
	}

	if (size >= 64) {
		data = body(ctx, data, size & ~(unsigned long)0x3f);
		size &= 0x3f;
	}

	memcpy(ctx->buffer, data, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
leal (%rdx,%rax), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movl %ecx, (%rdi)
movq %rdx, %rdi
shrq $0x1d, %rdi
cmpl %eax, %ecx
adcl %edi, 0x4(%rbx)
movq %rsi, %r14
andq $0x3f, %rax
je 0xfcb7
pushq $0x40
popq %r12
subq %rax, %r12
movq %rdx, %r15
leaq (%rbx,%rax), %rdi
addq $0x18, %rdi
subq %r12, %r15
jae 0xfcbc
movq %r14, %rsi
jmp 0xfd08
movq %rdx, %r15
jmp 0xfcdc
leaq 0x18(%rbx), %r13
movq %r14, %rsi
movq %r12, %rdx
callq 0xc960
addq %r12, %r14
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfd16
cmpq $0x40, %r15
jb 0xfcfb
movq %r15, %rdx
andq $-0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd16
movq %rax, %r14
andl $0x3f, %r15d
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc960
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/md5/md5.c
// Function: MD5_Final
void MD5_Final(unsigned char *result, MD5_CTX *ctx)
{
	unsigned long used, available;

	used = ctx->lo & 0x3f;

	ctx->buffer[used++] = 0x80;

	available = 64 - used;

	if (available < 8) {
		memset(&ctx->buffer[used], 0, available);
		body(ctx, ctx->buffer, 64);
		used = 0;
		available = 64;
	}

	memset(&ctx->buffer[used], 0, available - 8);

	ctx->lo <<= 3;
	OUT(&ctx->buffer[56], ctx->lo)
	OUT(&ctx->buffer[60], ctx->hi)

	body(ctx, ctx->buffer, 64);

	OUT(&result[0], ctx->a)
	OUT(&result[4], ctx->b)
	OUT(&result[8], ctx->c)
	OUT(&result[12], ctx->d)

	memset(ctx, 0, sizeof(*ctx));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %edx
andl $0x3f, %edx
leaq 0x18(%rsi), %r15
leaq 0x1(%rdx), %rdi
movb $-0x80, 0x18(%rsi,%rdx)
xorq $0x3f, %rdx
cmpq $0x7, %rdx
ja 0x105bb
pushq $0x40
popq %r12
addq %r15, %rdi
xorl %esi, %esi
callq 0xc690
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xfd16
xorl %edi, %edi
movq %r12, %rdx
addq %r15, %rdi
addq $-0x8, %rdx
xorl %esi, %esi
callq 0xc690
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
leal (,%rax,8), %edx
movl %edx, (%rbx)
movb %dl, 0x50(%rbx)
movl %eax, %edx
shrl $0x5, %edx
movb %dl, 0x51(%rbx)
movl %eax, %edx
shrl $0xd, %edx
movb %dl, 0x52(%rbx)
shrl $0x15, %eax
movb %al, 0x53(%rbx)
movl %ecx, 0x54(%rbx)
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfd16
movb 0x8(%rbx), %al
movb %al, (%r14)
movb 0x9(%rbx), %al
movb %al, 0x1(%r14)
movb 0xa(%rbx), %al
movb %al, 0x2(%r14)
movb 0xb(%rbx), %al
movb %al, 0x3(%r14)
movb 0xc(%rbx), %al
movb %al, 0x4(%r14)
movb 0xd(%rbx), %al
movb %al, 0x5(%r14)
movb 0xe(%rbx), %al
movb %al, 0x6(%r14)
movb 0xf(%rbx), %al
movb %al, 0x7(%r14)
movb 0x10(%rbx), %al
movb %al, 0x8(%r14)
movb 0x11(%rbx), %al
movb %al, 0x9(%r14)
movb 0x12(%rbx), %al
movb %al, 0xa(%r14)
movb 0x13(%rbx), %al
movb %al, 0xb(%r14)
movb 0x14(%rbx), %al
movb %al, 0xc(%r14)
movb 0x15(%rbx), %al
movb %al, 0xd(%r14)
movb 0x16(%rbx), %al
movb %al, 0xe(%r14)
movb 0x17(%rbx), %al
movb %al, 0xf(%r14)
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc690
nop
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_new
lxw_app *
lxw_app_new(void)
{
    lxw_app *app = calloc(1, sizeof(lxw_app));
    GOTO_LABEL_ON_MEM_ERROR(app, mem_error);

    app->heading_pairs = calloc(1, sizeof(struct lxw_heading_pairs));
    GOTO_LABEL_ON_MEM_ERROR(app->heading_pairs, mem_error);
    STAILQ_INIT(app->heading_pairs);

    app->part_names = calloc(1, sizeof(struct lxw_part_names));
    GOTO_LABEL_ON_MEM_ERROR(app->part_names, mem_error);
    STAILQ_INIT(app->part_names);

    return app;

mem_error:
    lxw_app_free(app);
    return NULL;
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0xc850
movq %rax, %rbx
testq %rax, %rax
je 0x106d5
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x106d9
movq %rax, 0x8(%rax)
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x106dd
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
pushq $0x1f
jmp 0x106df
pushq $0x22
jmp 0x106df
pushq $0x26
popq %rcx
movq 0x42911(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2c9ef(%rip), %rsi     # 0x3d0e0
leaq 0x2ca13(%rip), %rdx     # 0x3d10b
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
callq 0xcd00
xorl %ebx, %ebx
jmp 0x106d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_free
void
lxw_app_free(lxw_app *app)
{
    lxw_heading_pair *heading_pair;
    lxw_part_name *part_name;

    if (!app)
        return;

    /* Free the lists in the App object. */
    if (app->heading_pairs) {
        while (!STAILQ_EMPTY(app->heading_pairs)) {
            heading_pair = STAILQ_FIRST(app->heading_pairs);
            STAILQ_REMOVE_HEAD(app->heading_pairs, list_pointers);
            free(heading_pair->key);
            free(heading_pair->value);
            free(heading_pair);
        }
        free(app->heading_pairs);
    }

    if (app->part_names) {
        while (!STAILQ_EMPTY(app->part_names)) {
            part_name = STAILQ_FIRST(app->part_names);
            STAILQ_REMOVE_HEAD(app->part_names, list_pointers);
            free(part_name->name);
            free(part_name);
        }
        free(app->part_names);
    }

    free(app);
}

// Assembly:
testq %rdi, %rdi
je 0x107ab
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x10753
jmp 0x10760
movq 0x10(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x10736
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 0x10726
callq 0xc0d0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x1078f
jmp 0x1079c
movq 0x8(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x1077b
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0xc0d0
movq 0x10(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x1076b
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/app.c
// Function: lxw_app_add_part_name
void
lxw_app_add_part_name(lxw_app *self, const char *name)
{
    lxw_part_name *part_name;

    if (!name)
        return;

    part_name = calloc(1, sizeof(lxw_part_name));
    GOTO_LABEL_ON_MEM_ERROR(part_name, mem_error);

    part_name->name = lxw_strdup(name);
    GOTO_LABEL_ON_MEM_ERROR(part_name->name, mem_error);

    STAILQ_INSERT_TAIL(self->part_names, part_name, list_pointers);
    self->num_part_names++;

    return;

mem_error:
    if (part_name) {
        free(part_name->name);
        free(part_name);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x10c46
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x10c4c
movq %rax, %rbx
movq %r15, %rdi
callq 0xcd50
movq %rax, (%rbx)
testq %rax, %rax
je 0x10c75
movq %rbx, %rax
addq $0x8, %rax
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, (%rcx)
movq 0x10(%r14), %rcx
movq %rax, 0x8(%rcx)
incl 0x24(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq 0x423a5(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2c483(%rip), %rsi     # 0x3d0e0
leaq 0x2c4a7(%rip), %rdx     # 0x3d10b
movl $0x18d, %ecx            # imm = 0x18D
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xc8d0
movq 0x4237c(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2c45a(%rip), %rsi     # 0x3d0e0
leaq 0x2c47e(%rip), %rdx     # 0x3d10b
movl $0x190, %ecx            # imm = 0x190
xorl %eax, %eax
callq 0xc8d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc0d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_add_heading_pair
void
lxw_app_add_heading_pair(lxw_app *self, const char *key, const char *value)
{
    lxw_heading_pair *heading_pair;

    if (!key || !value)
        return;

    heading_pair = calloc(1, sizeof(lxw_heading_pair));
    GOTO_LABEL_ON_MEM_ERROR(heading_pair, mem_error);

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

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

    STAILQ_INSERT_TAIL(self->heading_pairs, heading_pair, list_pointers);
    self->num_heading_pairs++;

    return;

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

// 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 0x10d1c
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x10d28
movq %rax, %rbx
movq %r15, %rdi
callq 0xcd50
movq %rax, %r15
movq %rax, (%rbx)
testq %rax, %rax
je 0x10d57
movq %r12, %rdi
callq 0xcd50
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x10d5e
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)
incl 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x422c9(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2c3a7(%rip), %rsi     # 0x3d0e0
leaq 0x2c3cb(%rip), %rdx     # 0x3d10b
movl $0x1ab, %ecx            # imm = 0x1AB
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc8d0
movl $0x1ae, %ecx            # imm = 0x1AE
jmp 0x10d63
movl $0x1b1, %ecx            # imm = 0x1B1
movq 0x4228e(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2c36c(%rip), %rsi     # 0x3d0e0
leaq 0x2c390(%rip), %rdx     # 0x3d10b
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/chart.c
// Function: chart_series_free
STATIC void
_chart_series_free(lxw_chart_series *series)
{
    if (!series)
        return;

    free(series->title.name);
    free(series->line);
    free(series->fill);
    free(series->pattern);
    free(series->label_num_format);
    free(series->label_line);
    free(series->label_fill);
    free(series->label_pattern);

    _chart_free_font(series->label_font);

    if (series->marker) {
        free(series->marker->line);
        free(series->marker->fill);
        free(series->marker->pattern);
        free(series->marker);
    }

    _chart_free_range(series->categories);
    _chart_free_range(series->values);
    _chart_free_range(series->title.range);
    _chart_free_points(series);
    _chart_free_data_labels(series);

    if (series->x_error_bars) {
        free(series->x_error_bars->line);
        free(series->x_error_bars);
    }

    if (series->y_error_bars) {
        free(series->y_error_bars->line);
        free(series->y_error_bars);
    }

    free(series->trendline_line);
    free(series->trendline_name);

    free(series);
}

// Assembly:
testq %rdi, %rdi
je 0x11170
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xc0d0
movq 0x60(%rbx), %rdi
callq 0xc0d0
movq 0x68(%rbx), %rdi
callq 0xc0d0
movq 0x70(%rbx), %rdi
callq 0xc0d0
movq 0xa0(%rbx), %rdi
callq 0xc0d0
movq 0xb0(%rbx), %rdi
callq 0xc0d0
movq 0xb8(%rbx), %rdi
callq 0xc0d0
movq 0xc0(%rbx), %rdi
callq 0xc0d0
movq 0xa8(%rbx), %rdi
callq 0x11171
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x110e3
movq 0x8(%rax), %rdi
callq 0xc0d0
movq 0x78(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0xc0d0
movq 0x78(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0xc0d0
movq 0x78(%rbx), %rdi
callq 0xc0d0
movq (%rbx), %rdi
callq 0x1118c
movq 0x8(%rbx), %rdi
callq 0x1118c
movq 0x30(%rbx), %rdi
callq 0x1118c
movq %rbx, %rdi
callq 0x12ce5
movq %rbx, %rdi
callq 0x12f3a
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x1112e
movq 0x10(%rax), %rdi
callq 0xc0d0
movq 0xc8(%rbx), %rdi
callq 0xc0d0
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0x1114f
movq 0x10(%rax), %rdi
callq 0xc0d0
movq 0xd0(%rbx), %rdi
callq 0xc0d0
movq 0x100(%rbx), %rdi
callq 0xc0d0
movq 0xf8(%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/chart.c
// Function: chart_free_range
STATIC void
_chart_free_range(lxw_series_range *range)
{
    struct lxw_series_data_point *data_point;

    if (!range)
        return;

    if (range->data_cache) {
        while (!STAILQ_EMPTY(range->data_cache)) {
            data_point = STAILQ_FIRST(range->data_cache);
            free(data_point->string);
            STAILQ_REMOVE_HEAD(range->data_cache, list_pointers);

            free(data_point);
        }
        free(range->data_cache);
    }

    free(range->formula);
    free(range->sheetname);
    free(range);
}

// Assembly:
testq %rdi, %rdi
je 0x111fc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x111cf
jmp 0x111dc
movq 0x10(%r14), %rdi
callq 0xc0d0
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
jne 0x111c3
movq %rax, 0x8(%rax)
movq %r14, %rdi
callq 0xc0d0
movq 0x20(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x111a3
callq 0xc0d0
movq (%rbx), %rdi
callq 0xc0d0
movq 0x8(%rbx), %rdi
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/chart.c
// Function: chart_init_data_cache
STATIC lxw_error
_chart_init_data_cache(lxw_series_range *range)
{
    /* Initialize the series range data cache. */
    range->data_cache = calloc(1, sizeof(struct lxw_series_data_points));
    RETURN_ON_MEM_ERROR(range->data_cache, LXW_ERROR_MEMORY_MALLOC_FAILED);
    STAILQ_INIT(range->data_cache);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x116cd
movq %rax, 0x8(%rax)
xorl %eax, %eax
popq %rbx
retq
movq 0x41924(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2ba02(%rip), %rsi     # 0x3d0e0
leaq 0x2bdf7(%rip), %rdx     # 0x3d4dc
movl $0xa2, %ecx
xorl %eax, %eax
callq 0xc8d0
pushq $0x1
popq %rax
jmp 0x116cb
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: lxw_chart_add_data_cache
lxw_error
lxw_chart_add_data_cache(lxw_series_range *range, uint8_t *data,
                         uint16_t rows, uint8_t cols, uint8_t col)
{
    struct lxw_series_data_point *data_point;
    uint16_t i;

    range->ignore_cache = LXW_TRUE;
    range->num_data_points = rows;

    /* Initialize the series range data cache. */
    for (i = 0; i < rows; i++) {
        data_point = calloc(1, sizeof(struct lxw_series_data_point));
        RETURN_ON_MEM_ERROR(data_point, LXW_ERROR_MEMORY_MALLOC_FAILED);
        STAILQ_INSERT_TAIL(range->data_cache, data_point, list_pointers);
        data_point->number = data[i * cols + col];
    }

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x1c(%rdi)
movw %dx, 0x1e(%rdi)
movl %ecx, %r12d
movl %r8d, %r13d
addq %rsi, %r13
movl %edx, %ebp
pushq $0x1
popq %r14
pushq $0x28
popq %r15
subq $0x1, %rbp
jb 0x123fa
movq %r14, %rdi
movq %r15, %rsi
callq 0xc850
testq %rax, %rax
je 0x1240b
andq $0x0, 0x20(%rax)
movq %rax, %rcx
addq $0x20, %rcx
movq 0x20(%rbx), %rdx
movq 0x8(%rdx), %rdx
movq %rax, (%rdx)
movq 0x20(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movzbl (%r13), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rax)
addq %r12, %r13
jmp 0x123b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40be6(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2acc4(%rip), %rsi     # 0x3d0e0
leaq 0x2b0b9(%rip), %rdx     # 0x3d4dc
movl $0x1437, %ecx           # imm = 0x1437
xorl %eax, %eax
callq 0xc8d0
pushq $0x1
popq %rax
jmp 0x123fc
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_name
void
chart_series_set_name(lxw_chart_series *series, const char *name)
{
    if (!name)
        return;

    if (name[0] == '=')
        series->title.range->formula = lxw_strdup(name + 1);
    else
        series->title.name = lxw_strdup(name);
}

// Assembly:
testq %rsi, %rsi
je 0x12689
pushq %rbx
movq %rdi, %rbx
cmpb $0x3d, (%rsi)
jne 0x1267c
incq %rsi
movq %rsi, %rdi
callq 0xcd50
movq 0x30(%rbx), %rcx
movq %rax, (%rcx)
jmp 0x12688
movq %rsi, %rdi
callq 0xcd50
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_name_range
void
chart_series_set_name_range(lxw_chart_series *series, const char *sheetname,
                            lxw_row_t row, lxw_col_t col)
{
    if (!sheetname) {
        LXW_WARN("chart_series_set_name_range(): "
                 "sheetname must be specified");
        return;
    }

    /* Start and end row, col are the same for single cell range. */
    _chart_set_range(series->title.range, sheetname, row, col, row, col);
}

// Assembly:
testq %rsi, %rsi
je 0x1269e
movq 0x30(%rdi), %rdi
movzwl %cx, %ecx
movl %edx, %r8d
movl %ecx, %r9d
jmp 0x126ba
movq 0x40953(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2aff4(%rip), %rdi     # 0x3d6a3
pushq $0x46
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_set_range
STATIC void
_chart_set_range(lxw_series_range *range, const char *sheetname,
                 lxw_row_t first_row, lxw_col_t first_col,
                 lxw_row_t last_row, lxw_col_t last_col)
{
    char formula[LXW_MAX_FORMULA_RANGE_LENGTH] = { 0 };

    /* Set the range properties. */
    range->sheetname = lxw_strdup(sheetname);
    range->first_row = first_row;
    range->first_col = first_col;
    range->last_row = last_row;
    range->last_col = last_col;

    /* Free any existing range. */
    free(range->formula);

    /* Convert the range properties to a formula like: Sheet1!$A$1:$A$5. */
    lxw_rowcol_to_formula_abs(formula, sheetname,
                              first_row, first_col, last_row, last_col);

    range->formula = lxw_strdup(formula);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x9b, %edx
xorl %esi, %esi
callq 0xc690
movq %r12, %rdi
callq 0xcd50
movq %rax, 0x8(%rbx)
movl %r13d, 0x10(%rbx)
movw %r15w, 0x18(%rbx)
movl %r14d, 0x14(%rbx)
movw %bp, 0x1a(%rbx)
movq (%rbx), %rdi
callq 0xc0d0
movq %rsp, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xd180
movq %rsp, %rdi
callq 0xcd50
movq %rax, (%rbx)
addq $0xa8, %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/chart.c
// Function: chart_series_set_categories
void
chart_series_set_categories(lxw_chart_series *series, const char *sheetname,
                            lxw_row_t first_row, lxw_col_t first_col,
                            lxw_row_t last_row, lxw_col_t last_col)
{
    if (!sheetname) {
        LXW_WARN("chart_series_set_categories(): "
                 "sheetname must be specified");
        return;
    }

    _chart_set_range(series->categories, sheetname,
                     first_row, first_col, last_row, last_col);
}

// Assembly:
testq %rsi, %rsi
je 0x12759
movq (%rdi), %rdi
movzwl %cx, %ecx
movzwl %r9w, %r9d
jmp 0x126ba
movq 0x40898(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2af80(%rip), %rdi     # 0x3d6ea
pushq $0x46
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_values
void
chart_series_set_values(lxw_chart_series *series, const char *sheetname,
                        lxw_row_t first_row, lxw_col_t first_col,
                        lxw_row_t last_row, lxw_col_t last_col)
{
    if (!sheetname) {
        LXW_WARN("chart_series_set_values(): sheetname must be specified");
        return;
    }

    _chart_set_range(series->values, sheetname,
                     first_row, first_col, last_row, last_col);
}

// Assembly:
testq %rsi, %rsi
je 0x1278a
movq 0x8(%rdi), %rdi
movzwl %cx, %ecx
movzwl %r9w, %r9d
jmp 0x126ba
movq 0x40867(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2af96(%rip), %rdi     # 0x3d731
pushq $0x42
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_convert_line_args
STATIC lxw_chart_line *
_chart_convert_line_args(lxw_chart_line *user_line)
{
    lxw_chart_line *line;

    if (!user_line)
        return NULL;

    line = calloc(1, sizeof(struct lxw_chart_line));
    RETURN_ON_MEM_ERROR(line, NULL);

    /* Copy the user supplied properties. */
    line->color = user_line->color;
    line->none = user_line->none;
    line->width = user_line->width;
    line->dash_type = user_line->dash_type;
    line->transparency = user_line->transparency;

    if (line->transparency > 100)
        line->transparency = 0;

    return line;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12820
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x1282d
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
movb 0x4(%r14), %al
movb %al, 0x4(%rbx)
movss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%rbx)
movb 0xc(%r14), %al
movb %al, 0xc(%rbx)
movzbl 0xd(%r14), %eax
xorl %ecx, %ecx
cmpb $0x65, %al
cmovbl %eax, %ecx
movb %cl, 0xd(%rbx)
jmp 0x12822
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x407c4(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a8a2(%rip), %rsi     # 0x3d0e0
leaq 0x2ac97(%rip), %rdx     # 0x3d4dc
xorl %ebx, %ebx
movl $0x176, %ecx            # imm = 0x176
xorl %eax, %eax
callq 0xc8d0
jmp 0x12822
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_convert_fill_args
STATIC lxw_chart_fill *
_chart_convert_fill_args(lxw_chart_fill *user_fill)
{
    lxw_chart_fill *fill;

    if (!user_fill)
        return NULL;

    fill = calloc(1, sizeof(struct lxw_chart_fill));
    RETURN_ON_MEM_ERROR(fill, NULL);

    /* Copy the user supplied properties. */
    fill->color = user_fill->color;
    fill->none = user_fill->none;
    fill->transparency = user_fill->transparency;

    if (fill->transparency > 100)
        fill->transparency = 0;

    return fill;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x128bd
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x128ca
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
movb 0x4(%r14), %al
movb %al, 0x4(%rbx)
movzbl 0x5(%r14), %eax
xorl %ecx, %ecx
cmpb $0x65, %al
cmovbl %eax, %ecx
movb %cl, 0x5(%rbx)
jmp 0x128bf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40727(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a805(%rip), %rsi     # 0x3d0e0
leaq 0x2abfa(%rip), %rdx     # 0x3d4dc
xorl %ebx, %ebx
movl $0x191, %ecx            # imm = 0x191
xorl %eax, %eax
callq 0xc8d0
jmp 0x128bf
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_convert_pattern_args
STATIC lxw_chart_pattern *
_chart_convert_pattern_args(lxw_chart_pattern *user_pattern)
{
    lxw_chart_pattern *pattern;

    if (!user_pattern)
        return NULL;

    if (!user_pattern->type) {
        LXW_WARN("chart_xxx_set_pattern: 'type' must be specified");
        return NULL;
    }

    if (!user_pattern->fg_color) {
        LXW_WARN("chart_xxx_set_pattern: 'fg_color' must be specified");
        return NULL;
    }

    pattern = calloc(1, sizeof(struct lxw_chart_pattern));
    RETURN_ON_MEM_ERROR(pattern, NULL);

    /* Copy the user supplied properties. */
    pattern->fg_color = user_pattern->fg_color;
    pattern->bg_color = user_pattern->bg_color;
    pattern->type = user_pattern->type;

    if (!pattern->bg_color) {
        /* Default background color in Excel is white, when unspecified. */
        pattern->bg_color = LXW_COLOR_WHITE;
    }

    return pattern;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x129a5
movq %rdi, %r14
movb 0x8(%rdi), %bpl
testb %bpl, %bpl
je 0x12974
movl (%r14), %r15d
testl %r15d, %r15d
je 0x12989
pushq $0x1
popq %rdi
pushq $0xc
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x129b5
movq %rax, %rbx
movl %r15d, (%rax)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rbx)
movb %bpl, 0x8(%rbx)
testl %eax, %eax
jne 0x129a7
movl $0xffffff, 0x4(%rbx)    # imm = 0xFFFFFF
jmp 0x129a7
movq 0x4067d(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2c152(%rip), %rdi     # 0x3ead7
pushq $0x3b
jmp 0x1299c
movq 0x40668(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2c179(%rip), %rdi     # 0x3eb13
pushq $0x3f
popq %rsi
pushq $0x1
popq %rdx
callq 0xd000
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x4063c(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a71a(%rip), %rsi     # 0x3d0e0
leaq 0x2ab0f(%rip), %rdx     # 0x3d4dc
xorl %ebx, %ebx
movl $0x1b4, %ecx            # imm = 0x1B4
xorl %eax, %eax
callq 0xc8d0
jmp 0x129a7
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_marker_type
void
chart_series_set_marker_type(lxw_chart_series *series, uint8_t type)
{
    if (!series->marker) {
        lxw_chart_marker *marker = calloc(1, sizeof(struct lxw_chart_marker));
        RETURN_VOID_ON_MEM_ERROR(marker);
        series->marker = marker;
    }

    series->marker->type = type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x78(%rdi), %rax
testq %rax, %rax
jne 0x12a03
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x12a0d
movq %rax, 0x78(%r14)
movb %bl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x405e4(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a6c2(%rip), %rsi     # 0x3d0e0
leaq 0x2aab7(%rip), %rdx     # 0x3d4dc
movl $0x151c, %ecx           # imm = 0x151C
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_marker_size
void
chart_series_set_marker_size(lxw_chart_series *series, uint8_t size)
{
    if (!series->marker) {
        lxw_chart_marker *marker = calloc(1, sizeof(struct lxw_chart_marker));
        RETURN_VOID_ON_MEM_ERROR(marker);
        series->marker = marker;
    }

    series->marker->size = size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x78(%rdi), %rax
testq %rax, %rax
jne 0x12a5e
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x12a69
movq %rax, 0x78(%r14)
movb %bl, 0x1(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40588(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a666(%rip), %rsi     # 0x3d0e0
leaq 0x2aa5b(%rip), %rdx     # 0x3d4dc
movl $0x152b, %ecx           # imm = 0x152B
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_marker_line
void
chart_series_set_marker_line(lxw_chart_series *series, lxw_chart_line *line)
{
    if (!line)
        return;

    if (!series->marker) {
        lxw_chart_marker *marker = calloc(1, sizeof(struct lxw_chart_marker));
        RETURN_VOID_ON_MEM_ERROR(marker);
        series->marker = marker;
    }

    /* Free any previously allocated resource. */
    free(series->marker->line);

    series->marker->line = _chart_convert_line_args(line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x12ad9
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rax
testq %rax, %rax
jne 0x12ac0
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x12ae1
movq %rax, 0x78(%rbx)
movq 0x8(%rax), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0x127d2
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40510(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a5ee(%rip), %rsi     # 0x3d0e0
leaq 0x2a9e3(%rip), %rdx     # 0x3d4dc
movl $0x153d, %ecx           # imm = 0x153D
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_marker_fill
void
chart_series_set_marker_fill(lxw_chart_series *series, lxw_chart_fill *fill)
{
    if (!fill)
        return;

    if (!series->marker) {
        lxw_chart_marker *marker = calloc(1, sizeof(struct lxw_chart_marker));
        RETURN_VOID_ON_MEM_ERROR(marker);
        series->marker = marker;
    }

    /* Free any previously allocated resource. */
    free(series->marker->fill);

    series->marker->fill = _chart_convert_fill_args(fill);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x12b51
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rax
testq %rax, %rax
jne 0x12b38
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x12b59
movq %rax, 0x78(%rbx)
movq 0x10(%rax), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0x12881
movq 0x78(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40498(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a576(%rip), %rsi     # 0x3d0e0
leaq 0x2a96b(%rip), %rdx     # 0x3d4dc
movl $0x1552, %ecx           # imm = 0x1552
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_marker_pattern
void
chart_series_set_marker_pattern(lxw_chart_series *series,
                                lxw_chart_pattern *pattern)
{
    if (!pattern)
        return;

    if (!series->marker) {
        lxw_chart_marker *marker = calloc(1, sizeof(struct lxw_chart_marker));
        RETURN_VOID_ON_MEM_ERROR(marker);
        series->marker = marker;
    }

    /* Free any previously allocated resource. */
    free(series->marker->pattern);

    series->marker->pattern = _chart_convert_pattern_args(pattern);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x12bc9
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rax
testq %rax, %rax
jne 0x12bb0
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x12bd1
movq %rax, 0x78(%rbx)
movq 0x18(%rax), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0x12926
movq 0x78(%rbx), %rcx
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40420(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a4fe(%rip), %rsi     # 0x3d0e0
leaq 0x2a8f3(%rip), %rdx     # 0x3d4dc
movl $0x1568, %ecx           # imm = 0x1568
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8d0
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_points
lxw_error
chart_series_set_points(lxw_chart_series *series, lxw_chart_point *points[])
{
    uint16_t i = 0;
    uint16_t point_count = 0;

    if (points == NULL)
        return LXW_ERROR_NULL_PARAMETER_IGNORED;

    while (points[point_count])
        point_count++;

    if (point_count == 0)
        return LXW_ERROR_NULL_PARAMETER_IGNORED;

    /* Free any existing resource. */
    _chart_free_points(series);

    series->points = calloc(point_count, sizeof(lxw_chart_point));
    RETURN_ON_MEM_ERROR(series->points, LXW_ERROR_MEMORY_MALLOC_FAILED);

    for (i = 0; i < point_count; i++) {
        lxw_chart_point *src_point = points[i];
        lxw_chart_point *dst_point = &series->points[i];

        dst_point->line = _chart_convert_line_args(src_point->line);
        dst_point->fill = _chart_convert_fill_args(src_point->fill);
        dst_point->pattern = _chart_convert_pattern_args(src_point->pattern);
    }

    series->point_count = point_count;

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
pushq $0xc
popq %rax
testq %rsi, %rsi
je 0x12cad
movq %rsi, %r14
movw $0xffff, %bp            # imm = 0xFFFF
incl %ebp
movzwl %bp, %r15d
cmpq $0x0, (%r14,%r15,8)
jne 0x12c1e
testw %bp, %bp
je 0x12cad
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x12ce5
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0xc850
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x12cbc
leaq (%r15,%r15,2), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x12ca0
movq (%r14), %r13
movq (%rsp), %rax
movq 0x80(%rax), %rbx
movq (%r13), %rdi
callq 0x127d2
movq %rax, (%rbx,%r12,8)
movq 0x8(%r13), %rdi
callq 0x12881
movq %rax, 0x8(%rbx,%r12,8)
movq 0x10(%r13), %rdi
callq 0x12926
movq %rax, 0x10(%rbx,%r12,8)
addq $0x3, %r12
addq $0x8, %r14
jmp 0x12c5a
movq (%rsp), %rax
movw %bp, 0x90(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40335(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a413(%rip), %rsi     # 0x3d0e0
leaq 0x2a808(%rip), %rdx     # 0x3d4dc
movl $0x1588, %ecx           # imm = 0x1588
xorl %eax, %eax
callq 0xc8d0
pushq $0x1
popq %rax
jmp 0x12cad
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_free_points
STATIC void
_chart_free_points(lxw_chart_series *series)
{
    uint16_t index;

    for (index = 0; index < series->point_count; index++) {
        lxw_chart_point *point = &series->points[index];

        free(point->line);
        free(point->fill);
        free(point->pattern);
    }

    series->point_count = 0;
    free(series->points);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r14
xorl %r15d, %r15d
movzwl 0x90(%rbx), %eax
cmpq %rax, %r15
jae 0x12d30
movq 0x80(%rbx), %r12
movq -0x10(%r12,%r14), %rdi
callq 0xc0d0
movq -0x8(%r12,%r14), %rdi
callq 0xc0d0
movq (%r12,%r14), %rdi
callq 0xc0d0
incq %r15
addq $0x18, %r14
jmp 0x12cf7
andw $0x0, 0x90(%rbx)
movq 0x80(%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/chart.c
// Function: chart_free_data_labels
STATIC void
_chart_free_data_labels(lxw_chart_series *series)
{
    uint16_t index;

    for (index = 0; index < series->data_label_count; index++) {
        lxw_chart_custom_label *data_label = &series->data_labels[index];

        free(data_label->value);
        _chart_free_range(data_label->range);
        _chart_free_font(data_label->font);
        free(data_label->line);
        free(data_label->fill);
        free(data_label->pattern);
    }

    series->data_label_count = 0;
    free(series->data_labels);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x30
popq %r14
xorl %r15d, %r15d
movzwl 0x92(%rbx), %eax
cmpq %rax, %r15
jae 0x12fa3
movq 0x88(%rbx), %r12
movq -0x30(%r12,%r14), %rdi
callq 0xc0d0
movq (%r12,%r14), %rdi
callq 0x1118c
movq -0x20(%r12,%r14), %rdi
callq 0x11171
movq -0x18(%r12,%r14), %rdi
callq 0xc0d0
movq -0x10(%r12,%r14), %rdi
callq 0xc0d0
movq -0x8(%r12,%r14), %rdi
callq 0xc0d0
incq %r15
addq $0x60, %r14
jmp 0x12f4c
andw $0x0, 0x92(%rbx)
movq 0x88(%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/chart.c
// Function: chart_convert_font_args
STATIC lxw_chart_font *
_chart_convert_font_args(lxw_chart_font *user_font)
{
    lxw_chart_font *font;

    if (!user_font)
        return NULL;

    font = calloc(1, sizeof(struct lxw_chart_font));
    RETURN_ON_MEM_ERROR(font, NULL);

    /* Copy the user supplied properties. */
    font->name = lxw_strdup(user_font->name);
    font->size = user_font->size;
    font->bold = user_font->bold;
    font->italic = user_font->italic;
    font->underline = user_font->underline;
    font->rotation = user_font->rotation;
    font->color = user_font->color;
    font->pitch_family = user_font->pitch_family;
    font->charset = user_font->charset;
    font->baseline = user_font->baseline;

    /* Convert font size units. */
    if (font->size > 0.0)
        font->size = font->size * 100.0;

    /* Convert rotation into 60,000ths of a degree. */
    if (font->rotation)
        font->rotation = font->rotation * 60000;

    return font;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13060
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0xc850
testq %rax, %rax
je 0x1306d
movq %rax, %rbx
movq (%r14), %rdi
callq 0xcd50
movq %rax, (%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movb 0x10(%r14), %al
movb %al, 0x10(%rbx)
movb 0x11(%r14), %al
movb %al, 0x11(%rbx)
movb 0x12(%r14), %al
movb %al, 0x12(%rbx)
movq 0x14(%r14), %rax
movq %rax, %xmm1
movq %rax, 0x14(%rbx)
movb 0x1c(%r14), %al
movb %al, 0x1c(%rbx)
movb 0x1d(%r14), %al
movb %al, 0x1d(%rbx)
movb 0x1e(%r14), %al
movb %al, 0x1e(%rbx)
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x1304d
mulsd 0x2a488(%rip), %xmm0    # 0x3d4d0
movsd %xmm0, 0x8(%rbx)
movd %xmm1, %eax
testl %eax, %eax
je 0x13062
imull $0xea60, %eax, %eax     # imm = 0xEA60
movl %eax, 0x14(%rbx)
jmp 0x13062
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3ff84(%rip), %rax     # 0x52ff8
movq (%rax), %rdi
leaq 0x2a062(%rip), %rsi     # 0x3d0e0
leaq 0x2a457(%rip), %rdx     # 0x3d4dc
xorl %ebx, %ebx
movl $0x151, %ecx            # imm = 0x151
xorl %eax, %eax
callq 0xc8d0
jmp 0x13062
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_trendline
void
chart_series_set_trendline(lxw_chart_series *series, uint8_t type,
                           uint8_t value)
{
    if (type == LXW_CHART_TRENDLINE_TYPE_POLY
        || type == LXW_CHART_TRENDLINE_TYPE_AVERAGE) {

        if (value < 2) {
            LXW_WARN("chart_series_set_trendline(): order/period value must "
                     "be >= 2 for Polynomial and Moving Average types");
            return;
        }

        series->trendline_value_type = type;
    }

    series->has_trendline = LXW_TRUE;
    series->trendline_type = type;
    series->trendline_value = value;
}

// Assembly:
cmpl $0x5, %esi
je 0x131ef
cmpl $0x2, %esi
jne 0x131fb
cmpb $0x1, %dl
jbe 0x13210
movb %sil, 0xf0(%rdi)
movb $0x1, 0xd8(%rdi)
movb %sil, 0xdd(%rdi)
movb %dl, 0xde(%rdi)
retq
movq 0x3fde1(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a553(%rip), %rdi     # 0x3d774
pushq $0x71
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_trendline_forecast
void
chart_series_set_trendline_forecast(lxw_chart_series *series, double forward,
                                    double backward)
{
    if (!series->has_trendline) {
        LXW_WARN("chart_series_set_trendline_forecast(): trendline type "
                 "must be set first using chart_series_set_trendline()");
        return;
    }

    if (series->trendline_type == LXW_CHART_TRENDLINE_TYPE_AVERAGE) {
        LXW_WARN("chart_series_set_trendline(): forecast isn't available "
                 "in Excel for a Moving Average trendline");
        return;
    }

    series->has_trendline_forecast = LXW_TRUE;
    series->trendline_forward = forward;
    series->trendline_backward = backward;
}

// Assembly:
cmpb $0x0, 0xd8(%rdi)
je 0x13256
cmpb $0x5, 0xdd(%rdi)
je 0x1326b
movb $0x1, 0xd9(%rdi)
movsd %xmm0, 0xe0(%rdi)
movsd %xmm1, 0xe8(%rdi)
retq
movq 0x3fd9b(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a57f(%rip), %rdi     # 0x3d7e6
pushq $0x76
jmp 0x1327e
movq 0x3fd86(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a5e1(%rip), %rdi     # 0x3d85d
pushq $0x6a
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_trendline_equation
void
chart_series_set_trendline_equation(lxw_chart_series *series)
{
    if (!series->has_trendline) {
        LXW_WARN("chart_series_set_trendline_equation(): trendline type "
                 "must be set first using chart_series_set_trendline()");
        return;
    }

    if (series->trendline_type == LXW_CHART_TRENDLINE_TYPE_AVERAGE) {
        LXW_WARN("chart_series_set_trendline_equation(): equation isn't "
                 "available in Excel for a Moving Average trendline");
        return;
    }

    series->has_trendline_equation = LXW_TRUE;
}

// Assembly:
cmpb $0x0, 0xd8(%rdi)
je 0x132a1
cmpb $0x5, 0xdd(%rdi)
je 0x132b6
movb $0x1, 0xda(%rdi)
retq
movq 0x3fd50(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a616(%rip), %rdi     # 0x3d8c8
pushq $0x76
jmp 0x132c9
movq 0x3fd3b(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a678(%rip), %rdi     # 0x3d93f
pushq $0x73
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_trendline_r_squared
void
chart_series_set_trendline_r_squared(lxw_chart_series *series)
{
    if (!series->has_trendline) {
        LXW_WARN("chart_series_set_trendline_r_squared(): trendline type "
                 "must be set first using chart_series_set_trendline()");
        return;
    }

    if (series->trendline_type == LXW_CHART_TRENDLINE_TYPE_AVERAGE) {
        LXW_WARN("chart_series_set_trendline_r_squared(): R squared isn't "
                 "available in Excel for a Moving Average trendline");
        return;
    }

    series->has_trendline_r_squared = LXW_TRUE;
}

// Assembly:
cmpb $0x0, 0xd8(%rdi)
je 0x132ec
cmpb $0x5, 0xdd(%rdi)
je 0x13301
movb $0x1, 0xdb(%rdi)
retq
movq 0x3fd05(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a6b6(%rip), %rdi     # 0x3d9b3
pushq $0x77
jmp 0x13314
movq 0x3fcf0(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a719(%rip), %rdi     # 0x3da2b
pushq $0x75
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_trendline_intercept
void
chart_series_set_trendline_intercept(lxw_chart_series *series,
                                     double intercept)
{
    if (!series->has_trendline) {
        LXW_WARN("chart_series_set_trendline_intercept(): trendline type "
                 "must be set first using chart_series_set_trendline()");
        return;
    }

    if (series->trendline_type != LXW_CHART_TRENDLINE_TYPE_EXP
        && series->trendline_type != LXW_CHART_TRENDLINE_TYPE_LINEAR
        && series->trendline_type != LXW_CHART_TRENDLINE_TYPE_POLY) {

        LXW_WARN("chart_series_set_trendline_intercept(): intercept is only "
                 "available in Excel for Exponential, Linear and Polynomial "
                 "trendline types");
        return;
    }

    series->has_trendline_intercept = LXW_TRUE;
    series->trendline_intercept = intercept;
}

// Assembly:
cmpb $0x0, 0xd8(%rdi)
je 0x1334a
movzbl 0xdd(%rdi), %eax
cmpl $0x4, %eax
ja 0x13366
pushq $0x15
popq %rcx
btl %eax, %ecx
jae 0x13366
movb $0x1, 0xdc(%rdi)
movsd %xmm0, 0x108(%rdi)
retq
movq 0x3fca7(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a746(%rip), %rdi     # 0x3daa1
pushq $0x77
popq %rsi
pushq $0x1
popq %rdx
jmp 0xd000
movq 0x3fc8b(%rip), %rax     # 0x52ff8
movq (%rax), %rcx
leaq 0x2a7a2(%rip), %rdi     # 0x3db19
pushq $0x1
popq %rdx
movl $0x8f, %esi
jmp 0xd000
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_error_bars
void
chart_series_set_error_bars(lxw_series_error_bars *error_bars,
                            uint8_t type, double value)
{
    if (_chart_check_error_bars(error_bars, ""))
        return;

    error_bars->type = type;
    error_bars->value = value;
    error_bars->has_value = LXW_TRUE;
    error_bars->is_set = LXW_TRUE;

    if (type == LXW_CHART_ERROR_BAR_TYPE_STD_ERROR)
        error_bars->has_value = LXW_FALSE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x3330b(%rip), %rsi     # 0x46729
callq 0xc940
testl %eax, %eax
jne 0x13443
movb %bpl, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movw $0x101, 0x3(%rbx)       # imm = 0x101
testb %bpl, %bpl
jne 0x13443
movb $0x0, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_set_error_bars_line
void
chart_series_set_error_bars_line(lxw_series_error_bars *error_bars,
                                 lxw_chart_line *line)
{
    if (_chart_check_error_bars(error_bars, "_line"))
        return;

    if (!line)
        return;

    /* Free any previously allocated resource. */
    free(error_bars->line);

    error_bars->line = _chart_convert_line_args(line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2a717(%rip), %rsi     # 0x3dbbc
callq 0xc940
testq %r14, %r14
je 0x134c8
testl %eax, %eax
jne 0x134c8
movq 0x10(%rbx), %rdi
callq 0xc0d0
movq %r14, %rdi
callq 0x127d2
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq