LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_ne_header_flags
static void do_ne_header_flags(deark *c, lctx *d)
{
	de_ucstring *s = NULL;
	UI flags = d->ne_header_flags;
	UI n;

	s = ucstring_create(c);

	// TODO: Need better information about these flags.
	// (And do they depend on other fields, such as target_os?)

	n = flags & 0x0003;
	ucstring_append_flags_itemf(s, "dgroup=%u", n);
	flags -= n;

	if(flags & 0x0004) {
		ucstring_append_flags_item(s, "real mode");
		flags -= 0x0004;
	}
	if(flags & 0x0008) {
		ucstring_append_flags_item(s, "protected mode");
		flags -= 0x0008;
	}

	if(flags & 0x8000) {
		ucstring_append_flags_item(s, "DLL");
		flags -= 0x8000;
	}

	if(flags) {
		ucstring_append_flags_itemf(s, "0x%04x", flags);
	}

	de_dbg(c, "NE header flags: 0x%04x (%s)", d->ne_header_flags,
		ucstring_getpsz(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq 0x147079(%rip), %rsi    # 0x1a8adf
movb $0x0, %al
callq 0x1726d0
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x61a9c
movq -0x18(%rbp), %rdi
leaq 0x14705b(%rip), %rsi    # 0x1a8ae9
callq 0x172680
movl -0x1c(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x61ac0
movq -0x18(%rbp), %rdi
leaq 0x147041(%rip), %rsi    # 0x1a8af3
callq 0x172680
movl -0x1c(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x61ae8
movq -0x18(%rbp), %rdi
leaq 0x146d29(%rip), %rsi    # 0x1a8801
callq 0x172680
movl -0x1c(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x61b03
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x14fde6(%rip), %rsi    # 0x1b18e2
movb $0x0, %al
callq 0x1726d0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x172500
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movq %rax, %rcx
leaq 0x146fd3(%rip), %rsi    # 0x1a8b02
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: try_execomp_decompress
static void try_execomp_decompress(deark *c, lctx *d, struct fmtutil_specialexe_detection_data *edd)
{
	if(edd->detected_fmt==0) return;
	if(!edd->modname) {
		de_info(c, "Note: File seems to be compressed with %s, but that's "
			"not a supported format.", edd->detected_fmt_name);
		return;
	}

	de_dbg(c, "attempting %s decompression", edd->modname);
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, edd->modname, NULL, c->infile, 0, c->infile->len);
	de_dbg_indent(c, -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
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x61b76
jmp 0x61c00
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x61b9d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
leaq 0x147103(%rip), %rsi    # 0x1a8c97
movb $0x0, %al
callq 0x15c0c0
jmp 0x61c00
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x147135(%rip), %rsi    # 0x1a8ce5
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r9
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_pe_resource_section
static void do_pe_resource_section(deark *c, lctx *d, i64 pos, i64 len)
{
	if(d->rsrc_errflag) return;
	d->pe_cur_base_addr = pos;
	d->rsrc_item_count = 0;
	do_pe_resource_dir_table(c, d, 0, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x61de4
jmp 0x61e18
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x118(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x61e20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_pe_resource_dir_table
static void do_pe_resource_dir_table(deark *c, lctx *d, i64 rel_pos, int level)
{
	i64 named_node_count;
	i64 unnamed_node_count;
	i64 node_count;
	i64 i;

	// 16-byte "Resource node header" a.k.a "Resource directory table"

	if(d->rsrc_errflag) goto done;

	if(level>3) {
		de_warn(c, "Resource tree too deep");
		goto done;
	}

	de_dbg(c, "resource directory table at %"I64_FMT"(%"I64_FMT"), level=%d",
		(i64)(d->pe_cur_base_addr+rel_pos), rel_pos, level);

	named_node_count = de_getu16le(d->pe_cur_base_addr+rel_pos+12);
	unnamed_node_count = de_getu16le(d->pe_cur_base_addr+rel_pos+14);
	de_dbg(c, "number of node entries: named=%u, unnamed=%u", (UI)named_node_count,
		(UI)unnamed_node_count);

	node_count = named_node_count + unnamed_node_count;

	// An array of 8-byte "Resource node entries" follows the Resource node header.
	for(i=0; i<node_count; i++) {
		if(d->rsrc_errflag) goto done;
		do_pe_resource_node(c, d, rel_pos+16+8*i, level);
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x61e46
jmp 0x61f4f
cmpl $0x3, -0x1c(%rbp)
jle 0x61e63
movq -0x8(%rbp), %rdi
leaq 0x146f1f(%rip), %rsi    # 0x1a8d76
movb $0x0, %al
callq 0x15bc10
jmp 0x61f4f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rdx
addq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
leaq 0x146f08(%rip), %rsi    # 0x1a8d8d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rsi
addq -0x18(%rbp), %rsi
addq $0xc, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rsi
addq -0x18(%rbp), %rsi
addq $0xe, %rsi
callq 0x165280
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x30(%rbp), %rax
movl %eax, %ecx
leaq 0x146ed1(%rip), %rsi    # 0x1a8dbc
movb $0x0, %al
callq 0x15b0d0
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x61f4d
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x61f1c
jmp 0x61f4f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
movq -0x40(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movl -0x1c(%rbp), %ecx
callq 0x61f60
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x61f06
jmp 0x61f4f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: get_rsrc_type_info
static const struct rsrc_type_info_struct *get_rsrc_type_info(u32 id)
{
	size_t i;

	for(i=0; i<DE_ARRAYCOUNT(rsrc_type_info_arr); i++) {
		if(id == rsrc_type_info_arr[i].id) {
			return &rsrc_type_info_arr[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x11, -0x18(%rbp)
jae 0x622a1
movl -0xc(%rbp), %eax
leaq 0x1b56d0(%rip), %rcx    # 0x217940
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x62291
leaq 0x1b56bd(%rip), %rax    # 0x217940
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x622a9
jmp 0x62293
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6225f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: ne_pe_resource_type_is_supported
static int ne_pe_resource_type_is_supported(deark *c, lctx *d, u32 type_id)
{
	switch(type_id) {
	case DE_RT_CURSOR:
	case DE_RT_BITMAP:
	case DE_RT_ICON:
	case DE_RT_FONT:
	case DE_RT_MANIFEST:
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
decl %eax
subl $0x3, %eax
jb 0x622e2
jmp 0x622ce
movl -0x20(%rbp), %eax
subl $0x8, %eax
je 0x622e2
jmp 0x622d8
movl -0x20(%rbp), %eax
subl $0x18, %eax
jne 0x622eb
jmp 0x622e2
movl $0x1, -0x4(%rbp)
jmp 0x622f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_extract_CURSOR
static void do_extract_CURSOR(deark *c, lctx *d, i64 pos, i64 len, de_finfo *fi)
{
	UI firstword;
	i64 hotspot_x, hotspot_y;

	if(len<8) return;
	firstword = (UI)de_getu16le(pos);

	// For Win3 icons, the first word is the x hotspot.
	// For Win1 icons, it is one of the type codes below.
	if(d->fmt==EXE_FMT_NE && (firstword==0x0003 || firstword==0x0103 ||
		firstword==0x0203))
	{
		UI fourthword;
		// For Win3 icons, the 4th word is the high word of the
		// bitmap-info-header-size (definitely 0).
		// For Win1 icons, it is the width (definitely not 0).
		fourthword = (UI)de_getu16le(pos+6);
		if(fourthword!=0) {
			dbuf_create_file_from_slice(c->infile, pos, len, "win1.cur", fi, 0);
			return;
		}
	}

	hotspot_x = (i64)firstword;
	hotspot_y = de_getu16le(pos+2);
	de_dbg(c, "hotspot: %d,%d", (int)hotspot_x, (int)hotspot_y);
	do_extract_ico_cur(c, d, pos+4, len-4, 1, hotspot_x, hotspot_y, fi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x8, -0x20(%rbp)
jge 0x624f8
jmp 0x625eb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165280
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x62575
cmpl $0x3, -0x2c(%rbp)
je 0x62530
cmpl $0x103, -0x2c(%rbp)     # imm = 0x103
je 0x62530
cmpl $0x203, -0x2c(%rbp)     # imm = 0x203
jne 0x62575
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0x165280
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x62573
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq 0x1469d6(%rip), %rcx    # 0x1a8f3f
xorl %r9d, %r9d
callq 0x166be0
jmp 0x625eb
jmp 0x62575
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x165280
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
movq -0x40(%rbp), %rax
movl %eax, %ecx
leaq 0x14699c(%rip), %rsi    # 0x1a8f48
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x4, %rdx
movq -0x20(%rbp), %rcx
subq $0x4, %rcx
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq -0x28(%rbp), %rax
movl $0x1, %r8d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x62890
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_extract_BITMAP
static void do_extract_BITMAP(deark *c, lctx *d, i64 pos, i64 len, de_finfo *fi)
{
	if(len<12) return;

	if((d->fmt==EXE_FMT_NE) && (de_getbyte(pos)==0x02)) {
		do_decode_ddb(c, d, pos, len, fi);
		return;
	}

	de_dbg(c, "BITMAP at %"I64_FMT, pos);
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, "dib", "X", c->infile, pos, len);
	de_dbg_indent(c, -1);
}

// 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 %r8, -0x28(%rbp)
cmpq $0xc, -0x20(%rbp)
jge 0x62628
jmp 0x626c1
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x62668
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x62668
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x62ab0
jmp 0x626c1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1468e0(%rip), %rsi    # 0x1a8f57
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x14c74c(%rip), %rsi    # 0x1aedf3
leaq 0x16cec1(%rip), %rdx    # 0x1cf56f
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_extract_ICON
static void do_extract_ICON(deark *c, lctx *d, i64 pos, i64 len, de_finfo *fi)
{
	if(d->fmt==EXE_FMT_NE && len>14) {
		UI firstword;

		firstword = (UI)de_getu16le(pos);
		// For Win3 icons, the first word is the low word of bitmap-info-header-size
		// (usually 40, definitely not one of the Win1 type codes).
		// For Win1 icons, it is one of the type codes below.
		if(firstword==0x0001 || firstword==0x0101 || firstword==0x0201) {
			dbuf_create_file_from_slice(c->infile, pos, len, "win1.ico", fi, 0);
			return;
		}
	}

	do_extract_ico_cur(c, d, pos, len, 0, 0, 0, fi);
}

// 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 %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x62752
cmpq $0xe, -0x20(%rbp)
jle 0x62752
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165280
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
je 0x6272b
cmpl $0x101, -0x2c(%rbp)     # imm = 0x101
je 0x6272b
cmpl $0x201, -0x2c(%rbp)     # imm = 0x201
jne 0x62750
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq 0x14682f(%rip), %rcx    # 0x1a8f75
xorl %r9d, %r9d
callq 0x166be0
jmp 0x6277e
jmp 0x62752
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x62890
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_extract_FONT
static void do_extract_FONT(deark *c, lctx *d, i64 pos, i64 len, de_finfo *fi)
{
	i64 fntlen;

	if(len<6) return;
	// The "file size" is stored at offset 2. Respect it if possible.
	fntlen = de_getu32le(pos+2);
	if(fntlen<6 || fntlen>len) {
		fntlen = len;
	}

	get_font_facename(c, d, pos, fntlen, fi);

	dbuf_create_file_from_slice(c->infile, pos, fntlen, "fnt", fi, 0);
}

// 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 %r8, -0x28(%rbp)
cmpq $0x6, -0x20(%rbp)
jge 0x627b5
jmp 0x62823
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x165540
movq %rax, -0x30(%rbp)
cmpq $0x6, -0x30(%rbp)
jl 0x627df
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x627e7
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x62b60
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq 0x146763(%rip), %rcx    # 0x1a8f7e
xorl %r9d, %r9d
callq 0x166be0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_decode_ddb
static void do_decode_ddb(deark *c, lctx *d, i64 pos1, i64 len, de_finfo *fi)
{
	de_module_params *mparams = NULL;

	de_dbg(c, "BITMAP16 at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.fi = fi;
	de_run_module_by_id_on_slice(c, "ddb", mparams, c->infile, pos1, len);
	de_dbg_indent(c, -1);
	de_free(c, mparams);
}

// 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 %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x146482(%rip), %rsi    # 0x1a8f65
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x14c27c(%rip), %rsi    # 0x1aedb1
callq 0x15c9f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: get_font_facename
static void get_font_facename(deark *c, lctx *d, i64 pos, i64 len, de_finfo *fi)
{
	UI fnt_version;
	UI dfPoints;
	i64 dfFace;
	de_ucstring *s = NULL;

	if(!fi) goto done;
	if(len<109) goto done;
	fnt_version = (UI)de_getu16le(pos);
	if(fnt_version < 0x0200) goto done;
	dfPoints = (UI)de_getu16le(pos+68);
	dfFace = de_getu32le(pos+105);
	if(dfFace>=len) goto done;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos+dfFace, 64, len-dfFace, s,
		DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_ASCII);
	if(s->len<1) goto done;
	ucstring_printf(s, DE_ENCODING_LATIN1, "-%u", dfPoints);
	de_finfo_set_name_from_ucstring(c, fi, s, 0);

done:
	ucstring_destroy(s);
}

// 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 %r8, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x62b90
jmp 0x62c75
cmpq $0x6d, -0x20(%rbp)
jge 0x62b9c
jmp 0x62c75
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165280
movl %eax, -0x2c(%rbp)
cmpl $0x200, -0x2c(%rbp)     # imm = 0x200
jae 0x62bbe
jmp 0x62c75
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x44, %rsi
callq 0x165280
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x69, %rsi
callq 0x165540
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x62bfb
jmp 0x62c75
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rcx
subq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x40, %edx
movl $0x1, %r9d
movl $0x1, (%rsp)
callq 0x166a40
movq -0x40(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jge 0x62c48
jmp 0x62c75
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %ecx
movl $0x5, %esi
leaq 0x146327(%rip), %rdx    # 0x1a8f82
movb $0x0, %al
callq 0x171660
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %ecx, %ecx
callq 0x15d2c0
movq -0x40(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: de_finfo_set_name_from_pe_string
static void de_finfo_set_name_from_pe_string(deark *c, de_finfo *fi, dbuf *f,
	i64 pos)
{
	i64 nlen; // in UTF-16 code units (2 bytes each)
	de_ucstring *fname = NULL;

	if(!c->filenames_from_file) goto done;

	// The string length is stored in a two-byte prefix.
	nlen = de_getu16le(pos);
	if(nlen<1) goto done;

	fname = ucstring_create(c);
	dbuf_read_to_ucstring(c->infile, pos+2, nlen*2, fname, 0, DE_ENCODING_UTF16LE);
	de_finfo_set_name_from_ucstring(c, fi, fname, 0);

done:
	ucstring_destroy(fname);
}

// 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 $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0xd0(%rax)
jne 0x62cbf
jmp 0x62d26
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jge 0x62cdd
jmp 0x62d26
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x2, %rsi
movq -0x28(%rbp), %rdx
shlq %rdx
movq -0x30(%rbp), %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0x1669f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x15d2c0
movq -0x30(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: do_ne_pe_extract_resource
static void do_ne_pe_extract_resource(deark *c, lctx *d,
	u32 type_id, const struct rsrc_type_info_struct *rsrci,
	i64 pos, i64 len, de_finfo *fi)
{
	if(!d->extract_std_resources) return;
	if(len<1 || len>DE_MAX_SANE_OBJECT_SIZE) return;

	if(rsrci && rsrci->decoder_fn) {
		rsrci->decoder_fn(c, d, pos, len, fi);
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x4(%rax)
jne 0x62d6f
jmp 0x62db2
cmpq $0x1, -0x30(%rbp)
jl 0x62d80
cmpq $0x5f5e100, -0x30(%rbp) # imm = 0x5F5E100
jle 0x62d82
jmp 0x62db2
cmpq $0x0, -0x20(%rbp)
je 0x62db2
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x62db2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: identify_lx_rsrc
static const char *identify_lx_rsrc(deark *c, lctx *d, i64 pos, i64 len)
{
	u8 buf[2];
	int is_ba = 0;

	if(len<16) return NULL;
	de_read(buf, pos, 2);
	if(!de_memcmp(buf, "BA", 2)) {
		// Bitmap Array container format. Read the real type.
		de_read(buf, pos+14, 2);
		is_ba = 1;
	}

	if(!de_memcmp(buf, "BM", 2)) {
		return is_ba ? "ba.bmp" : "bmp";
	}
	if(!de_memcmp(buf, "CI", 2) || !de_memcmp(buf, "IC", 2)) {
		return is_ba ? "ba.os2.ico" : "os2.ico";
	}
	if(!de_memcmp(buf, "CP", 2) || !de_memcmp(buf, "PT", 2)) {
		return is_ba ? "ba.ptr" : "ptr";
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
cmpq $0x10, -0x28(%rbp)
jge 0x633f3
movq $0x0, -0x8(%rbp)
jmp 0x6351b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x2a(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %ecx
callq 0x164d10
leaq -0x2a(%rbp), %rax
movw (%rax), %ax
subw $0x4142, %ax            # imm = 0x4142
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x63448
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x2a(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0xe, %rdx
movl $0x2, %ecx
callq 0x164d10
movl $0x1, -0x30(%rbp)
leaq -0x2a(%rbp), %rax
movw (%rax), %ax
subw $0x4d42, %ax            # imm = 0x4D42
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6347f
movl -0x30(%rbp), %edx
leaq 0x14989f(%rip), %rax    # 0x1acd07
leaq 0x145e55(%rip), %rcx    # 0x1a92c4
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6351b
leaq -0x2a(%rbp), %rax
movw (%rax), %ax
subw $0x4943, %ax            # imm = 0x4943
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x634ab
leaq -0x2a(%rbp), %rax
movw (%rax), %ax
subw $0x4349, %ax            # imm = 0x4349
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x634c9
movl -0x30(%rbp), %edx
leaq 0x145e1c(%rip), %rax    # 0x1a92d1
leaq 0x145e12(%rip), %rcx    # 0x1a92ce
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6351b
leaq -0x2a(%rbp), %rax
movw (%rax), %ax
subw $0x5043, %ax            # imm = 0x5043
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x634f5
leaq -0x2a(%rbp), %rax
movw (%rax), %ax
subw $0x5450, %ax            # imm = 0x5450
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x63513
movl -0x30(%rbp), %edx
leaq 0x145ddd(%rip), %rax    # 0x1a92dc
leaq 0x145dd3(%rip), %rcx    # 0x1a92d9
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6351b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: extract_zip_from_sfx
static void extract_zip_from_sfx(deark *c, lctx *d,
	struct fmtutil_specialexe_detection_data *edd)
{
	de_module_params *mparams = NULL;

	if(!d->ei) return;
	de_dbg(c, "attempting zip extraction");
	de_dbg_indent(c, 1);

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.codes = "R";
	mparams->in_params.obj1 = (void*)edd;

	de_run_module_by_id_on_slice(c, "zip", mparams, d->ei->f, 0, d->ei->f->len);

	if(!(mparams->out_params.flags & 0x1)) {
		de_warn(c, "This look like a self-extracting ZIP file, but an attempt to "
			"extract the plain ZIP file failed.");
	}
	de_free(c, mparams);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6355c
jmp 0x63617
movq -0x8(%rbp), %rdi
leaq 0x145eb7(%rip), %rsi    # 0x1a941e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1745da(%rip), %rcx    # 0x1d7b73
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %r9
leaq 0x1714f6(%rip), %rsi    # 0x1d4ac7
xorl %eax, %eax
movl %eax, %r8d
callq 0x15c9f0
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x635fc
movq -0x8(%rbp), %rdi
leaq 0x145e43(%rip), %rsi    # 0x1a9438
movb $0x0, %al
callq 0x15bc10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: extract_arj_from_sfx
static void extract_arj_from_sfx(deark *c, lctx *d,
	struct fmtutil_specialexe_detection_data *edd)
{
	de_module_params *mparams = NULL;

	if(!d->ei) return;
	de_dbg(c, "attempting ARJ extraction, pos=%"I64_FMT, edd->payload_pos);
	de_dbg_indent(c, 1);

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.codes = "R";
	if(edd->payload_valid) {
		mparams->in_params.obj1 = (void*)edd;
	}

	de_run_module_by_id_on_slice(c, "arj", mparams, d->ei->f, 0, d->ei->f->len);

	if(!(mparams->out_params.flags & 0x1)) {
		de_warn(c, "This look like a self-extracting ARJ file, but an attempt to "
			"extract the plain ARJ file failed.");
	}
	de_free(c, mparams);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6364c
jmp 0x63719
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x145e39(%rip), %rsi    # 0x1a9498
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1744e2(%rip), %rcx    # 0x1d7b73
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x3(%rax)
je 0x636aa
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %r9
leaq 0x140591(%rip), %rsi    # 0x1a3c64
xorl %eax, %eax
movl %eax, %r8d
callq 0x15c9f0
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x636fe
movq -0x8(%rbp), %rdi
leaq 0x145dc4(%rip), %rsi    # 0x1a94bb
movb $0x0, %al
callq 0x15bc10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: extract_pak16_from_sfx
static void extract_pak16_from_sfx(deark *c, lctx *d,
	struct fmtutil_specialexe_detection_data *edd)
{
	de_module_params *mparams = NULL;

	if(!d->ei) return;
	de_dbg(c, "attempting PAKv1.6 extraction, pos=%"I64_FMT, edd->payload_pos);
	de_dbg_indent(c, 1);

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.codes = "6";

	de_run_module_by_id_on_slice(c, "arc", mparams, d->ei->f,
		d->ei->end_of_dos_code, d->ei->overlay_len);

	de_free(c, mparams);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6374c
jmp 0x637e6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x145dbc(%rip), %rsi    # 0x1a951b
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x16dcf0(%rip), %rcx    # 0x1d1481
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %r9
leaq 0x147945(%rip), %rsi    # 0x1ab10b
callq 0x15c9f0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exe.c
// Function: extract_ishieldsfx_ne
static void extract_ishieldsfx_ne(deark *c, lctx *d,
	struct fmtutil_specialexe_detection_data *edd)
{
	de_module_params *mparams = NULL;

	de_dbg(c, "[extracting InstallShield SFX NE]");

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.uint1 = (UI)d->ishield_sfx_ne_rsrc_pos;
	mparams->in_params.uint2 = (UI)d->ishield_sfx_ne_rsrc_len;

	de_dbg_indent(c, 1);
	de_run_module_by_id(c, "is_sfx", mparams);
	de_dbg_indent(c, -1);

	de_free(c, mparams);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x145d2b(%rip), %rsi    # 0x1a9542
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x145cef(%rip), %rsi    # 0x1a9564
callq 0x15c980
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exepack.c
// Function: de_module_exepack
void de_module_exepack(deark *c, struct deark_module_info *mi)
{
	mi->id = "exepack";
	mi->desc = "EXEPACK-compressed EXE";
	mi->run_fn = de_run_exepack;
	mi->help_fn = de_help_exepack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x145d7e(%rip), %rcx    # 0x1a9635
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x145d78(%rip), %rcx    # 0x1a963d
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x638f0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x26d(%rip), %rcx       # 0x63b50
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exepack.c
// Function: calc_decoder_fingerprint
static void calc_decoder_fingerprint(deark *c, lctx *d)
{
	i64 fp_start, fp_len;
	struct de_crcobj *crco = NULL;

	crco = de_crcobj_create(c, DE_CRCOBJ_CRC32_IEEE);
	fp_start = d->host_ei->entry_point;
	// The point of "- 15" is to exclude the error handler, particularly the
	// length of the error message. The error handler is not exactly 15 bytes
	// in all variants, but that should be okay, and this is the best logic
	// that I can figure out.
	fp_len = d->epilog_pos - 15 - fp_start;
	de_crcobj_addslice(crco, c->infile, fp_start, fp_len);
	d->decoder_fingerprint = de_crcobj_getval(crco);
	de_crcobj_destroy(crco);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x15eac0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq $0xf, %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x15f500
movq -0x28(%rbp), %rdi
callq 0x15f340
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0x15f2e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exepack.c
// Function: report_exepack_version
static void report_exepack_version(deark *c, lctx *d)
{
	const char *name = "?";

	// Not intended to be a complete list.
	// I know of some more variants, but they're rare.
	switch(d->decoder_fingerprint) {
	case 0x77dc4e4aU: name = "common258 (EXEPACK 3.00/4.00/etc.)"; break;
	case 0x7b0bb610U: name = "common277 (LINK 3.60/etc.)"; break;
	case 0xae58e006U: name = "common279 (EXEPACK 4.03)"; break;
	case 0xa6a446acU: name = "common283 (EXEPACK 4.05/4.06)"; break;
	case 0x1797940cU: name = "common290 (LINK 5.60/etc.)"; break;
	}

	de_dbg(c, "decoder fingerprint: 0x%08x", (UI)d->decoder_fingerprint);
	de_dbg(c, "variant: %s", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x153c26(%rip), %rax    # 0x1b7c2d
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0xa6a446ac, %eax       # imm = 0xA6A446AC
je 0x64075
jmp 0x6401e
movl -0x1c(%rbp), %eax
subl $0xae58e006, %eax       # imm = 0xAE58E006
je 0x64068
jmp 0x6402a
movl -0x1c(%rbp), %eax
subl $0x1797940c, %eax       # imm = 0x1797940C
je 0x64082
jmp 0x64036
movl -0x1c(%rbp), %eax
subl $0x77dc4e4a, %eax       # imm = 0x77DC4E4A
je 0x6404e
jmp 0x64042
movl -0x1c(%rbp), %eax
subl $0x7b0bb610, %eax       # imm = 0x7B0BB610
je 0x6405b
jmp 0x6408d
leaq 0x1456f6(%rip), %rax    # 0x1a974b
movq %rax, -0x18(%rbp)
jmp 0x6408d
leaq 0x14570c(%rip), %rax    # 0x1a976e
movq %rax, -0x18(%rbp)
jmp 0x6408d
leaq 0x14571a(%rip), %rax    # 0x1a9789
movq %rax, -0x18(%rbp)
jmp 0x6408d
leaq 0x145726(%rip), %rax    # 0x1a97a2
movq %rax, -0x18(%rbp)
jmp 0x6408d
leaq 0x145737(%rip), %rax    # 0x1a97c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edx
leaq 0x14573c(%rip), %rsi    # 0x1a97db
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x156b7e(%rip), %rsi    # 0x1bac33
movb $0x0, %al
callq 0x15b0d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exepack.c
// Function: do_read_reloc_tbl
static void do_read_reloc_tbl(deark *c, lctx *d)
{
	i64 reloc_pos;
	i64 reloc_endpos;

	reloc_pos = d->host_ei->entry_point + d->decoder_len;
	reloc_endpos = d->hdrpos + d->ohdr.exepack_size;

	if(!fmtutil_decompress_exepack_reloc_tbl(c, reloc_pos, reloc_endpos, d->guest_reloc_table)) {
		d->errflag = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x20(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x68(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
callq 0x179880
cmpl $0x0, %eax
jne 0x64134
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dms.c
// Function: de_module_amiga_dms
void de_module_amiga_dms(deark *c, struct deark_module_info *mi)
{
	mi->id = "amiga_dms";
	mi->desc = "Amiga DMS disk image";
	mi->run_fn = de_run_amiga_dms;
	mi->identify_fn = de_identify_amiga_dms;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x144eed(%rip), %rcx    # 0x1a9924
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x144ee9(%rip), %rcx    # 0x1a992e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x64a70
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xcd(%rip), %rcx        # 0x64b30
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dms.c
// Function: de_run_amiga_dms
static void de_run_amiga_dms(deark *c, de_module_params *mparams)
{
	struct dmsctx *d = NULL;

	d = de_malloc(c, sizeof(struct dmsctx));
	d->crco_cksum = de_crcobj_create(c, DE_CRCOBJ_SUM_BYTES);
	if(!do_dms_header(c, d, 0)) goto done;
	if(!dms_scan_file(c, d, DMS_FILE_HDR_LEN)) goto done;
	do_dms_main(c, d);

done:
	if(d) {
		destroy_saved_dcrmpr_state(c, d);
		de_crcobj_destroy(d->crco_cksum);
		de_free(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 $0x1310, %esi           # imm = 0x1310
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x15eac0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x64ba0
cmpl $0x0, %eax
jne 0x64acb
jmp 0x64af1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x38, %edx
callq 0x64ea0
cmpl $0x0, %eax
jne 0x64ae4
jmp 0x64af1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x652d0
cmpq $0x0, -0x18(%rbp)
je 0x64b1f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x65430
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15f2e0
movq -0x8(%rbp), %rdi
movq -0x18(%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/dms.c
// Function: de_identify_amiga_dms
static int de_identify_amiga_dms(deark *c)
{
	i64 dcmpr_size;

	if(dbuf_memcmp(c->infile, 0, "DMS!", 4)) return 0;
	dcmpr_size = de_getu32be(24);
	if(dcmpr_size==901120) return 100;
	return 85;
}

// 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 0x1452e5(%rip), %rdx    # 0x1a9e34
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x64b67
movl $0x0, -0x4(%rbp)
jmp 0x64b97
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x18, %esi
callq 0x165470
movq %rax, -0x18(%rbp)
cmpq $0xdc000, -0x18(%rbp)   # imm = 0xDC000
jne 0x64b90
movl $0x64, -0x4(%rbp)
jmp 0x64b97
movl $0x55, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dms.c
// Function: do_dms_main
static void do_dms_main(deark *c, struct dmsctx *d)
{
	i64 i;
	int real_track_failure_flag = 0;
	dbuf *outf = NULL;
	dbuf *trackbuf = NULL;

	trackbuf = dbuf_create_membuf(c, 11264, 0);
	dbuf_enable_wbuffer(trackbuf);
	outf = dbuf_create_output_file(c, "adf", NULL, 0);

	for(i=0; i<d->num_tracks_in_file; i++) {
		int ret_dcmpr;

		if(real_track_failure_flag && d->tracks_by_file_order[i].is_real) {
			continue;
		}

		dbuf_truncate(trackbuf, 0);

		ret_dcmpr = dms_read_and_decompress_track(c, d, i, trackbuf);

		if(!ret_dcmpr) {
			if(d->tracks_by_file_order[i].is_real) {
				real_track_failure_flag = 1;
			}
			continue;
		}

		if(d->tracks_by_file_order[i].is_real) {
			dbuf_copy(trackbuf, 0, trackbuf->len, outf);
		}
		else {
			write_extra_track(c, d, i, trackbuf);
		}
	}

	dbuf_close(outf);
	dbuf_close(trackbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c00, %esi           # imm = 0x2C00
xorl %edx, %edx
callq 0x168020
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
leaq 0x1715af(%rip), %rsi    # 0x1d68ce
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x65418
cmpl $0x0, -0x1c(%rbp)
je 0x6536f
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0xc(%rax), %eax
cmpl $0x0, %eax
je 0x6536f
jmp 0x65407
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x168900
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x65640
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x653bc
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpb $0x0, 0xc(%rax)
je 0x653ba
movl $0x1, -0x1c(%rbp)
jmp 0x65407
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpb $0x0, 0xc(%rax)
je 0x653f0
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x166070
jmp 0x65405
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x65a80
jmp 0x65407
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x65336
movq -0x28(%rbp), %rdi
callq 0x1676a0
movq -0x30(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dms.c
// Function: destroy_saved_dcrmpr_state
static void destroy_saved_dcrmpr_state(deark *c, struct dmsctx *d)
{
	if(d->saved_quick_state.saved_state) {
		destroy_std_cmpr_state(c, d->saved_quick_state.saved_state);
		d->saved_quick_state.saved_state = NULL;
	}
	if(d->saved_medium_state.saved_state) {
		destroy_std_cmpr_state(c, d->saved_medium_state.saved_state);
		d->saved_medium_state.saved_state = NULL;
	}
	if(d->saved_deep_cmpr_state.saved_state) {
		destroy_std_cmpr_state(c, d->saved_deep_cmpr_state.saved_state);
		d->saved_deep_cmpr_state.saved_state = NULL;
	}
	if(d->saved_heavy_state) {
		destroy_heavy_state(c, d->saved_heavy_state);
		d->saved_heavy_state = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x12f0(%rax)
je 0x65471
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x12f0(%rax), %rsi
callq 0x66690
movq -0x10(%rbp), %rax
movq $0x0, 0x12f0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x12f8(%rax)
je 0x654a2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x12f8(%rax), %rsi
callq 0x66690
movq -0x10(%rbp), %rax
movq $0x0, 0x12f8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1300(%rax)
je 0x654d3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x1300(%rax), %rsi
callq 0x66690
movq -0x10(%rbp), %rax
movq $0x0, 0x1300(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1308(%rax)
je 0x65504
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x1308(%rax), %rsi
callq 0x67330
movq -0x10(%rbp), %rax
movq $0x0, 0x1308(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dms.c
// Function: read_unix_timestamp
static void read_unix_timestamp(deark *c, i64 pos, struct de_timestamp *ts, const char *name)
{
	i64 t;
	char timestamp_buf[64];

	t = de_geti32be(pos);
	de_unix_time_to_timestamp(t, ts, 0x1);
	de_timestamp_to_string(ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %"I64_FMT" (%s)", name, t, timestamp_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1655d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x70(%rbp), %r8
leaq 0x13d4d3(%rip), %rsi    # 0x1a2a4d
movb $0x0, %al
callq 0x15b0d0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dms.c
// Function: dms_get_cmprtype_name
static const char *dms_get_cmprtype_name(UI n)
{
	const char *name = NULL;
	switch(n) {
	case DMSCMPR_NONE: name="uncompressed"; break;
	case DMSCMPR_RLE: name="simple (RLE)"; break;
	case DMSCMPR_QUICK: name="quick"; break;
	case DMSCMPR_MEDIUM: name="medium (RLE + LZ77)"; break;
	case DMSCMPR_DEEP: name="deep (RLE + LZ77+dynamic_huffman)"; break;
	case DMSCMPR_HEAVY1: name="heavy1 (optional RLE + LZ77-4K+Huffman)"; break;
	case DMSCMPR_HEAVY2: name="heavy2 (optional RLE + LZ77-8K+Huffman)"; break;
	}
	return name?name:"?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x65619
movq -0x18(%rbp), %rax
leaq 0x14433d(%rip), %rcx    # 0x1a98f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x170871(%rip), %rax    # 0x1d5e38
movq %rax, -0x10(%rbp)
jmp 0x65619
leaq 0x144426(%rip), %rax    # 0x1a99fa
movq %rax, -0x10(%rbp)
jmp 0x65619
leaq 0x144426(%rip), %rax    # 0x1a9a07
movq %rax, -0x10(%rbp)
jmp 0x65619
leaq 0x14441f(%rip), %rax    # 0x1a9a0d
movq %rax, -0x10(%rbp)
jmp 0x65619
leaq 0x144426(%rip), %rax    # 0x1a9a21
movq %rax, -0x10(%rbp)
jmp 0x65619
leaq 0x14443b(%rip), %rax    # 0x1a9a43
movq %rax, -0x10(%rbp)
jmp 0x65619
leaq 0x144456(%rip), %rax    # 0x1a9a6b
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6562a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x65637
leaq 0x1525fc(%rip), %rax    # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0x65637
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)