LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/tivariable.c
// Function: do_bitmap
static int do_bitmap(deark *c, lctx *d, i64 pos)
{
	i64 rowspan;
	int retval = 0;

	de_dbg_dimensions(c, d->w, d->h);
	rowspan = (d->w+7)/8;

	if(pos+rowspan*d->h > c->infile->len) {
		de_err(c, "Unexpected end of file");
		goto done;
	}

	de_convert_and_write_image_bilevel(c->infile, pos, d->w, d->h, rowspan,
		DE_CVTF_WHITEISZERO, NULL, 0);
	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
callq 0xe8f88
movq (%r15), %rdx
leaq 0x7(%rdx), %rax
leaq 0xe(%rdx), %r8
testq %rax, %rax
cmovnsq %rax, %r8
movq 0x8(%r15), %rcx
sarq $0x3, %r8
movq %r8, %rax
imulq %rcx, %rax
addq %rbx, %rax
movq 0x18(%r14), %rdi
cmpq 0x18(%rdi), %rax
jle 0xd1412
leaq 0x41911(%rip), %rsi     # 0x112d14
movq %r14, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe9295
movq %rbx, %rsi
movl $0x1, %r9d
pushq $0x0
pushq $0x0
callq 0xf2a98
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/unsupported.c
// Function: de_module_unsupported
void de_module_unsupported(deark *c, struct deark_module_info *mi)
{
	mi->id = "unsupported";
	mi->desc = "Identify some unsupported formats";
	mi->run_fn = de_run_unsupported;
	mi->identify_fn = de_identify_unsupported;
	mi->flags |= DE_MODFLAG_HIDDEN | DE_MODFLAG_NOEXTRACT;
	mi->unique_id = 1;
}

// Assembly:
leaq 0x6ee49(%rip), %rax     # 0x140280
movq %rax, (%rsi)
leaq 0x6ee4b(%rip), %rax     # 0x14028c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xd1467
movq %rax, 0x18(%rsi)
leaq 0x6f(%rip), %rax        # 0xd14c6
movq %rax, 0x20(%rsi)
orb $0x5, 0x30(%rsi)
movl $0x1, 0x34(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/vort.c
// Function: de_module_vort
void de_module_vort(deark *c, struct deark_module_info *mi)
{
	mi->id = "vort";
	mi->desc = "VORT ray tracer PIX image";
	mi->run_fn = de_run_vort;
	mi->identify_fn = de_identify_vort;
}

// Assembly:
leaq 0x6ece9(%rip), %rax     # 0x140514
movq %rax, (%rsi)
leaq 0x6ece4(%rip), %rax     # 0x140519
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd1850
movq %rax, 0x18(%rsi)
leaq 0x55a(%rip), %rax       # 0xd1da5
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/vort.c
// Function: read_vlq
static i64 read_vlq(deark *c, i64 *fpos)
{
	i64 nlen;
	i64 k;
	i64 val;
	i64 pos = *fpos;

	nlen = (i64)de_getbyte_p(&pos);
	*fpos += 1+nlen;
	if(nlen>7) {
		return 0;
	}

	val = 0;
	for(k=0; k<nlen; k++) {
		val = (val<<8) | (i64)de_getbyte_p(&pos);
	}
	if(val<0) return 0;
	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x18(%rdi), %rdi
callq 0xeeb4b
movzbl %al, %r15d
movq (%r14), %rax
addq %r15, %rax
incq %rax
movq %rax, (%r14)
cmpb $0x7, %r15b
jbe 0xd1e05
xorl %eax, %eax
jmp 0xd1e34
xorl %r12d, %r12d
testq %r15, %r15
je 0xd1e2b
movq %rsp, %r14
shlq $0x8, %r12
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xeeb4b
movzbl %al, %eax
orq %rax, %r12
decq %r15
jne 0xd1e10
xorl %eax, %eax
testq %r12, %r12
cmovgq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/vort.c
// Function: decode_simple_item
static void decode_simple_item(deark *c, lctx *d,
	const struct obj_type_info_struct *oti,
	i64 pos, i64 dlen, i64 val)
{
	if(oti->full_type==VORT_V_IMAGE) {
		switch(oti->primitive_type) {
		case VORT_I_ADDR: d->image_data_pos = val; break;
		case VORT_I_IMWIDTH: d->image_width = val; break;
		case VORT_I_IMHEIGHT: d->image_height = val; break;
		case VORT_I_IMDEPTH: d->reported_image_depth = val; break;
		case VORT_I_ALPHA: d->image_alpha_flag = 1; break;
		case VORT_I_COLORMAP: d->image_colormap_addr = val; break;
		case VORT_I_RLE_CODED: d->rle_flag = 1; break;
		}
	}
	else if(oti->full_type==VORT_V_COLORMAP) {
		switch(oti->primitive_type) {
		case VORT_C_ADDR: d->colormap_pos = val; break;
		case VORT_C_SIZE: d->colormap_size = val; break;
		}
	}
}

// Assembly:
movzbl 0x4(%rdx), %eax
cmpl $0x3, %eax
je 0xd219c
cmpl $0x1, %eax
jne 0xd21b2
movzbl 0x5(%rdx), %eax
cmpq $0xb, %rax
ja 0xd21b2
leaq 0x6e346(%rip), %rcx     # 0x1404d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r9, 0x8(%rsi)
retq
movzbl 0x5(%rdx), %eax
cmpl $0x1, %eax
je 0xd21ae
testl %eax, %eax
jne 0xd21b2
movq %r9, 0x28(%rsi)
retq
movq %r9, 0x30(%rsi)
retq
movq %r9, 0x38(%rsi)
retq
movq %r9, 0x10(%rsi)
retq
movb $0x1, 0x40(%rsi)
retq
movq %r9, 0x18(%rsi)
retq
movq %r9, 0x20(%rsi)
retq
movb $0x1, 0x41(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wad.c
// Function: de_module_wad
void de_module_wad(deark *c, struct deark_module_info *mi)
{
	mi->id = "wad";
	mi->desc = "Doom WAD";
	mi->run_fn = de_run_wad;
	mi->identify_fn = de_identify_wad;
}

// Assembly:
leaq 0x6e560(%rip), %rax     # 0x1407a3
movq %rax, (%rsi)
leaq 0x6e55a(%rip), %rax     # 0x1407a7
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd2268
movq %rax, 0x18(%rsi)
leaq 0x285(%rip), %rax       # 0xd24e8
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: de_module_wmf
void de_module_wmf(deark *c, struct deark_module_info *mi)
{
	mi->id = "wmf";
	mi->desc = "Windows Metafile";
	mi->desc2 = "extract bitmaps only";
	mi->run_fn = de_run_wmf;
	mi->identify_fn = de_identify_wmf;
}

// Assembly:
leaq 0x4a038(%rip), %rax     # 0x11c577
movq %rax, (%rsi)
leaq 0x48c39(%rip), %rax     # 0x11b182
movq %rax, 0x8(%rsi)
leaq 0x48c3f(%rip), %rax     # 0x11b193
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0xd256f
movq %rax, 0x18(%rsi)
leaq 0x36f(%rip), %rax       # 0xd28d9
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: de_identify_wmf
static int de_identify_wmf(deark *c)
{
	UI w0, w1, ver;
	i64 sz;
	int has_ext;

	w0 = (UI)de_getu16le(0);
	w1 = (UI)de_getu16le(2);
	if(w0==0xcdd7 && w1==0x9ac6) {
		return 100;
	}
	if(w1!=0x09) return 0;
	if(w0!=0x01 && w0!=0x02) return 0;
	ver = (UI)de_getu16le(4);
	if(ver!=0x0100 && ver!=0x0300) return 0;

	has_ext = de_input_file_has_ext(c, "wmf");
	if(has_ext) return 95;
	sz = de_getu32le(6) * 2;
	if(sz > c->infile->len || sz < 20) return 0;
	if(sz >= c->infile->len-8) return 70;
	return 14;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xeebc8
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xeebc8
movq %rax, %rcx
movl %r14d, %edx
xorl $0xcdd7, %edx           # imm = 0xCDD7
movl %ecx, %esi
xorl $0x9ac6, %esi           # imm = 0x9AC6
movl $0x64, %eax
orl %edx, %esi
je 0xd29b0
cmpl $0x9, %ecx
setne %al
addl $-0x3, %r14d
cmpl $-0x2, %r14d
setb %cl
orb %al, %cl
jne 0xd29ae
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xeebc8
andl $0xfffffdff, %eax       # imm = 0xFFFFFDFF
cmpl $0x100, %eax            # imm = 0x100
jne 0xd29ae
leaq 0x49c24(%rip), %rsi     # 0x11c577
movq %rbx, %rdi
callq 0xea491
movl %eax, %ecx
movl $0x5f, %eax
testl %ecx, %ecx
jne 0xd29b0
movq 0x18(%rbx), %rdi
movl $0x6, %esi
callq 0xeed61
leaq (%rax,%rax), %rcx
movq 0x18(%rbx), %rdx
movq 0x18(%rdx), %rdx
cmpq %rdx, %rcx
setg %sil
cmpq $0xa, %rax
setl %al
orb %sil, %al
movl $0x0, %eax
jne 0xd29b0
addq $-0x8, %rdx
cmpq %rdx, %rcx
movl $0xe, %ecx
movl $0x46, %eax
cmovll %ecx, %eax
jmp 0xd29b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: handler_colorref
static int handler_colorref(deark *c, lctx *d, struct decoder_params *dp)
{
	u32 colorref;

	if(dp->dlen<4) goto done;
	colorref = (u32)de_getu32le(dp->dpos);
	do_dbg_colorref(c, d, dp, colorref);
done:
	return 1;
}

// Assembly:
cmpq $0x4, 0x28(%rdx)
jl 0xd2b67
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rdx), %rsi
callq 0xeed61
movq %rbx, %rdi
movl %eax, %esi
callq 0xd36e6
popq %rbx
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: wmf_handler_TEXTOUT
static int wmf_handler_TEXTOUT(deark *c, lctx *d, struct decoder_params *dp)
{
	i64 pos = dp->dpos;
	i64 stringlen;
	de_ucstring *s = NULL;

	stringlen = de_getu16le(pos);
	pos += 2;

	if(pos+stringlen > dp->dpos+dp->dlen) goto done;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, stringlen, DE_DBG_MAX_STRLEN, s,
		0, d->input_encoding);
	de_dbg(c, "text: \"%s\"", ucstring_getpsz(s));

done:
	ucstring_destroy(s);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq 0x20(%rdx), %r15
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xeebc8
movq %rax, %r12
addq %r15, %rax
addq $0x2, %rax
movq 0x28(%r14), %rcx
addq 0x20(%r14), %rcx
cmpq %rcx, %rax
jle 0xd2baf
xorl %r14d, %r14d
jmp 0xd2bfb
addq $0x2, %r15
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl 0x4(%r13), %eax
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq %r14, %rdi
callq 0xf705c
leaq 0x684b6(%rip), %rsi     # 0x13b0a4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
callq 0xf6753
movl $0x1, %eax
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/wmf.c
// Function: handler_FILLREGION
static int handler_FILLREGION(deark *c, lctx *d, struct decoder_params *dp)
{
	unsigned int oi;
	i64 pos = dp->dpos;

	oi = (unsigned int)de_getu16le_p(&pos);
	de_dbg(c, "region object index: %u", oi);
	oi = (unsigned int)de_getu16le_p(&pos);
	de_dbg(c, "brush object index: %u", oi);
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdx), %rax
movq %rsp, %r14
movq %rax, (%r14)
movq 0x18(%rdi), %rdi
movq %r14, %rsi
callq 0xeebeb
leaq 0x6defe(%rip), %rsi     # 0x14107b
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xeebeb
leaq 0x6def7(%rip), %rsi     # 0x141093
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: wmf_handler_EXTTEXTOUT
static int wmf_handler_EXTTEXTOUT(deark *c, lctx *d, struct decoder_params *dp)
{
	i64 pos = dp->dpos;
	i64 stringlen;
	de_ucstring *s = NULL;
	u32 fwOpts;

	pos += 4; // Y, X

	stringlen = de_getu16le(pos);
	pos += 2;

	fwOpts = (u32)de_getu16le(pos);
	pos += 2;

	if(fwOpts & 0x0004) {
		// My best guess is that this flag determines whether the
		// Rectangle field exists. The specification says the field is
		// optional, but AFAICT does not say how to tell whether it exists.
		pos += 8; // Rectangle
	}

	if(pos+stringlen > dp->dpos+dp->dlen) goto done;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, stringlen, DE_DBG_MAX_STRLEN, s,
		0, d->input_encoding);
	de_dbg(c, "text: \"%s\"", ucstring_getpsz(s));

done:
	ucstring_destroy(s);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rdx), %r13
leaq 0x4(%r13), %rsi
movq 0x18(%rdi), %rdi
callq 0xeebc8
movq %rax, %r14
leaq 0x6(%r13), %rsi
movq 0x18(%rbx), %rdi
callq 0xeebc8
andl $0x4, %eax
leaq (,%rax,2), %rcx
addq %r13, %rcx
addq %r14, %rcx
addq $0x8, %rcx
movq 0x28(%r15), %rdx
addq 0x20(%r15), %rdx
cmpq %rdx, %rcx
jle 0xd323e
xorl %r15d, %r15d
jmp 0xd328c
leaq 0x8(%r13,%rax,2), %r13
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl 0x4(%r12), %eax
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq %r15, %rdi
callq 0xf705c
leaq 0x67e25(%rip), %rsi     # 0x13b0a4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r15, %rdi
callq 0xf6753
movl $0x1, %eax
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/wmf.c
// Function: wmf_handler_DIBSTRETCHBLT_STRETCHDIB
static int wmf_handler_DIBSTRETCHBLT_STRETCHDIB(deark *c, lctx *d, struct decoder_params *dp)
{
	i64 dib_pos;
	i64 dib_len;
	int hdrsize;
	int has_src_bitmap = 1;

	if(dp->rectype==0x41) { // DIBSTRETCHBLT
		has_src_bitmap = (dp->recsize_words != ((i64)(dp->recfunc>>8)+3));
		de_dbg(c, "has src bitmap: %d", has_src_bitmap);
	}

	if(!has_src_bitmap) goto done;
	if(dp->rectype==0x41) // DIBSTRETCHBLT
		hdrsize = 26;
	else
		hdrsize = 28;

	if(dp->recsize_bytes < hdrsize) goto done;
	dib_pos = dp->recpos + hdrsize;
	dib_len = dp->recsize_bytes - hdrsize;
	if(dib_len < 12) goto done;
	de_dbg(c, "DIB at %d, size=%d", (int)dib_pos, (int)dib_len);

	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice(c, "dib", NULL, c->infile, dib_pos, dib_len);
	de_dbg_indent(c, -1);

done:
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl $0x1c, %r15d
cmpb $0x41, 0x2(%rdx)
jne 0xd32fe
movq 0x10(%r14), %r15
movzbl 0x1(%r14), %r12d
addq $0x3, %r12
xorl %edx, %edx
cmpq %r12, %r15
setne %dl
leaq 0x6d836(%rip), %rsi     # 0x140b13
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
cmpq %r12, %r15
je 0xd335d
xorl %eax, %eax
cmpb $0x41, 0x2(%r14)
setne %al
leaq 0x1a(,%rax,2), %r15
movq 0x18(%r14), %r12
subq %r15, %r12
jl 0xd335d
cmpq $0xc, %r12
jl 0xd335d
addq 0x8(%r14), %r15
leaq 0x6d86e(%rip), %rsi     # 0x140b86
movq %rbx, %rdi
movl %r15d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%rbx), %rcx
leaq 0x500cf(%rip), %rsi     # 0x12340f
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %r8
movq %r12, %r9
callq 0xe9aa3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: handler_DELETEOBJECT
static int handler_DELETEOBJECT(deark *c, lctx *d, struct decoder_params *dp)
{
	unsigned int oi;
	oi = (unsigned int)de_getu16le(dp->dpos);
	de_dbg(c, "object index: %u", oi);
	if(d->object_table && oi<d->num_objects) {
		d->object_table[oi] = 0; // Mark this index as available
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq 0x20(%rdx), %rsi
callq 0xeebc8
movq %rax, %r14
leaq 0x6de2d(%rip), %rsi     # 0x1411bd
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xd33b3
cmpl %r14d, 0x18(%rbx)
jbe 0xd33b3
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: handler_CREATEPENINDIRECT
static int handler_CREATEPENINDIRECT(deark *c, lctx *d, struct decoder_params *dp)
{
	u32 colorref;
	i64 pos = dp->dpos;
	unsigned int width;
	unsigned int style;
	unsigned int base_style;
	de_ucstring *style_descr = NULL;

	if(dp->dlen<10) goto done;
	style = (unsigned int)de_getu16le_p(&pos);
	base_style = style&0x0f; // ?
	style_descr = ucstring_create(c);
	ucstring_append_flags_item(style_descr, get_penbasestyle_name(base_style));
	if((style&0x0f00)==0x0100) ucstring_append_flags_item(style_descr, "PS_ENDCAP_SQUARE");
	if((style&0x0f00)==0x0200) ucstring_append_flags_item(style_descr, "PS_ENDCAP_FLAG");
	if((style&0xf000)==0x1000) ucstring_append_flags_item(style_descr, "PS_JOIN_BEVEL");
	if((style&0xf000)==0x2000) ucstring_append_flags_item(style_descr, "PS_JOIN_MITER");
	de_dbg(c, "style: 0x%04x (%s)", style, ucstring_getpsz(style_descr));

	if(base_style!=0x5) {
		width = (unsigned int)de_getu32le(pos);
		width &= 0x0000ffffU;
		de_dbg(c, "width: %u", width);
	}
	pos += 4;

	if(base_style!=0x5) {
		colorref = (u32)de_getu32le(pos);
		do_dbg_colorref(c, d, dp, colorref);
	}

done:
	ucstring_destroy(style_descr);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x20(%rdx), %rax
movq %rax, 0x8(%rsp)
cmpq $0xa, 0x28(%rdx)
jge 0xd33e2
xorl %r14d, %r14d
jmp 0xd350c
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x8(%rsp), %rsi
callq 0xeebeb
movq %rax, %r15
movl %r15d, %ebp
movl %r15d, %r12d
andl $0xf, %r12d
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r14
cmpl $0x8, %r12d
ja 0xd3427
movl %r15d, %eax
andl $0xf, %eax
leaq 0x6ddce(%rip), %rcx     # 0x1411ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp 0xd3429
xorl %eax, %eax
testq %rax, %rax
leaq 0x58d1e(%rip), %rsi     # 0x12c151
cmovneq %rax, %rsi
movq %r14, %rdi
callq 0xf7105
movl %ebp, %eax
andl $0xf00, %eax            # imm = 0xF00
cmpl $0x100, %eax            # imm = 0x100
je 0xd345d
cmpl $0x200, %eax            # imm = 0x200
jne 0xd346c
leaq 0x6dc60(%rip), %rsi     # 0x1410bb
jmp 0xd3464
leaq 0x6dc46(%rip), %rsi     # 0x1410aa
movq %r14, %rdi
callq 0xf7105
andl $0xf000, %r15d          # imm = 0xF000
cmpl $0x1000, %r15d          # imm = 0x1000
je 0xd348e
cmpl $0x2000, %r15d          # imm = 0x2000
jne 0xd349d
leaq 0x6dc4c(%rip), %rsi     # 0x1410d8
jmp 0xd3495
leaq 0x6dc35(%rip), %rsi     # 0x1410ca
movq %r14, %rdi
callq 0xf7105
movq %r14, %rdi
callq 0xf705c
leaq 0x6dc3a(%rip), %rsi     # 0x1410e6
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
cmpl $0x5, %r12d
jne 0xd34c9
addq $0x4, 0x8(%rsp)
jmp 0xd350c
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0xeed61
movzwl %ax, %edx
leaq 0x6dc18(%rip), %rsi     # 0x1410f9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
movq 0x18(%rbx), %rdi
callq 0xeed61
movq %rbx, %rdi
movl %eax, %esi
callq 0xd36e6
movq %r14, %rdi
callq 0xf6753
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: handler_CREATEFONTINDIRECT
static int handler_CREATEFONTINDIRECT(deark *c, lctx *d, struct decoder_params *dp)
{
	i64 facename_size;
	i64 n, n2;
	u8 b;
	i64 pos = dp->dpos;

	n = de_geti16le_p(&pos);
	n2 = de_geti16le_p(&pos);
	de_dbg(c, "height,width: %d,%d", (int)n, (int)n2);
	pos += 9;
	b = de_getbyte_p(&pos);
	de_dbg(c, "charset: 0x%02x (%s)", (unsigned int)b,
		fmtutil_get_windows_charset_name(b));

	facename_size = dp->dlen-18;
	if(facename_size>32) facename_size=32;
	if(facename_size>=2) {
		de_ucstring *facename = NULL;
		facename = ucstring_create(c);
		dbuf_read_to_ucstring(c->infile, dp->dpos+18, facename_size, facename,
			DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_WINDOWS1252);
		de_dbg(c, "facename: \"%s\"", ucstring_getpsz_d(facename));
		ucstring_destroy(facename);
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x20(%rdx), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xeecce
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeecce
leaq 0x48968(%rip), %rsi     # 0x11bece
movq %rbx, %rdi
movl %r12d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe8617
addq $0x9, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %ebp
movl %ebp, %edi
callq 0xf8e88
leaq 0x4894c(%rip), %rsi     # 0x11bee2
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq 0x28(%r14), %rax
cmpq $0x14, %rax
jl 0xd3613
cmpq $0x32, %rax
movl $0x32, %r15d
cmovbq %rax, %r15
addq $-0x12, %r15
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq 0x20(%r14), %rsi
addq $0x12, %rsi
movq %r15, %rdx
movq %rax, %rcx
movl $0x1, %r8d
movl $0x9, %r9d
callq 0xefbd7
movq %r12, %rdi
callq 0xf70f6
leaq 0x488f9(%rip), %rsi     # 0x11bef7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r12, %rdi
callq 0xf6753
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wmf.c
// Function: handler_CREATEBRUSHINDIRECT
static int handler_CREATEBRUSHINDIRECT(deark *c, lctx *d, struct decoder_params *dp)
{
	unsigned int style;
	i64 pos = dp->dpos;

	if(dp->dlen<8) goto done;
	style = (unsigned int)de_getu16le_p(&pos);
	de_dbg(c, "style: 0x%04x (%s)", style, get_brushstyle_name(style));

	if(style==0x0 || style==0x2) {
		u32 colorref;
		colorref = (u32)de_getu32le(pos);
		do_dbg_colorref(c, d, dp, colorref);
	}
	pos += 4;

	if(style==0x2) {
		unsigned int h;
		h = (unsigned int)de_getu16le(pos);
		de_dbg(c, "hatch: %u", h);
	}

done:
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdx), %rax
movq %rax, (%rsp)
cmpq $0x8, 0x28(%rdx)
jl 0xd36d9
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %rsi
callq 0xeebeb
movq %rax, %r14
cmpl $0x6, %r14d
ja 0xd3667
movl %r14d, %eax
andl $0x7, %eax
leaq 0xba4ef(%rip), %rcx     # 0x18db50
movq (%rcx,%rax,8), %rax
jmp 0xd3669
xorl %eax, %eax
testq %rax, %rax
leaq 0x58ade(%rip), %rcx     # 0x12c151
cmovneq %rax, %rcx
leaq 0x6da68(%rip), %rsi     # 0x1410e6
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe8617
testl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
jne 0xd36ab
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
callq 0xeed61
movq %rbx, %rdi
movl %eax, %esi
callq 0xd36e6
movq (%rsp), %rsi
addq $0x4, %rsi
movq %rsi, (%rsp)
cmpl $0x2, %r14d
jne 0xd36d9
movq 0x18(%rbx), %rdi
callq 0xeebc8
leaq 0x6da98(%rip), %rsi     # 0x141165
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wpg.c
// Function: de_module_wpg
void de_module_wpg(deark *c, struct deark_module_info *mi)
{
	mi->id = "wpg";
	mi->desc = "WordPerfect Graphics";
	mi->run_fn = de_run_wpg;
	mi->identify_fn = de_identify_wpg;
}

// Assembly:
leaq 0x6dba9(%rip), %rax     # 0x1412f0
movq %rax, (%rsi)
leaq 0x6dba3(%rip), %rax     # 0x1412f4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd376c
movq %rax, 0x18(%rsi)
leaq 0x33b(%rip), %rax       # 0xd3aa2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wpg.c
// Function: handler_colormap
static void handler_colormap(deark *c, lctx *d, u8 rectype, i64 dpos1, i64 dlen)
{
	i64 start_index;
	i64 num_entries;
	i64 pos = dpos1;

	d->has_pal = 1;
	start_index = de_getu16le(pos);
	de_dbg(c, "start index: %d", (int)start_index);
	pos += 2;

	num_entries = de_getu16le(pos);
	de_dbg(c, "num entries: %d", (int)num_entries);
	pos += 2;

	if(start_index+num_entries>256) num_entries = 256 - start_index;
	if(start_index<0 || start_index+num_entries>256) return;

	if(num_entries > d->num_pal_entries) {
		d->num_pal_entries = num_entries;
	}

	de_read_palette_rgb(c->infile, pos, num_entries, 3, &d->pal[start_index],
		256-start_index, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x10(%rsi)
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xeebc8
movq %rax, %r12
leaq 0x6d376(%rip), %rsi     # 0x14162c
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
leaq 0x2(%rbx), %rsi
movq 0x18(%r15), %rdi
callq 0xeebc8
movq %rax, %r13
leaq 0x45bcd(%rip), %rsi     # 0x119ea7
movq %r15, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xe8617
leaq (%r12,%r13), %rax
movl $0x100, %r9d            # imm = 0x100
subq %r12, %r9
cmpq $0x101, %rax            # imm = 0x101
cmovgeq %r9, %r13
testq %r12, %r12
js 0xd4346
leaq (%r12,%r13), %rax
cmpq $0x100, %rax            # imm = 0x100
jg 0xd4346
addq $0x4, %rbx
cmpq 0x418(%r14), %r13
jle 0xd4323
movq %r13, 0x418(%r14)
movq 0x18(%r15), %rdi
leaq (%r14,%r12,4), %r8
addq $0x14, %r8
movl $0x0, (%rsp)
movl $0x3, %ecx
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf2c4e
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/wri.c
// Function: de_module_wri
void de_module_wri(deark *c, struct deark_module_info *mi)
{
	mi->id = "wri";
	mi->desc = "Microsoft Write";
	mi->run_fn = de_run_wri;
	mi->identify_fn = de_identify_wri;
	mi->help_fn = de_help_wri;
}

// Assembly:
leaq 0x6d28e(%rip), %rax     # 0x141641
movq %rax, (%rsi)
leaq 0x6d288(%rip), %rax     # 0x141645
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xd43e3
movq %rax, 0x18(%rsi)
leaq 0x1093(%rip), %rax      # 0xd5466
movq %rax, 0x20(%rsi)
leaq 0x10f6(%rip), %rax      # 0xd54d4
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wri.c
// Function: de_identify_wri
static int de_identify_wri(deark *c)
{
	u8 buf[6];
	de_read(buf, 0, 6);

	if((buf[0]==0x31 || buf[0]==0x32) &&
		!de_memcmp(&buf[1], "\xbe\x00\x00\x00\xab", 5))
	{
		i64 pnMac;
		pnMac = de_getu16le(48*2);
		if(pnMac==0) return 0; // Apparently MSWord, not Write
		return 100;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0xa(%rsp), %r15
movl $0x6, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
movb (%r15), %al
addb $-0x31, %al
cmpb $0x1, %al
ja 0xd54c8
movl $0xbe, %eax
xorl 0xb(%rsp), %eax
movzbl 0xf(%rsp), %ecx
xorl $0xab, %ecx
orl %eax, %ecx
jne 0xd54c8
movq 0x18(%r14), %rdi
movl $0x60, %esi
callq 0xeebc8
xorl %ecx, %ecx
testq %rax, %rax
movl $0x64, %ebx
cmovel %ecx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wri.c
// Function: do_emit_raw_sz
static void do_emit_raw_sz(deark *c, lctx *d, struct para_info *pinfo, const char *sz)
{
	size_t sz_len = de_strlen(sz);
	if(sz_len<1) return;
	dbuf_write(d->html_outf, (const u8*)sz, (i64)sz_len);
	if(sz[sz_len-1]=='\n') {
		pinfo->xpos = 0;
	}
	else {
		pinfo->xpos += (int)sz_len;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq %rdx, %rdi
callq 0x180e0
testq %rax, %rax
je 0xd553e
movq %rax, %r15
movq 0x70(%r12), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xef547
cmpb $0xa, -0x1(%r14,%r15)
jne 0xd553a
movl $0x0, 0x20(%rbx)
jmp 0xd553e
addl %r15d, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wri.c
// Function: end_para
static void end_para(deark *c, lctx *d, struct para_info *pinfo)
{
	if(!pinfo->in_para) return;

	if(pinfo->in_span) {
		do_emit_raw_sz(c, d, pinfo, "</span>");
		pinfo->in_span = 0;
	}

	if(!pinfo->has_content) {
		// No empty paragraphs allowed. HTML will collapse them, but Write does not.
		do_emit_codepoint(c, d, pinfo, 0xa0);
	}
	do_emit_raw_sz(c, d, pinfo, "</p>\n");
	pinfo->in_para = 0;
	default_text_styles(&pinfo->text_styles_current);
}

// Assembly:
cmpl $0x0, 0x1c(%rdx)
je 0xd55b8
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x2c(%rdx)
je 0xd557d
leaq 0x746cd(%rip), %rdx     # 0x149c38
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd54f8
movl $0x0, 0x2c(%rbx)
cmpl $0x0, 0x24(%rbx)
jne 0xd5596
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0xa0, %ecx
callq 0xd55b9
leaq 0x6c67d(%rip), %rdx     # 0x141c1a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd54f8
movl $0x0, 0x1c(%rbx)
movb $0x0, 0x31(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wri.c
// Function: do_emit_codepoint
static void do_emit_codepoint(deark *c, lctx *d, struct para_info *pinfo, i32 outcp)
{
	int styles_changed;

	if(!pinfo->in_para) {
		ensure_in_para(c, d, pinfo);
	}

	styles_changed = text_styles_differ(&pinfo->text_styles_current, &pinfo->text_styles_wanted);

	if(pinfo->in_span && styles_changed) {
		do_emit_raw_sz(c, d, pinfo, "</span>");
		pinfo->in_span = 0;
	}
	if(styles_changed) {
		if(pinfo->text_styles_wanted.tab_style) {
			do_emit_raw_sz(c, d, pinfo, "<span class=c>");
			pinfo->in_span = 1;
		}
		pinfo->text_styles_current = pinfo->text_styles_wanted; // struct copy
	}

	de_write_codepoint_to_html(c, d->html_outf, outcp);

	// FIXME: We'd like to know how many characters (not bytes) were written,
	// but we don't currently have a good way to do that in the case where the
	// codepoint was written as an HTML entity.
	pinfo->xpos++;

	if(outcp!=32) {
		pinfo->has_content = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, 0x1c(%rdx)
jne 0xd55e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd566f
movb 0x30(%rbx), %r12b
movb 0x31(%rbx), %r13b
cmpb %r12b, %r13b
setne %al
cmpl $0x0, 0x2c(%rbx)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xd5615
leaq 0x74635(%rip), %rdx     # 0x149c38
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd54f8
movl $0x0, 0x2c(%rbx)
cmpb %r12b, %r13b
je 0xd5643
cmpb $0x0, 0x30(%rbx)
je 0xd563e
leaq 0x6c5b8(%rip), %rdx     # 0x141bdf
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd54f8
movl $0x1, 0x2c(%rbx)
movb 0x30(%rbx), %al
jmp 0xd5640
xorl %eax, %eax
movb %al, 0x31(%rbx)
movq 0x70(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xeca70
incl 0x20(%rbx)
cmpl $0x20, %ebp
je 0xd5660
movl $0x1, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/wri.c
// Function: ensure_in_para
static void ensure_in_para(deark *c, lctx *d, struct para_info *pinfo)
{
	if(pinfo->in_para) return;
	do_emit_raw_sz(c, d, pinfo, "<p");
	switch(pinfo->justification) {
	case 1: do_emit_raw_sz(c, d, pinfo, " class=tc"); break;
	case 2: do_emit_raw_sz(c, d, pinfo, " class=tr"); break;
	case 3: do_emit_raw_sz(c, d, pinfo, " class=tj"); break;
	}
	do_emit_raw_sz(c, d, pinfo, ">");
	pinfo->in_para = 1;
}

// Assembly:
cmpl $0x0, 0x1c(%rsi)
je 0xd5676
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6c567(%rip), %rdx     # 0x141bee
callq 0xd54f8
movb 0x19(%rbx), %al
decb %al
cmpb $0x2, %al
ja 0xd56b1
movzbl %al, %eax
leaq 0x6c619(%rip), %rcx     # 0x141cb8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd54f8
leaq 0x74f01(%rip), %rdx     # 0x14a5b9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd54f8
movl $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xface.c
// Function: de_module_xface
void de_module_xface(deark *c, struct deark_module_info *mi)
{
	mi->id = "xface";
	mi->desc = "X-Face icon/avatar";
	mi->run_fn = de_run_xface;
	mi->identify_fn = de_identify_xface;
}

// Assembly:
leaq 0x6c5e9(%rip), %rax     # 0x141cc4
movq %rax, (%rsi)
leaq 0x6c5e5(%rip), %rax     # 0x141cca
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd5700
movq %rax, 0x18(%rsi)
leaq 0x547(%rip), %rax       # 0xd5c42
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xface.c
// Function: de_run_compfacei
static void de_run_compfacei(deark *c, de_module_params *mparams)
{
	i64 image_bytes_processed = 0;
	struct compfacei_ctx *cfictx = NULL;

	cfictx = de_malloc(c, sizeof(struct compfacei_ctx));
	cfictx->img = de_bitmap_create(c, XFACE_WIDTH, XFACE_HEIGHT, 1);

	while(1) {
		if(image_bytes_processed>=(XFACE_WIDTH*XFACE_HEIGHT)/8) break;
		if(!cfi_get_next_token(c, cfictx)) {
			goto done;
		}
		if(cfictx->token_numdigits==2) {
			cfi_set_image_byte(c, cfictx, (u8)cfictx->token_val);
		}
		else { // Assume numdigits==4
			cfi_set_image_byte(c, cfictx, (u8)(cfictx->token_val>>8));
			cfi_set_image_byte(c, cfictx, (u8)(cfictx->token_val&0xff));
		}
		image_bytes_processed += cfictx->token_numdigits/2;
	}

	de_bitmap_write_to_file_finfo(cfictx->img, NULL, DE_CREATEFLAG_IS_BWIMG);
done:
	de_bitmap_destroy(cfictx->img);
	de_free(c, cfictx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x50, %esi
callq 0xe8b2b
movq %rax, %r14
movl $0x30, %esi
movl $0x30, %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0xf266a
movq %rax, (%r14)
movq %r14, %r15
addq $0x30, %r15
xorl %r12d, %r12d
movabsq $0x100002600, %r13      # imm = 0x100002600
movq $0x0, 0x20(%r14)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x18(%r14)
callq 0xeead3
cmpb $0x20, %al
ja 0xd5d17
movzbl %al, %ecx
btq %rcx, %r13
jb 0xd5cf5
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0xd5d2c
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jb 0xd5d71
movq 0x20(%r14), %rcx
cmpq $0x1e, %rcx
ja 0xd5e2b
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%r14)
movb %al, 0x30(%r14,%rcx)
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x18(%r14)
callq 0xeead3
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0xd5d2c
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1b, %cl
ja 0xd5d2c
movq 0x20(%r14), %rcx
movb $0x0, 0x30(%r14,%rcx)
cmpq $0x4, 0x20(%r14)
jb 0xd5e2b
cmpb $0x2c, %al
ja 0xd5e2b
movzbl %al, %eax
btq %rax, %r13
jae 0xd5dae
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x18(%r14)
callq 0xeead3
jmp 0xd5d86
cmpq $0x2c, %rax
jne 0xd5e2b
xorl %eax, %eax
cmpq $0x5, 0x20(%r14)
setae %al
leal 0x2(,%rax,2), %eax
movl %eax, 0x28(%r14)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10937d
movl %eax, 0x2c(%r14)
cmpl $0x2, 0x28(%r14)
je 0xd5def
movzbl %ah, %esi
movq %r14, %rdi
callq 0xd6289
movb 0x2c(%r14), %al
movzbl %al, %esi
movq %r14, %rdi
callq 0xd6289
movl 0x28(%r14), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rax
addq %rax, %r12
cmpq $0x120, %r12            # imm = 0x120
jl 0xd5ced
movq (%r14), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xf22d0
jmp 0xd5e3c
leaq 0x6bf56(%rip), %rsi     # 0x141d88
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq (%r14), %rdi
callq 0xf228d
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xface.c
// Function: has_x_header
static int has_x_header(dbuf *f)
{
	char b[8];

	dbuf_read(f, (u8*)b, 0, 8);
	if((b[0]=='X' || b[0]=='x') &&
		(b[1]=='-') &&
		(b[2]=='F' || b[2]=='f') &&
		(b[3]=='A' || b[3]=='a') &&
		(b[4]=='C' || b[4]=='c') &&
		(b[5]=='E' || b[5]=='e') &&
		(b[6]==':') &&
		(b[7]==' ' || b[7]=='\t'))
	{
		return 1;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq %rsp, %r14
movl $0x8, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movb (%r14), %al
andb $-0x21, %al
cmpb $0x58, %al
jne 0xd5ec2
cmpb $0x2d, 0x1(%rsp)
jne 0xd5ec2
movb 0x2(%rsp), %al
andb $-0x21, %al
cmpb $0x46, %al
jne 0xd5ec2
movb 0x3(%rsp), %al
andb $-0x21, %al
cmpb $0x41, %al
jne 0xd5ec2
movb 0x4(%rsp), %al
andb $-0x21, %al
cmpb $0x43, %al
jne 0xd5ec2
movb 0x5(%rsp), %al
andb $-0x21, %al
cmpb $0x45, %al
jne 0xd5ec2
cmpb $0x3a, 0x6(%rsp)
jne 0xd5ec2
movb 0x7(%rsp), %al
cmpb $0x20, %al
sete %cl
cmpb $0x9, %al
sete %al
orb %cl, %al
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: UnCompress
static void
UnCompress(struct xfacectx *ctx, char *f, int wid, int hei, int lev)
{
	int ret;

	ret = BigPop(ctx, &gg_levels[lev][0]);
	if(ctx->errflag) return;

	switch (ret)
	{
		case WHITE :
			return;
		case BLACK :
			PopGreys(ctx, f, wid, hei);
			return;
		default :
			wid /= 2;
			hei /= 2;
			lev++;
			UnCompress(ctx, f, wid, hei, lev);
			if(ctx->errflag) return;
			UnCompress(ctx, &f[wid], wid, hei, lev);
			if(ctx->errflag) return;
			UnCompress(ctx, &f[hei * XFACE_WIDTH], wid, hei, lev);
			if(ctx->errflag) return;
			UnCompress(ctx, &f[wid + hei * XFACE_WIDTH], wid, hei, lev);
			return;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movslq %r8d, %rax
leaq (%rax,%rax,2), %r13
leaq 0x6bebc(%rip), %r15     # 0x141db0
leaq (%r15,%r13,2), %rsi
callq 0xd6111
cmpl $0x0, 0x8(%r14)
je 0xd5f13
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r15,%r13,2), %r15
addq $0x6, %r15
incl %ebx
cmpl $0x2, %eax
je 0xd5f04
testl %eax, %eax
je 0xd5fba
shrl %ebp
movl 0x4(%rsp), %ecx
shrl %ecx
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ecx, 0x4(%rsp)
movl %ebx, %r8d
callq 0xd5ecc
cmpl $0x0, 0x8(%r14)
jne 0xd5f04
movl %ebp, %esi
addq %r12, %rsi
movq %r14, %rdi
movl %ebp, %edx
movl 0x4(%rsp), %ecx
movl %ebx, %r8d
callq 0xd5ecc
cmpl $0x0, 0x8(%r14)
jne 0xd5f04
movl 0x4(%rsp), %ecx
movl %ecx, %eax
shll $0x4, %eax
leal (%rax,%rax,2), %r13d
leaq (%r12,%r13), %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %r8d
callq 0xd5ecc
cmpl $0x0, 0x8(%r14)
jne 0xd5f04
addl %ebp, %r13d
addq %r13, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xd6111
addq $0x6, %r15
incl %ebx
cmpl $0x0, 0x8(%r14)
je 0xd5f1d
jmp 0xd5f04
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl 0x4(%rsp), %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd61c1
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: BigMul
static void
BigMul(struct xfacectx *ctx, XFACE_WORD a)
{
	int i;
	XFACE_WORD *w;
	XFACE_COMP c;

	a &= WORDMASK;
	if ((a == 1) || (ctx->gg_B.b_words == 0))
		return;
	if (a == 0)	/* treat this as a == WORDCARRY */
	{			/* and just shift everything left a XFACE_WORD */
		if ((i = ctx->gg_B.b_words++) >= MAXWORDS - 1) {
			de_err(ctx->c, "xface: Internal error (1)");
			ctx->errflag = 1;
			return;
		}
		w = ctx->gg_B.b_word + i;
		while (i--)
		{
			*w = *(w - 1);
			w--;
		}
		*w = 0;
		return;
	}
	i = ctx->gg_B.b_words;
	w = ctx->gg_B.b_word;
	c = 0;
	while (i--)
	{
		c += (XFACE_COMP)*w * (XFACE_COMP)a;
		*(w++) = (XFACE_WORD)(c & WORDMASK);
		c >>= BITSPERWORD;
	}
	if (c)
	{
		if (ctx->gg_B.b_words++ >= MAXWORDS) {
			de_err(ctx->c, "Invalid or oversized X-Face image");
			ctx->errflag = 1;
			return;
		}
		*w = (XFACE_COMP)(c & WORDMASK);
	}
}

// Assembly:
cmpl $0x1, %esi
je 0xd6083
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %rax
testq %rax, %rax
je 0xd6082
testb %sil, %sil
je 0xd603e
movl %eax, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movzbl 0x24(%rbx,%rax), %edi
imull %esi, %edi
addl %ecx, %edi
movb %dil, 0x24(%rbx,%rax)
movl %edi, %ecx
shrl $0x8, %ecx
incq %rax
cmpl %eax, %edx
jne 0xd5ffe
cmpl $0x100, %edi            # imm = 0x100
jb 0xd6082
movl 0x20(%rbx), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x20(%rbx)
cmpl $0x240, %edx            # imm = 0x240
jl 0xd607e
movq (%rbx), %rdi
leaq 0x6bcf6(%rip), %rsi     # 0x141d32
jmp 0xd6055
leal 0x1(%rax), %ecx
movl %ecx, 0x20(%rbx)
cmpl $0x23f, %eax            # imm = 0x23F
jl 0xd6065
movq (%rbx), %rdi
leaq 0x6bcc3(%rip), %rsi     # 0x141d18
xorl %eax, %eax
callq 0xe9295
movl $0x1, 0x8(%rbx)
jmp 0xd6082
leaq (%rbx,%rax), %rcx
addq $0x24, %rcx
movb -0x1(%rcx), %dl
movb %dl, (%rcx)
decq %rcx
decl %eax
jne 0xd606d
movb $0x0, (%rcx)
jmp 0xd6082
movb %cl, 0x24(%rbx,%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: BigAdd
static void
BigAdd(struct xfacectx *ctx, XFACE_WORD a)
{
	int i;
	XFACE_WORD *w;
	XFACE_COMP c;

	a &= WORDMASK;
	if (a == 0)
		return;
	i = 0;
	w = ctx->gg_B.b_word;
	c = a;
	while ((i < ctx->gg_B.b_words) && c)
	{
		c += (XFACE_COMP)*w;
		*w++ = (XFACE_WORD)(c & WORDMASK);
		c >>= BITSPERWORD;
		i++;
	}
	if ((i == ctx->gg_B.b_words) && c)
	{
		if (ctx->gg_B.b_words++ >= MAXWORDS) {
			de_err(ctx->c, "xface: Internal error (3)");
			ctx->errflag = 1;
			return;
		}
		*w = (XFACE_COMP)(c & WORDMASK);
	}
}

// Assembly:
testl %esi, %esi
je 0xd6110
pushq %rbx
movq %rdi, %rbx
leaq 0x24(%rdi), %rax
cmpl $0x0, 0x20(%rdi)
jle 0xd6103
movzbl %sil, %esi
xorl %ecx, %ecx
movl $0x1, %edx
movl %edx, %r9d
movzbl (%rax), %edi
addl %esi, %edi
movb %dil, (%rax)
incq %rax
movl %edi, %esi
shrl $0x8, %esi
movl 0x20(%rbx), %r8d
decl %ecx
leal 0x1(%r9), %edx
cmpl %r8d, %r9d
jge 0xd60cf
cmpl $0xff, %edi
ja 0xd60a5
addl %ecx, %r8d
jne 0xd610f
cmpl $0xff, %edi
jbe 0xd610f
notl %ecx
movl %edx, 0x20(%rbx)
cmpl $0x23f, %ecx            # imm = 0x23F
jb 0xd610c
movq (%rbx), %rdi
leaq 0x6bc61(%rip), %rsi     # 0x141d54
xorl %eax, %eax
callq 0xe9295
movl $0x1, 0x8(%rbx)
jmp 0xd610f
jne 0xd610f
movl $0x1, 0x20(%rbx)
movb %sil, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: BigPop
static int
BigPop(struct xfacectx *ctx, const Prob *p)
{
	XFACE_WORD tmp = 0;
	int i;

	BigRSH(ctx, &tmp);
	i = 0;
	while ((tmp < p->p_offset) || (tmp >= p->p_range + p->p_offset))
	{
		p++;
		i++;
	}
	BigMul(ctx, p->p_range);
	if(ctx->errflag) return 0;
	BigAdd(ctx, tmp - p->p_offset);
	if(ctx->errflag) return 0;
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
movl 0x20(%rdi), %r15d
testl %r15d, %r15d
je 0xd615a
leaq 0x24(%rbx), %rdi
movl %r15d, %eax
decl %eax
movl %eax, 0x20(%rbx)
movb 0x24(%rbx), %cl
movb %cl, 0x7(%rsp)
je 0xd615f
leaq 0x25(%rbx), %rsi
movl %eax, %edx
callq 0x18270
addl $-0x2, %r15d
leaq (%rbx,%r15), %rdi
addq $0x25, %rdi
jmp 0xd615f
leaq 0x7(%rsp), %rdi
movb $0x0, (%rdi)
movzbl 0x7(%rsp), %ebp
xorl %r15d, %r15d
movzbl 0x1(%r14,%r15,2), %ecx
cmpb %cl, %bpl
jb 0xd6180
movzbl (%r14,%r15,2), %eax
addl %eax, %ecx
cmpl %ebp, %ecx
ja 0xd6185
incq %r15
jmp 0xd616a
movzbl %al, %esi
movq %rbx, %rdi
callq 0xd5fd9
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
jne 0xd61b6
subb 0x1(%r14,%r15,2), %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0xd6084
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
cmovnel %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: PopGreys
static void
PopGreys(struct xfacectx *ctx, char *f, int wid, int hei)
{
	if (wid > 3)
	{
		wid /= 2;
		hei /= 2;
		PopGreys(ctx, f, wid, hei);
		if(ctx->errflag) return;
		PopGreys(ctx, &f[wid], wid, hei);
		if(ctx->errflag) return;
		PopGreys(ctx, &f[XFACE_WIDTH * hei], wid, hei);
		if(ctx->errflag) return;
		PopGreys(ctx, &f[XFACE_WIDTH * hei + wid], wid, hei);
		if(ctx->errflag) return;
	}
	else
	{
		wid = BigPop(ctx, gg_freqs);
		if(ctx->errflag) return;
		if (wid & 1)
			f[0] = 1;
		if (wid & 2)
			f[1] = 1;
		if (wid & 4)
			f[XFACE_WIDTH] = 1;
		if (wid & 8)
			f[XFACE_WIDTH + 1] = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x4, %edx
jl 0xd6245
movl %ecx, %ebp
movl %edx, %r15d
movl %edx, %r12d
shrl %r12d
shrl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xd61c1
cmpl $0x0, 0x8(%r14)
jne 0xd627a
movl %r12d, %esi
addq %rbx, %rsi
movq %r14, %rdi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xd61c1
cmpl $0x0, 0x8(%r14)
jne 0xd627a
movl %ebp, %eax
shll $0x4, %eax
leal (%rax,%rax,2), %r13d
leaq (%rbx,%r13), %rsi
movq %r14, %rdi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xd61c1
cmpl $0x0, 0x8(%r14)
jne 0xd627a
addl %r12d, %r13d
addq %r13, %rbx
cmpl $0x7, %r15d
movl %r12d, %r15d
ja 0xd61df
leaq 0x6bb84(%rip), %rsi     # 0x141dd0
movq %r14, %rdi
callq 0xd6111
cmpl $0x0, 0x8(%r14)
jne 0xd627a
testb $0x1, %al
je 0xd6262
movb $0x1, (%rbx)
testb $0x2, %al
je 0xd626a
movb $0x1, 0x1(%rbx)
testb $0x4, %al
je 0xd6272
movb $0x1, 0x30(%rbx)
testb $0x8, %al
je 0xd627a
movb $0x1, 0x31(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xface.c
// Function: cfi_set_image_byte
static void cfi_set_image_byte(deark *c, struct compfacei_ctx *cfictx, u8 ch)
{
	de_unpack_pixels_bilevel_from_byte(cfictx->img, cfictx->imgpos_x, cfictx->imgpos_y,
		ch, 8, DE_CVTF_WHITEISZERO);
	cfictx->imgpos_x += 8;
	if(cfictx->imgpos_x>=XFACE_WIDTH) {
		cfictx->imgpos_x=0;
		cfictx->imgpos_y++;
	}
}

// Assembly:
pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl $0x8, %r8d
movl $0x1, %r9d
callq 0xf292a
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
cmpq $0x28, %rax
jl 0xd62c9
movq $0x0, 0x8(%rbx)
incq 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: de_module_stuffit
void de_module_stuffit(deark *c, struct deark_module_info *mi)
{
	mi->id = "stuffit";
	mi->desc = "StuffIt archive";
	mi->run_fn = de_run_stuffit;
	mi->identify_fn = de_identify_stuffit;
}

// Assembly:
leaq 0x6be06(%rip), %rax     # 0x1420d9
movq %rax, (%rsi)
leaq 0x6be04(%rip), %rax     # 0x1420e1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd62f8
movq %rax, 0x18(%rsi)
leaq 0xafa(%rip), %rax       # 0xd6ded
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: de_identify_stuffit
static int de_identify_stuffit(deark *c)
{
	u8 buf[9];

	de_read(buf, 0, sizeof(buf));
	if(!de_memcmp(buf, "SIT!", 4)) {
		return 100;
	}
	if(!de_memcmp(buf, "StuffIt (", 9)) {
		if(de_getbyte(82)==0x05) return 100;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x7(%rsp), %r15
movl $0x9, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
movl $0x64, %ebx
cmpl $0x21544953, (%r15)     # imm = 0x21544953
je 0xd6e50
movabsq $0x2074496666757453, %rax # imm = 0x2074496666757453
xorq 0x7(%rsp), %rax
movzbl 0xf(%rsp), %ecx
xorq $0x28, %rcx
orq %rax, %rcx
jne 0xd6e4e
movq 0x18(%r14), %rdi
movl $0x52, %esi
callq 0xeead3
cmpb $0x5, %al
je 0xd6e50
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: do_extract_folder
static void do_extract_folder(deark *c, lctx *d, struct member_data *md)
{
	dbuf *outf = NULL;
	de_finfo *fi = NULL;

	if(!md->is_folder) goto done;
	fi = de_finfo_create(c);
	fi->is_directory = 1;
	de_finfo_set_name_from_ucstring(c, fi, md->full_fname, DE_SNFLAG_FULLPATH);
	fi->original_filename_flag = 1;
	fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = md->mod_time;
	fi->timestamp[DE_TIMESTAMPIDX_CREATE] = md->create_time;
	outf = dbuf_create_output_file(c, NULL, fi, 0x0);
done:
	dbuf_close(outf);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, (%rsi)
je 0xd6ec6
movq %rsi, %r15
movq %rbx, %rdi
callq 0xea504
movq %rax, %r14
movb $0x1, %bpl
movb %bpl, 0x9(%rax)
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq 0xea53f
movb %bpl, 0x8(%r14)
movups 0x80(%r15), %xmm0
movups %xmm0, 0x18(%r14)
movups 0x90(%r15), %xmm0
movups %xmm0, 0x28(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %rdi
jmp 0xd6ecb
xorl %edi, %edi
xorl %r14d, %r14d
callq 0xf052b
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xea50e