LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_identify_zlib
static int de_identify_zlib(deark *c)
{
	u8 b[2];
	de_read(b, 0, 2);

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

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

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

	return 50;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x12(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %ecx
callq 0x164d10
movzbl -0x12(%rbp), %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x923bb
movl $0x0, -0x4(%rbp)
jmp 0x92401
movzbl -0x12(%rbp), %eax
cmpl $0x8, %eax
jl 0x923cd
movzbl -0x12(%rbp), %eax
cmpl $0x78, %eax
jle 0x923d6
movl $0x0, -0x4(%rbp)
jmp 0x92401
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movl $0x1f, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
je 0x923fa
movl $0x0, -0x4(%rbp)
jmp 0x92401
movl $0x32, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_mrw
void de_module_mrw(deark *c, struct deark_module_info *mi)
{
	mi->id = "mrw";
	mi->desc = "Minolta RAW";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_mrw;
	mi->identify_fn = de_identify_mrw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11d89a(%rip), %rcx    # 0x1afcc1
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11d890(%rip), %rcx    # 0x1afcc5
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x10ed95(%rip), %rcx    # 0x1a11d9
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d(%rip), %rcx        # 0x92470
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4e(%rip), %rcx        # 0x924b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_vgafont
void de_module_vgafont(deark *c, struct deark_module_info *mi)
{
	mi->id = "vgafont";
	mi->desc = "Raw 8xN bitmap font";
	mi->run_fn = de_run_vgafont;
	mi->help_fn = de_help_vgafont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x110b52(%rip), %rcx    # 0x1a3069
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11d7ac(%rip), %rcx    # 0x1afcd1
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x92550
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x24d(%rip), %rcx       # 0x92790
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_fontmania
void de_module_fontmania(deark *c, struct deark_module_info *mi)
{
	mi->id = "fontmania";
	mi->desc = "Font Mania .COM format";
	mi->run_fn = de_run_fontmania;
	mi->identify_fn = de_identify_fontmania;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11d50e(%rip), %rcx    # 0x1afce5
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11d50a(%rip), %rcx    # 0x1afcef
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x92810
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1ad(%rip), %rcx       # 0x929b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_fontmania
static void de_run_fontmania(deark *c, de_module_params *mparams)
{
	struct vgafont_ctx *d = NULL;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x165280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x11f008(%rip), %rsi    # 0x1b1872
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x5, %esi
callq 0x165060
movzbl %al, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
leaq 0x11d914(%rip), %rsi    # 0x1b01b9
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x8, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x3, 0x10(%rax)
jl 0x928f4
movq -0x18(%rbp), %rax
cmpq $0x14, 0x10(%rax)
jg 0x928f4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x20(%rcx), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x928fe
movq -0x18(%rbp), %rax
movb $0x1, 0x30(%rax)
jmp 0x9296c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x15b780
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
callq 0x164d10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x948b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x949b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x94af0
cmpq $0x0, -0x18(%rbp)
je 0x9299c
movq -0x18(%rbp), %rax
cmpb $0x0, 0x30(%rax)
je 0x9298f
movq -0x8(%rbp), %rdi
leaq 0x11d842(%rip), %rsi    # 0x1b01ca
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94b30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_identify_fontmania
static int de_identify_fontmania(deark *c)
{
	if(c->infile->len>65280) return 0;
	if(de_getbyte(0) != 0xeb) return 0;
	if(dbuf_memcmp(c->infile, 8, (const u8*)"FONT MANIA, V", 13)) {
		return 0;
	}
	return 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0xff00, 0x18(%rax)     # imm = 0xFF00
jle 0x929d7
movl $0x0, -0x4(%rbp)
jmp 0x92a2e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0xeb, %eax
je 0x929fb
movl $0x0, -0x4(%rbp)
jmp 0x92a2e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x8, %esi
leaq 0x11d7de(%rip), %rdx    # 0x1b01ed
movl $0xd, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x92a27
movl $0x0, -0x4(%rbp)
jmp 0x92a2e
movl $0x64, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_pcrfont
void de_module_pcrfont(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcrfont";
	mi->desc = "PCR font";
	mi->run_fn = de_run_pcrfont;
	mi->identify_fn = de_identify_pcrfont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11d2af(%rip), %rcx    # 0x1afd06
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11d7aa(%rip), %rcx    # 0x1b020f
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x92a90
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1bd(%rip), %rcx       # 0x92c40
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_identify_pcrfont
static int de_identify_pcrfont(deark *c)
{
	u8 h;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x11d5b9(%rip), %rdx    # 0x1b0218
movl $0x3, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x92c7a
movl $0x0, -0x4(%rbp)
jmp 0x92cfa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x5, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0x20, %eax
je 0x92c9d
movl $0x0, -0x4(%rbp)
jmp 0x92cfa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x7, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x6, %eax
jl 0x92cc4
movzbl -0x11(%rbp), %eax
cmpl $0x10, %eax
jle 0x92ccd
movl $0x0, -0x4(%rbp)
jmp 0x92cfa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0xa, %esi
callq 0x165060
movzbl %al, %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x92cf3
movl $0x0, -0x4(%rbp)
jmp 0x92cfa
movl $0x50, -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/misc.c
// Function: de_module_fontedit
void de_module_fontedit(deark *c, struct deark_module_info *mi)
{
	mi->id = "fontedit";
	mi->desc = "FONTEDIT font";
	mi->run_fn = de_run_fontedit;
	mi->identify_fn = de_identify_fontedit;
	mi->help_fn = de_help_fontedit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11cfe7(%rip), %rcx    # 0x1afd0e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11d555(%rip), %rcx    # 0x1b028a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x92d70
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x38d(%rip), %rcx       # 0x930e0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x45e(%rip), %rcx       # 0x931c0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_identify_fontedit
static int de_identify_fontedit(deark *c)
{
	u8 b1;
	i64 jmp1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x2200, 0x18(%rax)     # imm = 0x2200
jg 0x93110
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x336, 0x18(%rax)      # imm = 0x336
jge 0x9311c
movl $0x0, -0x4(%rbp)
jmp 0x931b2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0xeb, %eax
je 0x93140
movl $0x0, -0x4(%rbp)
jmp 0x931b2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x32, %eax
jl 0x93167
movzbl -0x11(%rbp), %eax
cmpl $0x33, %eax
jle 0x93170
movl $0x0, -0x4(%rbp)
jmp 0x931b2
movzbl -0x11(%rbp), %eax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x27, %rsi
leaq 0x11d105(%rip), %rdx    # 0x1b0298
movl $0x5, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x931ab
movl $0x0, -0x4(%rbp)
jmp 0x931b2
movl $0x5a, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_zbr
void de_module_zbr(deark *c, struct deark_module_info *mi)
{
	mi->id = "zbr";
	mi->desc = "ZBR (Zebra Metafile)";
	mi->desc2 = "extract preview image";
	mi->run_fn = de_run_zbr;
	mi->identify_fn = de_identify_zbr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11cb10(%rip), %rcx    # 0x1afd17
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11cb06(%rip), %rcx    # 0x1afd1b
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x114eba(%rip), %rcx    # 0x1a80de
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d(%rip), %rcx        # 0x93250
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbe(%rip), %rcx        # 0x93300
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_zbr
static void de_run_zbr(deark *c, de_module_params *mparams)
{
	i64 pos = 0;
	dbuf *outf = NULL;
	static const u8 hdrs[54] = {
		0x42,0x4d,0xc6,0x14,0,0,0,0,0,0,0x76,0,0,0, // FILEHEADER
		0x28,0,0,0,0x64,0,0,0,0x64,0,0,0,0x01,0,0x04,0, // INFOHEADER...
		0,0,0,0,0x50,0x14,0,0,0,0,0,0,0,0,0,0,
		0x10,0,0,0,0,0,0,0 };

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x64, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x11d04b(%rip), %rsi    # 0x1b02e4
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
leaq 0x110898(%rip), %rsi    # 0x1a3b43
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x166c60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x11d128(%rip), %rsi    # 0x1b03f0
movl $0x36, %edx
callq 0x166170
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1490, %edx           # imm = 0x1490
callq 0x166070
movq -0x20(%rbp), %rdi
callq 0x1676a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_identify_zbr
static int de_identify_zbr(deark *c)
{
	if(!dbuf_memcmp(c->infile, 0, "\x9a\x02", 2)) {
		if(de_input_file_has_ext(c, "zbr")) return 100;
		return 25;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x11cfd9(%rip), %rdx    # 0x1b02f8
movl $0x2, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x93355
movq -0x10(%rbp), %rdi
leaq 0x11c9de(%rip), %rsi    # 0x1afd17
callq 0x15d180
cmpl $0x0, %eax
je 0x9334c
movl $0x64, -0x4(%rbp)
jmp 0x9335c
movl $0x19, -0x4(%rbp)
jmp 0x9335c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_compress
void de_module_compress(deark *c, struct deark_module_info *mi)
{
	mi->id = "compress";
	mi->desc = "Compress (.Z)";
	mi->run_fn = de_run_compress;
	mi->identify_fn = de_identify_compress;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11e5d3(%rip), %rcx    # 0x1b195a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11c99b(%rip), %rcx    # 0x1afd30
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x933c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x15d(%rip), %rcx       # 0x93510
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_compress
static void de_run_compress(deark *c, de_module_params *mparams)
{
	struct de_dfilter_results dres;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_lzw_params delzwp;
	dbuf *f = NULL;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12de1e(%rip), %rsi    # 0x1c1207
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0xa0(%rbp)
leaq -0xbc(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x19140
movl $0x1, -0xbc(%rbp)
movl -0xb8(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0xbc(%rbp), %r8
callq 0x1843b0
movq -0xc8(%rbp), %rdi
callq 0x167c30
cmpl $0x0, -0x70(%rbp)
je 0x934f1
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x177360
movq -0xd0(%rbp), %rdi
movq %rax, %rdx
leaq 0x10d645(%rip), %rsi    # 0x1a0b2f
movb $0x0, %al
callq 0x15bfb0
movq -0xc8(%rbp), %rdi
callq 0x1676a0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_hpi
void de_module_hpi(deark *c, struct deark_module_info *mi)
{
	mi->id = "hpi";
	mi->desc = "Hemera Photo-Object image";
	mi->run_fn = de_run_hpi;
	mi->identify_fn = de_identify_hpi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11c7c7(%rip), %rcx    # 0x1afd3e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11c7bd(%rip), %rcx    # 0x1afd42
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x935b0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x18d(%rip), %rcx       # 0x93730
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_hpi
static void de_run_hpi(deark *c, de_module_params *mparams)
{
	i64 jpgpos, pngpos;
	i64 jpglen, pnglen;
	i64 pos;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0xc, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165580
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x11ccf9(%rip), %rsi    # 0x1b02fe
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165580
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165580
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x11cccc(%rip), %rsi    # 0x1b0315
movb $0x0, %al
callq 0x15b0d0
cmpq $0x0, -0x28(%rbp)
jle 0x936c8
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jg 0x936c8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0xff, %eax
jne 0x936c8
cmpq $0x0, -0x30(%rbp)
jne 0x9369c
leaq 0x12bc63(%rip), %rax    # 0x1bf2f9
movq %rax, -0x40(%rbp)
jmp 0x936a7
leaq 0x11cc88(%rip), %rax    # 0x1b032b
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x166be0
cmpq $0x0, -0x30(%rbp)
jle 0x93724
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jg 0x93724
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0x89, %eax
jne 0x93724
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0x11cc23(%rip), %rcx    # 0x1b033a
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x166be0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_dclimplode
void de_module_dclimplode(deark *c, struct deark_module_info *mi)
{
	mi->id = "dclimplode";
	mi->id_alias[0] = "ttcomp";
	mi->desc = "PKWARE DCL Implode compressed file";
	mi->run_fn = de_run_dclimplode;
	mi->identify_fn = de_identify_dclimplode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11c5c5(%rip), %rcx    # 0x1afd5c
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11c5c2(%rip), %rcx    # 0x1afd67
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0x11c5ba(%rip), %rcx    # 0x1afd6e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d(%rip), %rcx        # 0x937e0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4e(%rip), %rcx        # 0x93820
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_identify_dclimplode
static int de_identify_dclimplode(deark *c)
{
	u8 b0, b1;
	int i;
	u32 x;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x4, 0x18(%rax)
jge 0x93847
movl $0x0, -0x4(%rbp)
jmp 0x9391a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jle 0x93870
movl $0x0, -0x4(%rbp)
jmp 0x9391a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x165060
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x4, %eax
jl 0x93897
movzbl -0x12(%rbp), %eax
cmpl $0x6, %eax
jle 0x938a0
movl $0x0, -0x4(%rbp)
jmp 0x9391a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rsi
subq $0x4, %rsi
callq 0x165540
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x93913
movl -0x1c(%rbp), %eax
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
cmpl $0x1fe0200, %eax        # imm = 0x1FE0200
jne 0x93900
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x938f7
movzbl -0x12(%rbp), %eax
cmpl $0x6, %eax
jne 0x938f7
movl $0x28, -0x4(%rbp)
jmp 0x9391a
movl $0xa, -0x4(%rbp)
jmp 0x9391a
movl -0x1c(%rbp), %eax
shrl %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x938c7
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/misc.c
// Function: de_module_lgcompress
void de_module_lgcompress(deark *c, struct deark_module_info *mi)
{
	mi->id = "lgcompress";
	mi->desc = "Logitech Compress";
	mi->run_fn = de_run_lgcompress;
	mi->identify_fn = de_identify_lgcompress;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11c44a(%rip), %rcx    # 0x1afd91
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11c447(%rip), %rcx    # 0x1afd9c
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x93980
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbd(%rip), %rcx        # 0x93a30
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_lgcompress
static void de_run_lgcompress(deark *c, de_module_params *mparams)
{
	u8 mfnc;
	i64 orig_len;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x33, %eax
jl 0x939cd
movzbl -0x11(%rbp), %eax
cmpl $0x7e, %eax
jg 0x939cd
movq -0x8(%rbp), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x11c986(%rip), %rsi    # 0x1b034c
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x165540
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x10d5a5(%rip), %rsi    # 0x1a0f97
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
subq $0x8, %rdx
movq -0x20(%rbp), %r8
movl $0x8, %esi
movl $0x1, %ecx
callq 0x94ba0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_lzss_oku
static void de_run_lzss_oku(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;

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

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

	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x145574(%rip), %rsi    # 0x1d906a
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
xorl %r8d, %r8d
callq 0x178990
movq -0x18(%rbp), %rdi
callq 0x167c30
cmpl $0x0, -0xb0(%rbp)
je 0x93bb2
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x177360
movq -0xb8(%rbp), %rdi
movq %rax, %rdx
leaq 0x10c452(%rip), %rsi    # 0x19fffd
movb $0x0, %al
callq 0x15bfb0
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_lzhuf
static void de_run_lzhuf(deark *c, de_module_params *mparams)
{
	i64 unc_filesize;
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;

	// We're assuming the size field is 4 bytes, little-endian. (But it could
	// be platform-specific.)
#define LZHUF_HDRSIZE 4
#define LZHUF_IS_LE   1

	if(c->infile->len<LZHUF_HDRSIZE) goto done;
	unc_filesize = dbuf_getint_ext(c->infile, 0, LZHUF_HDRSIZE, LZHUF_IS_LE, 0);
	de_dbg(c, "orig filesize: %"I64_FMT, unc_filesize);

	outf = dbuf_create_output_file(c, "unc", NULL, 0);
	dbuf_enable_wbuffer(outf);
	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = LZHUF_HDRSIZE;
	dcmpri.len = c->infile->len-LZHUF_HDRSIZE;
	dcmpro.f = outf;
	dcmpro.len_known = 1;
	dcmpro.expected_len = unc_filesize;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x4, 0x18(%rax)
jge 0x93c3f
jmp 0x93d52
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x165a80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x11c6f8(%rip), %rsi    # 0x1b0368
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
leaq 0x1453e8(%rip), %rsi    # 0x1d906a
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x4, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x1, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18b940
movq -0x20(%rbp), %rdi
callq 0x167c30
cmpl $0x0, -0xb8(%rbp)
je 0x93d50
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x177360
movq -0xc0(%rbp), %rdi
movq %rax, %rdx
leaq 0x10c2b4(%rip), %rsi    # 0x19fffd
movb $0x0, %al
callq 0x15bfb0
jmp 0x93d52
movq -0x20(%rbp), %rdi
callq 0x1676a0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_compress_lzh
void de_module_compress_lzh(deark *c, struct deark_module_info *mi)
{
	mi->id = "compress_lzh";
	mi->desc = "SCO compress LZH";
	mi->run_fn = de_run_compress_lzh;
	mi->identify_fn = de_identify_compress_lzh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11c067(%rip), %rcx    # 0x1afdee
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11c066(%rip), %rcx    # 0x1afdfb
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x93dc0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x14d(%rip), %rcx       # 0x93f00
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_compress_lzh
static void de_run_compress_lzh(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	struct de_lh5x_params lzhparams;

#define SCOLZH_HDRSIZE 2
	if(c->infile->len<SCOLZH_HDRSIZE) goto done;
	outf = dbuf_create_output_file(c, "unc", NULL, 0);
	dbuf_enable_wbuffer(outf);
	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = SCOLZH_HDRSIZE;
	dcmpri.len = c->infile->len-SCOLZH_HDRSIZE;
	dcmpro.f = outf;

	de_zeromem(&lzhparams, sizeof(struct de_lh5x_params));
	lzhparams.fmt = DE_LH5X_FMT_LH5;
	lzhparams.zero_codes_block_behavior = DE_LH5X_ZCB_STOP;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x2, 0x18(%rax)
jge 0x93def
jmp 0x93ee4
movq -0x8(%rbp), %rdi
leaq 0x145270(%rip), %rsi    # 0x1d906a
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x2, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movl $0x5, -0xc0(%rbp)
movb $0x1, -0xbc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
leaq -0xc0(%rbp), %r8
callq 0x17ecb0
movq -0x18(%rbp), %rdi
callq 0x167c30
cmpl $0x0, -0xb0(%rbp)
je 0x93ee2
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x177360
movq -0xc8(%rbp), %rdi
movq %rax, %rdx
leaq 0x10c122(%rip), %rsi    # 0x19fffd
movb $0x0, %al
callq 0x15bfb0
jmp 0x93ee4
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_npack
void de_module_npack(deark *c, struct deark_module_info *mi)
{
	mi->id = "npack";
	mi->desc = "NPack compressed file";
	mi->run_fn = de_run_npack;
	mi->identify_fn = de_identify_npack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11be3b(%rip), %rcx    # 0x1afe32
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11be33(%rip), %rcx    # 0x1afe38
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x94030
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4d(%rip), %rcx        # 0x94070
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_lzs221
void de_module_lzs221(deark *c, struct deark_module_info *mi)
{
	mi->id = "lzs221";
	mi->desc = "LZS221 compressed file";
	mi->run_fn = de_run_lzs221;
	mi->identify_fn = de_identify_lzs221;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11bd77(%rip), %rcx    # 0x1afe4e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11bd70(%rip), %rcx    # 0x1afe55
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x94110
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4d(%rip), %rcx        # 0x94150
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_xpk
void de_module_xpk(deark *c, struct deark_module_info *mi)
{
	mi->id = "xpk";
	mi->desc = "XPK compressed file";
	mi->run_fn = de_run_xpk;
	mi->identify_fn = de_identify_xpk;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11bcb5(%rip), %rcx    # 0x1afe6c
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11bcab(%rip), %rcx    # 0x1afe70
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x94200
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x3d(%rip), %rcx        # 0x94220
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: do_split_onechunk
static void do_split_onechunk(deark *c, i64 chunknum, i64 offset, i64 size)
{
	dbuf *outf = NULL;
	char ext[32];

	de_snprintf(ext, sizeof(ext), "part%"I64_FMT, chunknum);
	outf = dbuf_create_output_file(c, ext, NULL, 0);
	dbuf_copy(c->infile, offset, size, outf);
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
leaq 0x11bca1(%rip), %rdx    # 0x1aff35
movb $0x0, %al
callq 0x15a980
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x166070
movq -0x28(%rbp), %rdi
callq 0x1676a0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: xor_cbfn
static int xor_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	i64 i;
	struct xorctx_struct *xorctx = (struct xorctx_struct*)brctx->userdata;

	for(i=0; i<buf_len; i++) {
		dbuf_writebyte(xorctx->outf, buf[i] ^ xorctx->key[xorctx->key_pos]);
		if(xorctx->key_len>1) {
			xorctx->key_pos = (xorctx->key_pos+1) % xorctx->key_len;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x94372
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl 0xc(%rdx), %edx
movzbl 0x10(%rcx,%rdx), %ecx
xorl %ecx, %eax
movzbl %al, %esi
callq 0x168380
movq -0x28(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jbe 0x94362
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movq -0x28(%rbp), %rax
movl %edx, 0xc(%rax)
jmp 0x94364
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x94307
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: get_bom_enc
static de_encoding get_bom_enc(deark *c, UI *blen)
{
	u8 buf[3];

	de_read(buf, 0, 3);
	if(buf[0]==0xef && buf[1]==0xbb && buf[2]==0xbf) {
		*blen = 3;
		return DE_ENCODING_UTF8;
	}
	else if(buf[0]==0xfe && buf[1]==0xff) {
		*blen = 2;
		return DE_ENCODING_UTF16BE;
	}
	else if(buf[0]==0xff && buf[1]==0xfe) {
		*blen = 2;
		return DE_ENCODING_UTF16LE;
	}
	*blen = 0;
	return DE_ENCODING_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x1b(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x3, %ecx
callq 0x164d10
movzbl -0x1b(%rbp), %eax
cmpl $0xef, %eax
jne 0x943de
movzbl -0x1a(%rbp), %eax
cmpl $0xbb, %eax
jne 0x943de
movzbl -0x19(%rbp), %eax
cmpl $0xbf, %eax
jne 0x943de
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x94445
movzbl -0x1b(%rbp), %eax
cmpl $0xfe, %eax
jne 0x94407
movzbl -0x1a(%rbp), %eax
cmpl $0xff, %eax
jne 0x94407
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x94445
movzbl -0x1b(%rbp), %eax
cmpl $0xff, %eax
jne 0x94430
movzbl -0x1a(%rbp), %eax
cmpl $0xfe, %eax
jne 0x94430
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x94445
jmp 0x94432
jmp 0x94434
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: cp437_cbfn
static int cp437_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	i32 u;
	i64 i;
	u8 ch;
	struct cp437ctx_struct *cp437ctx = (struct cp437ctx_struct*)brctx->userdata;

	for(i=0; i<buf_len; i++) {
		ch = buf[i];
		if(ch==0x09 || ch==0x0a || ch==0x0c || ch==0x0d) {
			// Leave HT, NL, FF, CR as-is.
			u = (i32)ch;
		}
		else if(ch==0x1a) {
			// Lots of CP437 files end with a Ctrl+Z character, but modern files
			// don't use any in-band character to signify end-of-file.
			// I don't just want to delete the character, though, so I guess I'll
			// change it to U+2404 SYMBOL FOR END OF TRANSMISSION.
			u = 0x2404;
		}
		else {
			u = de_char_to_unicode_ex((i32)ch, &cp437ctx->es);
		}
		dbuf_write_uchar_as_utf8(cp437ctx->outf, u);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x94508
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x9, %eax
je 0x944b7
movzbl -0x29(%rbp), %eax
cmpl $0xa, %eax
je 0x944b7
movzbl -0x29(%rbp), %eax
cmpl $0xc, %eax
je 0x944b7
movzbl -0x29(%rbp), %eax
cmpl $0xd, %eax
jne 0x944c0
movzbl -0x29(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x944e8
movzbl -0x29(%rbp), %eax
cmpl $0x1a, %eax
jne 0x944d2
movl $0x2404, -0x1c(%rbp)    # imm = 0x2404
jmp 0x944e6
movzbl -0x29(%rbp), %edi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x160a30
movl %eax, -0x1c(%rbp)
jmp 0x944e8
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x160cc0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x94477
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: crc_cbfn
static int crc_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	struct crcctx_struct *crcctx = (struct crcctx_struct*)brctx->userdata;
	size_t n;

	for(n=0; n<CRCM_NUMCRCS; n++) {
		if(!crcctx->crcos[n]) continue;
		de_crcobj_addbuf(crcctx->crcos[n], buf, buf_len);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0xb, -0x28(%rbp)
jae 0x94588
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
jne 0x94560
jmp 0x9457a
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15f430
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x94547
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: bytefreq_cbfn
static int bytefreq_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	i64 k;
	struct bytefreqctx_struct *bfctx = (struct bytefreqctx_struct*)brctx->userdata;

	for(k=0; k<buf_len; k++) {
		struct bytefreqentry *bf = &bfctx->e[(unsigned int)buf[k]];

		// Save the location of the first few occurrences of this byte value.
		if(bf->count<DE_BYTEFREQ_NUMLOC) {
			bf->locations[bf->count] = brctx->offset + k;
		}
		bf->count++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x9467c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x3, (%rax)
jge 0x94660
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
addq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x94613
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: run_deflate_internal
static void run_deflate_internal(deark *c, UI flags)
{
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	struct de_deflate_params deflparams;

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	de_zeromem(&deflparams, sizeof(struct de_deflate_params));
	deflparams.flags = flags;

	outf = dbuf_create_output_file(c, "unc", NULL, 0);
	dbuf_enable_wbuffer(outf);
	dcmpri.f = c->infile;
	dcmpri.pos = 0;
	dcmpri.len = c->infile->len;
	dcmpro.f = outf;
	fmtutil_decompress_deflate_ex(c, &dcmpri, &dcmpro, &dres, &deflparams);
	dbuf_flush(outf);
	if(dres.errcode) {
		de_err(c, "Decompression failed: %s", de_dfilter_get_errmsg(c, &dres));
		goto done;
	}
	if(dres.bytes_consumed_valid) {
		de_dbg(c, "decompressed %"I64_FMT" bytes to %"I64_FMT, dres.bytes_consumed,
			outf->len);
	}

done:
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x1773f0
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movl -0xc(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x144981(%rip), %rsi    # 0x1d906a
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
leaq -0xc0(%rbp), %r8
callq 0x17f4b0
movq -0x18(%rbp), %rdi
callq 0x167c30
cmpl $0x0, -0xb0(%rbp)
je 0x94793
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x177360
movq -0xc8(%rbp), %rdi
movq %rax, %rdx
leaq 0x10b873(%rip), %rsi    # 0x19fffd
movb $0x0, %al
callq 0x15bfb0
jmp 0x947bf
cmpb $0x0, -0xac(%rbp)
je 0x947bd
movq -0x8(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x10a58d(%rip), %rsi    # 0x19ed43
movb $0x0, %al
callq 0x15b0d0
jmp 0x947bf
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)