LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pcx.c
// Function: de_identify_mswordscr
static int de_identify_mswordscr(deark *c)
{
	u8 buf[8];

	de_read(buf, 0, 8);
	if(buf[0]==0xcd && (buf[1]==0 || buf[1]==2 || buf[1]==3
		|| buf[1]==4 || buf[1]==5) &&
		buf[2]==1 )
	{
		if(de_input_file_has_ext(c, "scr") || de_input_file_has_ext(c, "mwg"))
			return 100;

		return 10;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
movl $0x8, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
cmpb $-0x33, (%r15)
jne 0xb0858
movb 0x9(%rsp), %al
testb $-0x3, %al
setne %cl
addb $-0x3, %al
cmpb $0x3, %al
setae %al
testb %al, %cl
jne 0xb0858
cmpb $0x1, 0xa(%rsp)
jne 0xb0858
leaq 0x85a12(%rip), %rsi     # 0x136238
movq %rbx, %rdi
callq 0xea491
movl $0x64, %r14d
testl %eax, %eax
jne 0xb0858
leaq 0x85ef1(%rip), %rsi     # 0x136730
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
movl $0xa, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pcx.c
// Function: de_module_dcx
void de_module_dcx(deark *c, struct deark_module_info *mi)
{
	mi->id = "dcx";
	mi->desc = "DCX (multi-image PCX)";
	mi->run_fn = de_run_dcx;
	mi->identify_fn = de_identify_dcx;
}

// Assembly:
leaq 0x859ef(%rip), %rax     # 0x13625b
movq %rax, (%rsi)
leaq 0x859e9(%rip), %rax     # 0x13625f
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xb0891
movq %rax, 0x18(%rsi)
leaq 0x10f(%rip), %rax       # 0xb099b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pcx.c
// Function: de_run_dcx
static void de_run_dcx(deark *c, de_module_params *mparams)
{
	u32 *page_offset;
	i64 num_pages;
	i64 page;
	i64 page_size;

	page_offset = de_mallocarray(c, 1023, sizeof(u32));
	num_pages = 0;
	while(num_pages < 1023) {
		page_offset[num_pages] = (u32)de_getu32le(4 + 4*num_pages);
		if(page_offset[num_pages]==0)
			break;
		num_pages++;
	}

	de_dbg(c, "number of pages: %d", (int)num_pages);

	for(page=0; page<num_pages; page++) {
		if(page == num_pages-1) {
			// Last page. Assume it goes to the end of file.
			page_size = c->infile->len - page_offset[page];
		}
		else {
			page_size = page_offset[page+1] - page_offset[page];
		}
		if(page_size<0) page_size=0;
		de_dbg(c, "page %d at %u, size=%"I64_FMT, (int)page, (UI)page_offset[page],
			page_size);

		dbuf_create_file_from_slice(c->infile, page_offset[page], page_size, "pcx", NULL, 0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4, %r15d
movl $0x3ff, %esi            # imm = 0x3FF
movl $0x4, %edx
callq 0xe96f7
movq %rax, %r14
xorl %r12d, %r12d
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeed61
movl %eax, -0x4(%r14,%r15)
testl %eax, %eax
je 0xb08fd
decq %r12
addq $0x4, %r15
cmpq $-0x3ff, %r12           # imm = 0xFC01
jne 0xb08ba
leaq 0x85e4e(%rip), %rsi     # 0x136734
movq %rbx, %rdi
movl $0x3ff, %edx            # imm = 0x3FF
xorl %eax, %eax
callq 0xe8617
movl $0x3ff, %r15d           # imm = 0x3FF
jmp 0xb091c
movq %r12, %r15
negq %r15
leaq 0x85e2a(%rip), %rsi     # 0x136734
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe8617
testq %r12, %r12
je 0xb098c
leaq -0x1(%r15), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
jne 0xb0939
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r12
movl -0x4(%r14,%r15,4), %ecx
subq %rcx, %r12
jmp 0xb0945
movl (%r14,%rbp,4), %ecx
movl 0x4(%r14,%rbp,4), %r12d
subl %ecx, %r12d
testq %r12, %r12
movl $0x0, %eax
cmovleq %rax, %r12
movq %rbx, %rdi
leaq 0x85ded(%rip), %rsi     # 0x136748
movl %ebp, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movl (%r14,%rbp,4), %esi
movq %r12, %rdx
leaq 0x858ab(%rip), %rcx     # 0x136224
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xefd48
incq %rbp
cmpq %rbp, %r15
jne 0xb0922
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pcx.c
// Function: de_module_pcx2com
void de_module_pcx2com(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcx2com";
	mi->desc = "PCX2COM self-displaying image";
	mi->run_fn = de_run_pcx2com;
	mi->identify_fn = de_identify_pcx2com;
}

// Assembly:
leaq 0x858ad(%rip), %rax     # 0x136275
movq %rax, (%rsi)
leaq 0x858ab(%rip), %rax     # 0x13627d
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xb09ed
movq %rax, 0x18(%rsi)
leaq 0xd2(%rip), %rax        # 0xb0aba
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pcx.c
// Function: de_run_pcx2com
static void de_run_pcx2com(deark *c, de_module_params *mparams)
{
	i64 pos;
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "pcx", NULL, 0);

	// header
	dbuf_enable_wbuffer(outf);
	dbuf_write(outf, (const u8*)"\x0a\x05\x01\x08\x00\x00\x00\x00\x3f\x01\xc7", 11);
	dbuf_truncate(outf, 64);
	dbuf_write(outf, (const u8*)"\x00\x01\x40\x01\x01\x00\x40\x01\xc8", 9);
	dbuf_truncate(outf, 128);

	// image data, and 0x0c palette marker
	dbuf_copy(c->infile, 920, c->infile->len-920, outf);

	// VGA palette
	pos = 152;
	while(pos < 152+768) {
		u8 x;

		x = de_getbyte_p(&pos);
		dbuf_writebyte(outf, de_scale_63_to_255(x));
	}

	dbuf_close(outf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x85824(%rip), %rsi     # 0x136224
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r14
movq %rax, %rdi
callq 0xf0855
leaq 0x857d5(%rip), %rsi     # 0x1361f0
movl $0xb, %edx
movq %r14, %rdi
callq 0xef547
movl $0x40, %esi
movq %r14, %rdi
callq 0xf0f27
leaq 0x857c0(%rip), %rsi     # 0x1361fc
movl $0x9, %edx
movq %r14, %rdi
callq 0xef547
movl $0x80, %esi
movq %r14, %rdi
callq 0xf0f27
movq 0x18(%rbx), %rdi
movq $-0x398, %rdx           # imm = 0xFC68
addq 0x18(%rdi), %rdx
movl $0x398, %esi            # imm = 0x398
movq %r14, %rcx
callq 0xef481
leaq 0x8(%rsp), %r15
movq $0x98, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %edi
callq 0xec78a
movzbl %al, %esi
movq %r14, %rdi
callq 0xf0bd6
cmpq $0x398, 0x8(%rsp)       # imm = 0x398
jl 0xb0a7e
movq %r14, %rdi
callq 0xf052b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pcx.c
// Function: de_identify_pcx2com
static int de_identify_pcx2com(deark *c)
{
	if(c->infile->len<922 || c->infile->len>65280) return 0;

	if((UI)de_getu32be(0)!=0xb81300cdU) return 0;
	if(de_getbyte(c->infile->len-1) != 0x0c) return 0;

	// The is the substring "Self PCX", xor 0x80.
	if(dbuf_memcmp(c->infile, 104,
		(const u8*)"\xd3\xe5\xec\xe6\xa0\xd0\xc3\xd8", 8))
	{
		return 0;
	}

	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq $-0xff01, %rax          # imm = 0xFFFF00FF
addq 0x18(%rdi), %rax
xorl %ebx, %ebx
cmpq $-0xfb67, %rax          # imm = 0xFFFF0499
jb 0xb0b24
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeed0d
cmpl $0xb81300cd, %eax       # imm = 0xB81300CD
jne 0xb0b24
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rsi
decq %rsi
callq 0xeead3
cmpb $0xc, %al
jne 0xb0b24
movq 0x18(%r14), %rdi
leaq 0x85c5c(%rip), %rdx     # 0x136765
movl $0x68, %esi
movl $0x8, %ecx
callq 0xefc85
xorl %ecx, %ecx
testl %eax, %eax
movl $0x64, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pff2.c
// Function: de_module_pff2
void de_module_pff2(deark *c, struct deark_module_info *mi)
{
	mi->id = "pff2";
	mi->desc = "PFF2 font";
	mi->run_fn = de_run_pff2;
	mi->identify_fn = de_identify_pff2;
}

// Assembly:
leaq 0x84baf(%rip), %rax     # 0x13676e
movq %rax, (%rsi)
leaq 0x84baa(%rip), %rax     # 0x136773
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xb1be4
movq %rax, 0x18(%rsi)
leaq 0xf1(%rip), %rax        # 0xb1cd0
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pff2.c
// Function: de_run_pff2
static void de_run_pff2(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	struct de_iffctx *ictx = NULL;
	i64 i;

	d = de_malloc(c, sizeof(lctx));
	ictx = fmtutil_create_iff_decoder(c);

	ictx->userdata = (void*)d;
	ictx->alignment = 1;
	ictx->preprocess_chunk_fn = my_preprocess_pff2_chunk_fn;
	ictx->handle_chunk_fn = my_pff2_chunk_handler;
	ictx->f = c->infile;

	d->font = de_create_bitmap_font(c);
	d->font->has_nonunicode_codepoints = 0;
	d->font->has_unicode_codepoints = 1;
	d->font->prefer_unicode = 1;

	fmtutil_read_iff_format(ictx, 0, c->infile->len);

	if(d->font) {
		if(d->font->char_array) {
			for(i=0; i<d->font->num_chars; i++) {
				de_free(c, d->font->char_array[i].bitmap);
			}
			de_free(c, d->font->char_array);
		}
		de_destroy_bitmap_font(c, d->font);
	}

	fmtutil_destroy_iff_decoder(ictx);
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x10, %esi
callq 0xe8b2b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1075c0
movq %rax, %r15
movq %r14, 0x10(%rax)
movq $0x1, 0x48(%rax)
leaq 0xdb(%rip), %rax        # 0xb1cf6
movq %rax, 0x28(%r15)
leaq 0x124(%rip), %rax       # 0xb1d4a
movq %rax, 0x20(%r15)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r15)
movq %rbx, %rdi
callq 0xf5358
movq %rax, (%r14)
movw $0x100, 0x10(%rax)      # imm = 0x100
movb $0x1, 0x12(%rax)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1075e4
movq (%r14), %rsi
testq %rsi, %rsi
je 0xb1cb4
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0xb1cac
cmpq $0x0, 0x18(%rsi)
jle 0xb1c9e
movl $0x20, %r12d
xorl %r13d, %r13d
movq 0x20(%rsi), %rax
movq (%rax,%r12), %rsi
movq %rbx, %rdi
callq 0xe8be2
incq %r13
movq (%r14), %rsi
addq $0x28, %r12
cmpq 0x18(%rsi), %r13
jl 0xb1c7a
movq 0x20(%rsi), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe8be2
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xf536d
movq %r15, %rdi
callq 0x1075d3
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pff2.c
// Function: my_preprocess_pff2_chunk_fn
static int my_preprocess_pff2_chunk_fn(struct de_iffctx *ictx)
{
	const struct pff2_sectiontype_info *si;

	si = find_pffs_sectiontype_info(ictx->chunkctx->chunk4cc.id);
	if(si) {
		ictx->chunkctx->chunk_name = si->name;
	}

	if(ictx->chunkctx->dlen==0xffffffffU) {
		// The 'DATA' chunk's length is usually set to the special value 0xffffffff.
		// We are allowed to adjust ictx->chunkctx->dlen here.
		ictx->chunkctx->dlen = ictx->f->len - ictx->chunkctx->dpos;
	}
	return 1;
}

// Assembly:
movq 0x128(%rdi), %rax
movl 0x4(%rax), %edx
movl $0x8, %ecx
leaq 0xd4434(%rip), %rsi     # 0x186140
cmpl %edx, -0x8(%rcx,%rsi)
je 0xb1d21
addq $0x18, %rcx
cmpq $0x128, %rcx            # imm = 0x128
jne 0xb1d0c
jmp 0xb1d29
movq (%rcx,%rsi), %rcx
movq %rcx, 0x58(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, 0x48(%rax)
jne 0xb1d44
movq 0x18(%rdi), %rcx
movq 0x18(%rcx), %rcx
subq 0x40(%rax), %rcx
movq %rcx, 0x48(%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pff2.c
// Function: my_pff2_chunk_handler
static int my_pff2_chunk_handler(struct de_iffctx *ictx)
{
	deark *c = ictx->c;
	lctx *d = (lctx*)ictx->userdata;
	const struct pff2_sectiontype_info *si;

	si = find_pffs_sectiontype_info(ictx->chunkctx->chunk4cc.id);
	if(!si) goto done;
	ictx->handled = 1;

	// Default value decoders:
	if(si->flags&0x1) {
		de_ucstring *str;
		str = ucstring_create(c);
		dbuf_read_to_ucstring_n(ictx->f,
			ictx->chunkctx->dpos, ictx->chunkctx->dlen,
			DE_DBG_MAX_STRLEN, str, 0, DE_ENCODING_ASCII);
		de_dbg(c, "value: \"%s\"", ucstring_getpsz_d(str));
		ucstring_destroy(str);
	}
	else if(si->flags&0x2) {
		i64 n;
		n = dbuf_getu16be(ictx->f, ictx->chunkctx->dpos);
		de_dbg(c, "value: %d", (int)n);
	}

	if(si->hfn) {
		si->hfn(c, d, si, ictx->chunkctx->dpos, ictx->chunkctx->dlen);
	}

done:
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rbx
movq 0x10(%rdi), %r14
movq 0x128(%rdi), %rax
movl 0x4(%rax), %ecx
xorl %ebp, %ebp
leaq 0xd43ce(%rip), %r12     # 0x186140
cmpl %ecx, (%rbp,%r12)
je 0xb1d8b
addq $0x18, %rbp
cmpq $0x120, %rbp            # imm = 0x120
jne 0xb1d72
jmp 0xb1e47
movl $0x1, 0x130(%r15)
movl 0x4(%rbp,%r12), %ecx
testb $0x1, %cl
jne 0xb1dc7
testb $0x2, %cl
je 0xb1e20
movq 0x18(%r15), %rdi
movq 0x40(%rax), %rsi
callq 0xeeb67
leaq 0x78f6b(%rip), %rsi     # 0x12ad24
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
jmp 0xb1e20
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r13
movq 0x18(%r15), %rdi
movq 0x128(%r15), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
movl $0x1, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r13, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq %r13, %rdi
callq 0xf70f6
leaq 0x60960(%rip), %rsi     # 0x11276b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r13, %rdi
callq 0xf6753
movq 0x10(%rbp,%r12), %rax
testq %rax, %rax
je 0xb1e47
addq %rbp, %r12
movq 0x128(%r15), %rdx
movq 0x40(%rdx), %rcx
movq 0x48(%rdx), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *%rax
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: de_module_pict
void de_module_pict(deark *c, struct deark_module_info *mi)
{
	mi->id = "pict";
	mi->desc = "Macintosh PICT";
	mi->run_fn = de_run_pict;
	mi->identify_fn = de_identify_pict;
	mi->help_fn = de_help_pict;
}

// Assembly:
leaq 0x63df1(%rip), %rax     # 0x115ee0
movq %rax, (%rsi)
leaq 0x847c7(%rip), %rax     # 0x1368c0
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xb211f
movq %rax, 0x18(%rsi)
leaq 0x3b8(%rip), %rax       # 0xb24c7
movq %rax, 0x20(%rsi)
leaq 0x3f0(%rip), %rax       # 0xb250a
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: de_identify_pict
static int de_identify_pict(deark *c)
{
	struct detection_info dti;

	do_detect_version(c, &dti, 0);
	if(dti.file_version==2) {
		return 85;
	}
	else if(dti.file_version==1) {
		if(dti.has_fileheader) return 25;
		return 15;
	}
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xb2518
movl (%rbx), %eax
cmpl $0x2, %eax
je 0xb24fb
cmpl $0x1, %eax
jne 0xb2502
cmpl $0x0, 0xc(%rsp)
movl $0xf, %ecx
movl $0x19, %eax
cmovel %ecx, %eax
jmp 0xb2504
movl $0x55, %eax
jmp 0xb2504
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: do_detect_version
static void do_detect_version(deark *c, struct detection_info *dti, int mode)
{
	static const u8 v1pattern[2] = { 0x11, 0x01 };
	static const u8 v2pattern[6] = { 0x00, 0x11, 0x02, 0xff, 0x0c, 0x00 };
	u8 buf[6];
	int v1_nohdr = 0;
	int v2_nohdr = 0;
	int v1_hdr = 0;
	int v2_hdr = 0;

	dti->file_version = 0;
	dti->has_fileheader = 0;

	de_read(buf, 522, sizeof(buf));
	if(!de_memcmp(buf, v2pattern, 6)) {
		v2_hdr = 1;
	}
	else if(!de_memcmp(buf, v1pattern, 2)) {
		v1_hdr = 1;
	}
	else {
		de_read(buf, 10, sizeof(buf));
		if(!de_memcmp(buf, v2pattern, 6)) {
			v2_nohdr = 1;
		}
		else if(!de_memcmp(buf, v1pattern, 2)) {
			v1_nohdr = 1;
		}
	}

	if(!v1_hdr && !v2_hdr && !v1_nohdr && !v2_nohdr) {
		return;
	}

	if(v2_hdr) {
		dti->file_version = 2;
		dti->has_fileheader = 1;
		return;
	}
	else if(v2_nohdr) {
		dti->file_version = 2;
		return;
	}

	if(mode==0) {
		// For v1, check that the file ends as expected
		de_read(buf, c->infile->len-2, 2);
		if(buf[1]==0xff) {
			; // v1 files should end with 0xff
		}
		else if(buf[0]==0xff && buf[1]==0x00) {
			; // But a few have an extra NUL byte at the end
		}
	}

	if(v1_hdr) {
		dti->file_version = 1;
		dti->has_fileheader = 1;
		return;
	}
	else if(v1_nohdr) {
		dti->file_version = 1;
		return;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsi)
movq 0x18(%rdi), %rdi
leaq 0x2(%rsp), %r15
movl $0x20a, %edx            # imm = 0x20A
movl $0x6, %ecx
movq %r15, %rsi
callq 0xee8d4
movl $0xff021100, %eax       # imm = 0xFF021100
xorl (%r15), %eax
movzwl 0x4(%r15), %ecx
xorl $0xc, %ecx
orl %eax, %ecx
je 0xb25e6
movzwl 0x2(%rsp), %eax
xorl %r12d, %r12d
cmpl $0x111, %eax            # imm = 0x111
setne %r13b
je 0xb25b0
movq 0x18(%r14), %rdi
leaq 0x2(%rsp), %r15
movl $0xa, %edx
movl $0x6, %ecx
movq %r15, %rsi
callq 0xee8d4
movl $0xff021100, %eax       # imm = 0xFF021100
xorl (%r15), %eax
movzwl 0x4(%r15), %ecx
xorl $0xc, %ecx
orl %eax, %ecx
je 0xb25f5
cmpw $0x111, 0x2(%rsp)       # imm = 0x111
jne 0xb25fb
movb %r13b, %r12b
testl %ebp, %ebp
jne 0xb25d2
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rdx
addq $-0x2, %rdx
leaq 0x2(%rsp), %rsi
movl $0x2, %ecx
callq 0xee8d4
movl $0x1, (%rbx)
testl %r12d, %r12d
jne 0xb25fb
movl $0x1, 0x4(%rbx)
jmp 0xb25fb
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, (%rbx)
jmp 0xb25fb
movl $0x2, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: pict_read_rect
static void pict_read_rect(dbuf *f, i64 pos,
	struct pict_rect *rect, const char *dbgname)
{
	rect->t = dbuf_geti16be(f, pos);
	rect->l = dbuf_geti16be(f, pos+2);
	rect->b = dbuf_geti16be(f, pos+4);
	rect->r = dbuf_geti16be(f, pos+6);

	if(dbgname) {
		de_dbg(f->c, "%s: (%d,%d)-(%d,%d)", dbgname, (int)rect->l, (int)rect->t,
			(int)rect->r, (int)rect->b);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0xeec17
movq %rax, (%r14)
leaq 0x2(%r12), %rsi
movq %r15, %rdi
callq 0xeec17
movq %rax, 0x8(%r14)
leaq 0x4(%r12), %rsi
movq %r15, %rdi
callq 0xeec17
movq %rax, 0x10(%r14)
addq $0x6, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xeec17
movq %rax, 0x18(%r14)
testq %rbx, %rbx
je 0xb2686
movq 0x8(%r15), %rdi
movl (%r14), %r8d
movl 0x8(%r14), %ecx
movl 0x10(%r14), %edx
movl %edx, (%rsp)
leaq 0x812e8(%rip), %rsi     # 0x133961
movq %rbx, %rdx
movl %eax, %r9d
xorl %eax, %eax
callq 0xe8617
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_11
static void handler_11(struct item_handler_data *h)
{
	u8 ver;

	ver = dbuf_getbyte(h->inf, h->data_pos);
	de_dbg(h->c, "version: %u", (UI)ver);

	if(ver==2) {
		h->d->version = 2;
	}
	else if(ver!=1) {
		de_err(h->c, "Unsupported PICT version: %u", (UI)ver);
		h->fatal_errflag = 1;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xeead3
movq (%rbx), %rdi
movzbl %al, %ebp
leaq 0x846d2(%rip), %rsi     # 0x136d84
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
cmpb $0x1, %bpl
je 0xb26ea
cmpl $0x2, %ebp
jne 0xb26d3
movq 0x8(%rbx), %rax
movl $0x2, 0xc(%rax)
jmp 0xb26ea
movq (%rbx), %rdi
leaq 0x84696(%rip), %rsi     # 0x136d73
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9295
movb $0x1, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_pixpat
static void handler_pixpat(struct item_handler_data *h)
{
	UI pattype;
	i64 pos = h->data_pos;
	int needmsg = 1;
	int retval = 0;
	i64 colortable_size = 0;
	i64 pixdata_size = 0;
	struct fmtutil_macbitmap_info *bi = NULL;
	deark *c = h->c;

	pattype = (UI)dbuf_getu16be_p(h->inf, &pos);
	de_dbg(c, "PatType: %u", pattype);
	pos += 8; // Pat1Data

	if(pattype==2) { // ditherPat(?)
		pos += 6; // RGB
		retval = 1;
		goto done;
	}

	bi = de_malloc(c, sizeof(struct fmtutil_macbitmap_info));

	fmtutil_macbitmap_read_rowbytes_and_bounds(c, h->inf, bi, pos);
	pos += 10;
	fmtutil_macbitmap_read_pixmap_only_fields(c, h->inf, bi, pos);
	pos += 36;

	bi->uses_pal = 1;
	if(!fmtutil_macbitmap_read_colortable(c, h->inf, bi, pos, &colortable_size)) goto done;
	pos += colortable_size;

	if(!get_pixdata_size(c, h->d, bi, pos, &pixdata_size)) {
		goto done;
	}
	// Note: We could extract the "PixMap" pattern easily enough here, by calling
	// decode_pixdata(). But if we do that, maybe we should also extract the
	// Pat1Data data above, as well as other opcodes like BkPat.
	pos += pixdata_size;
	retval = 1;

done:
	if(!retval && needmsg) {
		de_err(c, "Failed to parse PixPat data");
	}
	if(retval) {
		h->data_len = pos - h->data_pos;
	}
	if(!retval) {
		h->fatal_errflag = 1;
	}
	de_free(c, bi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq (%rdi), %r14
movq 0x10(%rdi), %rdi
movq %r15, %rsi
callq 0xeeb91
movq %rax, %r12
leaq 0x84662(%rip), %rsi     # 0x136d90
movq %r14, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
movq (%r15), %rax
leaq 0x8(%rax), %rcx
movq %rcx, (%r15)
cmpl $0x2, %r12d
jne 0xb2757
addq $0xe, %rax
xorl %r15d, %r15d
jmp 0xb27eb
movl $0x480, %esi            # imm = 0x480
movq %r14, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x10(%rbx), %rsi
movq (%rsp), %rcx
movq %r14, %rdi
movq %rax, %rdx
callq 0xf950c
movq (%rsp), %rcx
addq $0xa, %rcx
movq %rcx, (%rsp)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xf9623
movq (%rsp), %rcx
addq $0x24, %rcx
movq %rcx, (%rsp)
movl $0x1, 0x74(%r15)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %r8
movq %r14, %rdi
movq %r15, %rdx
callq 0xf9824
testl %eax, %eax
je 0xb27f9
movq (%rsp), %rdx
addq 0x10(%rsp), %rdx
movq %rdx, (%rsp)
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb3537
testl %eax, %eax
je 0xb27f9
movq (%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
subq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
jmp 0xb280e
leaq 0x8459c(%rip), %rsi     # 0x136d9c
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9295
movb $0x1, 0x38(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe8be2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_RGBColor
static void handler_RGBColor(struct item_handler_data *h)
{
	UI clr16[3];
	u8 clr8[3];
	de_color clr;
	char csamp[16];
	i64 pos = h->data_pos;
	i64 k;

	for(k=0; k<3; k++) {
		clr16[k] = (UI)dbuf_getu16be_p(h->inf, &pos);
		clr8[k] = (u8)(clr16[k]>>8);
	}
	clr = DE_MAKE_RGB(clr8[0], clr8[1], clr8[2]);
	de_get_colorsample_code(h->c, clr, csamp, sizeof(csamp));
	de_dbg(h->c, "color: (0x%04x,0x%04x,0x%04x)%s", clr16[0], clr16[1], clr16[2], csamp);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
xorl %ebp, %ebp
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xeeb91
movl %eax, 0xc(%rsp,%rbp,4)
movb %ah, 0x9(%rsp,%rbp)
incq %rbp
cmpq $0x3, %rbp
jne 0xb283e
movzbl 0x9(%rsp), %eax
shll $0x10, %eax
movzbl 0xa(%rsp), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl 0xb(%rsp), %esi
orl %ecx, %esi
orl $0xff000000, %esi       # imm = 0xFF000000
movq (%rbx), %rdi
leaq 0x20(%rsp), %r14
movl $0x10, %ecx
movq %r14, %rdx
callq 0xe903b
movq (%rbx), %rdi
movl 0xc(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
leaq 0x84584(%rip), %rsi     # 0x136e2a
movq %r14, %r9
xorl %eax, %eax
callq 0xe8617
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_28
static void handler_28(struct item_handler_data *h)
{
	i64 tlen;
	de_ucstring *s = NULL;
	struct pict_point pt;

	pict_read_point(h->inf, h->data_pos, &pt, "txLoc");
	tlen = (i64)dbuf_getbyte(h->inf, h->data_pos+4);
	s = ucstring_create(h->c);
	dbuf_read_to_ucstring(h->inf, h->data_pos+5, tlen, s, 0, h->d->input_encoding);
	de_dbg(h->c, "text: \"%s\"", ucstring_getpsz(s));
	h->data_len = 5+tlen;
	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x28(%rdi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xeec17
movq %rax, %r12
addq $0x2, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xeec17
movq 0x8(%r14), %rdi
leaq 0x8455c(%rip), %rsi     # 0x136e50
leaq 0x8454f(%rip), %rdx     # 0x136e4a
movl %eax, %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0xe8617
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x4, %rsi
callq 0xeead3
movzbl %al, %r14d
movq (%rbx), %rdi
callq 0xf6410
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x5, %rsi
movl 0x8(%rax), %r9d
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xefbd7
movq (%rbx), %r12
movq %r15, %rdi
callq 0xf705c
leaq 0x88749(%rip), %rsi     # 0x13b0a4
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
addq $0x5, %r14
movq %r14, 0x30(%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_DxText
static void handler_DxText(struct item_handler_data *h)
{
	i64 tlen;
	i64 dx;
	de_ucstring *s = NULL;

	dx = (i64)dbuf_getbyte(h->inf, h->data_pos);
	de_dbg(h->c, "%s: %d", h->opcode==0x2a?"dv":"dh", (int)dx);

	tlen = (i64)dbuf_getbyte(h->inf, h->data_pos+1);
	h->data_len = 2+tlen;

	s = ucstring_create(h->c);
	dbuf_read_to_ucstring(h->inf, h->data_pos+2, tlen, s, 0, h->d->input_encoding);
	de_dbg(h->c, "text: \"%s\"", ucstring_getpsz(s));

	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xeead3
movq (%rbx), %rdi
cmpl $0x2a, 0x18(%rbx)
leaq 0x7281d(%rip), %rcx     # 0x1251c3
leaq 0x844af(%rip), %rdx     # 0x136e5c
cmoveq %rcx, %rdx
movzbl %al, %ecx
leaq 0x8c728(%rip), %rsi     # 0x13f0e3
xorl %eax, %eax
callq 0xe8617
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
incq %rsi
callq 0xeead3
movzbl %al, %r14d
leaq 0x2(%r14), %rax
movq %rax, 0x30(%rbx)
movq (%rbx), %rdi
callq 0xf6410
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x2, %rsi
movl 0x8(%rax), %r9d
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xefbd7
movq (%rbx), %rbx
movq %r15, %rdi
callq 0xf705c
leaq 0x88687(%rip), %rsi     # 0x13b0a4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_2b
static void handler_2b(struct item_handler_data *h)
{
	i64 tlen;
	i64 dh, dv;
	de_ucstring *s = NULL;

	dh = (i64)dbuf_getbyte(h->inf, h->data_pos);
	dv = (i64)dbuf_getbyte(h->inf, h->data_pos+1);
	de_dbg(h->c, "dh,dv: (%d,%d)", (int)dh, (int)dv);

	tlen = (i64)dbuf_getbyte(h->inf, h->data_pos+2);
	de_dbg(h->c, "text size: %d", (int)tlen);
	h->data_len = 3+tlen;

	s = ucstring_create(h->c);
	dbuf_read_to_ucstring(h->inf, h->data_pos+3, tlen, s, 0, h->d->input_encoding);
	de_dbg(h->c, "text: \"%s\"", ucstring_getpsz(s));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xeead3
movl %eax, %ebp
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
incq %rsi
callq 0xeead3
movq (%rbx), %rdi
movzbl %bpl, %edx
movzbl %al, %ecx
leaq 0x843ee(%rip), %rsi     # 0x136e5f
xorl %eax, %eax
callq 0xe8617
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x2, %rsi
callq 0xeead3
movzbl %al, %r14d
movq (%rbx), %rdi
leaq 0x843d7(%rip), %rsi     # 0x136e6e
movl %r14d, %edx
xorl %eax, %eax
callq 0xe8617
leaq 0x3(%r14), %rax
movq %rax, 0x30(%rbx)
movq (%rbx), %rdi
callq 0xf6410
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x3, %rsi
movl 0x8(%rax), %r9d
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xefbd7
movq (%rbx), %rbx
movq %r15, %rdi
callq 0xf705c
leaq 0x885bc(%rip), %rsi     # 0x13b0a4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe8617
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_2c
static void handler_2c(struct item_handler_data *h)
{
	i64 n;
	i64 tlen;
	i64 id;
	de_ucstring *s = NULL;

	n = dbuf_getu16be(h->inf, h->data_pos);
	h->data_len = 2+n;
	id = dbuf_getu16be(h->inf, h->data_pos+2);
	de_dbg(h->c, "old font id: %d", (int)id);
	tlen = (i64)dbuf_getbyte(h->inf, h->data_pos+4);
	s = ucstring_create(h->c);
	dbuf_read_to_ucstring(h->inf, h->data_pos+5, tlen, s, 0, h->d->input_encoding);
	de_dbg(h->c, "font name: \"%s\"", ucstring_getpsz(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xeeb67
addq $0x2, %rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x2, %rsi
callq 0xeeb67
movq (%rbx), %rdi
leaq 0x84345(%rip), %rsi     # 0x136e7c
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x4, %rsi
callq 0xeead3
movzbl %al, %r14d
movq (%rbx), %rdi
callq 0xf6410
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x5, %rsi
movl 0x8(%rax), %r9d
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xefbd7
movq (%rbx), %rbx
movq %r15, %rdi
callq 0xf705c
leaq 0x842f8(%rip), %rsi     # 0x136e8c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_a1
static void handler_a1(struct item_handler_data *h)
{
	i64 kind;
	i64 len;
	deark *c = h->c;

	kind = dbuf_getu16be(h->inf, h->data_pos);
	len = dbuf_getu16be(h->inf, h->data_pos+2);
	de_dbg(c, "comment kind: %d, size: %d", (int)kind, (int)len);
	h->data_len = 4+len;

	if(kind==100 && len>=4) {
		struct de_fourcc sig4cc;

		dbuf_read_fourcc(h->inf, h->data_pos+4, &sig4cc, 4, 0x0);
		de_dbg(c, "application comment, signature=0x%08x '%s'",
			(UI)sig4cc.id, sig4cc.id_dbgstr);
		de_dbg_hexdump(c, h->inf, h->data_pos+8, len-4, 256, NULL, 0x1);
	}
	else if(kind==224) {
		do_iccprofile_item(c, h->d, h->data_pos+4, len);
	}
	else {
		de_dbg_hexdump(c, h->inf, h->data_pos+4, len, 256, NULL, 0x1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r15
movq (%rdi), %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%r15), %rsi
callq 0xeeb67
movq %rax, %r12
movq 0x10(%r15), %rdi
movq 0x28(%r15), %rsi
addq $0x2, %rsi
callq 0xeeb67
movq %rax, %r14
leaq 0x83fd5(%rip), %rsi     # 0x13709b
movq %rbx, %rdi
movl %r12d, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0xe8617
leaq 0x4(%r14), %rax
movq %rax, 0x30(%r15)
cmpq $0x64, %r12
setne %al
cmpq $0x4, %r14
setl %cl
orb %al, %cl
jne 0xb3141
movq 0x10(%r15), %rdi
movq 0x28(%r15), %rsi
addq $0x4, %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1762
movl 0x4(%r12), %edx
leaq 0x20(%rsp), %rcx
leaq 0x83f94(%rip), %rsi     # 0x1370b6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x10(%r15), %rsi
movq 0x28(%r15), %rdx
addq $0x8, %rdx
addq $-0x4, %r14
jmp 0xb31f9
cmpq $0xe0, %r12
jne 0xb31ed
cmpq $0x4, %r14
jl 0xb3214
movq 0x28(%r15), %r12
leaq 0x4(%r12), %rsi
movq 0x8(%r15), %r13
movq 0x18(%rbx), %rdi
callq 0xeed0d
movq %rax, %r15
addq $-0x4, %r14
leaq 0x83f65(%rip), %rsi     # 0x1370e1
movq %rbx, %rdi
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r13), %rcx
cmpq $0x1, %r15
je 0xb31c8
movq %rcx, %rdi
callq 0xf052b
movq $0x0, 0x18(%r13)
testq %r15, %r15
jne 0xb3214
leaq 0x629eb(%rip), %rsi     # 0x115b9d
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xefda1
movq %rax, %rcx
movq %rax, 0x18(%r13)
testq %rcx, %rcx
je 0xb3222
movq 0x18(%rbx), %rdi
addq $0x8, %r12
movq %r12, %rsi
movq %r14, %rdx
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xef481
movq 0x10(%r15), %rsi
movq 0x28(%r15), %rdx
addq $0x4, %rdx
movl $0x1, (%rsp)
movl $0x100, %r8d            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rcx
xorl %r9d, %r9d
callq 0xe8bea
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x83ee7(%rip), %rsi     # 0x137110
movq %rbx, %rdi
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe8faa
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: handler_0c00
static void handler_0c00(struct item_handler_data *h)
{
	i64 hdrver;
	double hres, vres;
	struct pict_rect srcrect;

	hdrver = dbuf_getu16be(h->inf, h->data_pos);
	h->d->is_extended_v2 = (hdrver==0xfffe);

	de_dbg(h->c, "extended v2: %s", h->d->is_extended_v2?"yes":"no");
	if(h->d->is_extended_v2) {
		hres = pict_read_fixed(h->inf, h->data_pos+4);
		vres = pict_read_fixed(h->inf, h->data_pos+8);
		de_dbg(h->c, "dpi: %.2f"DE_CHAR_TIMES"%.2f", hres, vres);
		pict_read_rect(h->inf, h->data_pos+12, &srcrect, "srcRect");
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xeeb67
xorl %ecx, %ecx
cmpq $0xfffe, %rax           # imm = 0xFFFE
sete %cl
movq 0x8(%rbx), %rax
movl %ecx, 0x10(%rax)
movq (%rbx), %rdi
leaq 0x83ec7(%rip), %rax     # 0x137138
leaq 0x74fde(%rip), %rdx     # 0x128256
cmoveq %rax, %rdx
leaq 0x83ea5(%rip), %rsi     # 0x137128
xorl %eax, %eax
callq 0xe8617
movq 0x8(%rbx), %rax
cmpl $0x0, 0x10(%rax)
je 0xb330a
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x4, %rsi
callq 0xeedae
cvtsi2sd %rax, %xmm0
mulsd 0x734d6(%rip), %xmm0    # 0x126788
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0x8, %rsi
callq 0xeedae
cvtsi2sd %rax, %xmm1
mulsd 0x734b2(%rip), %xmm1    # 0x126788
movq (%rbx), %rdi
leaq 0x83e5c(%rip), %rsi     # 0x13713c
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0xe8617
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
addq $0xc, %rsi
leaq 0x83c5a(%rip), %rcx     # 0x136f5a
leaq 0x10(%rsp), %rdx
callq 0xb260a
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pict.c
// Function: get_pixdata_size
static int get_pixdata_size(deark *c, lctx *d, struct fmtutil_macbitmap_info *bi,
	i64 pos1, i64 *pixdata_size)
{
	i64 pos;
	i64 j;
	i64 bytecount;
	int retval = 0;

	pos = pos1;
	de_dbg(c, "PixData at %"I64_FMT, pos);
	de_dbg_indent(c, 1);

	if(bi->height<0 || bi->height>65535) {
		de_err(c, "Invalid bitmap height (%"I64_FMT")", (i64)bi->height);
		goto done;
	}

	// Make sure rowbytes is sane. We use it to decide how much memory to allocate.
	// Note: I've seen valid bitmaps with as many as 284 extra bytes per row.
	if(bi->rowbytes > (bi->npwidth * bi->pixelsize)/8 + 1000) {
		de_err(c, "Bad rowBytes value (%d)", (int)bi->rowbytes);
		goto done;
	}

	if(bi->packing_type>=3 || (bi->packing_type==0 && bi->rowbytes>=8)) {
		for(j=0; j<bi->height; j++) {
			if(bi->rowbytes > 250) {
				bytecount = de_getu16be_p(&pos);
			}
			else {
				bytecount = (i64)de_getbyte_p(&pos);
			}
			pos += bytecount;
		}
	}
	else if(bi->packing_type==1 || (bi->packing_type==0 && bi->rowbytes<8)) {
		pos += bi->rowbytes * bi->height; // uncompressed
	}
	else {
		de_err(c, "Unsupported packing type: %d", (int)bi->packing_type);
		goto done;
	}

	*pixdata_size = pos - pos1;
	de_dbg(c, "PixData size: %"I64_FMT, (i64)*pixdata_size);
	retval = 1;

done:
	de_dbg_indent(c, -1);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, (%rsp)
leaq 0x8385f(%rip), %rsi     # 0x136db8
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x20(%r12), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jb 0xb3593
leaq 0x83843(%rip), %rsi     # 0x136dc7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xb3672
movq 0x40(%r12), %rax
imulq 0x10(%r12), %rax
leaq 0x7(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
movq (%r12), %rax
sarq $0x3, %rcx
addq $0x3e8, %rcx            # imm = 0x3E8
cmpq %rcx, %rax
jle 0xb35d7
leaq 0x8381f(%rip), %rsi     # 0x136de3
xorl %ebp, %ebp
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9295
jmp 0xb3672
movq 0x30(%r12), %rcx
cmpq $0x2, %rcx
jg 0xb35f6
testq %rcx, %rcx
setne %sil
cmpq $0x8, %rax
setl %dil
orb %sil, %dil
jne 0xb3637
movq %r15, %rax
testq %rdx, %rdx
je 0xb3653
xorl %ebp, %ebp
movq %rsp, %r13
cmpq $0xfb, (%r12)
movq 0x18(%rbx), %rdi
movq %r13, %rsi
jl 0xb361b
callq 0xeeb91
jmp 0xb3623
callq 0xeeb4b
movzbl %al, %eax
addq (%rsp), %rax
movq %rax, (%rsp)
incq %rbp
cmpq 0x20(%r12), %rbp
jl 0xb3603
jmp 0xb3653
cmpq $0x1, %rcx
je 0xb3648
testq %rcx, %rcx
jne 0xb3690
cmpq $0x7, %rax
jg 0xb3690
imulq %rdx, %rax
addq %r15, %rax
movq %rax, (%rsp)
subq %r15, %rax
movq %rax, (%r14)
leaq 0x837b8(%rip), %rsi     # 0x136e18
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x83764(%rip), %rsi     # 0x136dfb
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ecx, %edx
jmp 0xb35cb
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/pkfont.c
// Function: de_module_pkfont
void de_module_pkfont(deark *c, struct deark_module_info *mi)
{
	mi->id = "pkfont";
	mi->desc = "PK Font";
	mi->run_fn = de_run_pkfont;
	mi->identify_fn = de_identify_pkfont;
}

// Assembly:
leaq 0x83761(%rip), %rax     # 0x137240
movq %rax, (%rsi)
leaq 0x8375e(%rip), %rax     # 0x137247
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xb3b04
movq %rax, 0x18(%rsi)
leaq 0xdca(%rip), %rax       # 0xb48c9
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: de_module_png
void de_module_png(deark *c, struct deark_module_info *mi)
{
	mi->id = "png";
	mi->desc = "PNG image";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_png;
	mi->identify_fn = de_identify_png;
	mi->help_fn = de_help_png;
}

// Assembly:
leaq 0x73e39(%rip), %rax     # 0x128730
movq %rax, (%rsi)
leaq 0x82c7f(%rip), %rax     # 0x137580
movq %rax, 0x8(%rsi)
leaq 0x60a85(%rip), %rax     # 0x115391
movq %rax, 0x10(%rsi)
leaq 0x1b(%rip), %rax        # 0xb4932
movq %rax, 0x18(%rsi)
leaq 0x4bf(%rip), %rax       # 0xb4de1
movq %rax, 0x20(%rsi)
leaq 0x4ca(%rip), %rax       # 0xb4df7
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: do_identify_png_internal
static int do_identify_png_internal(deark *c)
{
	u8 buf[8];
	de_read(buf, 0, sizeof(buf));
	if(!de_memcmp(buf, g_png_sig, 8)) return DE_PNGFMT_PNG;
	if(!de_memcmp(buf, "\x8b\x4a\x4e\x47\x0d\x0a\x1a\x0a", 8)) return DE_PNGFMT_JNG;
	if(!de_memcmp(buf, "\x8a\x4d\x4e\x47\x0d\x0a\x1a\x0a", 8)) return DE_PNGFMT_MNG;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0xa1a0a0d474e4a8b, %r14 # imm = 0xA1A0A0D474E4A8B
movq %rsp, %rbx
movl $0x8, %ecx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xee8d4
leaq 0x5fe(%r14), %rax
cmpq %rax, (%rbx)
je 0xb4e62
cmpq %r14, (%rsp)
je 0xb4e69
addq $0x2ff, %r14            # imm = 0x2FF
xorl %eax, %eax
cmpq %r14, (%rsp)
sete %al
leal (%rax,%rax,2), %eax
jmp 0xb4e6e
movl $0x1, %eax
jmp 0xb4e6e
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: declare_png_fmt
static void declare_png_fmt(deark *c, lctx *d)
{
	if(d->fmt==DE_PNGFMT_JNG) {
		de_declare_fmt(c, "JNG");
		return;
	}
	if(d->fmt==DE_PNGFMT_MNG) {
		de_declare_fmt(c, "MNG");
		return;
	}
	if(d->fmt!=DE_PNGFMT_PNG) return;
	if(d->is_APNG) {
		de_declare_fmt(c, "APNG");
		return;
	}
	if(d->is_CgBI) {
		de_declare_fmt(c, "CgBI");
		return;
	}
	if(!d->found_IDAT) return;
	de_declare_fmt(c, "PNG");
}

// Assembly:
movl (%rsi), %eax
cmpl $0x1, %eax
je 0xb4e9f
cmpl $0x2, %eax
je 0xb4e93
cmpl $0x3, %eax
jne 0xb4ed5
leaq 0x827f2(%rip), %rsi     # 0x137680
jmp 0xeb125
leaq 0x827e2(%rip), %rsi     # 0x13767c
jmp 0xeb125
cmpb $0x0, 0x8(%rsi)
je 0xb4eb1
leaq 0x827d8(%rip), %rsi     # 0x137684
jmp 0xeb125
cmpb $0x0, 0x7(%rsi)
je 0xb4ec3
leaq 0x827cb(%rip), %rsi     # 0x137689
jmp 0xeb125
cmpb $0x0, 0xc(%rsi)
je 0xb4ed5
leaq 0x827b5(%rip), %rsi     # 0x137685
jmp 0xeb125
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: finish_APNG_frame
static void finish_APNG_frame(deark *c, lctx *d)
{
	static const u8 IEND_data[12] = {0, 0, 0, 0, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82};

	if(!d->curr_APNG_frame) return;

	dbuf_write(d->curr_APNG_frame, IEND_data, 12);
	dbuf_close(d->curr_APNG_frame);
	d->curr_APNG_frame = NULL;
	d->curr_fcTL_width = 0;
	d->curr_fcTL_height = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xb4f0c
leaq 0x82646(%rip), %rsi     # 0x137530
movl $0xc, %edx
callq 0xef547
movq 0x40(%rbx), %rdi
callq 0xf052b
movq $0x0, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: handler_IHDR
static void handler_IHDR(deark *c, lctx *d, struct handler_params *hp)
{
	i64 w, h;
	u8 n;
	const char *name;

	if(hp->dlen<13) return;
	w = de_getu32be(hp->dpos);
	h = de_getu32be(hp->dpos+4);
	de_dbg_dimensions(c, w, h);

	n = de_getbyte(hp->dpos+8);
	de_dbg(c, "depth: %d bits/sample", (int)n);

	d->color_type = de_getbyte(hp->dpos+9);
	switch(d->color_type) {
	case 0: name="grayscale"; break;
	case 2: name="truecolor"; break;
	case 3: name="palette"; break;
	case 4: name="grayscale+alpha"; break;
	case 6: name="truecolor+alpha"; break;
	default: name="?";
	}
	de_dbg(c, "color type: %d (%s)", (int)d->color_type, name);

	n = de_getbyte(hp->dpos+12);
	de_dbg(c, "interlaced: %d", (int)n);
}

// Assembly:
cmpq $0xd, 0x8(%rdx)
jge 0xb52e9
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdx), %rsi
callq 0xeed0d
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq $0x4, %rsi
callq 0xeed0d
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xe8f88
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq $0x8, %rsi
callq 0xeead3
movzbl %al, %edx
leaq 0x82535(%rip), %rsi     # 0x137876
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq $0x9, %rsi
callq 0xeead3
movb %al, 0x9(%r15)
movzbl %al, %edx
cmpb $0x6, %al
ja 0xb5376
leaq 0x821cf(%rip), %rax     # 0x13753c
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmp 0xb537d
leaq 0x76dd4(%rip), %rcx     # 0x12c151
leaq 0x8a6e4(%rip), %rsi     # 0x13fa68
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq $0xc, %rsi
callq 0xeead3
movzbl %al, %edx
leaq 0x6993c(%rip), %rsi     # 0x11ece4
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8617
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: handler_bKGD
static void handler_bKGD(deark *c, lctx *d, struct handler_params *hp)
{
	i64 r, g, b;
	u8 idx;

	if(d->color_type==0 || d->color_type==4) {
		if(hp->dlen<2) return;
		r = de_getu16be(hp->dpos);
		de_dbg(c, "%s gray shade: %d", hp->cti->name, (int)r);
	}
	else if(d->color_type==2 || d->color_type==6) {
		if(hp->dlen<6) return;
		r = de_getu16be(hp->dpos);
		g = de_getu16be(hp->dpos+2);
		b = de_getu16be(hp->dpos+4);
		de_dbg(c, "%s: (%d,%d,%d)", hp->cti->name, (int)r, (int)g, (int)b);
	}
	else if(d->color_type==3) {
		if(hp->dlen<1) return;
		idx = de_getbyte(hp->dpos);
		de_dbg(c, "%s palette index: %d", hp->cti->name, (int)idx);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x9(%rsi), %eax
cmpq $0x6, %rax
ja 0xb552d
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x82090(%rip), %rcx     # 0x1374e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x2, 0x8(%r14)
jl 0xb552d
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
callq 0xeeb67
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %rdx
leaq 0x82435(%rip), %rsi     # 0x1378b4
movq %rbx, %rdi
movl %eax, %ecx
jmp 0xb551b
cmpq $0x6, 0x8(%r14)
jl 0xb552d
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
callq 0xeeb67
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq $0x2, %rsi
callq 0xeeb67
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq $0x4, %rsi
callq 0xeeb67
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %rdx
leaq 0x823f1(%rip), %rsi     # 0x1378c6
movq %rbx, %rdi
movl %r15d, %ecx
movl %r12d, %r8d
movl %eax, %r9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8617
cmpq $0x0, 0x8(%r14)
jle 0xb552d
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
callq 0xeead3
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %rdx
movzbl %al, %ecx
leaq 0x823bd(%rip), %rsi     # 0x1378d5
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8617
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: handler_acTL
static void handler_acTL(deark *c, lctx *d, struct handler_params *hp)
{
	unsigned int n;
	i64 pos = hp->dpos;

	if(!d->found_IDAT) {
		d->is_APNG = 1;
		declare_png_fmt(c, d);
	}
	if(hp->dlen<8) return;
	n = (unsigned int)de_getu32be_p(&pos);
	de_dbg(c, "num frames: %u", n);
	n = (unsigned int)de_getu32be_p(&pos);
	de_dbg(c, "num plays: %u%s", n, (n==0)?" (infinite)":"");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, (%rsp)
cmpb $0x0, 0xc(%rsi)
jne 0xb555c
movb $0x1, 0x8(%rsi)
movq %rbx, %rdi
callq 0xb4e76
cmpq $0x8, 0x8(%r14)
jl 0xb55b8
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xeed31
leaq 0x5e61c(%rip), %rsi     # 0x113b95
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xeed31
testl %eax, %eax
leaq 0x6a940(%rip), %rdx     # 0x11feda
leaq 0x8fb0f(%rip), %rcx     # 0x1450b0
cmoveq %rdx, %rcx
leaq 0x8233e(%rip), %rsi     # 0x1378ea
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/png.c
// Function: handler_cHRM
static void handler_cHRM(deark *c, lctx *d, struct handler_params *hp)
{
	i64 n[8];
	double nd[8];
	size_t i;

	if(hp->dlen<32) return;
	for(i=0; i<8; i++) {
		n[i] = de_getu32be(hp->dpos+4*(i64)i);
		nd[i] = ((double)n[i])/100000.0;
	}
	de_dbg(c, "white point: (%1.5f, %1.5f)", nd[0], nd[1]);
	de_dbg(c, "red        : (%1.5f, %1.5f)", nd[2], nd[3]);
	de_dbg(c, "green      : (%1.5f, %1.5f)", nd[4], nd[5]);
	de_dbg(c, "blue       : (%1.5f, %1.5f)", nd[6], nd[7]);
}

// Assembly:
cmpq $0x20, 0x8(%rdx)
jge 0xb55c8
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
addq %r15, %rsi
callq 0xeed0d
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x81f7f(%rip), %xmm0    # 0x137578
movsd %xmm0, (%rsp,%r15,2)
addq $0x4, %r15
cmpq $0x20, %r15
jne 0xb55da
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
leaq 0x822df(%rip), %rsi     # 0x1378fa
movq %rbx, %rdi
movb $0x2, %al
callq 0xe8617
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
leaq 0x822de(%rip), %rsi     # 0x137916
movq %rbx, %rdi
movb $0x2, %al
callq 0xe8617
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
leaq 0x822dd(%rip), %rsi     # 0x137932
movq %rbx, %rdi
movb $0x2, %al
callq 0xe8617
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
leaq 0x822dc(%rip), %rsi     # 0x13794e
movq %rbx, %rdi
movb $0x2, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe8617