LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionapp.c
// Function: de_module_psionapp
void de_module_psionapp(deark *c, struct deark_module_info *mi)
{
	mi->id = "psionapp";
	mi->desc = "Psion .APP/.IMG and .OPA/.OPO";
	mi->desc2 = "extract images";
	mi->run_fn = de_run_psionapp;
	mi->identify_fn = de_identify_psionapp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xaade9(%rip), %rcx     # 0x1c50b0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xaade4(%rip), %rcx     # 0x1c50b9
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0xaadf3(%rip), %rcx     # 0x1c50d7
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d(%rip), %rcx        # 0x11a310
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xae(%rip), %rcx        # 0x11a3b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionapp.c
// Function: de_run_psionapp
static void de_run_psionapp(deark *c, de_module_params *mparams)
{
	u8 b;
	const char *s;
	lctx *d = NULL;

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

	s = de_get_ext_option(c, "psionapp:convertpic");
	if(s) {
		d->convert_images = 1;
	}

	b = de_getbyte(0);
	if(b=='O') {
		do_opo_opa(c, d);
	}
	else {
		do_img_app(c, d);
	}

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xaada1(%rip), %rsi     # 0x1c50e6
callq 0x15cb30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11a35f
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x4f, %eax
jne 0x11a38b
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x11a450
jmp 0x11a398
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x11a530
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionapp.c
// Function: de_identify_psionapp
static int de_identify_psionapp(deark *c)
{
	u8 b[16];
	de_read(b, 0, 16);
	if(!de_memcmp(b, "ImageFileType**\0", 16))
		return 100;
	if(!de_memcmp(b, "OPLObjectFile**\0", 16))
		return 100;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x10, %ecx
callq 0x164d10
leaq -0x20(%rbp), %rax
movups (%rax), %xmm0
movaps 0xaacac(%rip), %xmm1    # 0x1c5090
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x11a405
movl $0x64, -0x4(%rbp)
jmp 0x11a43b
leaq -0x20(%rbp), %rax
movups (%rax), %xmm0
movaps 0xaac8d(%rip), %xmm1    # 0x1c50a0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x11a434
movl $0x64, -0x4(%rbp)
jmp 0x11a43b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionapp.c
// Function: do_opo_opa
static void do_opo_opa(deark *c, lctx *d)
{
	i64 offset_2ndheader;
	i64 pos;
	i64 n;
	i64 len;

	de_declare_fmt(c, "Psion OPO/OPA");

	// The second header marks the end of the embedded files section, I guess.
	offset_2ndheader = de_getu16le(18);
	de_dbg(c, "offset of second header: %d", (int)offset_2ndheader);
	pos = 20;

	// Read length of source filename
	n = (i64)de_getbyte(pos);
	pos++;
	pos+=n;
	while(pos<offset_2ndheader) {
		// Read length of this embedded file
		len = de_getu16le(pos);
		pos+=2;
		handle_embedded_file(c, d, pos, len);
		pos+=len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xaac8f(%rip), %rsi     # 0x1c50fa
callq 0x15e380
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x12, %esi
callq 0x165280
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xaac71(%rip), %rsi     # 0x1c5108
movb $0x0, %al
callq 0x15b0d0
movq $0x14, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x11a524
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165280
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x11a5d0
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x11a4d6
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionapp.c
// Function: do_img_app
static void do_img_app(deark *c, lctx *d)
{
	i64 i;
	i64 offset;
	i64 len;

	de_declare_fmt(c, "Psion IMG/APP");

	for(i=0; i<4; i++) {
		offset = de_getu16le(40 + 4*i);
		len = de_getu16le(40 + 4*i + 2);
		if(offset==0) break;
		handle_embedded_file(c, d, offset, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xaac20(%rip), %rsi     # 0x1c516b
callq 0x15e380
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jge 0x11a5c9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
shlq $0x2, %rsi
addq $0x28, %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
shlq $0x2, %rsi
addq $0x28, %rsi
addq $0x2, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11a5a6
jmp 0x11a5c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x11a5d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11a558
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionapp.c
// Function: handle_embedded_file
static void handle_embedded_file(deark *c, lctx *d, i64 offset, i64 len)
{
	u8 buf[16];
	const char *ext;
	int extract_this_file;
	int is_pic;

	de_dbg(c, "embedded file at %d, len=%d", (int)offset, (int)len);
	is_pic = 0;
	ext = "bin";
	extract_this_file = 0;

	if(len>0 && c->extract_level>=2)
		extract_this_file = 1;

	// As far as I can tell, there's no way to tell the type of an
	// embedded file, except by sniffing it.
	de_read(buf, offset, 16);
	if(len>=8) {
		if(!de_memcmp(buf, "PIC\xdc\x30\x30", 6)) {
			// Looks like a PIC file
			is_pic = 1;
			ext = "pic";
			extract_this_file = 1;
		}
	}

	if(extract_this_file) {
		if(is_pic && d->convert_images) {
			// Convert PIC to PNG.
			// For consistency, this option shouldn't exist. But I'm not sure that
			// PIC files embedded in APP files are really the same as PIC files on
			// their own. They might need special handling. Until I'm sure they don't,
			// I'll leave this option here.
			de_run_module_by_id_on_slice(c, "psionpic", NULL, c->infile, offset, len);
		}
		else {
			// Just extract the file
			dbuf_create_file_from_slice(c->infile, offset, len, ext, NULL, is_pic?0:DE_CREATEFLAG_IS_AUX);
		}
	}
	else {
		de_dbg(c, "(not extracting this file)");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq 0xaab25(%rip), %rsi     # 0x1c5124
movb $0x0, %al
callq 0x15b0d0
movl $0x0, -0x40(%rbp)
leaq 0xa6bf3(%rip), %rax     # 0x1c1207
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0x11a63a
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jl 0x11a63a
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x10, %ecx
callq 0x164d10
cmpq $0x8, -0x20(%rbp)
jl 0x11a690
leaq -0x30(%rbp), %rdi
leaq 0xaaada(%rip), %rsi     # 0x1c5140
movl $0x6, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x11a68e
movl $0x1, -0x40(%rbp)
leaq 0xa741a(%rip), %rax     # 0x1c1a9d
movq %rax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x11a690
cmpl $0x0, -0x3c(%rbp)
je 0x11a6ff
cmpl $0x0, -0x40(%rbp)
je 0x11a6cb
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x11a6cb
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0xaaa87(%rip), %rsi     # 0x1c5147
xorl %eax, %eax
movl %eax, %edx
callq 0x15c9f0
jmp 0x11a6fd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x40(%rbp), %r8d
movl $0x1, %r9d
xorl %eax, %eax
cmpl $0x0, %r8d
cmovnel %eax, %r9d
xorl %eax, %eax
movl %eax, %r8d
callq 0x166be0
jmp 0x11a711
movq -0x8(%rbp), %rdi
leaq 0xaaa46(%rip), %rsi     # 0x1c5150
movb $0x0, %al
callq 0x15b0d0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: de_module_psionpic
void de_module_psionpic(deark *c, struct deark_module_info *mi)
{
	mi->id = "psionpic";
	mi->desc = "Psion PIC, a.k.a. EPOC PIC";
	mi->run_fn = de_run_psionpic;
	mi->identify_fn = de_identify_psionpic;
	mi->help_fn = de_help_psionpic;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xaaa10(%rip), %rcx     # 0x1c5147
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xaaa56(%rip), %rcx     # 0x1c519b
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x11a780
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x25d(%rip), %rcx       # 0x11a9c0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x29e(%rip), %rcx       # 0x11aa10
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: do_read_plane_info
static void do_read_plane_info(deark *c, lctx *d, struct plane_info_struct *pi, i64 pos1)
{
	i64 image_relative_pos;
	i64 pos = pos1;

	de_zeromem(pi, sizeof(struct plane_info_struct));
	pi->crc_reported = (u32)de_getu16le_p(&pos);
	pi->width = de_getu16le_p(&pos);
	pi->height = de_getu16le_p(&pos);
	pi->image_size_in_bytes = de_getu16le_p(&pos);
	image_relative_pos = de_getu32le_p(&pos);

	pi->image_pos = pos1 + 12 + image_relative_pos;
	pi->rowspan = ((pi->width+15)/16)*2; // 2-byte alignment

	de_dbg(c, "bitmap descriptor at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	de_dbg(c, "image pos: %"I64_FMT, pi->image_pos);
	de_dbg(c, "image len: %"I64_FMT, pi->image_size_in_bytes);
	de_dbg_dimensions(c, pi->width, pi->height);
	de_dbg(c, "crc (reported): 0x%04x", (UI)pi->crc_reported);
	check_crc(c, d, pi);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
addq $0xc, %rcx
addq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0xf, %rax
movl $0x10, %ecx
cqto
idivq %rcx
movq %rax, %rcx
shlq %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xaa6a7(%rip), %rsi     # 0x1c51df
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0xaa698(%rip), %rsi     # 0x1c51f8
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0xaa68d(%rip), %rsi     # 0x1c5207
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x15bba0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0xb5da1(%rip), %rsi     # 0x1d094c
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11ae60
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: detect_format
static int detect_format(deark *c, lctx *d)
{
	if(d->bw)
		return PPIC_FMT_1_1;

	if(d->num_planes>=3 &&
		d->plane_info[0].width==24 && d->plane_info[0].height==24 &&
		d->plane_info[1].width==48 && d->plane_info[1].height==48 &&
		could_be_2bit(d, 1))
	{
		return PPIC_FMT_1_2;
	}

	if(d->num_planes>=1 &&
		d->plane_info[0].width==24 && d->plane_info[0].height==24)
	{
		return PPIC_FMT_1_1;
	}

	if(d->num_planes>=2 && could_be_2bit(d, 0)) {
		return PPIC_FMT_2_2;
	}

	return PPIC_FMT_1_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x11ac06
movl $0x1, -0x4(%rbp)
jmp 0x11acc1
movq -0x18(%rbp), %rax
cmpq $0x3, (%rax)
jl 0x11ac67
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x18, (%rax)
jne 0x11ac67
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x18, 0x8(%rax)
jne 0x11ac67
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x30, 0x30(%rax)
jne 0x11ac67
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x30, 0x38(%rax)
jne 0x11ac67
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x11af00
cmpl $0x0, %eax
je 0x11ac67
movl $0x2, -0x4(%rbp)
jmp 0x11acc1
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
jl 0x11ac97
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x18, (%rax)
jne 0x11ac97
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x18, 0x8(%rax)
jne 0x11ac97
movl $0x1, -0x4(%rbp)
jmp 0x11acc1
movq -0x18(%rbp), %rax
cmpq $0x2, (%rax)
jl 0x11acba
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x11af00
cmpl $0x0, %eax
je 0x11acba
movl $0x3, -0x4(%rbp)
jmp 0x11acc1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: do_bitmap_2planes
static void do_bitmap_2planes(deark *c, lctx *d, i64 pn1, i64 pn2)
{
	de_bitmap *img = NULL;
	i64 planespan;
	// AFAIK, all relevant devices support only 3 colors. Two of the four codes
	// map to black. We'll make the two blacks slightly different, just to avoid
	// losing information.
	static const de_color pal[4] = { 0xffffffff, 0xff808080U, 0xff010101U, 0xff000000U };

	de_dbg(c, "making a grayscale image from planes %d and %d", (int)pn1, (int)pn2);

	// TODO: Support -padpix (need samples with width not a multiple of 16)
	img = de_bitmap_create(c, d->plane_info[pn1].width, d->plane_info[pn1].height, 1);

	planespan = d->plane_info[1].image_pos - d->plane_info[0].image_pos;
	de_convert_image_paletted_planar(c->infile, d->plane_info[0].image_pos, 2,
		d->plane_info[0].rowspan, planespan, pal, img, 0x1);
	de_bitmap_write_to_file(img, NULL, 0);

	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq 0xaa53d(%rip), %rsi     # 0x1c5244
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movl $0x1, %ecx
callq 0x16b750
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %rax
movl $0x2, %edx
leaq 0xaa549(%rip), %r9      # 0x1c52e0
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x16c690
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x16afd0
movq -0x28(%rbp), %rdi
callq 0x16af60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: do_bitmap_1plane
static void do_bitmap_1plane(deark *c, lctx *d, i64 plane_num)
{
	struct plane_info_struct *pi = &d->plane_info[plane_num];

	de_dbg(c, "making a bilevel image from plane %d", (int)plane_num);

	de_convert_and_write_image_bilevel2(c->infile, pi->image_pos, pi->width, pi->height,
		pi->rowspan, DE_CVTF_WHITEISZERO|DE_CVTF_LSBFIRST, NULL, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xaa46a(%rip), %rsi     # 0x1c5273
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r8
movl $0x3, %r9d
xorl %eax, %eax
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x16c000
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: check_crc
static void check_crc(deark *c, lctx *d, struct plane_info_struct *pi)
{
	u32 crc_calc;

	de_crcobj_reset(d->crco);
	de_crcobj_addslice(d->crco, c->infile, pi->image_pos, pi->image_size_in_bytes);
	crc_calc = de_crcobj_getval(d->crco);
	de_dbg(c, "crc (calculated): 0x%04x", (UI)crc_calc);
	if(crc_calc != pi->crc_reported) {
		de_warn(c, "CRC check failed: Expected 0x%04x, got 0x%04x",
			(UI)pi->crc_reported, (UI)crc_calc);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x15f250
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x15f500
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x15f340
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x861c3(%rip), %rsi     # 0x1a1087
movb $0x0, %al
callq 0x15b0d0
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
je 0x11aef3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edx
movl -0x1c(%rbp), %ecx
leaq 0xaa32a(%rip), %rsi     # 0x1c5216
movb $0x0, %al
callq 0x15bc10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/psionpic.c
// Function: could_be_2bit
static int could_be_2bit(lctx *d, int startpos)
{
	i64 i;
	if( (d->num_planes - startpos)%2 != 0) {
		// Not an even number of bitmaps.
		return 0;
	}
	for(i=startpos; i<d->num_planes; i+=2) {
		if(d->plane_info[i].width!=d->plane_info[i+1].width ||
			d->plane_info[i].height!=d->plane_info[i+1].height)
		{
			// Bitmaps aren't the same size.
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
subq %rcx, %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x11af35
movl $0x0, -0x4(%rbp)
jmp 0x11afcd
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x11afc6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x11afaa
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
je 0x11afb3
movl $0x0, -0x4(%rbp)
jmp 0x11afcd
jmp 0x11afb5
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x11af3d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/pcf.c
// Function: de_module_pcf
void de_module_pcf(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcf";
	mi->desc = "PCF font";
	mi->run_fn = de_run_pcf;
	mi->identify_fn = de_identify_pcf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xaa2f9(%rip), %rcx     # 0x1c52f0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xaa2ef(%rip), %rcx     # 0x1c52f4
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x11b030
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x35d(%rip), %rcx       # 0x11b380
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/pcf.c
// Function: process_table_by_type
static int process_table_by_type(deark *c, lctx *d, u32 tbltype)
{
	i64 k;
	struct table_entry *te;

	for(k=0; k<d->table_count; k++) {
		te = &d->tables[k];
		if(te->type == tbltype) {
			if(te->handler_fn) {
				te->handler_fn(c, d, te);
			}
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x11b5f2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x48, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x11b5e2
movq -0x30(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x11b5d9
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x11b5f9
jmp 0x11b5e4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11b58b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/pcf.c
// Function: lookup_table_entry_type_info
static void lookup_table_entry_type_info(deark *c, lctx *d, struct table_entry *te)
{
	switch(te->type) {
	case TBLTYPE_PROPERTIES:
		te->type_name = "properties";
		te->handler_fn = handler_properties;
		break;
	case 0x2:
		te->type_name = "accelerators";
		break;
	case TBLTYPE_METRICS:
		te->type_name = "metrics";
		te->handler_fn = handler_metrics;
		break;
	case TBLTYPE_BITMAPS:
		te->type_name = "bitmaps";
		te->handler_fn = handler_bitmaps;
		break;
	case 0x10:
		te->type_name = "ink metrics";
		break;
	case TBLTYPE_BDF_ENCODINGS:
		te->type_name = "BDF encodings";
		te->handler_fn = handler_bdf_encodings;
		break;
	case 0x40:
		te->type_name = "swidths";
		break;
	case 0x80:
		te->type_name = "glyph names";
		break;
	case 0x100:
		te->type_name = "BDF accelerators";
		break;
	default:
		te->type_name = "?";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x11ba48
jmp 0x11b9d1
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x11ba6b
jmp 0x11b9df
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x11ba7f
jmp 0x11b9ed
movl -0x1c(%rbp), %eax
subl $0x8, %eax
je 0x11baa2
jmp 0x11b9fb
movl -0x1c(%rbp), %eax
subl $0x10, %eax
je 0x11bac2
jmp 0x11ba09
movl -0x1c(%rbp), %eax
subl $0x20, %eax
je 0x11bad3
jmp 0x11ba17
movl -0x1c(%rbp), %eax
subl $0x40, %eax
je 0x11baf3
jmp 0x11ba25
movl -0x1c(%rbp), %eax
subl $0x80, %eax
je 0x11bb04
jmp 0x11ba35
movl -0x1c(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x11bb15
jmp 0x11bb26
movq -0x18(%rbp), %rax
leaq 0x85e87(%rip), %rcx     # 0x1a18da
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
leaq 0x34e(%rip), %rcx       # 0x11bdb0
movq %rcx, 0x40(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa9994(%rip), %rcx     # 0x1c540a
movq %rcx, 0x38(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa9952(%rip), %rcx     # 0x1c53dc
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
leaq 0x4e7(%rip), %rcx       # 0x11bf80
movq %rcx, 0x40(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0x8f12b(%rip), %rcx     # 0x1aabd8
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
leaq 0x924(%rip), %rcx       # 0x11c3e0
movq %rcx, 0x40(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa990b(%rip), %rcx     # 0x1c53d8
movq %rcx, 0x38(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa9906(%rip), %rcx     # 0x1c53e4
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
leaq 0xc53(%rip), %rcx       # 0x11c740
movq %rcx, 0x40(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa98f4(%rip), %rcx     # 0x1c53f2
movq %rcx, 0x38(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa98eb(%rip), %rcx     # 0x1c53fa
movq %rcx, 0x38(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0xa98e6(%rip), %rcx     # 0x1c5406
movq %rcx, 0x38(%rax)
jmp 0x11bb35
movq -0x18(%rbp), %rax
leaq 0x9c0fc(%rip), %rcx     # 0x1b7c2d
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/pcf.c
// Function: read_and_check_format_field
static int read_and_check_format_field(deark *c, lctx *d, struct table_entry *te, i64 pos)
{
	u32 format;

	format = (u32)de_getu32le_p(&pos);
	de_dbg(c, "format: 0x%08x", (unsigned int)format);
	if(format != te->fmt.raw_format) {
		de_err(c, "Can't handle conflicting \"format\" fields");
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0xa8928(%rip), %rsi     # 0x1c5472
movb $0x0, %al
callq 0x15b0d0
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x11cb77
movq -0x10(%rbp), %rdi
leaq 0xa891a(%rip), %rsi     # 0x1c5481
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x4(%rbp)
jmp 0x11cb7e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/pcf.c
// Function: read_prop_string
static struct de_stringreaderdata *read_prop_string(deark *c, lctx *d,
	struct table_entry *te, i64 pos, const char *name)
{
	struct de_stringreaderdata *srd = NULL;

	srd = dbuf_read_string(c->infile, pos, te->offset+te->size-pos, 256,
		DE_CONVFLAG_STOP_AT_NUL|DE_CONVFLAG_WANT_UTF8, DE_ENCODING_ASCII);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz_d(srd->str));
	return srd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x18(%rbp), %rax
addq 0x28(%rax), %rdx
subq -0x20(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
movl $0x11, %r8d
movl $0x1, %r9d
callq 0x1664c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x172650
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x9ada9(%rip), %rsi     # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: de_module_plist
void de_module_plist(deark *c, struct deark_module_info *mi)
{
	mi->id = "plist";
	mi->desc = ".plist property list, binary format";
	mi->run_fn = de_run_plist;
	mi->identify_fn = de_identify_plist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x85bd1(%rip), %rcx     # 0x1a2ad8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xa8973(%rip), %rcx     # 0x1c5888
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x11cf40
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xfd(%rip), %rcx        # 0x11d030
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: de_run_plist
static void de_run_plist(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	if(c->infile->len>0xffffffffU) {
		// We *could* support huge PLIST files, but until I learn that they
		// are valid, for efficiency I'll make sure an offset can fit in
		// 4 bytes.
		de_err(c, "PLIST too large (%"I64_FMT")", c->infile->len);
		goto done;
	}

	if(!do_header(c, d, 0)) goto done;

	if(!do_trailer(c, d, c->infile->len-32)) goto done;
	read_offset_table(c, d);

	do_one_object_by_refnum(c, d, d->top_object_refnum);

done:
	if(d) {
		de_free(c, d->objref_table);
		de_free(c, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, 0x18(%rax)
jle 0x11cf9d
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
leaq 0xa8918(%rip), %rsi     # 0x1c58ac
movb $0x0, %al
callq 0x15bfb0
jmp 0x11cffb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11d080
cmpl $0x0, %eax
jne 0x11cfb5
jmp 0x11cffb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
subq $0x20, %rdx
callq 0x11d140
cmpl $0x0, %eax
jne 0x11cfd9
jmp 0x11cffb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11d380
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x11d4d0
cmpq $0x0, -0x18(%rbp)
je 0x11d020
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_header
static int do_header(deark *c, lctx *d, i64 pos)
{
	int retval = 0;

	de_dbg(c, "header at %d", (int)pos);

	if(dbuf_memcmp(c->infile, pos, "bplist", 6)) {
		de_err(c, "Not in binary PLIST format");
		goto done;
	}
	if(dbuf_memcmp(c->infile, pos+6, "00", 2)) {
		// TODO: Support other versions?
		de_err(c, "Unsupported binary PLIST version");
		goto done;
	}

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xa7ee2(%rip), %rsi     # 0x1c4f8e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa87fc(%rip), %rdx     # 0x1c58c2
movl $0x6, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x11d0e9
movq -0x8(%rbp), %rdi
leaq 0xa87e9(%rip), %rsi     # 0x1c58c9
movb $0x0, %al
callq 0x15bfb0
jmp 0x11d12a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
leaq 0x87038(%rip), %rdx     # 0x1a4138
movl $0x2, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x11d123
movq -0x8(%rbp), %rdi
leaq 0xa87ca(%rip), %rsi     # 0x1c58e4
movb $0x0, %al
callq 0x15bfb0
jmp 0x11d12a
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: read_offset_table
static void read_offset_table(deark *c, lctx *d)
{
	i64 k;
	i64 pos = d->objref_table_start;

	de_dbg(c, "objref table at %"I64_FMT, pos);
	de_dbg_indent(c, 1);

	d->objref_table = de_mallocarray(c, d->num_objrefs, sizeof(struct objref_struct));

	for(k=0; k<d->num_objrefs; k++) {
		i64 offs;

		if(pos+(i64)d->nbytes_per_objref_table_entry > c->infile->len-32) break;
		offs = dbuf_getint_ext(c->infile, pos, d->nbytes_per_objref_table_entry, 0, 0);
		if(c->debug_level>=2)
			de_dbg(c, "objref[%"I64_FMT"] offset: %"I64_FMT, k, offs);
		dbuf_constrain_offset(c->infile, &offs);
		d->objref_table[k].offs = (u32)offs;
		pos += (i64)d->nbytes_per_objref_table_entry;
	}

	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xa8622(%rip), %rsi     # 0x1c59cd
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x4, %edx
callq 0x15c450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jge 0x11d4ae
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %rcx
subq $0x20, %rcx
cmpq %rcx, %rax
jle 0x11d423
jmp 0x11d4ae
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x165a80
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jl 0x11d468
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xa8580(%rip), %rsi     # 0x1c59e1
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x164c60
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11d3e9
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_object_int
static void do_object_int(deark *c, lctx *d, i64 pos, i64 dlen_raw)
{
	unsigned int nbytes;
	i64 n;

	if(dlen_raw<0 || dlen_raw>3) return;
	nbytes = 1U<<(unsigned int)dlen_raw;
	n = dbuf_getint_ext(c->infile, pos, nbytes, 0, 1);
	de_dbg(c, "value: %"I64_FMT, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x11da76
cmpq $0x3, -0x20(%rbp)
jle 0x11da78
jmp 0x11dabe
movq -0x20(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x165a80
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x80d90(%rip), %rsi     # 0x19e847
movb $0x0, %al
callq 0x15b0d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_object_real
static void do_object_real(deark *c, lctx *d, i64 pos, i64 dlen_raw)
{
	double val;

	if(dlen_raw==2) {
		val = dbuf_getfloat32x(c->infile, pos, 0);
	}
	else if(dlen_raw==3) {
		val = dbuf_getfloat64x(c->infile, pos, 0);
	}
	else {
		return;
	}

	de_dbg(c, "value: %f", val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jne 0x11db09
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x165e00
movsd %xmm0, -0x28(%rbp)
jmp 0x11db2e
cmpq $0x3, -0x20(%rbp)
jne 0x11db2a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x165f20
movsd %xmm0, -0x28(%rbp)
jmp 0x11db2c
jmp 0x11db45
jmp 0x11db2e
movq -0x8(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
leaq 0x89218(%rip), %rsi     # 0x1a6d56
movb $0x1, %al
callq 0x15b0d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_object_date
static void do_object_date(deark *c, lctx *d, i64 pos)
{
	double val_flt;
	i64 val_int;
	struct de_timestamp ts;
	char timestamp_buf[64];

	val_flt = dbuf_getfloat64x(c->infile, pos, 0);
	val_int = (i64)val_flt;
	// Epoch is Jan 1, 2001. There are 31 years, with 8 leap days, between
	// that and the Unix time epoch.
	de_unix_time_to_timestamp(val_int + ((365*31 + 8)*86400), &ts, 0x1);
	de_timestamp_to_string(&ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "value: %f (%s)", val_flt, timestamp_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x165f20
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x3a4fc880, %rdi       # imm = 0x3A4FC880
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
leaq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
leaq -0x80(%rbp), %rdx
leaq 0xa7eff(%rip), %rsi     # 0x1c5ac9
movb $0x1, %al
callq 0x15b0d0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_object_string
static void do_object_string(deark *c, lctx *d, i64 pos, i64 len)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, len, DE_DBG_MAX_STRLEN, s, 0, DE_ENCODING_ASCII);
	de_dbg(c, "value: \"%s\"", ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl $0x1, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x172650
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x80bd7(%rip), %rsi     # 0x19e82b
movb $0x0, %al
callq 0x15b0d0
movq -0x28(%rbp), %rdi
callq 0x171750
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_object_utf16string
static void do_object_utf16string(deark *c, lctx *d, i64 pos, i64 len)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, len*2, DE_DBG_MAX_STRLEN*2, s, 0, DE_ENCODING_UTF16BE);
	de_dbg(c, "value: \"%s\"", ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
shlq %rdx
movq -0x28(%rbp), %r8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %r9d, %r9d
movl $0x4, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x172650
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x80b44(%rip), %rsi     # 0x19e82b
movb $0x0, %al
callq 0x15b0d0
movq -0x28(%rbp), %rdi
callq 0x171750
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/plist.c
// Function: do_object_array_or_set
static void do_object_array_or_set(deark *c, lctx *d, const char *tn,
	i64 objpos, i64 pos1, i64 numitems)
{
	i64 k;
	i64 pos = pos1;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);
	d->nesting_level++;
	if(d->nesting_level>MAX_PLIST_NESTING_LEVEL) {
		report_nesting_level_exceeded(c, d);
		goto done;
	}

	for(k=0; k<numitems; k++) {
		i64 refnum;

		if(d->exceeded_max_objects) goto done;
		de_dbg(c, "item[%d] (for %s@%"I64_FMT")", (int)k, tn, objpos);
		de_dbg_indent(c, 1);

		refnum = dbuf_getint_ext(c->infile, pos, d->nbytes_per_object_refnum, 0, 0);
		pos += (i64)d->nbytes_per_object_refnum;

		de_dbg(c, "refnum: %u", (unsigned int)refnum);
		if(!do_one_object_by_refnum(c, d, refnum)) goto done;

		de_dbg_indent(c, -1);
	}

done:
	d->nesting_level--;
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x15b580
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0xa, (%rax)
jle 0x11dd5b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11e040
jmp 0x11de30
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x11de2e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x11dd80
jmp 0x11de30
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0xa7d3f(%rip), %rsi     # 0x1c5ad8
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x165a80
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rax
movl %eax, %edx
leaq 0xa7b55(%rip), %rsi     # 0x1c5945
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x11d4d0
cmpl $0x0, %eax
jne 0x11de0f
jmp 0x11de30
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x11dd63
jmp 0x11de30
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x15b5a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/qtif.c
// Function: de_module_qtif
void de_module_qtif(deark *c, struct deark_module_info *mi)
{
	mi->id = "qtif";
	mi->desc = "QTIF (QuickTime Image Format)";
	mi->run_fn = de_run_qtif;
	mi->identify_fn = de_identify_qtif;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xa4a4f(%rip), %rcx     # 0x1c2ad6
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xa7ab5(%rip), %rcx     # 0x1c5b4a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x11e0c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbd(%rip), %rcx        # 0x11e170
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/qtif.c
// Function: de_run_qtif
static void de_run_qtif(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	if(mparams) {
		if(mparams->in_params.flags & 0x1) {
			d->fail_gracefully_mode = 1;
		}
	}

	if(de_havemodcode(c, mparams, 'I')) {
		// Raw data from a PICT file
		do_raw_idsc_data(c, d);
	}
	else {
		do_qtif_file_format(c, d);
	}

	if(mparams && d->decoded_ok) {
		mparams->out_params.flags |= 0x1;
	}

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x90, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11e109
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x11e107
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x11e109
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x49, %edx
callq 0x15d1d0
cmpl $0x0, %eax
je 0x11e12f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11e1f0
jmp 0x11e13c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11e2a0
cmpq $0x0, -0x10(%rbp)
je 0x11e15d
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x11e15d
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/qtif.c
// Function: de_identify_qtif
static int de_identify_qtif(deark *c)
{
	if(de_input_file_has_ext(c, "qtif")) return 20;
	if(de_input_file_has_ext(c, "qti")) return 5;
	if(de_input_file_has_ext(c, "qif")) return 5;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa494f(%rip), %rsi     # 0x1c2ad6
callq 0x15d180
cmpl $0x0, %eax
je 0x11e19a
movl $0x14, -0x4(%rbp)
jmp 0x11e1dd
movq -0x10(%rbp), %rdi
leaq 0xa7a9e(%rip), %rsi     # 0x1c5c43
callq 0x15d180
cmpl $0x0, %eax
je 0x11e1b8
movl $0x5, -0x4(%rbp)
jmp 0x11e1dd
movq -0x10(%rbp), %rdi
leaq 0xa7a84(%rip), %rsi     # 0x1c5c47
callq 0x15d180
cmpl $0x0, %eax
je 0x11e1d6
movl $0x5, -0x4(%rbp)
jmp 0x11e1dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/qtif.c
// Function: do_raw_idsc_data
static void do_raw_idsc_data(deark *c, lctx *d)
{
	int ret;

	de_dbg(c, "QuickTime 'idsc' data");

	de_dbg_indent(c, 1);
	ret = do_read_idsc(c, d, 0, c->infile->len);
	de_dbg_indent(c, -1);
	if(!ret) return;

	d->idat_pos = d->idsc_size;
	d->idat_size = c->infile->len - d->idat_pos;
	do_write_image(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa795d(%rip), %rsi     # 0x1c5b68
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x11e330
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
cmpl $0x0, -0x14(%rbp)
jne 0x11e256
jmp 0x11e28f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11e5a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)