LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: dclimplode_main
static void dclimplode_main(deark *c, i64 cmpr_pos, i64 cmpr_len,
	u8 orig_len_known, i64 orig_len)
{
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;

	outf = dbuf_create_output_file(c, "unc", NULL, 0);
	dbuf_enable_wbuffer(outf);
	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = cmpr_pos;
	dcmpri.len = cmpr_len;
	dcmpro.f = outf;
	if(orig_len_known) {
		dcmpro.len_known = 1;
		dcmpro.expected_len = orig_len;
	}

	fmtutil_dclimplode_codectype1(c, &dcmpri, &dcmpro, &dres, NULL);
	dbuf_flush(outf);
	if(dres.errcode) {
		de_err(c, "Decompression failed: %s", de_dfilter_get_errmsg(c, &dres));
	}

	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xe5a61(%rip), %rsi     # 0x14ce7a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r14
movq %rax, %rdi
callq 0xf0e3f
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %rbp
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xfa6e0
movq 0x18(%rbx), %rax
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r14, (%rbp)
cmpl $0x0, 0x4(%rsp)
je 0x67473
movb $0x1, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x10117f
movq %r14, %rdi
callq 0xf0ea4
cmpl $0x0, (%r15)
je 0x674bf
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa6a8
leaq 0xaccbf(%rip), %rsi     # 0x114171
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9df7
movq %r14, %rdi
callq 0xf0b13
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: do_lzstac_internal
static void do_lzstac_internal(deark *c, i64 cmpr_pos, i64 cmpr_len, UI flags)
{
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	struct de_lzstac_params lzstacparams;

	outf = dbuf_create_output_file(c, "unc", NULL, 0);
	dbuf_enable_wbuffer(outf);
	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = cmpr_pos;
	dcmpri.len = cmpr_len;
	dcmpro.f = outf;

	de_zeromem(&lzstacparams, sizeof(struct de_lzstac_params));
	lzstacparams.flags = flags;
	fmtutil_lzstac_codectype1(c, &dcmpri, &dcmpro, &dres, (void*)&lzstacparams);

	dbuf_flush(outf);
	if(dres.errcode) {
		de_err(c, "Decompression failed: %s", de_dfilter_get_errmsg(c, &dres));
		goto done;
	}
	if(dres.bytes_consumed_valid) {
		de_dbg(c, "decompressed %"I64_FMT" bytes to %"I64_FMT, dres.bytes_consumed,
			outf->len);
		if(dres.bytes_consumed<cmpr_len) {
			de_warn(c, "%"I64_FMT" extra bytes at end of file. File might not "
				"have decompressed correctly.", cmpr_len - dres.bytes_consumed);
		}
	}

done:
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
leaq 0xe597a(%rip), %rsi     # 0x14ce7a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %rbx
movq %rax, %rdi
callq 0xf0e3f
leaq 0x98(%rsp), %r13
leaq 0x80(%rsp), %r15
leaq 0x20(%rsp), %rbp
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0xfa6e0
movq 0x18(%r14), %rax
movq %rax, (%r13)
movq %r12, 0x8(%r13)
movq 0x10(%rsp), %r12
movq %r12, 0x10(%r13)
movq %rbx, (%r15)
leaq 0x1c(%rsp), %r8
movl 0xc(%rsp), %eax
movl %eax, (%r8)
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x101a0b
movq %rbx, %rdi
callq 0xf0ea4
cmpl $0x0, (%rbp)
je 0x675b8
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0xfa6a8
leaq 0xacbe0(%rip), %rsi     # 0x114171
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
callq 0xf0b13
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x24(%rsp)
je 0x6759e
movq 0x28(%rsp), %rdx
movq 0x18(%rbx), %rcx
leaq 0xab6b9(%rip), %rsi     # 0x112c88
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9226
subq 0x28(%rsp), %r12
jle 0x6759e
leaq 0xbd2f1(%rip), %rsi     # 0x1248d8
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe9b27
jmp 0x6759e
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_hpicn
void de_module_hpicn(deark *c, struct deark_module_info *mi)
{
	mi->id = "hpicn";
	mi->desc = "HP 100LX/200LX .ICN icon";
	mi->run_fn = de_run_hpicn;
	mi->identify_fn = de_identify_hpicn;
}

// Assembly:
leaq 0xbd791(%rip), %rax     # 0x124d90
movq %rax, (%rsi)
leaq 0xbd78d(%rip), %rax     # 0x124d96
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x67624
movq %rax, 0x18(%rsi)
leaq 0x80(%rip), %rax        # 0x6769f
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_hpicn
static void de_run_hpicn(deark *c, de_module_params *mparams)
{
	struct hpicn_params icnp;

	read_hpicn_params(c, &icnp);
	de_dbg_dimensions(c, icnp.w, icnp.h);
	de_convert_and_write_image_bilevel2(c->infile, 8, icnp.w, icnp.h, icnp.rowspan,
		DE_CVTF_WHITEISZERO, NULL, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x4, %esi
callq 0xef1ca
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x6, %esi
callq 0xef1ca
movq %rax, %r15
leaq 0x7(%r14), %rax
leaq 0xe(%r14), %r12
testq %rax, %rax
cmovnsq %rax, %r12
sarq $0x3, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe9b05
movq 0x18(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movl $0x1, %r9d
pushq $0x0
pushq $0x0
callq 0xf319c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_hpicn
static int de_identify_hpicn(deark *c)
{
	struct hpicn_params icnp;

	if(dbuf_memcmp(c->infile, 0, "\x01\x00\x01\x00", 4))
		return 0;
	read_hpicn_params(c, &icnp);
	if(8 + icnp.rowspan*icnp.h != c->infile->len) return 0;
	if(icnp.w<1 || icnp.w>2048 || icnp.h<1 || icnp.h>2048) return 0;
	if(icnp.w==44 && icnp.h==32) return 100;
	return 60;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xbd306(%rip), %rdx     # 0x1249b8
xorl %ebx, %ebx
movl $0x4, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x67749
movq 0x18(%r14), %rdi
movl $0x4, %esi
callq 0xef1ca
movq %rax, %r15
movq 0x18(%r14), %rdi
movl $0x6, %esi
callq 0xef1ca
leaq 0x7(%r15), %rcx
leaq 0xe(%r15), %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x3, %rdx
imulq %rax, %rdx
addq $0x8, %rdx
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rdx
jne 0x67749
movq $-0x801, %rcx           # imm = 0xF7FF
leaq (%r15,%rcx), %rdx
movq $-0x800, %rsi           # imm = 0xF800
cmpq %rsi, %rdx
setb %dl
addq %rax, %rcx
cmpq %rsi, %rcx
setb %cl
orb %dl, %cl
jne 0x67749
xorq $0x2c, %r15
xorq $0x20, %rax
orq %r15, %rax
movl $0x64, %eax
movl $0x3c, %ebx
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_xpuzzle
void de_module_xpuzzle(deark *c, struct deark_module_info *mi)
{
	mi->id = "xpuzzle";
	mi->desc = "X11 \"puzzle\" image";
	mi->run_fn = de_run_xpuzzle;
	mi->identify_fn = de_identify_xpuzzle;
}

// Assembly:
leaq 0xbd657(%rip), %rax     # 0x124daf
movq %rax, (%rsi)
leaq 0xbd655(%rip), %rax     # 0x124db7
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6777d
movq %rax, 0x18(%rsi)
leaq 0xf1(%rip), %rax        # 0x67869
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_xpuzzle
static void de_run_xpuzzle(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	struct xpuzzhdr hdr;
	de_color pal[256];
	i64 p;

	xpuzz_read_header(c, &hdr);
	de_dbg_dimensions(c, hdr.w, hdr.h);
	if(!de_good_image_dimensions(c, hdr.w, hdr.h)) goto done;

	img = de_bitmap_create(c,  hdr.w,  hdr.h, 3);

	// Read the palette
	p = 9;
	de_read_simple_palette(c, c->infile, p,  hdr.palentries, 3, pal, 256,
		DE_RDPALTYPE_24BIT, DE_RDPALFLAG_INITPAL);
	p += 3*hdr.palentries;

	// Read the bitmap
	de_convert_image_paletted(c->infile, p, 8, hdr.w, pal, img, 0);

	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x6cdc2
movq (%r15), %rbx
movq 0x8(%r15), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xe9b05
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf241d
testl %eax, %eax
je 0x6784d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r15
movq 0x18(%r14), %rsi
movq 0x18(%rsp), %r12
subq $0x8, %rsp
leaq 0x28(%rsp), %r13
movl $0x9, %edx
movl $0x3, %r8d
movq %r14, %rdi
movq %r12, %rcx
movq %r13, %r9
pushq $0x10
pushq $0x1
pushq $0x100                  # imm = 0x100
callq 0xf32f2
addq $0x20, %rsp
leaq (%r12,%r12,2), %rsi
addq $0x9, %rsi
movq 0x18(%r14), %rdi
subq $0x8, %rsp
movl $0x8, %edx
movq %rbx, %rcx
movq %r13, %r8
movq %r15, %r9
pushq $0x0
callq 0xf35b8
addq $0x10, %rsp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
jmp 0x67850
xorl %r15d, %r15d
movq %r15, %rdi
callq 0xf28d4
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_xpuzzle
static int de_identify_xpuzzle(deark *c)
{
	struct xpuzzhdr hdr;
	int retval = 0;

	xpuzz_read_header(c, &hdr);
	// 4096 is an arbitrary limit.
	if(hdr.w<1 || hdr.w>4096 || hdr.h<1 || hdr.h>4096) goto done;
	if(hdr.w * hdr.h + 3*hdr.palentries + 9 == c->infile->len) {
		retval = 20;
	}

done:
	return retval;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x6cdc2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq $-0x1001, %rax          # imm = 0xEFFF
leaq (%rdx,%rax), %rsi
movq $-0x1000, %rdi          # imm = 0xF000
cmpq %rdi, %rsi
setb %sil
addq %rcx, %rax
cmpq %rdi, %rax
setb %dil
xorl %eax, %eax
orb %sil, %dil
jne 0x678d5
imulq %rdx, %rcx
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
addq $0x9, %rax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
cmpq 0x18(%rcx), %rax
movl $0x14, %eax
cmovnel %edx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_bob
void de_module_bob(deark *c, struct deark_module_info *mi)
{
	mi->id = "bob";
	mi->desc = "Bob Ray Tracer bitmap image";
	mi->run_fn = de_run_bob;
	mi->identify_fn = de_identify_bob;
}

// Assembly:
leaq 0xc092f(%rip), %rax     # 0x128213
movq %rax, (%rsi)
leaq 0xbd4dc(%rip), %rax     # 0x124dca
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x67909
movq %rax, 0x18(%rsi)
leaq 0xe2(%rip), %rax        # 0x679e6
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_bob
static void de_run_bob(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	i64 w, h;
	u32 pal[256];
	i64 p;

	w = de_getu16le(0);
	h = de_getu16le(2);
	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 3);

	// Read the palette
	p = 4;
	de_read_simple_palette(c, c->infile, p, 256, 3, pal, 256, DE_RDPALTYPE_24BIT, 0);
	p += 256*3;

	// Read the bitmap
	de_convert_image_paletted(c->infile, p, 8, w, pal, img, 0);

	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef1ca
movq %rax, %r15
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xef1ca
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xf241d
testl %eax, %eax
je 0x679cd
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r12
movq 0x18(%r14), %rsi
subq $0x8, %rsp
leaq 0x8(%rsp), %r13
movl $0x4, %edx
movl $0x100, %ecx            # imm = 0x100
movl $0x3, %r8d
movq %r14, %rdi
movq %r13, %r9
pushq %rbx
pushq $0x1
pushq $0x100                  # imm = 0x100
callq 0xf32f2
addq $0x20, %rsp
movq 0x18(%r14), %rdi
subq $0x8, %rsp
movl $0x304, %esi            # imm = 0x304
movl $0x8, %edx
movq %r15, %rcx
movq %r13, %r8
movq %r12, %r9
pushq %rbx
callq 0xf35b8
addq $0x10, %rsp
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
movq %r12, %rbx
movq %rbx, %rdi
callq 0xf28d4
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_bob
static int de_identify_bob(deark *c)
{
	i64 w, h;

	if(!de_input_file_has_ext(c, "bob")) return 0;

	w = de_getu16le(0);
	h = de_getu16le(2);
	if(c->infile->len == 4 + 768 + w*h) {
		return 100;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc081e(%rip), %rsi     # 0x128213
callq 0xea936
testl %eax, %eax
je 0x67a3a
movq 0x18(%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0xef1ca
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef1ca
movq 0x18(%rbx), %rcx
imulq %r14, %rax
addq $0x304, %rax            # imm = 0x304
cmpq %rax, 0x18(%rcx)
movl $0x64, %eax
cmovnel %r15d, %eax
jmp 0x67a3c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_alias_pix
void de_module_alias_pix(deark *c, struct deark_module_info *mi)
{
	mi->id = "alias_pix";
	mi->id_alias[0] = "vivid";
	mi->desc = "Alias PIX image, Vivid .IMG";
	mi->run_fn = de_run_alias_pix;
	mi->identify_fn = de_identify_alias_pix;
}

// Assembly:
leaq 0xbd39d(%rip), %rax     # 0x124de6
movq %rax, (%rsi)
leaq 0xbd39d(%rip), %rax     # 0x124df0
movq %rax, 0x38(%rsi)
leaq 0xbd398(%rip), %rax     # 0x124df6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x67a79
movq %rax, 0x18(%rsi)
leaq 0x173(%rip), %rax       # 0x67be7
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_alias_pix
static void de_run_alias_pix(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	i64 w, h;
	i64 i;
	i64 pos;
	i64 firstline;
	i64 depth;
	i64 xpos, ypos;
	i64 runlen;
	u32 clr;

	w = de_getu16be(0);
	h = de_getu16be(2);
	firstline = de_getu16be(4);
	depth = de_getu16be(8);

	if(!de_good_image_dimensions(c, w, h)) goto done;
	if(firstline >= h) goto done;
	if(depth!=24) {
		de_err(c, "Unsupported image type");
		goto done;
	}

	img = de_bitmap_create(c, w, h, 3);

	pos = 10;
	xpos = 0;
	// I don't know for sure what to do with the "first scanline" field, in the
	// unlikely event it is not 0. The documentation doesn't say.
	ypos = firstline;
	while(1) {
		if(pos+4 > c->infile->len) {
			break; // EOF
		}
		runlen = (i64)de_getbyte(pos);
		clr = dbuf_getRGB(c->infile, pos+1, DE_GETRGBFLAG_BGR);
		pos+=4;

		for(i=0; i<runlen; i++) {
			de_bitmap_setpixel_rgb(img, xpos, ypos, clr);
			xpos++; // Runs are not allowed to span rows
		}

		if(xpos >= w) {
			xpos=0;
			ypos++;
		}
	}

	de_bitmap_write_to_file(img, NULL, 0);
done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef169
movq %rax, %rbx
movq 0x18(%r15), %rdi
movl $0x2, %esi
callq 0xef169
movq %rax, %r13
movq 0x18(%r15), %rdi
movl $0x4, %esi
callq 0xef169
movq %rax, %r12
movq 0x18(%r15), %rdi
movl $0x8, %esi
callq 0xef169
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, 0x8(%rsp)
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf241d
testl %eax, %eax
setne %al
cmpq %r13, %r12
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x67bd1
cmpq $0x18, %rbp
jne 0x67bbd
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r14
movq 0x18(%r15), %rdi
cmpq $0xe, 0x18(%rdi)
jl 0x67baf
movl $0xa, %ebx
movl $0xe, %eax
xorl %r13d, %r13d
movq %r15, 0x10(%rsp)
movq %rbx, %rbp
movq %rax, %rbx
movq %rbp, %rsi
callq 0xef0d5
movq %r15, %rcx
movl %eax, %r15d
movq 0x18(%rcx), %rdi
orq $0x1, %rbp
movq %rbp, %rsi
movl $0x1, %edx
callq 0xefa60
testb %r15b, %r15b
je 0x67b86
movl %eax, %ebp
movzbl %r15b, %r15d
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0xf2afd
incq %r13
decq %r15
jne 0x67b6e
xorl %eax, %eax
cmpq 0x8(%rsp), %r13
setge %al
movl $0x0, %ecx
cmovgeq %rcx, %r13
addq %rax, %r12
leaq 0x4(%rbx), %rax
movq 0x10(%rsp), %r15
movq 0x18(%r15), %rdi
cmpq 0x18(%rdi), %rax
jle 0x67b3a
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
jmp 0x67bd1
leaq 0xafab6(%rip), %rsi     # 0x11767a
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf28d4
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_alias_pix
static int de_identify_alias_pix(deark *c)
{
	i64 w, h, firstline, lastline, depth;

	if(!de_input_file_has_ext(c, "img") &&
		!de_input_file_has_ext(c, "als") &&
		!de_input_file_has_ext(c, "pix"))
	{
		return 0;
	}

	w = de_getu16be(0);
	h = de_getu16be(2);
	firstline = de_getu16be(4);
	lastline = de_getu16be(6);
	depth = de_getu16be(8);

	if(depth!=24) return 0;
	if(firstline>lastline) return 0;
	// 'lastline' should usually be h-1, but XnView apparently sets it to h.
	if(firstline>h-1 || lastline>h) return 0;
	if(!de_good_image_dimensions_noerr(c, w, h)) return 0;
	return 30;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb7d53(%rip), %rsi     # 0x11f94f
callq 0xea936
testl %eax, %eax
jne 0x67c2f
leaq 0xe35f4(%rip), %rsi     # 0x14b200
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
jne 0x67c2f
leaq 0xc2b87(%rip), %rsi     # 0x12a7a6
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
je 0x67cce
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef169
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef169
movq %rax, %r12
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef169
movq %rax, %r13
movq 0x18(%rbx), %rdi
movl $0x6, %esi
callq 0xef169
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movl $0x8, %esi
callq 0xef169
cmpq $0x18, %rax
setne %al
cmpq %rbp, %r13
setg %cl
orb %al, %cl
jne 0x67cbc
cmpq %r12, %r13
setge %al
cmpq %r12, %rbp
setg %cl
orb %al, %cl
jne 0x67cbc
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xf23f0
testl %eax, %eax
movl $0x1e, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x67cbc
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_applevol
void de_module_applevol(deark *c, struct deark_module_info *mi)
{
	mi->id = "applevol";
	mi->desc = "Apple volume label image";
	mi->run_fn = de_run_applevol;
	mi->identify_fn = de_identify_applevol;
}

// Assembly:
leaq 0xbd138(%rip), %rax     # 0x124e12
movq %rax, (%rsi)
leaq 0xbd137(%rip), %rax     # 0x124e1b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x67cff
movq %rax, 0x18(%rsi)
leaq 0x16a(%rip), %rax       # 0x67e64
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_applevol
static void de_run_applevol(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	i64 w, h;
	i64 i, j;
	i64 p;
	u8 palent;

	w = de_getu16be(1);
	h = de_getu16be(3);
	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 1);

	p = 5;
	for(j=0; j<h; j++) {
		for(i=0; i<w; i++) {
			palent = de_getbyte(p+w*j+i);
			de_bitmap_setpixel_gray(img, i, j, applevol_get_gray_shade(palent));
		}
	}

	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x1, %esi
callq 0xef169
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x3, %esi
callq 0xef169
movq %rax, %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf241d
testl %eax, %eax
je 0x67e4b
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movl $0x1, %ecx
callq 0xf2cab
movq %rax, %r12
testq %rbp, %rbp
jle 0x67e3d
movl $0x5, %r15d
xorl %r13d, %r13d
movq %rbp, (%rsp)
testq %r14, %r14
jle 0x67e2a
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
leaq (%r15,%rbp), %rsi
callq 0xef0d5
movzbl %al, %ecx
movb $-0x1, %al
cmpl $0xaa, %ecx
jle 0x67db5
leal -0xf6(%rcx), %edx
cmpl $0x9, %edx
ja 0x67dcb
leaq 0xbcbe8(%rip), %rcx     # 0x124990
movslq (%rcx,%rdx,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $-0x12, %al
jmp 0x67e0d
cmpl $0x2a, %ecx
je 0x67ddf
cmpl $0x55, %ecx
je 0x67de3
cmpl $0x80, %ecx
jne 0x67e0d
movb $0x66, %al
jmp 0x67e0d
cmpl $0xab, %ecx
je 0x67def
cmpl $0xd6, %ecx
jne 0x67e0d
xorl %eax, %eax
jmp 0x67e0d
movb $-0x34, %al
jmp 0x67e0d
movb $-0x67, %al
jmp 0x67e0d
movb $-0x78, %al
jmp 0x67e0d
movb $0x11, %al
jmp 0x67e0d
movb $0x33, %al
jmp 0x67e0d
movb $-0x45, %al
jmp 0x67e0d
movb $-0x56, %al
jmp 0x67e0d
movb $0x44, %al
jmp 0x67e0d
movb $-0x23, %al
jmp 0x67e0d
movb $0x77, %al
jmp 0x67e0d
movb $0x55, %al
jmp 0x67e0d
movb $0x22, %al
movzbl %al, %ecx
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xf2a4a
incq %rbp
cmpq %rbp, %r14
jne 0x67d7c
incq %r13
addq %r14, %r15
movq (%rsp), %rbp
cmpq %rbp, %r13
jne 0x67d71
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
jmp 0x67e4e
xorl %r12d, %r12d
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf28d4
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_hr
void de_module_hr(deark *c, struct deark_module_info *mi)
{
	mi->id = "hr";
	mi->desc = "TRS-80 HR (High Resolution) image";
	mi->run_fn = de_run_hr;
	mi->identify_fn = de_identify_hr;
}

// Assembly:
leaq 0xbcf8a(%rip), %rax     # 0x124e34
movq %rax, (%rsi)
leaq 0xbcf83(%rip), %rax     # 0x124e37
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x67ecf
movq %rax, 0x18(%rsi)
leaq 0x96(%rip), %rax        # 0x67f60
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_hr
static void de_run_hr(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	de_finfo *fi = NULL;

	fi = de_finfo_create(c);
	fi->density.code = DE_DENSITY_UNK_UNITS;
	fi->density.xdens = 2;
	fi->density.ydens = 1;
	img = de_bitmap_create(c, 640, 240, 1);
	de_convert_image_bilevel(c->infile, 0, 640/8, img, 0);
	de_bitmap_write_to_file_finfo(img, fi, DE_CREATEFLAG_IS_BWIMG);
	de_bitmap_destroy(img);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xea9a9
movq %rax, %r14
movl $0x1, 0x78(%rax)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x80(%r14)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x88(%r14)
movl $0x280, %esi            # imm = 0x280
movl $0xf0, %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0xf2cab
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x50, %edx
xorl %esi, %esi
movq %rax, %rcx
xorl %r8d, %r8d
callq 0xf3081
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0xf2917
movq %r15, %rdi
callq 0xf28d4
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xea9b3
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_ripicon
void de_module_ripicon(deark *c, struct deark_module_info *mi)
{
	mi->id = "ripicon";
	mi->desc = "RIP/RIPscrip/RIPterm Icon / BGI image";
	mi->run_fn = de_run_ripicon;
	mi->identify_fn = de_identify_ripicon;
}

// Assembly:
leaq 0xbceaf(%rip), %rax     # 0x124e59
movq %rax, (%rsi)
leaq 0xbcead(%rip), %rax     # 0x124e61
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x67fcf
movq %rax, 0x18(%rsi)
leaq 0x4d(%rip), %rax        # 0x68017
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_ripicon
static void de_run_ripicon(deark *c, de_module_params *mparams)
{
	i64 pos = 0;

	while(1) {
		i64 bytes_consumed = 0;

		if(!do_one_ripicon(c, pos, &bytes_consumed, 0)) break;
		pos += bytes_consumed;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rsp, %r14
xorl %r15d, %r15d
movq %r12, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x6ce14
movl $0x0, %ecx
testl %eax, %eax
je 0x68004
movq (%rsp), %rcx
addq %rcx, %r15
testl %eax, %eax
jne 0x67fe3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_ripicon
static int de_identify_ripicon(deark *c)
{
	int has_ext = 0;
	i64 pos = 0;
	size_t i;
	static const char *exts[] = { "icn", "hot", "msk", "bgi" };

	for(i=0; i<DE_ARRAYCOUNT(exts); i++) {
		if(de_input_file_has_ext(c, exts[i])) {
			has_ext = 1;
			break;
		}
	}
	if(!has_ext) return 0;

	while(1) {
		i64 bytes_consumed = 0;

		if(!do_one_ripicon(c, pos, &bytes_consumed, 1)) break;
		pos += bytes_consumed;
		if(pos == c->infile->len) return 50;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xbc993(%rip), %r15     # 0x1249c0
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
jne 0x6804c
addq $0x4, %r14
cmpq $0x10, %r14
jne 0x6802d
jmp 0x68096
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x6ce14
testl %eax, %eax
je 0x68088
addq 0x8(%rsp), %r14
movq 0x18(%rbx), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %r14
sete %al
jmp 0x6808d
movl $0x6, %eax
testl %eax, %eax
je 0x68054
cmpl $0x6, %eax
jne 0x6809a
xorl %eax, %eax
jmp 0x6809f
movl $0x32, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_lss16
void de_module_lss16(deark *c, struct deark_module_info *mi)
{
	mi->id = "lss16";
	mi->desc = "SYSLINUX LSS16 image";
	mi->run_fn = de_run_lss16;
	mi->identify_fn = de_identify_lss16;
}

// Assembly:
leaq 0xbcdd7(%rip), %rax     # 0x124e87
movq %rax, (%rsi)
leaq 0xbcdd3(%rip), %rax     # 0x124e8d
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x680d5
movq %rax, 0x18(%rsi)
leaq 0x226(%rip), %rax       # 0x682f6
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_vbm
void de_module_vbm(deark *c, struct deark_module_info *mi)
{
	mi->id = "vbm";
	mi->desc = "C64/128 VBM (VDC BitMap)";
	mi->run_fn = de_run_vbm;
	mi->identify_fn = de_identify_vbm;
}

// Assembly:
leaq 0xbcb7f(%rip), %rax     # 0x124ea2
movq %rax, (%rsi)
leaq 0xbcb79(%rip), %rax     # 0x124ea6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x68348
movq %rax, 0x18(%rsi)
leaq 0x91(%rip), %rax        # 0x683d4
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_vbm
static void de_run_vbm(deark *c, de_module_params *mparams)
{
	i64 width, height;
	u8 ver;

	ver = de_getbyte(3);
	if(ver!=2) {
		// TODO: Support VBM v3.
		de_err(c, "Unsupported VBM version (%d)", (int)ver);
		return;
	}
	width = de_getu16be(4);
	height = de_getu16be(6);
	de_convert_and_write_image_bilevel2(c->infile, 8, width, height, (width+7)/8,
		DE_CVTF_WHITEISZERO, NULL, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x3, %esi
callq 0xef0d5
cmpb $0x2, %al
jne 0x683b9
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef169
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x6, %esi
callq 0xef169
movq 0x18(%rbx), %rdi
leaq 0x7(%r14), %rcx
leaq 0xe(%r14), %r8
testq %rcx, %rcx
cmovnsq %rcx, %r8
sarq $0x3, %r8
movl $0x8, %esi
movq %r14, %rdx
movq %rax, %rcx
movl $0x1, %r9d
pushq $0x0
pushq $0x0
callq 0xf319c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movzbl %al, %edx
leaq 0xbce12(%rip), %rsi     # 0x1251d5
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9df7
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_vbm
static int de_identify_vbm(deark *c)
{
	u8 b[4];
	de_read(b, 0, 4);
	if(de_memcmp(b, "BM\xcb", 3)) return 0;
	if(b[3]!=2 && b[3]!=3) return 0;
	if(de_input_file_has_ext(c, "vbm")) return 100;
	return 80;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
movl $0x4, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xeeee8
movzwl (%r15), %eax
xorl $0x4d42, %eax           # imm = 0x4D42
movzbl 0x2(%r15), %ecx
xorl $0xcb, %ecx
orw %ax, %cx
jne 0x6843b
movb 0xf(%rsp), %al
addb $-0x4, %al
cmpb $-0x2, %al
jb 0x6843b
leaq 0xbca7e(%rip), %rsi     # 0x124ea2
movq %r14, %rdi
callq 0xea936
testl %eax, %eax
movl $0x50, %eax
movl $0x64, %ebx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_fp_art
void de_module_fp_art(deark *c, struct deark_module_info *mi)
{
	mi->id = "fp_art";
	mi->desc = "PFS: 1st Publisher clip art (.ART)";
	mi->run_fn = de_run_fp_art;
	mi->identify_fn = de_identify_fp_art;
}

// Assembly:
leaq 0xbca71(%rip), %rax     # 0x124ebf
movq %rax, (%rsi)
leaq 0xbca6e(%rip), %rax     # 0x124ec6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x68473
movq %rax, 0x18(%rsi)
leaq 0x2fb(%rip), %rax       # 0x68769
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_fp_art
static int de_identify_fp_art(deark *c)
{
	UI fld1;

	if(!de_input_file_has_ext(c, "art")) return 0;
	fld1 = (UI)de_getu16le(0);
	if(fld1==0xffff) {
		return fp_art_id_hires(c);
	}
	return fp_art_id_stdres(c, fld1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0xc816d(%rip), %rsi     # 0x1308e9
callq 0xea936
testl %eax, %eax
je 0x68824
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef1ca
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x68828
movq %rsp, %rsi
movq $0x2, (%rsi)
movq 0x18(%r14), %rdi
callq 0xef1ed
xorl %ebx, %ebx
cmpl $0x12c, %eax            # imm = 0x12C
jne 0x68889
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xef1ed
cmpl $0x12c, %eax            # imm = 0x12C
jne 0x68889
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xef1ed
addl $0xffffdfff, %eax       # imm = 0xFFFFDFFF
cmpl $0xffffe000, %eax       # imm = 0xFFFFE000
jb 0x68889
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xef1ed
addl $0xffffdfff, %eax       # imm = 0xFFFFDFFF
cmpl $0xffffe000, %eax       # imm = 0xFFFFE000
jb 0x68889
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xef1ed
xorl %ecx, %ecx
cmpl $0x1, %eax
movl $0x3b, %ebx
jmp 0x68886
xorl %ebx, %ebx
jmp 0x68889
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x6d02e
cmpb $0x0, (%r15)
je 0x68889
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, %rsi
imulq %rcx, %rsi
addq $0x8, %rsi
movq 0x18(%r14), %rdx
movq 0x18(%rdx), %rdx
movl $0x4a, %ebx
cmpq %rdx, %rsi
je 0x68889
incq %rax
imulq %rcx, %rax
addq $0x8, %rax
xorl %ecx, %ecx
cmpq %rdx, %rax
movl $0x18, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_ybm
void de_module_ybm(deark *c, struct deark_module_info *mi)
{
	mi->id = "ybm";
	mi->desc = "Bennet Yee's face format, a.k.a. YBM";
	mi->run_fn = de_run_ybm;
	mi->identify_fn = de_identify_ybm;
}

// Assembly:
leaq 0xbc64d(%rip), %rax     # 0x124ee9
movq %rax, (%rsi)
leaq 0xbc647(%rip), %rax     # 0x124eed
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x688c1
movq %rax, 0x18(%rsi)
leaq 0x186(%rip), %rax       # 0x68a42
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_ybm
static void de_run_ybm(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	i64 npwidth, pdwidth, height;
	i64 i, j;
	i64 words_per_row;
	i64 pos;

	pos = 2;
	npwidth = de_getu16be_p(&pos);
	height = de_getu16be_p(&pos);
	de_dbg_dimensions(c, npwidth, height);
	if(!de_good_image_dimensions(c, npwidth, height)) goto done;
	pdwidth = de_pad_to_n(npwidth, 16);
	words_per_row = pdwidth/16;

	img = de_bitmap_create2(c, npwidth, pdwidth, height, 1);

	for(j=0; j<height; j++) {
		for(i=0; i<words_per_row; i++) {
			u8 x;

			// This encoding is unusual: LSB-first 16-bit integers.
			x = de_getbyte_p(&pos);
			de_unpack_pixels_bilevel_from_byte(img, i*16+8, j, x, 8,
				DE_CVTF_WHITEISZERO|DE_CVTF_LSBFIRST|DE_CVTF_ONLYWHITE);
			x = de_getbyte_p(&pos);
			de_unpack_pixels_bilevel_from_byte(img, i*16, j, x, 8,
				DE_CVTF_WHITEISZERO|DE_CVTF_LSBFIRST|DE_CVTF_ONLYWHITE);
		}
	}
	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq $0x2, (%r15)
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xef193
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef193
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe9b05
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xf241d
testl %eax, %eax
je 0x68a29
movl $0x10, %esi
movq %r14, %rdi
callq 0xea80b
leaq 0xf(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
movq %rcx, (%rsp)
movq %rbx, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, 0x20(%rsp)
movq %rax, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0xf2ce6
movq %rax, 0x8(%rsp)
testq %r12, %r12
jle 0x68a16
sarq $0x4, (%rsp)
xorl %r15d, %r15d
leaq 0x30(%rsp), %rbx
movq %r12, 0x10(%rsp)
movq 0x18(%rsp), %r13
cmpq $0x10, 0x20(%rsp)
jl 0x68a05
movl $0x8, %r14d
movq (%rsp), %rbp
movq 0x18(%r13), %rdi
movq %rbx, %rsi
callq 0xef14d
leaq -0x8(%r14), %rcx
movq %rcx, 0x28(%rsp)
movzbl %al, %ecx
movq %r15, %r12
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x8, %r8d
movl $0x7, %r9d
callq 0xf2f6b
movq 0x18(%r13), %rdi
movq %rbx, %rsi
callq 0xef14d
movzbl %al, %ecx
movq %r15, %rdi
movq %r12, %r15
movq 0x28(%rsp), %rsi
movq %r12, %rdx
movl $0x8, %r8d
movl $0x7, %r9d
callq 0xf2f6b
addq $0x10, %r14
decq %rbp
jne 0x68994
incq %r15
movq 0x10(%rsp), %r12
cmpq %r12, %r15
jne 0x68982
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
jmp 0x68a2b
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0xf28d4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_ybm
static int de_identify_ybm(deark *c)
{
	i64 width, height;
	i64 rowspan;

	if(dbuf_memcmp(c->infile, 0, "!!", 2))
		return 0;
	width = de_getu16be(2);
	height = de_getu16be(4);
	rowspan = ((width+15)/16)*2;
	if(6+height*rowspan == c->infile->len)
		return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xb1883(%rip), %rdx     # 0x11a2d7
xorl %r14d, %r14d
movl $0x2, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x68ab9
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef169
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef169
leaq 0xf(%r14), %rcx
addq $0x1e, %r14
testq %rcx, %rcx
cmovnsq %rcx, %r14
sarq $0x4, %r14
imulq %rax, %r14
leaq 0x6(,%r14,2), %rax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
cmpq 0x18(%rcx), %rax
movl $0x64, %r14d
cmovnel %edx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_olpc565
void de_module_olpc565(deark *c, struct deark_module_info *mi)
{
	mi->id = "olpc565";
	mi->desc = "OLPC .565 firmware icon";
	mi->run_fn = de_run_olpc565;
	mi->identify_fn = de_identify_olpc565;
}

// Assembly:
leaq 0xbc447(%rip), %rax     # 0x124f12
movq %rax, (%rsi)
leaq 0xbc445(%rip), %rax     # 0x124f1a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x68af0
movq %rax, 0x18(%rsi)
leaq 0x141(%rip), %rax       # 0x68c2c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_olpc565
static void de_run_olpc565(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	i64 width, height;
	i64 i, j;
	i64 rowspan;
	u8 b0, b1;
	u32 clr;

	width = de_getu16le(4);
	height = de_getu16le(6);
	if(!de_good_image_dimensions(c, width, height)) goto done;
	rowspan = width*2;

	img = de_bitmap_create(c, width, height, 3);

	for(j=0; j<height; j++) {
		for(i=0; i<width; i++) {
			b0 = de_getbyte(8 + j*rowspan + i*2);
			b1 = de_getbyte(8 + j*rowspan + i*2 + 1);
			clr = (((u32)b1)<<8) | b0;
			clr = de_rgb565_to_888(clr);
			de_bitmap_setpixel_rgb(img, i, j, clr);
		}
	}
	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x4, %esi
callq 0xef1ca
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x6, %esi
callq 0xef1ca
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf241d
testl %eax, %eax
je 0x68c13
movq %rbx, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r12
testq %r15, %r15
jle 0x68c05
leaq (%r14,%r14), %rax
movq %rax, 0x8(%rsp)
movl $0x9, %eax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %r15, 0x10(%rsp)
movq 0x18(%rsp), %rbx
testq %r14, %r14
jle 0x68be7
movq (%rsp), %rbp
xorl %r15d, %r15d
movq %r13, 0x20(%rsp)
movq 0x18(%rbx), %rdi
leaq -0x1(%rbp), %rsi
callq 0xef0d5
movq %r12, %r13
movq %r14, %r12
movl %eax, %r14d
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
callq 0xef0d5
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %edi
movq %r12, %r14
movq %r13, %r12
movq 0x20(%rsp), %r13
orl %eax, %edi
callq 0xece9d
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0xf2afd
incq %r15
addq $0x2, %rbp
cmpq %r15, %r14
jne 0x68b8d
incq %r13
movq (%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %r15
cmpq %r15, %r13
jne 0x68b7c
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
jmp 0x68c16
xorl %r12d, %r12d
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf28d4
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_iim
void de_module_iim(deark *c, struct deark_module_info *mi)
{
	mi->id = "iim";
	mi->desc = "InShape IIM";
	mi->run_fn = de_run_iim;
	mi->identify_fn = de_identify_iim;
}

// Assembly:
leaq 0xbc2d9(%rip), %rax     # 0x124f32
movq %rax, (%rsi)
leaq 0xbc2d3(%rip), %rax     # 0x124f36
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x68c7e
movq %rax, 0x18(%rsi)
leaq 0x143(%rip), %rax       # 0x68dbc
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_iim
static void de_run_iim(deark *c, de_module_params *mparams)
{
	de_bitmap *img = NULL;
	i64 width, height;
	i64 i, j;
	i64 n, bpp;
	i64 rowspan;
	u32 clr;

	// This code is based on reverse engineering, and may be incorrect.

	n = de_getu16be(8); // Unknown field
	bpp = de_getu16be(10);
	if(n!=4 || bpp!=24) {
		de_dbg(c, "This type of IIM image is not supported");
		goto done;
	}
	width = de_getu16be(12);
	height = de_getu16be(14);
	if(!de_good_image_dimensions(c, width, height)) goto done;
	rowspan = width*3;

	img = de_bitmap_create(c, width, height, 3);

	for(j=0; j<height; j++) {
		for(i=0; i<width; i++) {
			clr = dbuf_getRGB(c->infile, 16+j*rowspan+i*3, 0);
			de_bitmap_setpixel_rgb(img, i, j, clr);
		}
	}
	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x8, %esi
callq 0xef169
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0xa, %esi
callq 0xef169
cmpq $0x4, %r14
jne 0x68d8d
cmpq $0x18, %rax
jne 0x68d8d
movq 0x18(%rbx), %rdi
movl $0xc, %esi
callq 0xef169
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xef169
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf241d
testl %eax, %eax
je 0x68da3
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r15
testq %r12, %r12
jle 0x68d7f
leaq (%r14,%r14,2), %rax
movq %rax, 0x8(%rsp)
movl $0x10, %eax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %r12, 0x10(%rsp)
testq %r14, %r14
jle 0x68d65
movq (%rsp), %rbp
xorl %r12d, %r12d
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xefa60
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0xf2afd
incq %r12
addq $0x3, %rbp
cmpq %r12, %r14
jne 0x68d3b
incq %r13
movq (%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %r12
cmpq %r12, %r13
jne 0x68d2f
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
jmp 0x68da6
leaq 0xbc4cd(%rip), %rsi     # 0x125261
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
jmp 0x68da6
xorl %r15d, %r15d
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf28d4
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_pm_xv
void de_module_pm_xv(deark *c, struct deark_module_info *mi)
{
	mi->id = "pm_xv";
	mi->desc = "PM (XV)";
	mi->run_fn = de_run_pm_xv;
	mi->identify_fn = de_identify_pm_xv;
}

// Assembly:
leaq 0xbc159(%rip), %rax     # 0x124f42
movq %rax, (%rsi)
leaq 0xbc155(%rip), %rax     # 0x124f48
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x68e0e
movq %rax, 0x18(%rsi)
leaq 0x272(%rip), %rax       # 0x6907b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_crg
void de_module_crg(deark *c, struct deark_module_info *mi)
{
	mi->id = "crg";
	mi->desc = "Calamus Raster Graphic";
	mi->run_fn = de_run_crg;
	mi->identify_fn = de_identify_crg;
}

// Assembly:
leaq 0xbbe78(%rip), %rax     # 0x124f50
movq %rax, (%rsi)
leaq 0xbbe72(%rip), %rax     # 0x124f54
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x690fd
movq %rax, 0x18(%rsi)
leaq 0x1c0(%rip), %rax       # 0x692b8
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_farbfeld
void de_module_farbfeld(deark *c, struct deark_module_info *mi)
{
	mi->id = "farbfeld";
	mi->desc = "farbfeld image";
	mi->run_fn = de_run_farbfeld;
	mi->identify_fn = de_identify_farbfeld;
}

// Assembly:
leaq 0xbbc86(%rip), %rax     # 0x124f6b
movq %rax, (%rsi)
leaq 0xbbc85(%rip), %rax     # 0x124f74
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6930a
movq %rax, 0x18(%rsi)
leaq 0x1ed(%rip), %rax       # 0x694f2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_hsiraw
void de_module_hsiraw(deark *c, struct deark_module_info *mi)
{
	mi->id = "hsiraw";
	mi->desc = "HSI Raw";
	mi->run_fn = de_run_hsiraw;
	mi->identify_fn = de_identify_hsiraw;
}

// Assembly:
leaq 0xbba64(%rip), %rax     # 0x124f83
movq %rax, (%rsi)
leaq 0xbba61(%rip), %rax     # 0x124f8a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x69544
movq %rax, 0x18(%rsi)
leaq 0x286(%rip), %rax       # 0x697c5
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_qdv
void de_module_qdv(deark *c, struct deark_module_info *mi)
{
	mi->id = "qdv";
	mi->desc = "QDV (Giffer)";
	mi->run_fn = de_run_qdv;
	mi->identify_fn = de_identify_qdv;
}

// Assembly:
leaq 0xbb7a0(%rip), %rax     # 0x124f92
movq %rax, (%rsi)
leaq 0xbb79a(%rip), %rax     # 0x124f96
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x69817
movq %rax, 0x18(%rsi)
leaq 0x120(%rip), %rax       # 0x69932
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_run_qdv
static void de_run_qdv(deark *c, de_module_params *mparams)
{
	i64 w, h;
	i64 num_pal_colors;
	i64 pos;
	de_bitmap *img = NULL;
	de_color pal[256];

	// Warning: This decoder is based on reverse engineering, and may be
	// incorrect or incomplete.

	w = de_getu16be(0);
	h = de_getu16be(2);
	de_dbg_dimensions(c, w, h);
	if(!de_good_image_dimensions(c, w, h)) goto done;

	num_pal_colors = 1 + (i64)de_getbyte(4);
	de_dbg(c, "number of palette colors: %d", (int)num_pal_colors);

	pos = 5;
	de_read_simple_palette(c, c->infile, pos, num_pal_colors, 3, pal, 256,
		DE_RDPALTYPE_24BIT, DE_RDPALFLAG_INITPAL);
	pos += 3*num_pal_colors;

	img = de_bitmap_create(c, w, h, 3);
	de_convert_image_paletted(c->infile, pos, 8, w, pal, img, 0);
	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xef169
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef169
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe9b05
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf241d
testl %eax, %eax
je 0x69918
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef0d5
movzbl %al, %ebp
leaq 0x1(%rbp), %r12
leaq 0xa7b27(%rip), %rsi     # 0x1113b4
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rsi
subq $0x8, %rsp
leaq 0x8(%rsp), %r13
movl $0x5, %edx
movl $0x3, %r8d
movq %rbx, %rdi
movq %r12, %rcx
movq %r13, %r9
pushq $0x10
pushq $0x1
pushq $0x100                  # imm = 0x100
callq 0xf32f2
addq $0x20, %rsp
leaq 0x8(%rbp,%rbp,2), %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r12
movq 0x18(%rbx), %rdi
subq $0x8, %rsp
movl $0x8, %edx
movq %rbp, %rsi
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
pushq $0x0
callq 0xf35b8
addq $0x10, %rsp
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf2923
movq %r12, %rdi
callq 0xf28d4
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_identify_qdv
static int de_identify_qdv(deark *c)
{
	i64 w, h;
	i64 num_pal_colors;

	w = de_getu16be(0);
	h = de_getu16be(2);
	num_pal_colors = 1 + (i64)de_getbyte(4);
	if(5+num_pal_colors*3+w*h != c->infile->len)
		return 0;
	if(de_input_file_has_ext(c, "qdv"))
		return 100;
	return 30;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef169
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef169
movq %rax, %r12
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef0d5
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
imulq %r15, %r12
addq %r12, %rax
addq $0x8, %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jne 0x699a9
leaq 0xbb602(%rip), %rsi     # 0x124f92
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0x1e, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc2.c
// Function: de_module_vitec
void de_module_vitec(deark *c, struct deark_module_info *mi)
{
	mi->id = "vitec";
	mi->desc = "VITec image format";
	mi->run_fn = de_run_vitec;
	mi->identify_fn = de_identify_vitec;
}

// Assembly:
leaq 0xbb5e4(%rip), %rax     # 0x124fa3
movq %rax, (%rsi)
leaq 0xbb5e0(%rip), %rax     # 0x124fa9
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x699e4
movq %rax, 0x18(%rsi)
leaq 0x28e(%rip), %rax       # 0x69c6d
movq %rax, 0x20(%rsi)
retq