LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xb5f75(%rip), %rsi     # 0x1173b0
callq 0xdfa87
testq %rax, %rax
je 0x6148c
movq %rax, %rdi
callq 0xdfb3b
testq %rax, %rax
jle 0x61572
movq %rax, %r12
leaq 0xb5f91(%rip), %rsi     # 0x1173f1
movq %rbx, %rdi
callq 0xdfa87
movq %r12, %rcx
testq %rax, %rax
je 0x61498
movq %rax, %rdi
callq 0xdfb3b
movq %rax, %rcx
cmpq %r12, %rax
jge 0x61498
leaq 0xb5f77(%rip), %rsi     # 0x1173fe
jmp 0x61579
leaq 0xb5f28(%rip), %rsi     # 0x1173bb
jmp 0x61579
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq %rcx, %rax
decq %rax
cqto
idivq %rcx
movq %rax, %rdx
cmpq $0x101, %rax            # imm = 0x101
jl 0x614c3
cmpb $0x0, 0xa0(%rbx)
je 0x615a0
movq %rcx, (%rsp)
movq %rbx, 0x8(%rsp)
xorl %eax, %eax
testq %rdx, %rdx
cmovleq %rax, %rdx
movq %rdx, 0x10(%rsp)
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x8(%rsp), %r15
cmpq %r13, 0x10(%rsp)
je 0x61591
movq 0x18(%r15), %rax
movq 0x18(%rax), %rsi
addq %rcx, %rsi
movq %r12, %rdi
movq %rcx, 0x18(%rsp)
callq 0xdfb45
movq %r12, %rbx
movq %rax, %r12
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
pushq $0x20
popq %rsi
leaq 0xb5f3f(%rip), %rdx     # 0x117461
movq %r13, %rcx
xorl %eax, %eax
callq 0xde40c
movq %r15, %rdi
movq %rbp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %rbp
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r12
movq %rax, %rcx
callq 0xe45f4
movq %rbp, %rdi
callq 0xe5591
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
addq %rax, %r14
incq %r13
subq %rax, %rcx
jmp 0x614e7
leaq 0xb5e65(%rip), %rsi     # 0x1173de
movq %rbx, %rdi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf2a5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb5e6f(%rip), %rsi     # 0x117416
movq %rbx, %rdi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf2a5
// File: /workspace/github_c_makefile_star2_O2/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 0xb5ad6(%rip), %rax     # 0x1170c0
movq %rax, (%rsi)
leaq 0xb5ad0(%rip), %rax     # 0x1170c4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6160f
movq %rax, 0x18(%rsi)
leaq 0x132(%rip), %rax       # 0x6173c
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
pushq $0x78
popq %rsi
callq 0xdecaf
movq %rax, %r14
movb $-0x1, 0x10(%rax)
movl $0x1, 0x8(%rax)
leaq 0xb5e9d(%rip), %rsi     # 0x1174d7
movq %rbx, %rdi
callq 0xdfa87
testq %rax, %rax
je 0x616e3
movq %rax, %r15
movq %rax, %rdi
callq 0x180e0
testb $0x1, %al
jne 0x6166e
movl %eax, %ecx
shrl %ecx
movl %ecx, 0x8(%r14)
addl $0xffffff37, %eax       # imm = 0xFFFFFF37
cmpl $0xffffff38, %eax       # imm = 0xFFFFFF38
jae 0x61684
leaq 0xb5e6a(%rip), %rsi     # 0x1174df
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
jmp 0x6171a
pushq $0x1
popq %r12
xorl %r13d, %r13d
movl %ecx, %eax
cmpq %rax, %r13
jae 0x616e3
andl $0x0, 0x4(%rsp)
andl $0x0, (%rsp)
leal -0x1(%r12), %eax
movzbl (%r15,%rax), %edi
leaq 0x4(%rsp), %rsi
callq 0xe11c4
movl %eax, %ebp
movl %r12d, %eax
movzbl (%r15,%rax), %edi
movq %rsp, %rsi
callq 0xe11c4
movl (%rsp), %ecx
orl 0x4(%rsp), %ecx
jne 0x6166e
shlb $0x4, %bpl
orb %bpl, %al
movb %al, 0x10(%r14,%r13)
incq %r13
movl 0x8(%r14), %ecx
addl $0x2, %r12d
jmp 0x6168b
leaq 0xc6df3(%rip), %rsi     # 0x1284dd
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, (%r14)
movq %rax, %rdi
callq 0xe589c
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1e29(%rip), %rcx      # 0x63539
xorl %esi, %esi
movq %r14, %r8
callq 0xe4745
movq (%r14), %rdi
callq 0xe5591
movq %rbx, %rdi
movq %r14, %rsi
callq 0xded32
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb1319(%rip), %rax     # 0x112a6a
movq %rax, (%rsi)
leaq 0xb5988(%rip), %rax     # 0x1170e3
movq %rax, 0x8(%rsi)
leaq 0xb5988(%rip), %rax     # 0x1170ee
movq %rax, 0x10(%rsi)
leaq 0x5(%rip), %rax         # 0x61776
movq %rax, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x5(%rsp), %r15
pushq $0x3
popq %r14
movq %r15, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xe3cb7
movb (%r15), %al
movb 0x1(%r15), %cl
cmpb $-0x11, %al
jne 0x617bb
cmpb $-0x45, %cl
jne 0x617bb
cmpb $-0x41, 0x7(%rsp)
jne 0x617bb
pushq $0x2
popq %r13
jmp 0x617e8
movl %eax, %edx
xorb $-0x2, %dl
movl %ecx, %esi
notb %sil
orb %dl, %sil
jne 0x617d4
pushq $0x4
popq %r13
pushq $0x2
popq %r14
jmp 0x617e8
notb %al
xorb $-0x2, %cl
xorl %edx, %edx
orb %al, %cl
sete %dl
leal (%rdx,%rdx), %r14d
leal (%rdx,%rdx,2), %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe08d2
movl %eax, %ebp
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r15
leaq 0xbb85b(%rip), %rsi     # 0x11d060
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r12
movq %rax, %rdi
callq 0xe589c
cmpb $0x0, 0xcc(%rbx)
je 0x61832
movq %r12, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xe1790
testl %r13d, %r13d
pushq $0x2
popq %rax
cmovnel %r13d, %eax
testl %ebp, %ebp
cmovnel %ebp, %eax
xorl %ecx, %ecx
cmpl %r13d, %eax
cmovneq %rcx, %r14
subq %r14, %r15
movq 0x18(%rbx), %rdi
movzbl %al, %ecx
orl $0x300, %ecx            # imm = 0x300
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xe66ec
movq %r12, %rdi
callq 0xe5591
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbb7ac(%rip), %rsi     # 0x11d060
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
movq %rax, %rdi
callq 0xe589c
pushq $0xd
popq %rsi
movq %r14, %rdi
callq 0xe11fc
cmpb $0x0, 0xcc(%rbx)
je 0x618f0
movq (%rsp), %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xe1790
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1c9d(%rip), %rcx      # 0x6359c
movq %rsp, %rbx
xorl %esi, %esi
movq %rbx, %r8
callq 0xe4745
movq (%rbx), %rdi
callq 0xe5591
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc8990(%rip), %rax     # 0x12a2b3
movq %rax, (%rsi)
leaq 0xb57eb(%rip), %rax     # 0x117118
movq %rax, 0x38(%rsi)
leaq 0xb57e6(%rip), %rax     # 0x11711e
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x61957
movq %rax, 0x18(%rsi)
leaq 0x159(%rip), %rax       # 0x61aa7
movq %rax, 0x28(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb5b93(%rip), %rsi     # 0x117522
movl $0xff, %edx
callq 0xdfae5
movl %eax, %ebp
movb %bpl, (%rsp)
cmpb $-0x1, %bpl
jne 0x619bd
cmpl $0x2, 0x90(%rbx)
jl 0x619b7
movb $0x1, (%rsp)
movb $0x1, %bpl
jmp 0x619bd
movb $0x0, (%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
leaq 0x123269(%rip), %r13    # 0x184c30
cmpq $0x58, %r14
je 0x619f4
movb 0x4(%r13,%r14,2), %al
andb $0x1, %al
orb %bpl, %al
je 0x619ee
leaq (%r14,%r14), %rax
movl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0xe0ae9
movq %rax, 0x8(%rsp,%r14)
addq $0x8, %r14
jmp 0x619c7
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1c0f(%rip), %rcx      # 0x63612
movq %rsp, %r8
xorl %esi, %esi
callq 0xe4745
leaq 0xb5b16(%rip), %r14     # 0x11752a
leaq 0xb5b2a(%rip), %r12     # 0x117545
xorl %ebp, %ebp
cmpq $0x58, %rbp
je 0x61a81
movq 0x8(%rsp,%rbp), %rdi
testq %rdi, %rdi
je 0x61a7b
movb 0x5(%r13,%rbp,2), %r15b
testb %r15b, %r15b
je 0x61a53
callq 0xe0e95
movq 0x8(%r13,%rbp,2), %rdx
movq %rbx, %rdi
cmpb $0x10, %r15b
jne 0x61a6f
leaq 0xb5ae6(%rip), %rsi     # 0x117537
jmp 0x61a72
callq 0xe0eb7
movq 0x8(%r13,%rbp,2), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0xdf42e
jmp 0x61a7b
movq %r12, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0xdf42e
addq $0x8, %rbp
jmp 0x61a1d
pushq $0x1
popq %rbx
cmpq $0xc, %rbx
je 0x61a98
movq (%rsp,%rbx,8), %rdi
callq 0xe0e8d
incq %rbx
jmp 0x61a84
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb5679(%rip), %rax     # 0x117135
movq %rax, (%rsi)
leaq 0xb5678(%rip), %rax     # 0x11713e
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x61ada
movq %rax, 0x18(%rsi)
orb $0x5, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc.c
// Function: de_run_datetime
static void de_run_datetime(deark *c, de_module_params *mparams)
{
	struct de_timestamp timestamp;
	i64 dtime, ddate;
	i64 t;

	dtime = de_getu16le(0);
	ddate = de_getu16le(2);
	de_dos_datetime_to_timestamp(&timestamp, ddate, dtime);
	datetime_msg(c, &timestamp, "DOS time,date");

	ddate = de_getu16le(0);
	dtime = de_getu16le(2);
	de_dos_datetime_to_timestamp(&timestamp, ddate, dtime);
	datetime_msg(c, &timestamp, "DOS date,time");

	t = de_geti32le(0);
	de_unix_time_to_timestamp(t, &timestamp, 0x1);
	datetime_msg(c, &timestamp, "Unix-LE");

	t = de_geti32be(0);
	de_unix_time_to_timestamp(t, &timestamp, 0x1);
	datetime_msg(c, &timestamp, "Unix-BE");

	t = de_getu32be(0);
	de_mac_time_to_timestamp(t, &timestamp);
	datetime_msg(c, &timestamp, "Mac/HFS-BE");

	t = de_geti64le(0);
	de_FILETIME_to_timestamp(t, &timestamp, 0x1);
	datetime_msg(c, &timestamp, "Windows FILETIME");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xe3fa3
movq %rax, %r15
movq 0x18(%rbx), %rdi
pushq $0x2
popq %r12
movq %r12, %rsi
callq 0xe3fa3
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe0110
leaq 0xb5af3(%rip), %rdx     # 0x117612
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63655
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xe3fa3
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xe3fa3
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe0110
leaq 0xb5ac7(%rip), %rdx     # 0x117620
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63655
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xe40f2
pushq $0x1
popq %rbp
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe002e
leaq 0xb5aa8(%rip), %rdx     # 0x11762e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63655
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xe40e8
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe002e
leaq 0xb5a86(%rip), %rdx     # 0x117636
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63655
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xe404f
movq %rax, %rdi
movq %r14, %rsi
callq 0xe0102
leaq 0xb5a66(%rip), %rdx     # 0x11763e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63655
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xe418b
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe0051
leaq 0xb5a47(%rip), %rdx     # 0x117649
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63655
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe02e(%rip), %rax     # 0x11fc4f
movq %rax, (%rsi)
leaq 0xb552f(%rip), %rax     # 0x11715a
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x61c3f
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb550f(%rip), %rax     # 0x11716b
movq %rax, (%rsi)
leaq 0xb550e(%rip), %rax     # 0x117174
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x61c7a
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc83f9(%rip), %rax     # 0x12a2d2
movq %rax, (%rsi)
leaq 0xb52d5(%rip), %rax     # 0x1171b8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x61efe
movq %rax, 0x18(%rsi)
leaq 0xd(%rip), %rax         # 0x61f06
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xe3cb7
movzbl (%r14), %ecx
movl %ecx, %eax
andl $0xf, %eax
cmpl $0x8, %eax
setne %al
leal -0x79(%rcx), %edx
cmpb $-0x71, %dl
setb %dl
orb %al, %dl
jne 0x61f5c
shll $0x8, %ecx
movzbl 0x7(%rsp), %eax
orl %ecx, %eax
xorl %ecx, %ecx
movw $0x1f, %si
xorl %edx, %edx
divw %si
testw %dx, %dx
pushq $0x32
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb5264(%rip), %rax     # 0x1171d1
movq %rax, (%rsi)
leaq 0xb525e(%rip), %rax     # 0x1171d5
movq %rax, 0x8(%rsi)
leaq 0xa637f(%rip), %rax     # 0x108301
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x61f9d
movq %rax, 0x18(%rsi)
leaq 0x92(%rip), %rax        # 0x6202a
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa81e0(%rip), %rax     # 0x10a233
movq %rax, (%rsi)
leaq 0xb5184(%rip), %rax     # 0x1171e1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62078
movq %rax, 0x18(%rsi)
leaq 0x191(%rip), %rax       # 0x62204
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
movl $0x100, %esi            # imm = 0x100
movq %rcx, %rax
cqto
idivq %rsi
movq %rax, 0x10(%r14)
testb %cl, %cl
sete %dl
addq $-0x1500, %rcx          # imm = 0xEB00
cmpq $-0x1200, %rcx          # imm = 0xEE00
setae %cl
testb %cl, %dl
jne 0x620da
leaq 0xb3726(%rip), %rsi     # 0x1157f1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
jmp 0x621eb
andq $0x0, 0x18(%r14)
shlq $0x8, %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdecaf
movq %rax, 0x28(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %rax, %rsi
callq 0xe3cb7
leaq 0xb55ab(%rip), %rsi     # 0x1176bc
movq %rbx, %rdi
callq 0xdfa87
testq %rax, %rax
je 0x621c9
leaq 0xdde7c(%rip), %rsi     # 0x13ffa5
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r15
leaq 0xc6edd(%rip), %r13     # 0x12901c
leaq 0xb554f(%rip), %r12     # 0x117695
xorl %ebp, %ebp
cmpq 0x20(%r14), %rbp
jge 0x621bf
movq %rbp, %rax
cqto
idivq 0x10(%r14)
testq %rdx, %rdx
jne 0x6216b
movq %r15, %rdi
leaq 0xb5560(%rip), %rsi     # 0x1176c6
callq 0xe5fe4
movq 0x28(%r14), %rax
movzbl (%rax,%rbp), %edx
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0xe5905
movq 0x20(%r14), %rax
decq %rax
cmpq %rax, %rbp
je 0x62197
movq %r15, %rdi
movq %r12, %rsi
callq 0xe5fe4
movq 0x10(%r14), %rcx
movq %rbp, %rax
cqto
idivq %rcx
decq %rcx
cmpq %rcx, %rdx
jne 0x621ba
movq %r15, %rdi
leaq 0xa0fd2(%rip), %rsi     # 0x103187
callq 0xe5fe4
incq %rbp
jmp 0x62148
movq %r15, %rdi
callq 0xe5591
jmp 0x621eb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x637dd
movq %r14, %rdi
callq 0x6384a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x638d9
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6392b
// File: /workspace/github_c_makefile_star2_O2/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 0xb4fdc(%rip), %rax     # 0x1171f5
movq %rax, (%rsi)
leaq 0xb4fdc(%rip), %rax     # 0x1171ff
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6223e
movq %rax, 0x18(%rsi)
leaq 0xfc(%rip), %rax        # 0x62335
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rdi
pushq $0x2
popq %rsi
callq 0xe3fa3
movq %rax, 0x18(%r14)
leaq 0xb6bce(%rip), %rsi     # 0x118e35
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
pushq $0x5
popq %rsi
callq 0xe3eb4
movzbl %al, %edx
movq %rdx, 0x10(%r14)
leaq 0xb5457(%rip), %rsi     # 0x1176e5
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x10(%r14), %rax
movq %rax, %rsi
shlq $0x8, %rsi
movq %rsi, 0x20(%r14)
addq $-0x15, %rax
cmpq $-0x12, %rax
jb 0x622c2
movq 0x18(%r14), %rax
addq %rsi, %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x622ea
movb $0x1, 0x30(%r14)
leaq 0xb5428(%rip), %rsi     # 0x1176f6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6392b
movq %rbx, %rdi
callq 0xdecaf
movq %rax, 0x28(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %rax, %rsi
callq 0xe3cb7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x637dd
movq %r14, %rdi
callq 0x6384a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x638d9
cmpb $0x0, 0x30(%r14)
jne 0x622c7
jmp 0x622d8
// File: /workspace/github_c_makefile_star2_O2/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 0x62379
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3eb4
cmpb $-0x15, %al
jne 0x62379
movq 0x18(%r14), %rdi
leaq 0xb53b5(%rip), %rdx     # 0x117719
pushq $0x8
popq %rsi
pushq $0xd
popq %rcx
callq 0xe4d48
xorl %ecx, %ecx
testl %eax, %eax
pushq $0x64
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb4e8c(%rip), %rax     # 0x117216
movq %rax, (%rsi)
leaq 0xb53a7(%rip), %rax     # 0x11773b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x623af
movq %rax, 0x18(%rsi)
leaq 0x10f(%rip), %rax       # 0x624b9
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x5(%rsp), %r15
pushq $0xb
popq %rcx
movq %r15, %rsi
xorl %edx, %edx
callq 0xe3cb7
cmpb $0x1, 0x6(%r15)
jne 0x62443
movzbl 0xc(%rsp), %edx
cmpb 0xf(%rsp), %dl
jne 0x62443
cmpb $0x0, 0xd(%rsp)
jne 0x62443
cmpb $0x0, 0xe(%rsp)
jne 0x62443
movq %rdx, 0x10(%r14)
leaq 0xb52de(%rip), %rsi     # 0x1176e5
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
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 0x62443
movq %rsi, %rax
orq $0xb, %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x6246e
movb $0x1, 0x30(%r14)
leaq 0xb52d8(%rip), %rsi     # 0x117727
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6392b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xdecaf
movq %rax, 0x28(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %rax, %rsi
callq 0xe3cb7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x637dd
movq %r14, %rdi
callq 0x6384a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x638d9
cmpb $0x0, 0x30(%r14)
jne 0x62448
jmp 0x62459
// File: /workspace/github_c_makefile_star2_O2/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 0xb5278(%rip), %rdx     # 0x117744
xorl %ebx, %ebx
pushq $0x3
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
jne 0x6251a
movq 0x18(%r14), %rdi
pushq $0x5
popq %rsi
callq 0xe3eb4
cmpb $0x20, %al
jne 0x6251a
movq 0x18(%r14), %rdi
pushq $0x7
popq %rsi
callq 0xe3eb4
movl %eax, %r15d
leal -0x11(%r15), %eax
cmpb $-0xb, %al
jb 0x6251a
movq 0x18(%r14), %rdi
pushq $0xa
popq %rsi
callq 0xe3eb4
xorl %ecx, %ecx
cmpb %r15b, %al
pushq $0x50
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb4cf5(%rip), %rax     # 0x11721e
movq %rax, (%rsi)
leaq 0xb5283(%rip), %rax     # 0x1177b6
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x62559
movq %rax, 0x18(%rsi)
leaq 0x256(%rip), %rax       # 0x6279f
movq %rax, 0x20(%rsi)
leaq 0x2b8(%rip), %rax       # 0x6280c
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x62802
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3eb4
cmpb $-0x15, %al
jne 0x62802
movq 0x18(%r14), %rdi
pushq $0x1
popq %rsi
callq 0xe3eb4
leal -0x34(%rax), %ecx
cmpb $-0x2, %cl
jb 0x62802
movq 0x18(%r14), %rdi
addb $0x29, %al
movzbl %al, %esi
leaq 0xb4fd4(%rip), %rdx     # 0x1177c4
pushq $0x5
popq %rcx
callq 0xe4d48
xorl %ecx, %ecx
testl %eax, %eax
pushq $0x5a
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb4a06(%rip), %rax     # 0x117227
movq %rax, (%rsi)
leaq 0xb4a04(%rip), %rax     # 0x11722f
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62846
movq %rax, 0x18(%rsi)
leaq 0x1ba(%rip), %rax       # 0x629fb
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x62a55
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xe3eb4
cmpb $-0x17, %al
jne 0x62a55
movq 0x18(%rbx), %rdi
leaq 0xb4e17(%rip), %rdx     # 0x117843
pushq $0x7
popq %rsi
pushq $0xe
popq %rcx
callq 0xe4d48
pushq $0x64
popq %r14
testl %eax, %eax
je 0x62a55
movq 0x18(%rbx), %rdi
leaq 0xb4e08(%rip), %rdx     # 0x117852
pushq $0xb
popq %rsi
pushq $0xe
popq %rcx
callq 0xe4d48
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb47dc(%rip), %rax     # 0x117243
movq %rax, (%rsi)
leaq 0xb47d6(%rip), %rax     # 0x117247
movq %rax, 0x8(%rsi)
leaq 0xac996(%rip), %rax     # 0x10f412
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x62a97
movq %rax, 0x18(%rsi)
leaq 0x69(%rip), %rax        # 0x62afb
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb4dbc(%rip), %rsi     # 0x117861
pushq $0x68
popq %rdx
xorl %eax, %eax
callq 0xde896
leaq 0xa82ad(%rip), %rsi     # 0x10ad63
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe4e62
movq %rax, %r14
leaq 0xb4ea3(%rip), %rsi     # 0x117970
pushq $0x36
popq %rdx
movq %rax, %rdi
callq 0xe46ba
movq 0x18(%rbx), %rdi
pushq $0x68
popq %rsi
movl $0x1490, %edx           # imm = 0x1490
movq %r14, %rcx
callq 0xe45f4
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe5591
// File: /workspace/github_c_makefile_star2_O2/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 0xb63d1(%rip), %rax     # 0x118f1d
movq %rax, (%rsi)
leaq 0xb4706(%rip), %rax     # 0x11725c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62b71
movq %rax, 0x18(%rsi)
leaq 0xe8(%rip), %rax        # 0x62c54
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0xc5952(%rip), %rsi     # 0x1284dd
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r14
movq %rax, %rdi
callq 0xe589c
leaq 0x30(%rsp), %r12
leaq 0x18(%rsp), %r13
leaq 0x50(%rsp), %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0xee7ee
movq 0x18(%rbx), %rax
movq %rax, (%r12)
andq $0x0, 0x8(%r12)
movq 0x18(%rax), %rax
leaq 0x4(%rsp), %r8
andq $0x0, 0x8(%r8)
movq %rax, 0x10(%r12)
andl $0x0, 0x10(%r8)
movq %r14, (%r13)
movb $0x0, 0x8(%r13)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%r8)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0xf644c
movq %r14, %rdi
callq 0xe58e8
cmpl $0x0, (%r15)
je 0x62c3b
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xee7bc
leaq 0xa50d1(%rip), %rsi     # 0x107cff
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdf2a5
movq %r14, %rdi
callq 0xe5591
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb45ed(%rip), %rax     # 0x11726a
movq %rax, (%rsi)
leaq 0xb45e7(%rip), %rax     # 0x11726e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62ca2
movq %rax, 0x18(%rsi)
leaq 0x11d(%rip), %rax       # 0x62dba
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe40bf
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %rax, %r13
leaq 0xb4b98(%rip), %rsi     # 0x11787b
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %rax, %r15
leaq 0xb4b7a(%rip), %rsi     # 0x117892
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
testq %r13, %r13
jle 0x62d71
leaq (%r12,%r13), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x62d71
movq %r12, %rsi
callq 0xe3eb4
cmpb $-0x1, %al
jne 0x62d71
testq %r15, %r15
leaq 0xc3889(%rip), %rax     # 0x1265da
leaq 0xb4b50(%rip), %rcx     # 0x1178a8
cmoveq %rax, %rcx
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe4e0b
testq %r15, %r15
jle 0x62dac
leaq (%r15,%r14), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x62dac
movq %r14, %rsi
callq 0xe3eb4
cmpb $-0x77, %al
jne 0x62dac
movq 0x18(%rbx), %rdi
leaq 0xb4b1c(%rip), %rcx     # 0x1178b7
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe4e0b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb44a5(%rip), %rax     # 0x117288
movq %rax, (%rsi)
leaq 0xb44a6(%rip), %rax     # 0x117293
movq %rax, 0x38(%rsi)
leaq 0xb44a2(%rip), %rax     # 0x11729a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62e13
movq %rax, 0x18(%rsi)
leaq 0x19(%rip), %rax        # 0x62e27
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x62ea1
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3eb4
cmpb $0x1, %al
ja 0x62ea1
movl %eax, %ebp
movq 0x18(%r15), %rdi
pushq $0x1
popq %rsi
callq 0xe3eb4
movl %eax, %r14d
leal -0x7(%r14), %eax
cmpb $-0x3, %al
jb 0x62ea1
movq 0x18(%r15), %rdi
movq 0x18(%rdi), %rsi
addq $-0x4, %rsi
callq 0xe409f
pushq $0x8
popq %rcx
subl $0x1, %ecx
jb 0x62ea1
movl %eax, %edx
andl $0xfffffe00, %edx       # imm = 0xFFFFFE00
cmpl $0x1fe0200, %edx        # imm = 0x1FE0200
je 0x62e91
shrl %eax
jmp 0x62e78
xorb $0x6, %r14b
orb %r14b, %bpl
pushq $0x28
popq %rax
pushq $0xa
popq %rbx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb4408(%rip), %rax     # 0x1172bd
movq %rax, (%rsi)
leaq 0xb4409(%rip), %rax     # 0x1172c8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62eda
movq %rax, 0x18(%rsi)
leaq 0x7b(%rip), %rax        # 0x62f50
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rsi
callq 0xe3eb4
leal -0x33(%rax), %ecx
cmpb $0x4b, %cl
ja 0x62f09
movzbl %al, %edx
leaq 0xb49ca(%rip), %rsi     # 0x1178c9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0xe409f
movq %rax, %r14
leaq 0xa5248(%rip), %rsi     # 0x108167
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rdx
addq $-0x8, %rdx
pushq $0x8
popq %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6396f
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc.c
// Function: de_run_lzss_oku
static void de_run_lzss_oku(deark *c, de_module_params *mparams)
{
	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 = 0;
	dcmpri.len = c->infile->len;
	dcmpro.f = outf;

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

	dbuf_close(outf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0xdcfc1(%rip), %rsi     # 0x13ff8a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r14
movq %rax, %rdi
callq 0xe589c
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x40(%rsp), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xee7ee
movq 0x18(%rbx), %rax
movq %rax, (%r15)
andq $0x0, 0x8(%r15)
movq 0x18(%rax), %rax
movq %rax, 0x10(%r15)
movq %r14, (%r12)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0xef3c0
movq %r14, %rdi
callq 0xe58e8
cmpl $0x0, (%r13)
je 0x63059
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xee7bc
leaq 0xa4175(%rip), %rsi     # 0x1071c1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdf2a5
movq %r14, %rdi
callq 0xe5591
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq