LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/wri.c
// Function: do_picture_metafile
static void do_picture_metafile(deark *c, lctx *d, struct para_info *pinfo,
	struct picctx_struct *picctx)
{
	i64 pos = pinfo->thisparapos;

	if(picctx->cbHeader+picctx->cbSize > pinfo->thisparalen) goto done;
	de_dbg(c, "metafile data at %"I64_FMT, pos+picctx->cbHeader);
	dbuf_create_file_from_slice(c->infile, pos+picctx->cbHeader, picctx->cbSize,
		"wmf", NULL, 0);
done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x13d37f
jmp 0x13d3cd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rdx
leaq 0x9039a(%rip), %rsi     # 0x1cd730
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x6ad93(%rip), %rcx     # 0x1a8153
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x166be0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/wri.c
// Function: do_picture_bitmap
static void do_picture_bitmap(deark *c, lctx *d, struct para_info *pinfo,
	struct picctx_struct *picctx)
{
	i64 hdrpos, bitspos;
	i64 bitssize;
	dbuf *tmpf = NULL;

	if(picctx->cbHeader + picctx->cbSize > pinfo->thisparalen) goto done;
	hdrpos = pinfo->thisparapos + 16;
	bitspos = pinfo->thisparapos + picctx->cbHeader;
	bitssize = picctx->cbSize;
	de_dbg(c, "processing DDB, header at %"I64_FMT", pixels at %"I64_FMT,
		hdrpos, bitspos);

	// Most commonly, the DDB bits immediately follow the header. But in this
	// format, they are separated, with some non-DDB data in between.
	// We'll construct a temporary DDB, in which they are contiguous, to pass
	// to the ddb module.
	tmpf = dbuf_create_membuf(c, 14+bitssize, 0);
	dbuf_copy(c->infile, hdrpos, 14, tmpf);
	dbuf_copy(c->infile, bitspos, bitssize, tmpf);

	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, "ddb", "N", tmpf, 0, tmpf->len);
	de_dbg_indent(c, -1);

done:
	dbuf_close(tmpf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x13d41f
jmp 0x13d4f5
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x902e5(%rip), %rsi     # 0x1cd745
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0xe, %rsi
xorl %edx, %edx
callq 0x168020
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rcx
movl $0xe, %edx
callq 0x166070
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x166070
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x18(%rax), %r9
leaq 0x718db(%rip), %rsi     # 0x1aedb1
leaq 0x6291f(%rip), %rdx     # 0x19fdfc
xorl %eax, %eax
movl %eax, %r8d
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x40(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/wri.c
// Function: do_picture_ole
static void do_picture_ole(deark *c, lctx *d, struct para_info *pinfo,
	struct picctx_struct *picctx)
{
	i64 pos = pinfo->thisparapos;
	i64 ole_len;
	de_module_params *mparams = NULL;

	pos += picctx->cbHeader;

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.input_encoding = d->input_encoding;

	ole_len = de_min_int(picctx->ole_dwDataSize, pinfo->thisparapos+pinfo->thisparalen-pos);
	de_dbg(c, "OLE1 data at %"I64_FMT", len=%"I64_FMT, pos, ole_len);
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice(c, "ole1", mparams, c->infile, pos, ole_len);
	de_dbg_indent(c, -1);

	de_free(c, mparams);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rsi
subq -0x28(%rbp), %rsi
callq 0x15ccf0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x901d0(%rip), %rsi     # 0x1cd772
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x67e31(%rip), %rsi     # 0x1a5407
callq 0x15c9f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x15b820
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x190e0
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jae 0x13d62e
jmp 0x13d675
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x166170
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x13d665
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
jmp 0x13d675
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/wri.c
// Function: do_emit_ucstring
static void do_emit_ucstring(deark *c, lctx *d, struct para_info *pinfo,
	de_ucstring *s)
{
	i64 k;

	if(!s) return;
	for(k=0; k<s->len; k++) {
		do_emit_codepoint(c, d, pinfo, s->str[k]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13d6a1
jmp 0x13d6e5
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x13d6e5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0x13d800
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13d6a9
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x13d710
jmp 0x13d78d
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x13d73d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x98043(%rip), %rcx     # 0x1d5770
callq 0x13d600
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x13d75d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0xa0, %ecx
callq 0x13d800
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x90057(%rip), %rcx     # 0x1cd7c7
callq 0x13d600
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x18(%rbp), %rdi
addq $0x31, %rdi
callq 0x13da20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/wri.c
// Function: get_objecttype1_name
static const char *get_objecttype1_name(unsigned int t)
{
	const char *name;
	switch(t) {
	case 1: name="static"; break;
	case 2: name="embedded"; break;
	case 3: name="link"; break;
	default: name="?"; break;
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x13d7c8
jmp 0x13d7b4
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x13d7d5
jmp 0x13d7be
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x13d7e2
jmp 0x13d7ef
leaq 0x7fd32(%rip), %rax     # 0x1bd501
movq %rax, -0x10(%rbp)
jmp 0x13d7fa
leaq 0x7fd1c(%rip), %rax     # 0x1bd4f8
movq %rax, -0x10(%rbp)
jmp 0x13d7fa
leaq 0x75e33(%rip), %rax     # 0x1b361c
movq %rax, -0x10(%rbp)
jmp 0x13d7fa
leaq 0x7a437(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x13d832
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13d900
movq -0x18(%rbp), %rdi
addq $0x31, %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x13d9e0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x13d87d
cmpl $0x0, -0x20(%rbp)
je 0x13d87d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x97f03(%rip), %rcx     # 0x1d5770
callq 0x13d600
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
cmpl $0x0, -0x20(%rbp)
je 0x13d8be
movq -0x18(%rbp), %rax
cmpb $0x0, 0x30(%rax)
je 0x13d8b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x8feec(%rip), %rcx     # 0x1cd78c
callq 0x13d600
movq -0x18(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movb 0x30(%rcx), %cl
movb %cl, 0x31(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0x161d10
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
cmpl $0x20, -0x1c(%rbp)
je 0x13d8f0
movq -0x18(%rbp), %rax
movl $0x1, 0x24(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x13d923
jmp 0x13d9d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x8fe65(%rip), %rcx     # 0x1cd79b
callq 0x13d600
movq -0x18(%rbp), %rax
movzbl 0x19(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x13d961
jmp 0x13d94d
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x13d97b
jmp 0x13d957
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x13d995
jmp 0x13d9ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x8fe2a(%rip), %rcx     # 0x1cd79e
callq 0x13d600
jmp 0x13d9ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x8fe1a(%rip), %rcx     # 0x1cd7a8
callq 0x13d600
jmp 0x13d9ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x8fe0a(%rip), %rcx     # 0x1cd7b2
callq 0x13d600
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x986a9(%rip), %rcx     # 0x1d6069
callq 0x13d600
movq -0x18(%rbp), %rax
movl $0x1, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x8fde7(%rip), %rcx     # 0x1cd84e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x8fddf(%rip), %rcx     # 0x1cd854
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x13daa0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2d(%rip), %rcx        # 0x13dac0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/xface.c
// Function: de_identify_xface
static int de_identify_xface(deark *c)
{
	int has_ext;
	int has_hdr;

	has_hdr = has_x_header(c->infile);
	has_ext = de_input_file_has_ext(c, "xface");
	if(has_hdr && has_ext) return 100;
	if(has_hdr) return 80;
	if(has_ext) return 5;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x13de40
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8fd67(%rip), %rsi     # 0x1cd84e
callq 0x15d180
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x13db04
cmpl $0x0, -0x14(%rbp)
je 0x13db04
movl $0x64, -0x4(%rbp)
jmp 0x13db29
cmpl $0x0, -0x18(%rbp)
je 0x13db13
movl $0x50, -0x4(%rbp)
jmp 0x13db29
cmpl $0x0, -0x14(%rbp)
je 0x13db22
movl $0x5, -0x4(%rbp)
jmp 0x13db29
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x50, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x16b750
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x120, -0x18(%rbp)     # imm = 0x120
jl 0x13dbe1
jmp 0x13dc6f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13ed60
cmpl $0x0, %eax
jne 0x13dbf8
jmp 0x13dc84
movq -0x20(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x13dc1b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
movzbl %al, %edx
callq 0x13ede0
jmp 0x13dc51
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
shrl $0x8, %eax
movzbl %al, %edx
callq 0x13ede0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
andl $0xff, %eax
movzbl %al, %edx
callq 0x13ede0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x13dbd2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x8, %edx
callq 0x16afa0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x16af60
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: uncompface_main
static void
uncompface_main(deark *c)
{
  struct xfacectx *ctx = NULL;

  ctx = de_malloc(c, sizeof(struct xfacectx));
  ctx->c = c;
  ctx->inf = c->infile;

  ReadBuf(ctx);
  uncompface(ctx);

  de_free(c, ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1368, %esi           # imm = 0x1368
callq 0x15b780
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x13dd20
movq -0x10(%rbp), %rdi
callq 0x13dde0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: ReadBuf
static void
ReadBuf(struct xfacectx *ctx)
{
	i64 amt_to_read;
	i64 startpos;

	startpos = 0;
	amt_to_read = ctx->inf->len;
	if(amt_to_read > FACEBUFLEN-1)
		amt_to_read = FACEBUFLEN-1;

	// Handle a possible "X-Face:" prefix.
	if(amt_to_read>=8 && has_x_header(ctx->inf)) {
		de_dbg(ctx->c, "found X-Face prefix");
		startpos += 8;
		amt_to_read -= 8;
	}

	dbuf_read(ctx->inf, (u8*)ctx->gg_fbuf, startpos, amt_to_read);

	ctx->gg_fbuf[amt_to_read] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x7ff, -0x10(%rbp)     # imm = 0x7FF
jle 0x13dd56
movq $0x7ff, -0x10(%rbp)     # imm = 0x7FF
cmpq $0x8, -0x10(%rbp)
jl 0x13dd9c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13de40
cmpl $0x0, %eax
je 0x13dd9c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x8fb11(%rip), %rsi     # 0x1cd88e
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0xb64, %rsi            # imm = 0xB64
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x164d10
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, 0xb64(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: uncompface
static void
uncompface(struct xfacectx *ctx)
{
	UnCompAll(ctx);
	if(ctx->errflag) return;
	Gen(ctx, ctx->gg_F, sizeof(ctx->gg_F));
	if(ctx->errflag) return;
	WriteFace(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13df00
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13de01
jmp 0x13de2f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x264, %rsi            # imm = 0x264
movl $0x900, %edx            # imm = 0x900
callq 0x13e100
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13de26
jmp 0x13de2f
movq -0x8(%rbp), %rdi
callq 0x13e4b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x8, %ecx
callq 0x164d10
movsbl -0x18(%rbp), %eax
cmpl $0x58, %eax
je 0x13de74
movsbl -0x18(%rbp), %eax
cmpl $0x78, %eax
jne 0x13dee9
movsbl -0x17(%rbp), %eax
cmpl $0x2d, %eax
jne 0x13dee9
movsbl -0x16(%rbp), %eax
cmpl $0x46, %eax
je 0x13de8f
movsbl -0x16(%rbp), %eax
cmpl $0x66, %eax
jne 0x13dee9
movsbl -0x15(%rbp), %eax
cmpl $0x41, %eax
je 0x13dea1
movsbl -0x15(%rbp), %eax
cmpl $0x61, %eax
jne 0x13dee9
movsbl -0x14(%rbp), %eax
cmpl $0x43, %eax
je 0x13deb3
movsbl -0x14(%rbp), %eax
cmpl $0x63, %eax
jne 0x13dee9
movsbl -0x13(%rbp), %eax
cmpl $0x45, %eax
je 0x13dec5
movsbl -0x13(%rbp), %eax
cmpl $0x65, %eax
jne 0x13dee9
movsbl -0x12(%rbp), %eax
cmpl $0x3a, %eax
jne 0x13dee9
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
je 0x13dee0
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
jne 0x13dee9
movl $0x1, -0x4(%rbp)
jmp 0x13def0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: WriteFace
static void
WriteFace(struct xfacectx *ctx)
{
	i64 i, j;
	de_bitmap *img = NULL;

	img = de_bitmap_create(ctx->c, XFACE_WIDTH, XFACE_HEIGHT, 1);

	for(j=0; j<XFACE_HEIGHT; j++) {
		for(i=0; i<XFACE_WIDTH; i++) {
			if(ctx->gg_F[j*XFACE_WIDTH + i] == 0) {
				de_bitmap_setpixel_gray(img, i, j, 255);
			}
		}
	}

	de_bitmap_write_to_file_finfo(img, NULL, DE_CREATEFLAG_IS_BWIMG);
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x30, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x16b750
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x30, -0x18(%rbp)
jge 0x13e54f
movq $0x0, -0x10(%rbp)
cmpq $0x30, -0x10(%rbp)
jge 0x13e53f
movq -0x8(%rbp), %rax
imulq $0x30, -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movsbl 0x264(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x13e52f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0xff, %ecx
callq 0x16b1c0
jmp 0x13e531
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x13e4f8
jmp 0x13e541
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13e4e9
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x8, %edx
callq 0x16afa0
movq -0x20(%rbp), %rdi
callq 0x16af60
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: BigRead
static void
BigRead(struct xfacectx *ctx, const char *fbuf)
{
	int c;

	while (*fbuf != '\0')
	{
		c = *(fbuf++);
		if ((c < FIRSTPRINT) || (c > LASTPRINT))
			continue;
		BigMul(ctx, NUMPRINTS);
		if(ctx->errflag) return;
		BigAdd(ctx, (XFACE_WORD)(c - FIRSTPRINT));
		if(ctx->errflag) return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x13e609
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x21, -0x14(%rbp)
jl 0x13e5cd
cmpl $0x7e, -0x14(%rbp)
jle 0x13e5cf
jmp 0x13e5a0
movq -0x8(%rbp), %rdi
movl $0x5e, %esi
callq 0x13e760
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13e5e9
jmp 0x13e609
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x21, %eax
movzbl %al, %esi
callq 0x13e8f0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13e607
jmp 0x13e609
jmp 0x13e5a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
leaq 0x8f2f7(%rip), %rsi     # 0x1cd930
imulq $0x6, %rax, %rax
addq %rax, %rsi
callq 0x13ea00
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13e657
jmp 0x13e74d
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x13e672
jmp 0x13e663
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0x13e68a
jmp 0x13e66d
jmp 0x13e74d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x13eae0
jmp 0x13e74d
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x13e610
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13e6d2
jmp 0x13e74d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x13e610
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13e6fc
jmp 0x13e74d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
imull $0x30, -0x18(%rbp), %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x13e610
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13e728
jmp 0x13e74d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
imull $0x30, -0x18(%rbp), %ecx
addl %ecx, %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x13e610
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x13e91c
jmp 0x13e9f4
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0x13e955
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x13e95e
jmp 0x13e99a
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13e93a
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x13e9f4
cmpl $0x0, -0x1c(%rbp)
je 0x13e9f4
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x20(%rcx)
cmpl $0x240, %eax            # imm = 0x240
jl 0x13e9e4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x8ef0e(%rip), %rsi     # 0x1cd8de
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x13e9f4
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x13ec40
movl $0x0, -0x20(%rbp)
movzbl -0x19(%rbp), %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jl 0x13ea5a
movzbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movq -0x18(%rbp), %rdx
movzbl 0x1(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
setge %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x13ea63
jmp 0x13ea7a
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13ea28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %esi
callq 0x13e760
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13ea9d
movl $0x0, -0x4(%rbp)
jmp 0x13ead0
movq -0x10(%rbp), %rdi
movzbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
subl %ecx, %eax
movzbl %al, %esi
callq 0x13e8f0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13eaca
movl $0x0, -0x4(%rbp)
jmp 0x13ead0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x3, -0x14(%rbp)
jle 0x13ebbf
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x13eae0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13eb3e
jmp 0x13ec2b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x13eae0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13eb67
jmp 0x13ec2b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
imull $0x30, -0x18(%rbp), %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x13eae0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13eb92
jmp 0x13ec2b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
imull $0x30, -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x13eae0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13ebbd
jmp 0x13ec2b
jmp 0x13ec2b
movq -0x8(%rbp), %rdi
leaq 0x8ed86(%rip), %rsi     # 0x1cd950
callq 0x13ea00
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13ebde
jmp 0x13ec2b
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13ebf0
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x13ec03
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x13ec16
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x13ec29
movq -0x10(%rbp), %rax
movb $0x1, 0x31(%rax)
jmp 0x13ec2b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: BigRSH
static void
BigRSH(struct xfacectx *ctx, XFACE_WORD *r)
{
	int i;
	XFACE_WORD *w;

	if (ctx->gg_B.b_words == 0)
	{
		*r = 0;
		return;
	}

	{
		i = --ctx->gg_B.b_words;
		w = ctx->gg_B.b_word;
		*r = *w;
		while (i--)
		{
			*w = *(w + 1);
			w++;
		}
		*w = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x13ec5f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x13ecbd
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rcx)
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x13ecb6
movq -0x20(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13ec8b
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/../foreign/uncompface.h
// Function: gen_helper
static void gen_helper(struct xfacectx *ctx, const u8 *arr, size_t arr_len,
	int h, int k)
{
	size_t arr_idx = 0;

	if(k<0 || h<0 || h>=(int)sizeof(ctx->gg_F)) {
		return;
	}
	arr_idx = (size_t)(k/8);
	if(arr_idx>=arr_len) {
		return;
	}
	if((arr[arr_idx]>>(7-(k%8)))&0x1) {
		ctx->gg_F[h] ^= 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x13ecf4
cmpl $0x0, -0x1c(%rbp)
jl 0x13ecf4
cmpl $0x900, -0x1c(%rbp)     # imm = 0x900
jl 0x13ecf6
jmp 0x13ed5b
movl -0x20(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x13ed13
jmp 0x13ed5b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x2c(%rbp), %eax
movl $0x7, %ecx
subl %edx, %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13ed5b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0x264(%rax,%rcx), %edx
xorl $0x1, %edx
movb %dl, 0x264(%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/xface.c
// Function: cfi_get_next_token
static int cfi_get_next_token(deark *c, struct compfacei_ctx *cfictx)
{
	int ret;

	ret = cfi_get_next_token_lowlevel(c, cfictx);
	if(!ret) return 0;

	// TODO: Make sure the format is correct.
	// Should be "0[Xx][2 or 4 hex digits]".

	// Most files have two bytes per token (0X????,0X????...), but some
	// have just one (0X??,0X??,...)
	if(cfictx->tokenbuf_strlen<=4)
		cfictx->token_numdigits = 2;
	else
		cfictx->token_numdigits = 4;

	cfictx->token_val = (unsigned int)de_strtoll((const char*)cfictx->tokenbuf, NULL, 0);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13ee60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x13ed8f
movl $0x0, -0x4(%rbp)
jmp 0x13edd5
movq -0x18(%rbp), %rax
cmpq $0x4, 0x20(%rax)
ja 0x13eda7
movq -0x18(%rbp), %rax
movl $0x2, 0x28(%rax)
jmp 0x13edb2
movq -0x18(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x18fa00
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x8, %r8d
movl $0x1, %r9d
movzbl -0x11(%rbp), %ecx
callq 0x16bce0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x30, 0x8(%rax)
jl 0x13ee58
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/xface.c
// Function: cfi_get_next_token_lowlevel
static int cfi_get_next_token_lowlevel(deark *c, struct compfacei_ctx *cfictx)
{
	int retval = 0;
	u8 ch;

	cfictx->tokenbuf_strlen = 0;

	// Read [whitespace][1 or more alphanumerics][whitespace][comma].
	// Save the alphanumerics in tokenbuf.

	ch = de_getbyte(cfictx->input_parse_pos++);

	// Skip whitespace
	// (Note that de_getbyte returns NUL bytes after the end of file,
	// and NUL doesn't count as whitespace, so this loop will definitely
	// end eventually.)
	while(cfi_is_whitespace(ch)) {
		ch = de_getbyte(cfictx->input_parse_pos++);
	}

	// Copy alphanumerics to tokenbuf
	while(cfi_is_alnum(ch)) {
		if(cfictx->tokenbuf_strlen >= CFI_TOKENBUFLEN-1) {
			goto done;
		}
		cfictx->tokenbuf[cfictx->tokenbuf_strlen++] = ch;
		ch = de_getbyte(cfictx->input_parse_pos++);
	}
	cfictx->tokenbuf[cfictx->tokenbuf_strlen] = '\0';
	if(cfictx->tokenbuf_strlen<4) {
		goto done;
	}

	// Skip whitespace
	while(cfi_is_whitespace(ch)) {
		ch = de_getbyte(cfictx->input_parse_pos++);
	}

	// Check for the terminating comma
	if(ch != ',') {
		goto done;
	}

	retval = 1;
done:
	if(!retval) {
		de_err(c, "Error parsing Compface format");
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
callq 0x165060
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %edi
callq 0x13efd0
cmpl $0x0, %eax
je 0x13eed9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
callq 0x165060
movb %al, -0x15(%rbp)
jmp 0x13eea6
jmp 0x13eedb
movzbl -0x15(%rbp), %edi
callq 0x13f020
cmpl $0x0, %eax
je 0x13ef3c
movq -0x10(%rbp), %rax
cmpq $0x1f, 0x20(%rax)
jb 0x13eef9
jmp 0x13efa1
movb -0x15(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movb %dl, 0x30(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
callq 0x165060
movb %al, -0x15(%rbp)
jmp 0x13eedb
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movb $0x0, 0x30(%rax,%rcx)
movq -0x10(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jae 0x13ef5a
jmp 0x13efa1
jmp 0x13ef5c
movzbl -0x15(%rbp), %edi
callq 0x13efd0
cmpl $0x0, %eax
je 0x13ef8f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
callq 0x165060
movb %al, -0x15(%rbp)
jmp 0x13ef5c
movzbl -0x15(%rbp), %eax
cmpl $0x2c, %eax
je 0x13ef9a
jmp 0x13efa1
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x13efb9
movq -0x8(%rbp), %rdi
leaq 0x8e960(%rip), %rsi     # 0x1cd912
movb $0x0, %al
callq 0x15bfb0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x8ebb2(%rip), %rcx     # 0x1cdc59
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x8ebac(%rip), %rcx     # 0x1cdc61
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x13f0e0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x22d(%rip), %rcx       # 0x13f300
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x19(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x9, %ecx
callq 0x164d10
leaq -0x19(%rbp), %rax
movl (%rax), %eax
subl $0x21544953, %eax       # imm = 0x21544953
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x13f345
movl $0x64, -0x4(%rbp)
jmp 0x13f38b
leaq -0x19(%rbp), %rdi
leaq 0x8ef83(%rip), %rsi     # 0x1ce2d3
movl $0x9, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x13f384
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x52, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0x5, %eax
jne 0x13f382
movl $0x64, -0x4(%rbp)
jmp 0x13f38b
jmp 0x13f384
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_oldfmt
static void do_oldfmt(deark *c, lctx *d)
{
	i64 pos = 0;

	if(!do_master_header(c, d, pos)) goto done;
	pos += 22;
	do_sequence_of_members(c, d, pos);

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13f460
cmpl $0x0, %eax
jne 0x13f3d0
jmp 0x13f3ed
movq -0x18(%rbp), %rax
addq $0x16, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13f570
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_master_header
static int do_master_header(deark *c, lctx *d, i64 pos1)
{
	i64 pos = pos1;

	de_dbg(c, "master header at %d", (int)pos1);
	de_dbg_indent(c, 1);
	pos += 4; // signature

	d->nmembers = (int)de_getu16be_p(&pos);
	de_dbg(c, "number of members: %d", d->nmembers);

	d->archive_size = de_getu32be_p(&pos);
	de_dbg(c, "reported archive file size: %"I64_FMT, d->archive_size);

	pos += 4; // expected to be "rLau"

	d->ver = de_getbyte_p(&pos);
	de_dbg(c, "version: %u", (unsigned int)d->ver);

	de_dbg_indent(c, -1);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x8e872(%rip), %rsi     # 0x1cdcff
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165210
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x72651(%rip), %rsi     # 0x1b1b2b
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1654b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x8e803(%rip), %rsi     # 0x1cdd13
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %edx
leaq 0x83136(%rip), %rsi     # 0x1c2686
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq