LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gws.c
// Function: gwsexe_decode_decompressed_image
static void gwsexe_decode_decompressed_image(deark *c, struct gws_exepic_ctx *d,
	dbuf *inf, i64 inf_pos)
{
	de_bitmap *img = NULL;

	img = de_bitmap_create(c, d->w, d->h, 3);
	if(d->nplanes>1) {
		de_convert_image_paletted_planar(inf, inf_pos, d->nplanes,
			d->byprpp*d->nplanes, d->byprpp, d->pal, img, 0x2);
	}
	else {
		de_convert_image_paletted(inf, inf_pos, d->depth_adj, d->byprpp, d->pal,
			img, 0);
	}
	de_bitmap_write_to_file(img, NULL, DE_CREATEFLAG_OPT_IMAGE);
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq 0x20(%rsi), %rsi
movq 0x28(%r14), %rdx
movl $0x3, %ecx
callq 0xf266a
movq %rax, %rbx
movq 0x30(%r14), %rdx
cmpq $0x2, %rdx
jl 0x6494e
movq 0x40(%r14), %r8
movq %r8, %rcx
imulq %rdx, %rcx
addq $0xd8, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %r9
pushq $0x2
pushq %rbx
callq 0xf30b3
jmp 0x64974
movq 0x18(%r14), %rdx
movq 0x40(%r14), %rcx
addq $0xd8, %r14
subq $0x8, %rsp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %r8
movq %rbx, %r9
pushq $0x0
callq 0xf2f79
addq $0x10, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xf22dc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf228d
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_null
void de_module_null(deark *c, struct deark_module_info *mi)
{
	mi->id = "null";
	mi->desc = "Do nothing";
	mi->run_fn = de_run_null;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xbf88c(%rip), %rax     # 0x12426c
movq %rax, (%rsi)
leaq 0xbf887(%rip), %rax     # 0x124271
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x649fe
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_join
void de_module_join(deark *c, struct deark_module_info *mi)
{
	mi->id = "join";
	mi->desc = "Concatenate files";
	mi->run_fn = de_run_join;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
leaq 0xbf876(%rip), %rax     # 0x12427c
movq %rax, (%rsi)
leaq 0xbf871(%rip), %rax     # 0x124281
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x64a24
movq %rax, 0x18(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_join
static void de_run_join(deark *c, de_module_params *mparams)
{
	int k;
	int num_parts = 1;
	dbuf *outf = NULL;

	if(c->mp_data) {
		num_parts += c->mp_data->count;
	}

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

	for(k=0; k<num_parts; k++) {
		dbuf *inf;

		if(k>0 && c->mp_data) {
			de_dbg(c, "[mp file %d: %s]", k-1, c->mp_data->item[k-1].fn);
		}
		inf = de_mp_acquire_dbuf(c, k);
		if(!inf) {
			goto done;
		}

		dbuf_copy(inf, 0, inf->len, outf);

		de_mp_release_dbuf(c, k, &inf);
	}

done:
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x64a5f
movl (%rax), %ebp
leaq 0xd0d79(%rip), %rsi     # 0x1357bd
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r14
testl %ebp, %ebp
js 0x64af3
incl %ebp
jmp 0x64a7a
leaq 0xd0d57(%rip), %rsi     # 0x1357bd
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r14
movl $0x1, %ebp
movl %ebp, %ebp
movq $-0x10, %r12
movq %rsp, %r15
xorl %r13d, %r13d
testq %r13, %r13
je 0x64ab4
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x64ab4
movq 0x8(%rax), %rax
movq (%rax,%r12), %rcx
leal -0x1(%r13), %edx
movq %rbx, %rdi
leaq 0xb3506(%rip), %rsi     # 0x117fb3
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl %r13d, %esi
callq 0xebaf7
movq %rax, (%rsp)
testq %rax, %rax
je 0x64af3
movq 0x18(%rax), %rdx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xef481
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0xebb50
incq %r13
addq $0x10, %r12
cmpq %r13, %rbp
jne 0x64a89
movq %r14, %rdi
callq 0xf052b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_split
void de_module_split(deark *c, struct deark_module_info *mi)
{
	mi->id = "split";
	mi->desc = "Split the file into equal-sized chunks";
	mi->run_fn = de_run_split;
	mi->help_fn = de_help_split;
}

// Assembly:
leaq 0xbf782(%rip), %rax     # 0x124293
movq %rax, (%rsi)
leaq 0xbf77e(%rip), %rax     # 0x124299
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x64b36
movq %rax, 0x18(%rsi)
leaq 0x186(%rip), %rax       # 0x64cb7
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_split
static void de_run_split(deark *c, de_module_params *mparams)
{
	const char *s;
	i64 pos;
	i64 chunknum;
	i64 chunksize, chunkstride;
	i64 chunkcount;

	s = de_get_ext_option(c, "split:size");
	if(!s) {
		de_err(c, "\"-opt split:size=<n>\" is required.");
		goto done;
	}
	chunksize = de_atoi64(s);
	if(chunksize<1) {
		de_err(c, "Invalid chunk size");
		goto done;
	}

	s = de_get_ext_option(c, "split:stride");
	if(s) {
		chunkstride = de_atoi64(s);
		if(chunkstride<chunksize) {
			de_err(c, "Stride must be "DE_CHAR_GEQ" size");
			goto done;
		}
	}
	else {
		chunkstride = chunksize;
	}

	chunkcount = (c->infile->len + (chunkstride-1)) / chunkstride;

	if((chunkcount>256) && (!c->user_set_max_output_files)) {
		de_err(c, "Large number of chunks; use \"-maxfiles %"I64_FMT"\" if you "
			"really want to do this.", chunkcount);
		goto done;
	}

	pos = 0;
	for(chunknum = 0; chunknum<chunkcount; chunknum++) {
		i64 this_chunk_size;

		this_chunk_size = de_min_int(chunksize, c->infile->len-pos);
		do_split_onechunk(c, chunknum, pos, this_chunk_size);

		pos += chunkstride;
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xbfa62(%rip), %rsi     # 0x1245b0
callq 0xe9b74
testq %rax, %rax
je 0x64b9c
movq %rax, %rdi
callq 0xe9c2f
testq %rax, %rax
jle 0x64beb
movq %rax, %r12
leaq 0xbfa7e(%rip), %rsi     # 0x1245f1
movq %rbx, %rdi
callq 0xe9b74
movq %r12, %rcx
testq %rax, %rax
je 0x64ba5
movq %rax, %rdi
callq 0xe9c2f
movq %rax, %rcx
cmpq %r12, %rax
jge 0x64ba5
leaq 0xbfa64(%rip), %rsi     # 0x1245fe
jmp 0x64bf2
leaq 0xbfa18(%rip), %rsi     # 0x1245bb
jmp 0x64bf2
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq %rcx, %rax
decq %rax
cqto
idivq %rcx
cmpq $0x101, %rax            # imm = 0x101
jl 0x64c0a
cmpb $0x0, 0xa0(%rbx)
jne 0x64c13
leaq 0xbfa46(%rip), %rsi     # 0x124616
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9295
leaq 0xbf9ec(%rip), %rsi     # 0x1245de
movq %rbx, %rdi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9295
testq %rax, %rax
jle 0x64ca8
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rsi
addq %r15, %rsi
movq %r12, %rdi
callq 0xe9c3b
movq %rax, %r12
movl $0x20, %esi
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
leaq 0xbfa0c(%rip), %rdx     # 0x124661
movq %r14, %rcx
xorl %eax, %eax
callq 0xe8193
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %r12
movq %rax, %rcx
callq 0xef481
movq %rbp, %rdi
callq 0xf052b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
addq %rcx, %r13
incq %r14
subq %rcx, %r15
cmpq %r14, %rax
jne 0x64c2b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_xor
void de_module_xor(deark *c, struct deark_module_info *mi)
{
	mi->id = "xor";
	mi->desc = "Invert bits, or XOR with a key";
	mi->run_fn = de_run_xor;
	mi->help_fn = de_help_xor;
}

// Assembly:
leaq 0xbf5de(%rip), %rax     # 0x1242c0
movq %rax, (%rsi)
leaq 0xbf5d8(%rip), %rax     # 0x1242c4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x64d07
movq %rax, 0x18(%rsi)
leaq 0x14a(%rip), %rax       # 0x64e4c
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_xor
static void de_run_xor(deark *c, de_module_params *mparams)
{
	struct xorctx_struct *xorctx = NULL;
	int badkey_flag = 0;
	const char *opt_key;

	xorctx = de_malloc(c, sizeof(struct xorctx_struct));
	xorctx->key[0] = 0xff;
	xorctx->key_len = 1;

	opt_key = de_get_ext_option(c, "xor:key");
	if(opt_key) {
		UI key_strlen;
		UI k;

		key_strlen = (UI)de_strlen(opt_key);
		if(key_strlen%2) { badkey_flag = 1; goto done; }
		xorctx->key_len = key_strlen/2;
		if(xorctx->key_len<1 || (size_t)xorctx->key_len>sizeof(xorctx->key)) {
			badkey_flag = 1;
			goto done;
		}
		for(k=0; k<xorctx->key_len; k++) {
			u8 d1, d2;
			int errflag1 = 0;
			int errflag2 = 0;

			d1 = de_decode_hex_digit(opt_key[k*2], &errflag1);
			d2 = de_decode_hex_digit(opt_key[k*2+1], &errflag2);
			if(errflag1 || errflag2) { badkey_flag = 1; goto done; }
			xorctx->key[k] = (d1<<4) | d2;
		}
	}

	xorctx->outf = dbuf_create_output_file(c, "bin", NULL, 0);
	dbuf_enable_wbuffer(xorctx->outf);
	dbuf_buffered_read(c->infile, 0, c->infile->len, xor_cbfn, (void*)xorctx);

done:
	if(badkey_flag) {
		de_err(c, "Bad XOR key");
	}
	if(xorctx) {
		dbuf_close(xorctx->outf);
		de_free(c, xorctx);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x78, %esi
callq 0xe8b2b
movq %rax, %r14
movb $-0x1, 0x10(%rax)
movl $0x1, 0x8(%rax)
leaq 0xbf9a0(%rip), %rsi     # 0x1246d7
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0xe9b74
testq %rax, %rax
je 0x64dee
movq %rax, %r15
movq %rax, %rdi
callq 0x180e0
testb $0x1, %al
jne 0x64d70
movl %eax, %ecx
shrl %ecx
movl %ecx, 0x8(%r14)
addl $0xffffff37, %eax       # imm = 0xFFFFFF37
cmpl $0xffffff38, %eax       # imm = 0xFFFFFF38
jae 0x64d8b
leaq 0xbf968(%rip), %rsi     # 0x1246df
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0x64e2a
movl $0x1, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movl %r13d, 0xc(%rsp)
movl %r13d, 0x8(%rsp)
leal -0x1(%r12), %eax
movzbl (%r15,%rax), %edi
leaq 0xc(%rsp), %rsi
callq 0xebbbc
movl %eax, %ebp
movl %r12d, %eax
movzbl (%r15,%rax), %edi
leaq 0x8(%rsp), %rsi
callq 0xebbbc
movl 0x8(%rsp), %ecx
orl 0xc(%rsp), %ecx
jne 0x64d70
shlb $0x4, %bpl
orb %bpl, %al
movb %al, 0x10(%r14,%rbx)
incq %rbx
movl 0x8(%r14), %eax
addl $0x2, %r12d
cmpq %rax, %rbx
jb 0x64d96
leaq 0xd09c8(%rip), %rsi     # 0x1357bd
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, (%r14)
movq %rax, %rdi
callq 0xf0855
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1fa8(%rip), %rcx      # 0x66dc8
xorl %esi, %esi
movq %r14, %r8
callq 0xef5e4
movq (%r14), %rdi
callq 0xf052b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_plaintext
void de_module_plaintext(deark *c, struct deark_module_info *mi)
{
	mi->id = "plaintext";
	mi->desc = "Plain text";
	mi->desc2 = "Convert to UTF-8";
	mi->run_fn = de_run_plaintext;
}

// Assembly:
leaq 0xbacb5(%rip), %rax     # 0x11fb16
movq %rax, (%rsi)
leaq 0xbf478(%rip), %rax     # 0x1242e3
movq %rax, 0x8(%rsi)
leaq 0xbf478(%rip), %rax     # 0x1242ee
movq %rax, 0x10(%rsi)
leaq 0x5(%rip), %rax         # 0x64e86
movq %rax, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_plaintext
static void de_run_plaintext(deark *c, de_module_params *mparams)
{
	de_encoding input_encoding;
	de_encoding enc_from_bom;
	UI existing_bom_len = 0;
	i64 dpos, dlen;
	dbuf *outf = NULL;

	enc_from_bom = get_bom_enc(c, &existing_bom_len);
	input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_UNKNOWN);
	if(input_encoding==DE_ENCODING_UNKNOWN) {
		if(enc_from_bom!=DE_ENCODING_UNKNOWN) {
			input_encoding = enc_from_bom;
		}
		else {
			input_encoding = DE_ENCODING_UTF8;
		}
	}
	if(input_encoding!=enc_from_bom) {
		// Even if there was something that looked like a BOM, ignore it.
		existing_bom_len = 0;
	}

	dpos = (i64)existing_bom_len;
	dlen = c->infile->len - dpos;

	outf = dbuf_create_output_file(c, "txt", NULL, 0);
	dbuf_enable_wbuffer(outf);

	if(c->write_bom) {
		dbuf_write_uchar_as_utf8(outf, 0xfeff);
	}

	dbuf_copy_slice_convert_to_utf8(c->infile, dpos, dlen,
		DE_EXTENC_MAKE(input_encoding, DE_ENCSUBTYPE_HYBRID),
		outf, 0);

	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xd(%rsp), %r15
movl $0x3, %r14d
movl $0x3, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
movb (%r15), %al
movb 0x1(%r15), %cl
cmpb $-0x11, %al
jne 0x64ed1
cmpb $-0x45, %cl
jne 0x64ed1
movl $0x2, %edi
cmpb $-0x41, 0xf(%rsp)
je 0x64efd
movl %eax, %edx
xorb $-0x2, %dl
movl %ecx, %esi
notb %sil
movl $0x4, %edi
movl $0x2, %r14d
orb %dl, %sil
je 0x64efd
notb %al
xorb $-0x2, %cl
movl $0x3, %edi
orb %al, %cl
jne 0x64f99
movq %rdi, 0x10(%rsp)
movl %edi, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xeb220
movl %eax, %ebp
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r15
leaq 0xc538e(%rip), %rsi     # 0x12a2b0
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r12
movq %rax, %rdi
callq 0xf0855
cmpb $0x0, 0xcc(%rbx)
je 0x64f4f
movq %r12, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec1c4
testl %ebp, %ebp
cmovnel %ebp, %r13d
xorl %eax, %eax
cmpl 0x10(%rsp), %r13d
cmovneq %rax, %r14
subq %r14, %r15
movq 0x18(%rbx), %rdi
movzbl %r13b, %ecx
orl $0x300, %ecx            # imm = 0x300
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xf1883
movq %r12, %rdi
callq 0xf052b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %r13d
movq $0x0, 0x10(%rsp)
xorl %r14d, %r14d
jmp 0x64f05
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_cp437
static void de_run_cp437(deark *c, de_module_params *mparams)
{
	struct cp437ctx_struct cp437ctx;

	cp437ctx.outf = dbuf_create_output_file(c, "txt", NULL, 0);
	dbuf_enable_wbuffer(cp437ctx.outf);
	de_encconv_init(&cp437ctx.es, DE_ENCODING_CP437_G);
	if(c->write_bom) {
		dbuf_write_uchar_as_utf8(cp437ctx.outf, 0xfeff);
	}
	dbuf_buffered_read(c->infile, 0, c->infile->len, cp437_cbfn, (void*)&cp437ctx);
	dbuf_close(cp437ctx.outf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc52ce(%rip), %rsi     # 0x12a2b0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
movq %rax, %rdi
callq 0xf0855
movq %r14, %rdi
movl $0xd, %esi
callq 0xebbf7
cmpb $0x0, 0xcc(%rbx)
je 0x65020
movq (%rsp), %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec1c4
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1dfa(%rip), %rcx      # 0x66e29
movq %rsp, %rbx
xorl %esi, %esi
movq %rbx, %r8
callq 0xef5e4
movq (%rbx), %rdi
callq 0xf052b
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_crc
void de_module_crc(deark *c, struct deark_module_info *mi)
{
	mi->id = "crc";
	mi->id_alias[0] = "crc32";
	mi->desc = "Calculate various CRCs";
	mi->run_fn = de_run_crc;
	mi->help_fn = de_help_crc;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xd2540(%rip), %rax     # 0x137593
movq %rax, (%rsi)
leaq 0xbf2bb(%rip), %rax     # 0x124318
movq %rax, 0x38(%rsi)
leaq 0xbf2b6(%rip), %rax     # 0x12431e
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x65087
movq %rax, 0x18(%rsi)
leaq 0x155(%rip), %rax       # 0x651d3
movq %rax, 0x28(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_crc
static void de_run_crc(deark *c, de_module_params *mparams)
{
	struct crcctx_struct crcctx;
	size_t n;

	de_zeromem(&crcctx, sizeof(struct crcctx_struct));
	crcctx.opt_all = (u8)de_get_ext_option_bool(c, "crc:all", 0xff);
	if(crcctx.opt_all==0xff) {
		if(c->extract_level>=2) {
			crcctx.opt_all = 1;
		}
		else {
			crcctx.opt_all = 0;
		}
	}

	for(n=0; n<CRCM_NUMCRCS; n++) {
		if((crcm_map[n].flags & 0x1)==0 && !crcctx.opt_all) continue;
		crcctx.crcos[n] = de_crcobj_create(c, crcm_map[n].crctype);
	}

	dbuf_buffered_read(c->infile, 0, c->infile->len, crc_cbfn, (void*)&crcctx);

	for(n=0; n<CRCM_NUMCRCS; n++) {
		u32 val = 0;
		u64 val64 = 0;

		if(!crcctx.crcos[n]) continue;

		if(crcm_map[n].nbits==0) {
			val64 = de_crcobj_getval64(crcctx.crcos[n]);
		}
		else {
			val = de_crcobj_getval(crcctx.crcos[n]);
		}

		if(crcm_map[n].nbits==0) {
			de_msg(c, "%-18s: 0x%"U64_FMTx, crcm_map[n].name, val64);
		}
		else if(crcm_map[n].nbits==16) {
			de_msg(c, "%-18s: 0x%04x", crcm_map[n].name, (UI)val);
		}
		else {
			de_msg(c, "%-18s: 0x%08x", crcm_map[n].name, (UI)val);
		}
	}

	for(n=0; n<CRCM_NUMCRCS; n++) {
		de_crcobj_destroy(crcctx.crcos[n]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0xbf663(%rip), %rsi     # 0x124722
movl $0xff, %edx
callq 0xe9bd0
movl %eax, %ebp
movb %bpl, (%rsp)
cmpb $-0x1, %bpl
jne 0x650ed
cmpl $0x2, 0x90(%rbx)
jl 0x650e7
movb $0x1, (%rsp)
movb $0x1, %bpl
jmp 0x650ed
movb $0x0, (%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
leaq 0x11cb29(%rip), %r13    # 0x181c20
movb 0x4(%r13,%r14,2), %al
andb $0x1, %al
orb %bpl, %al
je 0x65118
leaq (%r14,%r14), %rax
movl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0xeb499
movq %rax, 0x8(%rsp,%r14)
addq $0x8, %r14
cmpq $0x58, %r14
jne 0x650f7
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1d6e(%rip), %rcx      # 0x66e9f
movq %rsp, %r8
xorl %esi, %esi
callq 0xef5e4
leaq 0xbf5e8(%rip), %r14     # 0x12472a
leaq 0xbf5fc(%rip), %r12     # 0x124745
xorl %ebp, %ebp
movq 0x8(%rsp,%rbp), %rdi
testq %rdi, %rdi
je 0x651a3
movb 0x5(%r13,%rbp,2), %r15b
testb %r15b, %r15b
je 0x6517b
callq 0xeb865
movq 0x8(%r13,%rbp,2), %rdx
movq %rbx, %rdi
cmpb $0x10, %r15b
jne 0x65197
leaq 0xbf5be(%rip), %rsi     # 0x124737
jmp 0x6519a
callq 0xeb887
movq 0x8(%r13,%rbp,2), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9461
jmp 0x651a3
movq %r12, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0xe9461
addq $0x8, %rbp
cmpq $0x58, %rbp
jne 0x6514b
movl $0x1, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0xeb858
incq %rbx
cmpq $0xc, %rbx
jne 0x651b2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_datetime
void de_module_datetime(deark *c, struct deark_module_info *mi)
{
	mi->id = "datetime";
	mi->desc = "Interpret a date/time field";
	mi->run_fn = de_run_datetime;
	mi->flags |= DE_MODFLAG_HIDDEN | DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xbf14d(%rip), %rax     # 0x124335
movq %rax, (%rsi)
leaq 0xbf14c(%rip), %rax     # 0x12433e
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x65206
movq %rax, 0x18(%rsi)
orb $0x5, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_hexdump
void de_module_hexdump(deark *c, struct deark_module_info *mi)
{
	mi->id = "hexdump";
	mi->desc = "Print a hex dump";
	mi->run_fn = de_run_hexdump;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xc7ac9(%rip), %rax     # 0x12cebf
movq %rax, (%rsi)
leaq 0xbef5a(%rip), %rax     # 0x12435a
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x65414
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_bytefreq
void de_module_bytefreq(deark *c, struct deark_module_info *mi)
{
	mi->id = "bytefreq";
	mi->desc = "Print a byte frequence analysis";
	mi->run_fn = de_run_bytefreq;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xbef38(%rip), %rax     # 0x12436b
movq %rax, (%rsi)
leaq 0xbef37(%rip), %rax     # 0x124374
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x65451
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_zlib
void de_module_zlib(deark *c, struct deark_module_info *mi)
{
	mi->id = "zlib";
	mi->desc = "Raw zlib compressed data";
	mi->run_fn = de_run_zlib;
	mi->identify_fn = de_identify_zlib;
}

// Assembly:
leaq 0xd1ef3(%rip), %rax     # 0x1375b2
movq %rax, (%rsi)
leaq 0xbecef(%rip), %rax     # 0x1243b8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x656e4
movq %rax, 0x18(%rsi)
leaq 0xf(%rip), %rax         # 0x656ee
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_identify_zlib
static int de_identify_zlib(deark *c)
{
	u8 b[2];
	de_read(b, 0, 2);

	if((b[0]&0x0f) != 8)
		return 0;

	if(b[0]<0x08 || b[0]>0x78)
		return 0;

	if(((((unsigned int)b[0])<<8)|b[1])%31 != 0)
		return 0;

	return 50;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0x6(%rsp), %r14
movl $0x2, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movzbl (%r14), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x8, %ecx
setne %cl
leal -0x79(%rax), %edx
cmpb $-0x71, %dl
setb %dl
orb %cl, %dl
jne 0x6574a
shll $0x8, %eax
movzbl 0x7(%rsp), %ecx
orl %eax, %ecx
imull $0x7bdf, %ecx, %eax     # imm = 0x7BDF
movzwl %ax, %eax
xorl %ecx, %ecx
cmpl $0x843, %eax            # imm = 0x843
movl $0x32, %ebx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_mrw
void de_module_mrw(deark *c, struct deark_module_info *mi)
{
	mi->id = "mrw";
	mi->desc = "Minolta RAW";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_mrw;
	mi->identify_fn = de_identify_mrw;
}

// Assembly:
leaq 0xbec76(%rip), %rax     # 0x1243d1
movq %rax, (%rsi)
leaq 0xbec70(%rip), %rax     # 0x1243d5
movq %rax, 0x8(%rsi)
leaq 0xafc21(%rip), %rax     # 0x115391
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x6578b
movq %rax, 0x18(%rsi)
leaq 0x9b(%rip), %rax        # 0x65821
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_vgafont
void de_module_vgafont(deark *c, struct deark_module_info *mi)
{
	mi->id = "vgafont";
	mi->desc = "Raw 8xN bitmap font";
	mi->run_fn = de_run_vgafont;
	mi->help_fn = de_help_vgafont;
}

// Assembly:
leaq 0xb1a75(%rip), %rax     # 0x1172c3
movq %rax, (%rsi)
leaq 0xbeb89(%rip), %rax     # 0x1243e1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x65873
movq %rax, 0x18(%rsi)
leaq 0x19f(%rip), %rax       # 0x65a0d
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_vgafont
static void de_run_vgafont(deark *c, de_module_params *mparams)
{
	struct vgafont_ctx *d = NULL;

	d = de_malloc(c, sizeof(struct vgafont_ctx));
	d->height = c->infile->len / 256;
	if((c->infile->len % 256) || d->height<VGAFONT_MINH || d->height>VGAFONT_MAXH) {
		de_err(c, "Bad file size");
		goto done;
	}

	d->font_data_pos = 0;
	d->font_data_size = d->height*256;
	d->fontdata = de_malloc(c, d->font_data_size);
	dbuf_read(c->infile, d->fontdata, d->font_data_pos, d->font_data_size);

	if(de_get_ext_option(c, "vgafont:c")) {
		i64 i;
		dbuf *ff;

		ff = dbuf_create_output_file(c, "h", NULL, 0);
		for(i=0; i<(d->font_data_size); i++) {
			if(i%d->height==0) dbuf_puts(ff, "\t");
			dbuf_printf(ff, "%d", (int)d->fontdata[i]);
			if(i!=(d->font_data_size-1)) dbuf_puts(ff, ",");
			if(i%d->height==(d->height-1)) dbuf_puts(ff, "\n");
		}
		dbuf_close(ff);
		goto done;
	}

	vgafont_common_config1(c, d);
	vgafont_common_config2(c, d);
	vgafont_main(c, d, NULL, 0);

done:
	destroy_vgafont_ctx(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
leaq 0xff(%rax), %rsi
testq %rax, %rax
cmovnsq %rax, %rsi
sarq $0x8, %rsi
movq %rsi, 0x10(%r14)
testb %al, %al
sete %cl
addq $-0x1500, %rax          # imm = 0xEB00
cmpq $-0x1200, %rax          # imm = 0xEE00
setae %al
testb %al, %cl
jne 0x658da
leaq 0xbd0e6(%rip), %rsi     # 0x1229b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0x659f4
movq $0x0, 0x18(%r14)
shlq $0x8, %rsi
movq %rsi, 0x20(%r14)
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, 0x28(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %rax, %rsi
callq 0xee8d4
leaq 0xbefab(%rip), %rsi     # 0x1248bc
movq %rbx, %rdi
callq 0xe9b74
testq %rax, %rax
je 0x659d2
leaq 0xe7b8c(%rip), %rsi     # 0x14d4b5
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r15
cmpq $0x0, 0x20(%r14)
jle 0x659c8
leaq 0xd09d2(%rip), %r13     # 0x13631c
leaq 0xbef44(%rip), %r12     # 0x124895
xorl %ebp, %ebp
movq %rbp, %rax
cqto
idivq 0x10(%r14)
testq %rdx, %rdx
jne 0x65970
movq %r15, %rdi
leaq 0xbef5b(%rip), %rsi     # 0x1248c6
callq 0xf10ed
movq 0x28(%r14), %rax
movzbl (%rax,%rbp), %edx
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0xf08da
movq 0x20(%r14), %rax
decq %rax
cmpq %rax, %rbp
je 0x6599c
movq %r15, %rdi
movq %r12, %rsi
callq 0xf10ed
movq 0x10(%r14), %rcx
movq %rbp, %rax
cqto
idivq %rcx
decq %rcx
cmpq %rcx, %rdx
jne 0x659bf
movq %r15, %rdi
leaq 0xaa7cd(%rip), %rsi     # 0x110187
callq 0xf10ed
incq %rbp
cmpq 0x20(%r14), %rbp
jl 0x65953
movq %r15, %rdi
callq 0xf052b
jmp 0x659f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6702a
movq %r14, %rdi
callq 0x6709b
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x67131
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x67183
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_fontmania
void de_module_fontmania(deark *c, struct deark_module_info *mi)
{
	mi->id = "fontmania";
	mi->desc = "Font Mania .COM format";
	mi->run_fn = de_run_fontmania;
	mi->identify_fn = de_identify_fontmania;
}

// Assembly:
leaq 0xbe9d3(%rip), %rax     # 0x1243f5
movq %rax, (%rsi)
leaq 0xbe9d3(%rip), %rax     # 0x1243ff
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x65a47
movq %rax, 0x18(%rsi)
leaq 0x102(%rip), %rax       # 0x65b44
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_fontmania
static void de_run_fontmania(deark *c, de_module_params *mparams)
{
	struct vgafont_ctx *d = NULL;

	d = de_malloc(c, sizeof(struct vgafont_ctx));
	d->font_data_pos = de_getu16le(2);
	de_dbg(c, "data pos: %"I64_FMT, d->font_data_pos);
	d->height = (i64)de_getbyte(5);
	de_dbg(c, "char size: 8"DE_CHAR_TIMES"%d", (int)d->height);
	d->font_data_size = d->height*256;

	if(d->height<VGAFONT_MINH || d->height>VGAFONT_MAXH ||
		(d->font_data_pos + d->font_data_size > c->infile->len))
	{
		d->need_errmsg = 1;
		goto done;
	}

	d->fontdata = de_malloc(c, d->font_data_size);
	de_read(d->fontdata, d->font_data_pos, d->font_data_size);

	vgafont_common_config1(c, d);
	vgafont_common_config2(c, d);
	vgafont_main(c, d, NULL, 0);

done:
	if(d) {
		if(d->need_errmsg) {
			de_err(c, "Bad or unsupported Font Mania font");
		}
		destroy_vgafont_ctx(c, d);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xeebc8
movq %rax, 0x18(%r14)
leaq 0xc05c1(%rip), %rsi     # 0x126035
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movl $0x5, %esi
callq 0xeead3
movzbl %al, %edx
movq %rdx, 0x10(%r14)
leaq 0xbee48(%rip), %rsi     # 0x1248e5
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x10(%r14), %rax
movq %rax, %rsi
shlq $0x8, %rsi
movq %rsi, 0x20(%r14)
addq $-0x15, %rax
cmpq $-0x12, %rax
jb 0x65ad1
movq 0x18(%r14), %rax
addq %rsi, %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x65af9
movb $0x1, 0x30(%r14)
leaq 0xbee19(%rip), %rsi     # 0x1248f6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67183
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, 0x28(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %rax, %rsi
callq 0xee8d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6702a
movq %r14, %rdi
callq 0x6709b
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x67131
cmpb $0x0, 0x30(%r14)
jne 0x65ad6
jmp 0x65ae7
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_identify_fontmania
static int de_identify_fontmania(deark *c)
{
	if(c->infile->len>65280) return 0;
	if(de_getbyte(0) != 0xeb) return 0;
	if(dbuf_memcmp(c->infile, 8, (const u8*)"FONT MANIA, V", 13)) {
		return 0;
	}
	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0xff00, 0x18(%rdi)     # imm = 0xFF00
jg 0x65b8e
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $-0x15, %al
jne 0x65b8e
movq 0x18(%r14), %rdi
leaq 0xbeda6(%rip), %rdx     # 0x124919
movl $0x8, %esi
movl $0xd, %ecx
callq 0xefc85
xorl %ecx, %ecx
testl %eax, %eax
movl $0x64, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_pcrfont
void de_module_pcrfont(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcrfont";
	mi->desc = "PCR font";
	mi->run_fn = de_run_pcrfont;
	mi->identify_fn = de_identify_pcrfont;
}

// Assembly:
leaq 0xbe877(%rip), %rax     # 0x124416
movq %rax, (%rsi)
leaq 0xbed92(%rip), %rax     # 0x12493b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x65bc4
movq %rax, 0x18(%rsi)
leaq 0x113(%rip), %rax       # 0x65cd2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_pcrfont
static void de_run_pcrfont(deark *c, de_module_params *mparams)
{
	u8 hdr[11];
	struct vgafont_ctx *d = NULL;

	d = de_malloc(c, sizeof(struct vgafont_ctx));

	de_read(hdr, 0, 11);
	// I assume either hdr[7] or hdr[10] is the high byte of the font data size,
	// but I don't know which.
	if(hdr[6]!=0x1 || hdr[7]!=hdr[10] || hdr[8]!=0 || hdr[9]!=0) {
		d->need_errmsg = 1;
		goto done;
	}
	d->height = (i64)hdr[7];
	de_dbg(c, "char size: 8"DE_CHAR_TIMES"%d", (int)d->height);

	d->font_data_pos = 11;
	d->font_data_size = d->height*256;
	if(d->height<VGAFONT_MINH || d->height>VGAFONT_MAXH ||
		(d->font_data_pos + d->font_data_size > c->infile->len))
	{
		d->need_errmsg = 1;
		goto done;
	}

	d->fontdata = de_malloc(c, d->font_data_size);
	dbuf_read(c->infile, d->fontdata, d->font_data_pos, d->font_data_size);

	vgafont_common_config1(c, d);
	vgafont_common_config2(c, d);
	vgafont_main(c, d, NULL, 0);

done:
	if(d) {
		if(d->need_errmsg) {
			de_err(c, "Unsupported type of PCR font");
		}
		destroy_vgafont_ctx(c, d);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x5(%rsp), %r15
movl $0xb, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
cmpb $0x1, 0x6(%r15)
jne 0x65c5c
movzbl 0xc(%rsp), %edx
cmpb 0xf(%rsp), %dl
jne 0x65c5c
cmpb $0x0, 0xd(%rsp)
jne 0x65c5c
cmpb $0x0, 0xe(%rsp)
jne 0x65c5c
movq %rdx, 0x10(%r14)
leaq 0xbecc5(%rip), %rsi     # 0x1248e5
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq $0xb, 0x18(%r14)
movq 0x10(%r14), %rax
movq %rax, %rsi
shlq $0x8, %rsi
movq %rsi, 0x20(%r14)
addq $-0x15, %rax
cmpq $-0x12, %rax
jb 0x65c5c
movq %rsi, %rax
orq $0xb, %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x65c87
movb $0x1, 0x30(%r14)
leaq 0xbecbf(%rip), %rsi     # 0x124927
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67183
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, 0x28(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %rax, %rsi
callq 0xee8d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6702a
movq %r14, %rdi
callq 0x6709b
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x67131
cmpb $0x0, 0x30(%r14)
jne 0x65c61
jmp 0x65c72
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_identify_pcrfont
static int de_identify_pcrfont(deark *c)
{
	u8 h;

	if(dbuf_memcmp(c->infile, 0, "KPG", 3)) return 0;
	if(de_getbyte(5)!=0x20) return 0;
	h = de_getbyte(7);
	if(h<6 || h>16) return 0;
	if(de_getbyte(10)!=h) return 0;
	return 80;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xbec5f(%rip), %rdx     # 0x124944
xorl %ebx, %ebx
movl $0x3, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x65d3d
movq 0x18(%r14), %rdi
movl $0x5, %esi
callq 0xeead3
cmpb $0x20, %al
jne 0x65d3d
movq 0x18(%r14), %rdi
movl $0x7, %esi
callq 0xeead3
movl %eax, %r15d
leal -0x11(%r15), %eax
cmpb $-0xb, %al
jb 0x65d3d
movq 0x18(%r14), %rdi
movl $0xa, %esi
callq 0xeead3
xorl %ecx, %ecx
cmpb %r15b, %al
movl $0x50, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_fontedit
void de_module_fontedit(deark *c, struct deark_module_info *mi)
{
	mi->id = "fontedit";
	mi->desc = "FONTEDIT font";
	mi->run_fn = de_run_fontedit;
	mi->identify_fn = de_identify_fontedit;
	mi->help_fn = de_help_fontedit;
}

// Assembly:
leaq 0xbe6d2(%rip), %rax     # 0x12441e
movq %rax, (%rsi)
leaq 0xbec60(%rip), %rax     # 0x1249b6
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x65d7c
movq %rax, 0x18(%rsi)
leaq 0x260(%rip), %rax       # 0x65fcc
movq %rax, 0x20(%rsi)
leaq 0x2c8(%rip), %rax       # 0x6603f
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_identify_fontedit
static int de_identify_fontedit(deark *c)
{
	u8 b1;
	i64 jmp1;

	if(c->infile->len>0x2200 || c->infile->len<(54+3*256)) return 0;
	if(de_getbyte(0) != 0xeb) return 0;
	b1 = de_getbyte(1);
	if(b1<0x32 || b1>0x33) return 0;
	jmp1 = (i64)b1 + 2;
	// Code for "INT 10/AX=1110h": the system call that sets the custom font
	if(dbuf_memcmp(c->infile, jmp1+39,
		(const void*)"\xb8\x10\x11\xcd\x10", 5))
	{
		return 0;
	}
	return 90;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq $-0x2201, %rax          # imm = 0xDDFF
addq 0x18(%rdi), %rax
xorl %ebx, %ebx
cmpq $-0x1ecb, %rax          # imm = 0xE135
jb 0x66035
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $-0x15, %al
jne 0x66035
movq 0x18(%r14), %rdi
movl $0x1, %esi
callq 0xeead3
leal -0x34(%rax), %ecx
cmpb $-0x2, %cl
jb 0x66035
movq 0x18(%r14), %rdi
addb $0x29, %al
movzbl %al, %esi
leaq 0xbe9a5(%rip), %rdx     # 0x1249c4
movl $0x5, %ecx
callq 0xefc85
xorl %ecx, %ecx
testl %eax, %eax
movl $0x5a, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_evafont
void de_module_evafont(deark *c, struct deark_module_info *mi)
{
	mi->id = "evafont";
	mi->desc = "EVAfont .COM format";
	mi->run_fn = de_run_evafont;
	mi->identify_fn = de_identify_evafont;
}

// Assembly:
leaq 0xbe3d3(%rip), %rax     # 0x124427
movq %rax, (%rsi)
leaq 0xbe3d1(%rip), %rax     # 0x12442f
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x66079
movq %rax, 0x18(%rsi)
leaq 0x1c0(%rip), %rax       # 0x66234
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_identify_evafont
static int de_identify_evafont(deark *c)
{
	if(c->infile->len>65280) return 0;
	if(de_getbyte(0) != 0xe9) return 0;

	if(!dbuf_memcmp(c->infile, 7, (const u8*)" font driver v", 14)) {
		return 100; // v2.01:
	}
	if(!dbuf_memcmp(c->infile, 11, (const u8*)" font loader v", 14)) {
		return 100; // v3.05:
	}
	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
cmpq $0xff00, 0x18(%rdi)     # imm = 0xFF00
jg 0x66298
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeead3
cmpb $-0x17, %al
jne 0x66298
movq 0x18(%rbx), %rdi
leaq 0xbe7de(%rip), %rdx     # 0x124a43
movl $0x7, %esi
movl $0xe, %ecx
callq 0xefc85
movl $0x64, %r14d
testl %eax, %eax
je 0x66298
movq 0x18(%rbx), %rdi
leaq 0xbe7c9(%rip), %rdx     # 0x124a52
movl $0xb, %esi
movl $0xe, %ecx
callq 0xefc85
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_zbr
void de_module_zbr(deark *c, struct deark_module_info *mi)
{
	mi->id = "zbr";
	mi->desc = "ZBR (Zebra Metafile)";
	mi->desc2 = "extract preview image";
	mi->run_fn = de_run_zbr;
	mi->identify_fn = de_identify_zbr;
}

// Assembly:
leaq 0xbe199(%rip), %rax     # 0x124443
movq %rax, (%rsi)
leaq 0xbe193(%rip), %rax     # 0x124447
movq %rax, 0x8(%rsi)
leaq 0xb6243(%rip), %rax     # 0x11c502
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x662da
movq %rax, 0x18(%rsi)
leaq 0x71(%rip), %rax        # 0x66346
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_zbr
static void de_run_zbr(deark *c, de_module_params *mparams)
{
	i64 pos = 0;
	dbuf *outf = NULL;
	static const u8 hdrs[54] = {
		0x42,0x4d,0xc6,0x14,0,0,0,0,0,0,0x76,0,0,0, // FILEHEADER
		0x28,0,0,0,0x64,0,0,0,0x64,0,0,0,0x01,0,0x04,0, // INFOHEADER...
		0,0,0,0,0x50,0x14,0,0,0,0,0,0,0,0,0,0,
		0x10,0,0,0,0,0,0,0 };

	pos += 4; // signature, version
	pos += 100; // comment

	de_dbg(c, "preview image at %d", (int)pos);
	// By design, this image is formatted as a headerless BMP/DIB. We'll just
	// add the 54 bytes of headers needed to make it a BMP, and call it done.
	outf = dbuf_create_output_file(c, "preview.bmp", NULL, DE_CREATEFLAG_IS_AUX);
	dbuf_write(outf, hdrs, 54);
	dbuf_copy(c->infile, pos, 16*4 + 100*52, outf);
	dbuf_close(outf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbe779(%rip), %rsi     # 0x124a61
movl $0x68, %edx
xorl %eax, %eax
callq 0xe8617
leaq 0xb1b58(%rip), %rsi     # 0x117e53
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xefda1
movq %rax, %r14
leaq 0xbe85c(%rip), %rsi     # 0x124b70
movl $0x36, %edx
movq %rax, %rdi
callq 0xef547
movq 0x18(%rbx), %rdi
movl $0x68, %esi
movl $0x1490, %edx           # imm = 0x1490
movq %r14, %rcx
callq 0xef481
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf052b
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_compress
void de_module_compress(deark *c, struct deark_module_info *mi)
{
	mi->id = "compress";
	mi->desc = "Compress (.Z)";
	mi->run_fn = de_run_compress;
	mi->identify_fn = de_identify_compress;
}

// Assembly:
leaq 0xbfd80(%rip), %rax     # 0x12611d
movq %rax, (%rsi)
leaq 0xbe0b5(%rip), %rax     # 0x12445c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x663c2
movq %rax, 0x18(%rsi)
leaq 0xed(%rip), %rax        # 0x664aa
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_compress
static void de_run_compress(deark *c, de_module_params *mparams)
{
	struct de_dfilter_results dres;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_lzw_params delzwp;
	dbuf *f = NULL;

	f = dbuf_create_output_file(c, "bin", NULL, 0);
	dbuf_enable_wbuffer(f);

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = 0;
	dcmpri.len = c->infile->len;
	dcmpro.f = f;
	dcmpro.len_known = 0;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_UNIXCOMPRESS;
	delzwp.flags |= DE_LZWFLAG_HAS3BYTEHEADER;

	fmtutil_decompress_lzw(c, &dcmpri, &dcmpro, &dres, &delzwp);
	dbuf_flush(f);
	if(dres.errcode!=0) {
		de_err(c, "%s", de_dfilter_get_errmsg(c, &dres));
	}
	dbuf_close(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0xcf3e0(%rip), %rsi     # 0x1357bd
xorl %ebp, %ebp
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r14
movq %rax, %rdi
callq 0xf0855
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r13
leaq 0x58(%rsp), %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0xfa1dc
movq 0x18(%rbx), %rax
movq %rax, (%r12)
movq %rbp, 0x8(%r12)
movq 0x18(%rax), %rax
movq %rax, 0x10(%r12)
movq %r14, (%r13)
movb $0x0, 0x8(%r13)
leaq 0xc(%rsp), %r8
movq %rbp, 0x8(%r8)
movl $0x0, 0x10(%r8)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%r8)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x102400
movq %r14, %rdi
callq 0xf08ba
cmpl $0x0, (%r15)
je 0x66490
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa1a4
leaq 0xae8dc(%rip), %rsi     # 0x114d5f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9295
movq %r14, %rdi
callq 0xf052b
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_hpi
void de_module_hpi(deark *c, struct deark_module_info *mi)
{
	mi->id = "hpi";
	mi->desc = "Hemera Photo-Object image";
	mi->run_fn = de_run_hpi;
	mi->identify_fn = de_identify_hpi;
}

// Assembly:
leaq 0xbdf93(%rip), %rax     # 0x12446a
movq %rax, (%rsi)
leaq 0xbdf8d(%rip), %rax     # 0x12446e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x664fc
movq %rax, 0x18(%rsi)
leaq 0x11d(%rip), %rax       # 0x66614
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_hpi
static void de_run_hpi(deark *c, de_module_params *mparams)
{
	i64 jpgpos, pngpos;
	i64 jpglen, pnglen;
	i64 pos;

	pos = 12;
	jpgpos = de_getu32le_p(&pos);
	jpglen = de_getu32le_p(&pos);
	de_dbg(c, "jpeg: pos=%"I64_FMT", len=%"I64_FMT, jpgpos, jpglen);
	pngpos = de_getu32le_p(&pos);
	pnglen = de_getu32le_p(&pos);
	de_dbg(c, "png: pos=%"I64_FMT", len=%"I64_FMT, pngpos, pnglen);

	if(jpglen>0 && jpgpos+jpglen<=c->infile->len && de_getbyte(jpgpos)==0xff) {
		const char *ext;

		if(pnglen==0) ext="jpg";
		else ext="foreground.jpg";
		dbuf_create_file_from_slice(c->infile, jpgpos, jpglen, ext, NULL, 0);
	}
	if(pnglen>0 && pngpos+pnglen<=c->infile->len && de_getbyte(pngpos)==0x89) {
		dbuf_create_file_from_slice(c->infile, pngpos, pnglen, "mask.png", NULL, 0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq $0xc, (%r15)
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, %r13
leaq 0xbe53e(%rip), %rsi     # 0x124a7b
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, %r15
leaq 0xbe520(%rip), %rsi     # 0x124a92
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
testq %r13, %r13
jle 0x665cb
leaq (%r12,%r13), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x665cb
movq %r12, %rsi
callq 0xeead3
cmpb $-0x1, %al
jne 0x665cb
testq %r15, %r15
leaq 0xcd307(%rip), %rax     # 0x1338b2
leaq 0xbe4f6(%rip), %rcx     # 0x124aa8
cmoveq %rax, %rcx
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xefd48
testq %r15, %r15
jle 0x66606
leaq (%r15,%r14), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x66606
movq %r14, %rsi
callq 0xeead3
cmpb $-0x77, %al
jne 0x66606
movq 0x18(%rbx), %rdi
leaq 0xbe4c2(%rip), %rcx     # 0x124ab7
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xefd48
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_dclimplode
void de_module_dclimplode(deark *c, struct deark_module_info *mi)
{
	mi->id = "dclimplode";
	mi->id_alias[0] = "ttcomp";
	mi->desc = "PKWARE DCL Implode compressed file";
	mi->run_fn = de_run_dclimplode;
	mi->identify_fn = de_identify_dclimplode;
}

// Assembly:
leaq 0xbde47(%rip), %rax     # 0x124488
movq %rax, (%rsi)
leaq 0xbde48(%rip), %rax     # 0x124493
movq %rax, 0x38(%rsi)
leaq 0xbde44(%rip), %rax     # 0x12449a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x66671
movq %rax, 0x18(%rsi)
leaq 0x19(%rip), %rax        # 0x66685
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_identify_dclimplode
static int de_identify_dclimplode(deark *c)
{
	u8 b0, b1;
	int i;
	u32 x;

	if(c->infile->len<4) return 0;
	b0 = de_getbyte(0);
	if(b0>1) return 0;
	b1 = de_getbyte(1);
	if(b1<4 || b1>6) return 0;

	// Look for the end-of-data code in the last 2 or 3 bytes.
	// Assumes the last byte is padded with '0' bits, and there are
	// no extraneous bytes after that.
	x = (u32)de_getu32le(c->infile->len-4);
	for(i=0; i<8; i++) {
		if((x & 0xfffffe00U)==0x01fe0200U) {
			if(b0==0 && b1==6) return 40;
			return 10;
		}
		x >>= 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0x4, 0x18(%rdi)
jl 0x66706
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $0x1, %al
ja 0x66706
movl %eax, %ebp
movq 0x18(%r15), %rdi
movl $0x1, %esi
callq 0xeead3
movl %eax, %r14d
leal -0x7(%r14), %eax
cmpb $-0x3, %al
jb 0x66706
movq 0x18(%r15), %rdi
movq 0x18(%rdi), %rsi
addq $-0x4, %rsi
callq 0xeed61
movl $0x8, %ecx
movl %eax, %edx
andl $0xfffffe00, %edx       # imm = 0xFFFFFE00
cmpl $0x1fe0200, %edx        # imm = 0x1FE0200
je 0x666f2
shrl %eax
decl %ecx
jne 0x666da
jmp 0x66706
xorb $0x6, %r14b
orb %r14b, %bpl
movl $0x28, %eax
movl $0xa, %ebx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_module_lgcompress
void de_module_lgcompress(deark *c, struct deark_module_info *mi)
{
	mi->id = "lgcompress";
	mi->desc = "Logitech Compress";
	mi->run_fn = de_run_lgcompress;
	mi->identify_fn = de_identify_lgcompress;
}

// Assembly:
leaq 0xbdda3(%rip), %rax     # 0x1244bd
movq %rax, (%rsi)
leaq 0xbdda4(%rip), %rax     # 0x1244c8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6673f
movq %rax, 0x18(%rsi)
leaq 0x83(%rip), %rax        # 0x667bd
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc.c
// Function: de_run_lgcompress
static void de_run_lgcompress(deark *c, de_module_params *mparams)
{
	u8 mfnc;
	i64 orig_len;

	mfnc = de_getbyte(2);
	if(mfnc>=0x33 && mfnc<=126) {
		de_dbg(c, "missing filename char: '%c'", (int)mfnc);
	}
	orig_len = de_getu32le(4);
	de_dbg(c, "orig len: %"I64_FMT, orig_len);

	dclimplode_main(c, 8, c->infile->len-8, 1, orig_len);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x2, %esi
callq 0xeead3
leal -0x33(%rax), %ecx
cmpb $0x4b, %cl
ja 0x66770
movzbl %al, %edx
leaq 0xbe363(%rip), %rsi     # 0x124ac9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xeed61
movq %rax, %r14
leaq 0xaea6b(%rip), %rsi     # 0x1151f3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rdx
addq $-0x8, %rdx
movl $0x8, %esi
movq %rbx, %rdi
movl $0x1, %ecx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x671c7