LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_zip
static void detect_exesfx_zip(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	int ret;
	i64 foundpos = 0;

	if(!edd->zip_eocd_looked_for) {
		if(c->infile==ei->f && c->detection_data && c->detection_data->zip_eocd_looked_for) {
			edd->zip_eocd_looked_for = 1;
			edd->zip_eocd_found = c->detection_data->zip_eocd_found;
			edd->zip_eocd_pos = c->detection_data->zip_eocd_pos;
		}
		else {
			edd->zip_eocd_found = (u8)fmtutil_find_zip_eocd(c, c->infile, 0, &edd->zip_eocd_pos);
			edd->zip_eocd_looked_for = 1;
		}
	}

	if(!edd->zip_eocd_found) goto done;

	// Look for a ZIP file in the overlay (approximately)
	if(ei->overlay_len < 10) goto done; // Overlay too small

	ret = dbuf_search(ei->f, (const u8*)"PK\x03\x04", 4, ei->end_of_dos_code-10, 20,
		&foundpos);
	if(!ret) goto done;
	edd->detected_fmt = DE_SPECIALEXEFMT_ZIPSFX;

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_ZIPSFX) {
		de_strlcpy(edd->detected_fmt_name, "ZIP", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq $0x0, (%rsp)
cmpb $0x0, 0x4(%rdx)
je 0x105db2
movb 0x5(%rbx), %al
jmp 0x105dcd
movq 0x18(%rdi), %rsi
cmpq (%r14), %rsi
je 0x105e2b
leaq 0x28(%rbx), %rcx
xorl %edx, %edx
callq 0xf8ed5
movb %al, 0x5(%rbx)
movb $0x1, 0x4(%rbx)
testb %al, %al
je 0x105e05
cmpq $0xa, 0x50(%r14)
jl 0x105e05
movq (%r14), %rdi
movq 0x48(%r14), %rcx
addq $-0xa, %rcx
leaq 0x463ac(%rip), %rsi     # 0x14c196
movq %rsp, %r9
movl $0x4, %edx
movl $0x14, %r8d
callq 0xf149c
testl %eax, %eax
je 0x105e05
movb $0x65, 0x1(%rbx)
cmpb $0x65, 0x1(%rbx)
jne 0x105e23
addq $0x50, %rbx
leaq 0x20479(%rip), %rsi     # 0x12628f
movl $0x28, %edx
movq %rbx, %rdi
callq 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x105dbb
cmpb $0x0, 0x6(%rcx)
je 0x105dbb
movb $0x1, 0x4(%rbx)
movb 0x7(%rcx), %al
movb %al, 0x5(%rbx)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rbx)
jmp 0x105dcd
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_car
static void detect_exesfx_car(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	i64 foundpos = 0;

	if(ei->overlay_len<27) goto done;
	if(ei->entry_point!=11566 || ei->regSS!=978) {
		goto done;
	}

	if(dbuf_memcmp(ei->f, 11256,
		(const void*)"\x43\x41\x52\x20\x53\x65\x6c\xd8\xf0\x6e\x23\xf8\x0a\x41\xdd\xfd", 16))
	{
		goto done;
	}

	if(!is_lhalike_data_at(ei, ei->end_of_dos_code, 'h', &foundpos)) {
		goto done;
	}

	edd->payload_pos = foundpos;
	edd->payload_len = ei->f->len - edd->payload_pos;

	edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
	edd->payload_valid = 1;
	edd->payload_file_ext = "car";

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX) {
		de_strlcpy(edd->detected_fmt_name, "CAR (MylesHi!)", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq $0x0, (%rsp)
cmpq $0x1b, 0x50(%rsi)
jl 0x105edc
movq %rsi, %r14
cmpq $0x2d2e, 0x40(%rsi)     # imm = 0x2D2E
jne 0x105edc
cmpq $0x3d2, 0x10(%r14)      # imm = 0x3D2
jne 0x105edc
movq (%r14), %rdi
leaq 0x46313(%rip), %rdx     # 0x14c19b
movl $0x2bf8, %esi           # imm = 0x2BF8
movl $0x10, %ecx
callq 0xefc85
testl %eax, %eax
jne 0x105edc
movq (%r14), %rdi
movq 0x48(%r14), %rsi
movq %rsp, %rcx
movl $0x68, %edx
callq 0x105d2a
testl %eax, %eax
je 0x105edc
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x18(%rbx)
movb $0x64, 0x1(%rbx)
movb $0x1, 0x3(%rbx)
leaq 0x266e7(%rip), %rax     # 0x12c5bf
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0x105f01
addq $0x50, %rbx
leaq 0x462bf(%rip), %rsi     # 0x14c1ac
movl $0x28, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_lhark
static void detect_exesfx_lhark(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	if(!detect_lhark_sfx(c, ei, edd)) {
		goto done;
	}

	edd->payload_pos = ei->end_of_dos_code;
	edd->payload_len = ei->f->len - edd->payload_pos;
	if(edd->payload_len<28) goto done;

	edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
	edd->payload_valid = 1;
	edd->payload_file_ext = "lzh";

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX) {
		de_strlcpy(edd->detected_fmt_name, "LHARK", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x105c32
testl %eax, %eax
je 0x105f51
movq 0x48(%r14), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x18(%rbx)
cmpq $0x1c, %rcx
jl 0x105f51
movb $0x64, 0x1(%rbx)
movb $0x1, 0x3(%rbx)
leaq 0x3f135(%rip), %rax     # 0x145082
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0x105f76
addq $0x50, %rbx
leaq 0x26120(%rip), %rsi     # 0x12c082
movl $0x28, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_larc
static void detect_exesfx_larc(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	int found;
	i64 foundpos = 0;

	calc_entrypoint_crc(c, ei);
	if(ei->entrypoint_crcs!=0x81681852d3882b18ULL) {
		goto done;
	}

	found = is_lhalike_data_at(ei, ei->entry_point+525, 'z', &foundpos);
	if(!found) goto done;

	edd->payload_pos = foundpos;
	edd->payload_len = ei->f->len - edd->payload_pos;
	if(edd->payload_len<21) goto done;

	edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
	edd->payload_valid = 1;
	edd->payload_file_ext = "lzs";

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX) {
		de_strlcpy(edd->detected_fmt_name, "LArc", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq $0x0, (%rsp)
callq 0x1057dc
movabsq $-0x7e97e7ad2c77d4e8, %rax # imm = 0x81681852D3882B18
cmpq %rax, 0x68(%r14)
jne 0x106209
movl $0x20d, %esi            # imm = 0x20D
addq 0x40(%r14), %rsi
movq (%r14), %rdi
movq %rsp, %rcx
movl $0x7a, %edx
callq 0x105d2a
testl %eax, %eax
je 0x106209
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x18(%rbx)
cmpq $0x15, %rcx
jl 0x106209
movb $0x64, 0x1(%rbx)
movb $0x1, 0x3(%rbx)
leaq 0x2631b(%rip), %rax     # 0x12c520
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0x10622e
addq $0x50, %rbx
leaq 0x264f1(%rip), %rsi     # 0x12c70b
movl $0x28, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_pak_nogate
static void detect_exesfx_pak_nogate(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	int found = 0;
	int canextract = 0;
	u8 v16flag = 0;

	read_exe_testbytes(ei);
	if(ei->ovl64b[0]!=0x1a && ei->ovl64b[0]!=0xfe) goto done;

	if(!de_memcmp(ei->ep64b, (const u8*)"\x55\x8b\xec\x83\xec\x50", 6)) {
		// PAK 1.51-2.51
		found = 1;

		// There's a problem with PAK v1.6. If there are any file or archive
		// comments, the payload will not be in proper PAK format.
		// We can convert it, but it needs special detection and handling.
		if(ei->entry_point==2656) {
			v16flag = 1;
		}
		else {
			canextract = 1;
		}
	}
	if(!found && !de_memcmp(ei->ep64b, (const u8*)"\xfb\xba\x53\x03\x2e\x89\x16\x65", 8)) {
		// GSARC 1.0 and PAK 1.0
		found = 1;
		canextract = 1;
	}

	if(!found) goto done;
	if(ei->ovl64b[0] != 0x1a) canextract = 0;

	edd->payload_pos = ei->end_of_dos_code;
	edd->payload_len = ei->f->len - edd->payload_pos;
	if(edd->payload_len<2) goto done;

	if(v16flag) {
		edd->detected_fmt = DE_SPECIALEXEFMT_PAK16SFX;
	}
	else {
		edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
		edd->payload_valid = canextract;
		edd->payload_file_ext = "pak";
	}

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX ||
		edd->detected_fmt==DE_SPECIALEXEFMT_PAK16SFX)
	{
		de_strlcpy(edd->detected_fmt_name, "PAK", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x105bf5
movzbl 0xb0(%r14), %eax
cmpl $0xfe, %eax
je 0x1063e0
cmpl $0x1a, %eax
jne 0x106456
movl $0x83ec8b55, %ecx       # imm = 0x83EC8B55
xorl 0x70(%r14), %ecx
movzwl 0x74(%r14), %edx
xorl $0x50ec, %edx           # imm = 0x50EC
orl %ecx, %edx
je 0x10640c
movabsq $0x6516892e0353bafb, %rcx # imm = 0x6516892E0353BAFB
cmpq %rcx, 0x70(%r14)
jne 0x106456
movb $0x1, %cl
jmp 0x106417
cmpq $0xa60, 0x40(%r14)      # imm = 0xA60
setne %cl
cmpb $0x1a, %al
sete %al
movq 0x48(%r14), %rdx
movq %rdx, 0x10(%rbx)
movq (%r14), %rsi
movq 0x18(%rsi), %rsi
subq %rdx, %rsi
movq %rsi, 0x18(%rbx)
cmpq $0x2, %rsi
jl 0x106456
testb %cl, %cl
je 0x106452
andb %cl, %al
movb $0x64, 0x1(%rbx)
movb %al, 0x3(%rbx)
leaq 0xe255(%rip), %rax      # 0x1146a1
movq %rax, 0x40(%rbx)
jmp 0x106456
movb $0x67, 0x1(%rbx)
movzbl 0x1(%rbx), %eax
cmpl $0x67, %eax
je 0x106464
cmpl $0x64, %eax
jne 0x106483
addq $0x50, %rbx
leaq 0x45d65(%rip), %rsi     # 0x14c1d4
movl $0x28, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_rar
static void detect_exesfx_rar(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	// TODO: Lots more work to do here. Maybe better to delete the RSFX test.
	if(ei->overlay_len < 8) goto done;

	read_exe_testbytes(ei);

	if(de_memcmp(ei->ovl64b, "Rar!\x1a\x07", 6) &&
		de_memcmp(ei->ovl64b, "RE\x7e\x5e", 4))
	{
		goto done;
	}

	if(dbuf_memcmp(ei->f, 28, (const u8*)"RSFX", 4)) {
		goto done;
	}

	edd->payload_pos = ei->end_of_dos_code;
	edd->payload_len = ei->overlay_len;
	edd->payload_valid = 1;
	edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
	edd->payload_file_ext = "rar";

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX) {
		de_strlcpy(edd->detected_fmt_name, "RAR", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq $0x8, 0x50(%rsi)
jl 0x106508
movq %rsi, %r14
movq %rsi, %rdi
callq 0x105bf5
movl $0x21726152, %eax       # imm = 0x21726152
xorl 0xb0(%r14), %eax
movzwl 0xb4(%r14), %ecx
xorl $0x71a, %ecx            # imm = 0x71A
orl %eax, %ecx
je 0x1064cf
cmpl $0x5e7e4552, 0xb0(%r14) # imm = 0x5E7E4552
jne 0x106508
movq (%r14), %rdi
leaq 0x45d06(%rip), %rdx     # 0x14c1df
movl $0x1c, %esi
movl $0x4, %ecx
callq 0xefc85
testl %eax, %eax
jne 0x106508
movups 0x48(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x3(%rbx)
movb $0x64, 0x1(%rbx)
leaq 0x3ecf4(%rip), %rax     # 0x1451f8
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0x10652d
addq $0x50, %rbx
leaq 0x45ccb(%rip), %rsi     # 0x14c1e4
movl $0x28, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_zoo
static void detect_exesfx_zoo(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	if(ei->overlay_len < 24) goto done;
	read_exe_testbytes(ei);
	if((UI)de_getu32le_direct(&ei->ovl64b[20]) != 0xfdc4a7dcU) goto done;

	calc_entrypoint_crc(c, ei);
	switch((UI)(ei->entrypoint_crcs>>32)) {
	case 0x6d384fa1U: // SEZ 2.00
	case 0xec5138deU: // SEZ 2.30
		// TODO: More Zoo SFX variants
		break;
	default:
		goto done;
	}

	edd->payload_pos = ei->end_of_dos_code;
	edd->payload_len = ei->overlay_len;
	edd->payload_valid = 1;
	edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
	edd->payload_file_ext = "zoo";

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX) {
		de_strlcpy(edd->detected_fmt_name, "Zoo", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpq $0x18, 0x50(%rsi)
jl 0x10659e
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x105bf5
leaq 0xc4(%r14), %rdi
callq 0xeed5e
cmpl $0xfdc4a7dc, %eax       # imm = 0xFDC4A7DC
jne 0x10659e
movq %r15, %rdi
movq %r14, %rsi
callq 0x1057dc
movl 0x6c(%r14), %eax
cmpl $0x6d384fa1, %eax       # imm = 0x6D384FA1
je 0x106582
cmpl $0xec5138de, %eax       # imm = 0xEC5138DE
jne 0x10659e
movups 0x48(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x3(%rbx)
movb $0x64, 0x1(%rbx)
leaq 0x3e54e(%rip), %rax     # 0x144ae8
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0x1065c1
addq $0x50, %rbx
leaq 0x45c39(%rip), %rsi     # 0x14c1e8
movl $0x28, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe8219
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_arj
static void detect_exesfx_arj(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	int ret;
	i64 foundpos = 0;

	if(ei->overlay_len < ARJ_MIN_FILE_SIZE) goto done;

	// Aribrarily allow up to 16 extra bytes before the ARJ data starts.
	// Maybe 2 is sufficient. Dunno.
	ret = fmtutil_scan_for_arj_data(ei->f, ei->end_of_dos_code, 16, 0, &foundpos);

	if(ret) {
		edd->detected_fmt = DE_SPECIALEXEFMT_ARJSFX;
		edd->payload_pos = foundpos;
		edd->payload_len = ei->f->len - foundpos;
		edd->payload_valid = 1;
		goto done;
	}

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_ARJSFX) {
		de_strlcpy(edd->detected_fmt_name, "ARJ", sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq $0x0, (%rsp)
cmpq $0x54, 0x50(%rsi)
jl 0x106618
movq %rsi, %r14
movq (%rsi), %rdi
movq 0x48(%rsi), %rsi
movq %rsp, %r8
movl $0x10, %edx
xorl %ecx, %ecx
callq 0xf9ad4
testl %eax, %eax
je 0x106618
movb $0x66, 0x1(%rbx)
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x18(%rbx)
movb $0x1, 0x3(%rbx)
cmpb $0x66, 0x1(%rbx)
jne 0x106636
addq $0x50, %rbx
leaq 0x11922(%rip), %rsi     # 0x117f4b
movl $0x28, %edx
movq %rbx, %rdi
callq 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-exe.c
// Function: detect_exesfx_fbex
static void detect_exesfx_fbex(deark *c,
	struct fmtutil_exe_info *ei, struct fmtutil_specialexe_detection_data *edd)
{
	i64 pos;
	i64 n;

	read_exe_testbytes(ei);
	if(de_memcmp(ei->ovl64b, "FBIN", 4)) goto done;
	n = de_getu32le_direct(&ei->ovl64b[4]);

	pos = ei->end_of_dos_code + 8 + n;
	if(pos+40 > ei->f->len) goto done;
	if(dbuf_memcmp(ei->f, pos, "FBEX", 4)) goto done;
	pos += 4;
	edd->payload_len = dbuf_getu32le_p(ei->f, &pos);
	edd->payload_pos = pos;
	if(edd->payload_len<32) goto done;
	if(edd->payload_pos+edd->payload_len > ei->f->len) goto done;
	// If there's other stuff after this item, fail completely instead
	// of partially.
	if(edd->payload_pos+edd->payload_len+32 < ei->f->len) goto done;
	if(dbuf_memcmp(ei->f, edd->payload_pos, "MZ", 2)) goto done;

	edd->payload_valid = 1;
	edd->detected_fmt = DE_SPECIALEXEFMT_SFX;
	edd->payload_file_ext = "exe";

done:
	if(edd->detected_fmt==DE_SPECIALEXEFMT_SFX) {
		de_strlcpy(edd->detected_fmt_name, "FBEX overlay",
			sizeof(edd->detected_fmt_name));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x105bf5
cmpl $0x4e494246, 0xb0(%r14) # imm = 0x4E494246
jne 0x10671f
leaq 0xb4(%r14), %rdi
callq 0xeed5e
movq 0x48(%r14), %rcx
leaq (%rax,%rcx), %r15
addq $0x8, %r15
movq %r15, (%rsp)
addq %rcx, %rax
addq $0x30, %rax
movq (%r14), %rdi
cmpq 0x18(%rdi), %rax
jg 0x10671f
leaq 0x45b55(%rip), %rdx     # 0x14c1f1
movl $0x4, %ecx
movq %r15, %rsi
callq 0xefc85
testl %eax, %eax
jne 0x10671f
addq $0x4, %r15
movq %rsp, %r12
movq %r15, (%r12)
movq (%r14), %rdi
movq %r12, %rsi
callq 0xeed83
movq %rax, 0x18(%rbx)
movq (%r12), %rsi
movq %rsi, 0x10(%rbx)
cmpq $0x20, %rax
jl 0x10671f
leaq (%rsi,%rax), %rcx
movq (%r14), %rdi
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
setg %cl
addq %rsi, %rax
addq $0x20, %rax
cmpq %rdx, %rax
setl %al
orb %cl, %al
jne 0x10671f
leaq 0x45af8(%rip), %rdx     # 0x14c1f6
movl $0x2, %ecx
callq 0xefc85
testl %eax, %eax
jne 0x10671f
movb $0x1, 0x3(%rbx)
movb $0x64, 0x1(%rbx)
leaq 0x1d21a(%rip), %rax     # 0x123935
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0x10673d
addq $0x50, %rbx
leaq 0x45ac9(%rip), %rsi     # 0x14c1f9
movl $0x28, %edx
movq %rbx, %rdi
callq 0xe8219
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-lzah.c
// Function: fmtutil_get_lzhuf_d_code_and_len
void fmtutil_get_lzhuf_d_code_and_len(UI n, UI *pd_code, UI *pd_len)
{
	if(n<32 || n>=256) { *pd_code = 0; *pd_len = 3; }
	else if(n<80) { *pd_code = (n-16)>>4; *pd_len = 4; }
	else if(n<144) { *pd_code = (n-48)>>3; *pd_len = 5; }
	else if(n<192) { *pd_code = (n-96)>>2; *pd_len = 6; }
	else if(n<240) { *pd_code = (n-144)>>1; *pd_len = 7; }
	else { *pd_code = n-192; *pd_len = 8; };
}

// Assembly:
leal -0x100(%rdi), %eax
cmpl $0xffffff20, %eax       # imm = 0xFFFFFF20
jae 0x106762
movl $0x3, %eax
xorl %edi, %edi
jmp 0x1067c0
cmpl $0x4f, %edi
ja 0x106774
addl $-0x10, %edi
shrl $0x4, %edi
movl $0x4, %eax
jmp 0x1067c0
cmpl $0x8f, %edi
ja 0x106789
addl $-0x30, %edi
shrl $0x3, %edi
movl $0x5, %eax
jmp 0x1067c0
cmpl $0xbf, %edi
ja 0x10679e
addl $-0x60, %edi
shrl $0x2, %edi
movl $0x6, %eax
jmp 0x1067c0
cmpl $0xef, %edi
ja 0x1067b5
addl $0xffffff70, %edi       # imm = 0xFFFFFF70
shrl %edi
movl $0x7, %eax
jmp 0x1067c0
addl $0xffffff40, %edi       # imm = 0xFFFFFF40
movl $0x8, %eax
movl %edi, (%rsi)
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-lzah.c
// Function: my_lh1_codec_addbuf
static void my_lh1_codec_addbuf(struct de_dfilter_ctx *dfctx,
	const u8 *buf, i64 buf_len)
{
	struct lzahuf_ctx *cctx = (struct lzahuf_ctx*)dfctx->codec_private;

	if(dfctx->finished_flag || cctx->errflag) {
		goto done;
	}

	lzhuf_Decode_continue(cctx, buf, buf_len, 0);

done:
	if(cctx->errflag) {
		dfctx->finished_flag = 1;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
cmpb $0x0, 0x20(%rdi)
jne 0x106b51
cmpl $0x0, 0x54(%r14)
jne 0x106b51
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x106c7b
cmpl $0x0, 0x54(%r14)
je 0x106b5c
movb $0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-lzah.c
// Function: my_lh1_codec_finish
static void my_lh1_codec_finish(struct de_dfilter_ctx *dfctx)
{
	struct lzahuf_ctx *cctx = (struct lzahuf_ctx*)dfctx->codec_private;

	lzhuf_Decode_continue(cctx, NULL, 0, 1);

	cctx->total_nbytes_processed -= (i64)(cctx->bbll.nbits_in_bitbuf/8);
	de_bitbuf_lowlevel_empty(&cctx->bbll);
	dfctx->dres->bytes_consumed = cctx->total_nbytes_processed;
	dfctx->dres->bytes_consumed_valid = 1;

	if(cctx->errflag) {
		de_dfilter_set_generic_error(cctx->c, dfctx->dres, cctx->modname);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x106c7b
leaq 0x70(%rbx), %rdi
movl 0x74(%rbx), %eax
shrl $0x3, %eax
subq %rax, 0x58(%rbx)
callq 0xf1bdd
movq 0x58(%rbx), %rax
movq 0x8(%r14), %rsi
movq %rax, 0x8(%rsi)
movb $0x1, 0x4(%rsi)
cmpl $0x0, 0x54(%rbx)
je 0x106bbc
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfa311
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-lzah.c
// Function: my_lh1_codec_command
static void my_lh1_codec_command(struct de_dfilter_ctx *dfctx, int cmd, UI flags)
{
	struct lzahuf_ctx *cctx = (struct lzahuf_ctx*)dfctx->codec_private;

	if(cmd==DE_DFILTER_COMMAND_FINISH_BLOCK) {
		lzhuf_Decode_continue(cctx, NULL, 0, 1);
		cctx->total_nbytes_processed -= (i64)(cctx->bbll.nbits_in_bitbuf/8);
		de_bitbuf_lowlevel_empty(&cctx->bbll);
		if(cctx->lh1p.is_dms_deep) {
			de_lz77buffer_set_curpos(cctx->ringbuf, cctx->ringbuf->curpos + 60);
		}
	}
	else if(cmd==DE_DFILTER_COMMAND_RESET_COUNTERS) {
		cctx->nbytes_written = 0;
		cctx->total_nbytes_processed = 0;
		cctx->errflag = 0;
		dfctx->finished_flag = 0;
	}
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
cmpl $0x4, %esi
je 0x106c0d
cmpl $0x3, %esi
jne 0x106c1f
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x106c7b
leaq 0x70(%rbx), %rdi
movl 0x74(%rbx), %eax
shrl $0x3, %eax
subq %rax, 0x58(%rbx)
callq 0xf1bdd
cmpb $0x0, 0x14(%rbx)
je 0x106c1f
movq 0x68(%rbx), %rdi
movl 0x10(%rdi), %esi
addl $0x3c, %esi
popq %rbx
jmp 0xfb30d
xorps %xmm0, %xmm0
movups %xmm0, 0x54(%rbx)
movl $0x0, 0x64(%rbx)
movb $0x0, 0x20(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-lzah.c
// Function: my_lh1_codec_destroy
static void my_lh1_codec_destroy(struct de_dfilter_ctx *dfctx)
{
	struct lzahuf_ctx *cctx = (struct lzahuf_ctx*)dfctx->codec_private;

	if(cctx) {
		de_lz77buffer_destroy(cctx->c, cctx->ringbuf);
		cctx->ringbuf = NULL;
		de_free(dfctx->c, cctx);
	}
	dfctx->codec_private = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x106c50
movq (%r14), %rdi
movq 0x68(%r14), %rsi
callq 0xfaed4
movq $0x0, 0x68(%r14)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xe8be2
movq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/../foreign/lzhuf.h
// Function: lzah_lz77buf_writebytecb
static void lzah_lz77buf_writebytecb(struct de_lz77buffer *rb, u8 n)
{
	struct lzahuf_ctx *cctx = (struct lzahuf_ctx*)rb->userdata;

	if(lzah_have_enough_output(cctx)) {
		return;
	}
	dbuf_writebyte(cctx->dcmpro->f, n);
	cctx->nbytes_written++;
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
movq 0x20(%rbx), %rax
cmpb $0x0, 0x8(%rax)
je 0x107502
movq 0x60(%rbx), %rcx
cmpq 0x10(%rax), %rcx
jge 0x107514
movq (%rax), %rdi
movzbl %sil, %esi
callq 0xf0bd6
incq 0x60(%rbx)
jmp 0x10751c
movq 0x18(%rbx), %rax
movb $0x1, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/../foreign/lzhuf.h
// Function: lzhuf_decodesubtree_node
static void lzhuf_decodesubtree_node(struct lzahuf_ctx *cctx, UI p1, u64 val, UI val_nbits,
	char *b2buf, size_t b2buf_len)
{
	if(cctx->son[p1] < cctx->lzhuf_T) { // [pointer node]
		lzhuf_decodesubtree_nodepair(cctx, cctx->son[p1], val, val_nbits, b2buf, b2buf_len);
	}
	else { // [leaf node]
		de_dbg(cctx->c, "code: \"%s\" = %d [%u]",
			de_print_base2_fixed(b2buf, b2buf_len, val, val_nbits),
			(int)cctx->son[p1], (UI)(cctx->son[p1]-cctx->lzhuf_T));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %rbx
movl %esi, %r13d
movzwl 0xcd6(%rdi,%r13,2), %r12d
cmpl %r12d, 0x3c(%rdi)
jbe 0x107579
leaq (%r15,%r15), %rdx
incl %ebp
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %ecx
movq %r14, %r8
callq 0x10751e
movl %r12d, %r13d
leaq 0x1(,%r15,2), %r15
movzwl 0xcd8(%rbx,%r13,2), %r12d
cmpl %r12d, 0x3c(%rbx)
ja 0x107546
incq %r13
movq (%rbx), %r12
movl $0x48, %esi
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xe9d03
movzwl 0xcd6(%rbx,%r13,2), %ecx
movl %ecx, %r8d
subl 0x3c(%rbx), %r8d
leaq 0x44d32(%rip), %rsi     # 0x14c2d7
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe8617
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-iff.c
// Function: fmtutil_read_iff_format
void fmtutil_read_iff_format(struct de_iffctx *ictx, i64 pos, i64 len)
{
	deark *c = ictx->c;
	struct iff_parser_data *pctx = NULL;

	if(!ictx->f || !ictx->handle_chunk_fn) return; // Internal error

	ictx->level = 0;
	fourcc_clear(&ictx->main_fmt4cc);
	fourcc_clear(&ictx->main_contentstype4cc);
	fourcc_clear(&ictx->curr_container_fmt4cc);
	fourcc_clear(&ictx->curr_container_contentstype4cc);
	if(ictx->alignment==0) {
		ictx->alignment = 2;
	}
	if(ictx->sizeof_len==0) {
		ictx->sizeof_len = 4;
	}

	if(ictx->input_encoding==DE_ENCODING_UNKNOWN) {
		ictx->input_encoding = DE_ENCODING_ASCII;
	}

	pctx = de_malloc(c, sizeof(struct iff_parser_data));
	ictx->private_data = (void*)pctx;
	do_iff_chunk_sequence(c, ictx, NULL, pos, len, 0);
	ictx->private_data = NULL;
	de_free(c, pctx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x18(%rdi)
je 0x107690
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x107690
movq %rdx, %r14
movq %rsi, %r15
movq (%rbx), %r12
leaq 0x64(%rbx), %rdi
movl $0xc4, %edx
xorl %esi, %esi
callq 0x18140
cmpq $0x0, 0x48(%rbx)
jne 0x10762e
movq $0x2, 0x48(%rbx)
cmpq $0x0, 0x50(%rbx)
jne 0x10763d
movq $0x4, 0x50(%rbx)
cmpl $0x0, 0x60(%rbx)
jne 0x10764a
movl $0x1, 0x60(%rbx)
movl $0x50, %esi
movq %r12, %rdi
callq 0xe8b2b
movq %rax, %r13
movq %rax, 0x8(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x10769a
movq $0x0, 0x8(%rbx)
movq %r12, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe8be2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-iff.c
// Function: do_iff_text_chunk
static void do_iff_text_chunk(deark *c, struct de_iffctx *ictx, i64 dpos, i64 dlen,
	const char *name)
{
	de_ucstring *s = NULL;

	if(dlen<1) return;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(ictx->f,
		dpos, dlen, DE_DBG_MAX_STRLEN,
		s, DE_CONVFLAG_STOP_AT_NUL, ictx->input_encoding);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));
	ucstring_destroy(s);
}

// Assembly:
testq %rcx, %rcx
jle 0x107eda
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
callq 0xf6410
movq %rax, %r15
movq 0x18(%rbp), %rdi
movl 0x60(%rbp), %eax
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %r8
movl $0x1, %r9d
callq 0xefc2a
movq %r15, %rdi
callq 0xf705c
leaq 0x24276(%rip), %rsi     # 0x12c12a
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/fmtutil-iff.c
// Function: do_iff_anno
static void do_iff_anno(deark *c, struct de_iffctx *ictx, i64 pos, i64 len)
{
	i64 foundpos;

	if(len<1) return;

	// Some ANNO chunks seem to be padded with one or more NUL bytes. Probably
	// best not to save them.
	if(dbuf_search_byte(ictx->f, 0x00, pos, len, &foundpos)) {
		len = foundpos - pos;
	}
	if(len<1) return;
	if(c->extract_level>=2) {
		dbuf_create_file_from_slice(ictx->f, pos, len, "anno.txt", NULL, DE_CREATEFLAG_IS_AUX);
	}
	else {
		de_ucstring *s = NULL;
		s = ucstring_create(c);
		dbuf_read_to_ucstring_n(ictx->f, pos, len, DE_DBG_MAX_STRLEN, s, 0, ictx->input_encoding);
		de_dbg(c, "annotation: \"%s\"", ucstring_getpsz(s));
		ucstring_destroy(s);
	}
}

// Assembly:
testq %rcx, %rcx
jle 0x107fab
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
leaq 0x8(%rsp), %r15
xorl %esi, %esi
movq %r15, %r8
callq 0xefa77
movq (%r15), %r15
subq %r14, %r15
testl %eax, %eax
cmoveq %r13, %r15
testq %r15, %r15
jle 0x107f9e
cmpl $0x2, 0x90(%rbx)
jl 0x107f4c
movq 0x18(%r12), %rdi
leaq 0x444e8(%rip), %rcx     # 0x14c41e
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xefd48
jmp 0x107f9e
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r13
movq 0x18(%r12), %rdi
movl 0x60(%r12), %eax
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq %r13, %rdi
callq 0xf705c
leaq 0x20913(%rip), %rsi     # 0x12889c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r13, %rdi
callq 0xf6753
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_print_module_list
void de_print_module_list(deark *c)
{
	int i, k;
	struct sort_data_struct *sort_data = NULL;

	de_register_modules(c);

	// An index to the modules. Will be sorted by name.
	sort_data = de_mallocarray(c, c->num_modules, sizeof(struct sort_data_struct));

	for(k=0; k<c->num_modules; k++) {
		sort_data[k].c = c;
		sort_data[k].module_index = k;
	}

	qsort((void*)sort_data, (size_t)c->num_modules, sizeof(struct sort_data_struct),
		module_compare_fn);

	for(k=0; k<c->num_modules; k++) {
		const char *desc;
		i = sort_data[k].module_index;
		if(!c->module_info[i].id) continue;
		if(c->extract_level<2) {
			if(c->module_info[i].flags & (DE_MODFLAG_HIDDEN |
				DE_MODFLAG_NONWORKING | DE_MODFLAG_WARNPARSEONLY))
			{
				continue;
			}
		}
		desc = c->module_info[i].desc ? c->module_info[i].desc : "-";
		de_printf(c, DE_MSGTYPE_MESSAGE, "%-14s %s\n", c->module_info[i].id, desc);
	}

	de_free(c, sort_data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1a0(%rdi), %rax
testq %rax, %rax
je 0x107fcd
movq %rbx, %rdi
callq *%rax
jmp 0x107fde
leaq 0x4449a(%rip), %rsi     # 0x14c46e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9544
movslq 0x1a8(%rbx), %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0xe96f7
movq %rax, %r14
movslq 0x1a8(%rbx), %rsi
testq %rsi, %rsi
jle 0x108019
leaq 0x8(%r14), %rax
xorl %ecx, %ecx
movq %rbx, -0x8(%rax)
movl %ecx, (%rax)
incq %rcx
addq $0x10, %rax
cmpq %rcx, %rsi
jne 0x108007
leaq 0xbe(%rip), %rcx        # 0x1080de
movl $0x10, %edx
movq %r14, %rdi
callq 0x18070
movl 0x1a8(%rbx), %eax
testl %eax, %eax
jle 0x1080a9
movq %r14, %r12
addq $0x8, %r12
leaq 0x2460a(%rip), %r13     # 0x12c64f
leaq 0x44418(%rip), %r15     # 0x14c464
xorl %ebp, %ebp
movslq (%r12), %rcx
movq 0x1b0(%rbx), %rdx
leaq (%rcx,%rcx,8), %rsi
movq (%rdx,%rsi,8), %rcx
testq %rcx, %rcx
je 0x10809a
cmpl $0x1, 0x90(%rbx)
jg 0x108079
leaq (%rdx,%rsi,8), %rdi
testb $0x23, 0x30(%rdi)
jne 0x10809a
movq 0x8(%rdx,%rsi,8), %r8
testq %r8, %r8
cmoveq %r13, %r8
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe856b
movl 0x1a8(%rbx), %eax
incq %rbp
movslq %eax, %rcx
addq $0x10, %r12
cmpq %rcx, %rbp
jl 0x10804e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: detect_module_for_file
static struct deark_module_info *detect_module_for_file(deark *c, int *errflag)
{
	int i;
	int result;
	int orig_errcount;
	struct deark_module_info *best_module = NULL;

	*errflag = 0;
	if(!c->detection_data) {
		c->detection_data = de_malloc(c, sizeof(struct de_detection_data_struct));
	}

	// This value is made available to modules' identification functions, so
	// that they can potentially skip expensive tests that cannot possibly return
	// a high enough confidence.
	c->detection_data->best_confidence_so_far = 0;

	orig_errcount = c->error_count;
	for(i=0; i<c->num_modules; i++) {
		if(c->module_info[i].identify_fn==NULL) continue;

		// If autodetect is disabled for this module, and its autodetect routine
		// doesn't do anything that may be needed by other modules, don't bother
		// to run this module's autodetection.
		if((c->module_info[i].flags & DE_MODFLAG_DISABLEDETECT) &&
			!(c->module_info[i].flags & DE_MODFLAG_SHAREDDETECTION))
		{
			continue;
		}

		result = c->module_info[i].identify_fn(c);

		if(c->error_count > orig_errcount) {
			// Detection routines don't normally produce errors. If one does,
			// it's probably an internal error, or other serious problem.
			*errflag = 1;
			return NULL;
		}

		if(c->module_info[i].flags & DE_MODFLAG_DISABLEDETECT) {
			// Ignore results of autodetection.
			continue;
		}

		if(result <= c->detection_data->best_confidence_so_far) continue;

		// This is the best result so far.
		c->detection_data->best_confidence_so_far = result;
		best_module = &c->module_info[i];
		if(c->detection_data->best_confidence_so_far>=100) break;
	}

	return best_module;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rsi)
movq 0x28(%rdi), %rax
testq %rax, %rax
jne 0x10895b
movl $0x20, %esi
movq %r14, %rdi
callq 0xe8b2b
movq %rax, 0x28(%r14)
movl $0x0, (%rax)
cmpl $0x0, 0x1a8(%r14)
jle 0x1089f2
movq %rbx, (%rsp)
movl 0x48(%r14), %ebp
movq 0x1b0(%r14), %rcx
xorl %r12d, %r12d
movl $0x110, %r13d           # imm = 0x110
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x20(%rcx,%r12), %rax
testq %rax, %rax
je 0x1089d3
movl 0x30(%rcx,%r12), %edx
andl %r13d, %edx
cmpl $0x100, %edx            # imm = 0x100
je 0x1089d3
movq %r14, %rdi
callq *%rax
cmpl %ebp, 0x48(%r14)
jg 0x1089e8
movq 0x1b0(%r14), %rcx
testb $0x1, 0x31(%rcx,%r12)
jne 0x1089d3
movq 0x28(%r14), %rdx
cmpl (%rdx), %eax
jle 0x1089d3
movl %eax, (%rdx)
cmpl $0x63, %eax
jg 0x108a07
leaq (%rcx,%r12), %r15
incq %rbx
movslq 0x1a8(%r14), %rax
addq $0x48, %r12
cmpq %rax, %rbx
jl 0x10898c
jmp 0x1089f5
movq (%rsp), %rax
movl $0x1, (%rax)
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r12, %rcx
movq %rcx, %r15
jmp 0x1089f5
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: do_modhelp_internal
static void do_modhelp_internal(deark *c, struct deark_module_info *module_to_use)
{
	int k;
	u8 printed_something = 0;
	u8 suppress_nohelpmsg = 0;

	if(!module_to_use) goto done;
	de_msg(c, "Module: %s", module_to_use->id);

	for(k=0; k<DE_MAX_MODULE_ALIASES; k++) {
		if(module_to_use->id_alias[k]) {
			de_msg(c, "Alias: %s", module_to_use->id_alias[k]);
		}
		else {
			break;
		}
	}

	if(module_to_use->desc) {
		de_msg(c, "Description: %s", module_to_use->desc);
	}
	if(module_to_use->desc2) {
		de_msg(c, "Other notes: %s", module_to_use->desc2);
		printed_something = 1;
	}

	if(module_to_use->flags&DE_MODFLAG_MULTIPART) {
		de_msg(c, "This module supports multiple input files; "
			"use the \"-mp\" option.");
		printed_something = 1;
	}

	if(module_to_use->flags&DE_MODFLAG_INTERNALONLY) {
		de_msg(c, "This module is intended for internal use only.");
		suppress_nohelpmsg = 1;
	}

	if(!module_to_use->help_fn) {
		if(!suppress_nohelpmsg) {
			de_msg(c, "No%s help available for module \"%s\".",
				(printed_something?" other":""), module_to_use->id);
		}
		goto done;
	}

	de_msg(c, "Help for module \"%s\":", module_to_use->id);
	module_to_use->help_fn(c);

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdx
leaq 0x43b78(%rip), %rsi     # 0x14c59f
xorl %r15d, %r15d
xorl %eax, %eax
callq 0xe9461
movq %r14, %rsi
movb $0x1, %bpl
leaq 0x43dcf(%rip), %r14     # 0x14c80d
movq %rsi, %r12
movq 0x38(%rsi,%r15,8), %rdx
testq %rdx, %rdx
je 0x108a6c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe9461
movq %r12, %rsi
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x108a41
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x108a89
leaq 0x43d9b(%rip), %rsi     # 0x14c817
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
movq %r12, %rsi
movq 0x10(%rsi), %rdx
testq %rdx, %rdx
je 0x108aad
leaq 0x43d8e(%rip), %rsi     # 0x14c827
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
movq %r12, %rsi
movl $0x1, %eax
jmp 0x108aaf
xorl %eax, %eax
movl 0x30(%rsi), %ecx
testb $0x40, %cl
je 0x108ad5
leaq 0x43d79(%rip), %rsi     # 0x14c837
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
movq %r12, %rsi
movl 0x30(%r12), %ecx
movl $0x1, %eax
testb %cl, %cl
js 0x108b10
cmpq $0x0, 0x28(%rsi)
jne 0x108b2c
testl %eax, %eax
leaq 0x3c5c7(%rip), %rax     # 0x1450b0
leaq 0x43ddc(%rip), %rdx     # 0x14c8cc
cmoveq %rax, %rdx
movq (%rsi), %rcx
leaq 0x43da9(%rip), %rsi     # 0x14c8a7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe9461
leaq 0x43d61(%rip), %rsi     # 0x14c878
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
movq %r12, %rsi
cmpq $0x0, 0x28(%r12)
je 0x108b54
movq (%rsi), %rdx
movq %rsi, %r14
leaq 0x43d9a(%rip), %rsi     # 0x14c8d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x28(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_destroy
void de_destroy(deark *c)
{
	int i;

	if(!c) return;
	if(c->zip_data) { de_zip_close_file(c); }
	if(c->tar_data) { de_tar_close_file(c); }
	if(c->extrlist_dbuf) { dbuf_close(c->extrlist_dbuf); }
	for(i=0; i<c->num_ext_options; i++) {
		de_free(c, c->ext_option[i].name);
		de_free(c, c->ext_option[i].val);
	}
	if(c->base_output_filename) { de_free(c, c->base_output_filename); }
	if(c->special_1st_filename) { de_free(c, c->special_1st_filename); }
	if(c->output_archive_filename) { de_free(c, c->output_archive_filename); }
	if(c->extrlist_filename) { de_free(c, c->extrlist_filename); }
	if(c->detection_data) { de_free(c, c->detection_data); }
	if(c->mp_data) {
		for(i=0; i<c->mp_data->count; i++) {
			dbuf_close(c->mp_data->item[i].f);
			// (The .fn field is owned by the caller (deark-cmd.c)).
		}
		de_free(c, c->mp_data->item);
		de_free(c, c->mp_data);
	}
	for(i=0; i<DE_NUM_PERSISTENT_MEM_ITEMS; i++) {
		if(c->persistent_item[i]) {
			de_free(c, c->persistent_item[i]);
		}
	}
	de_free(c, c->module_info);
	de_free(NULL,c);
}

// Assembly:
testq %rdi, %rdi
je 0x108d68
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x138(%rdi)
je 0x108c1a
movq %rbx, %rdi
callq 0xed91f
cmpq $0x0, 0x140(%rbx)
je 0x108c2c
movq %rbx, %rdi
callq 0xedc6a
movq 0x148(%rbx), %rdi
testq %rdi, %rdi
je 0x108c3d
callq 0xf052b
cmpl $0x0, 0x1b8(%rbx)
jle 0x108c7a
leaq 0x1c8(%rbx), %r14
xorl %r15d, %r15d
movq -0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xe8be2
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xe8be2
incq %r15
movslq 0x1b8(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x108c50
movq 0x150(%rbx), %rsi
testq %rsi, %rsi
je 0x108c8e
movq %rbx, %rdi
callq 0xe8be2
movq 0x158(%rbx), %rsi
testq %rsi, %rsi
je 0x108ca2
movq %rbx, %rdi
callq 0xe8be2
movq 0x160(%rbx), %rsi
testq %rsi, %rsi
je 0x108cb6
movq %rbx, %rdi
callq 0xe8be2
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0x108cca
movq %rbx, %rdi
callq 0xe8be2
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x108cdb
movq %rbx, %rdi
callq 0xe8be2
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x108d2a
cmpl $0x0, (%rax)
jle 0x108d12
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rax), %rax
movq (%rax,%r14), %rdi
callq 0xf052b
incq %r15
movq 0x30(%rbx), %rax
movslq (%rax), %rcx
addq $0x10, %r14
cmpq %rcx, %r15
jl 0x108cf2
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xe8be2
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
callq 0xe8be2
movl $0x58, %r14d
movq (%rbx,%r14,8), %rsi
testq %rsi, %rsi
je 0x108d41
movq %rbx, %rdi
callq 0xe8be2
incq %r14
cmpq $0x5e, %r14
jne 0x108d30
movq 0x1b0(%rbx), %rsi
movq %rbx, %rdi
callq 0xe8be2
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe8be2
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_filename_pattern
void de_set_output_filename_pattern(deark *c, const char *dirname, const char *fn,
	unsigned int flags)
{
	if(c->base_output_filename) de_free(c, c->base_output_filename);
	c->base_output_filename = NULL;
	if(!fn && !dirname) return;
	if(!fn) fn = "output";
	if(c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
		flags |= 0x4;
	}
	c->base_output_filename = make_output_filename(c, dirname, fn, NULL, flags);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x150(%rdi), %rsi
testq %rsi, %rsi
je 0x108db1
movq %rbx, %rdi
callq 0xe8be2
movq $0x0, 0x150(%rbx)
movq %r14, %rax
orq %r15, %rax
je 0x108df5
testq %r15, %r15
leaq 0x42e50(%rip), %rdx     # 0x14bc1e
cmovneq %r15, %rdx
movl %ebp, %r8d
orl $0x4, %r8d
cmpl $0x1, 0x7c(%rbx)
cmovnel %ebp, %r8d
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x108e00
movq %rax, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_special_1st_filename
void de_set_output_special_1st_filename(deark *c, const char *dirname, const char *fn)
{
	if(c->special_1st_filename) {
		de_free(c, c->special_1st_filename);
		c->special_1st_filename = NULL;
	}
	if(fn) {
		UI flags = 0;

		if(c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
			flags |= 0x4;
		}

		c->special_1st_filename = make_output_filename(c, dirname, fn, NULL, flags);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x158(%rdi), %rsi
testq %rsi, %rsi
je 0x108f91
movq %rbx, %rdi
callq 0xe8be2
movq $0x0, 0x158(%rbx)
testq %r14, %r14
je 0x108fbc
xorl %r8d, %r8d
cmpl $0x1, 0x7c(%rbx)
sete %r8b
shll $0x2, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x108e00
movq %rax, 0x158(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_archive_filename
void de_set_output_archive_filename(deark *c, const char *dname, const char *fn,
	unsigned int flags)
{
	const char *suffix = NULL;
	if(c->output_archive_filename) de_free(c, c->output_archive_filename);

	if(flags&0x10) {
		c->archive_to_stdout = 1;
		return;
	}

	if((flags & 0x20) && c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
		if(c->archive_fmt==DE_ARCHIVEFMT_ZIP) {
			suffix = ".zip";
		}
		else if(c->archive_fmt==DE_ARCHIVEFMT_TAR) {
			suffix = ".tar";
		}
		else {
			suffix = ".err";
		}
	}

	c->output_archive_filename = make_output_filename(c, dname, fn, suffix, flags);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x160(%rdi), %rsi
testq %rsi, %rsi
je 0x108fe8
movq %rbx, %rdi
callq 0xe8be2
testb $0x10, %bpl
jne 0x109025
testb $0x20, %bpl
je 0x10902e
cmpl $0x1, 0x7c(%rbx)
jne 0x10902e
movl 0x80(%rbx), %eax
cmpl $0x2, %eax
leaq 0x400f6(%rip), %rcx     # 0x149100
leaq 0x4379f(%rip), %rdx     # 0x14c7b0
cmoveq %rcx, %rdx
cmpl $0x1, %eax
leaq 0x3ff47(%rip), %rcx     # 0x148f66
cmovneq %rdx, %rcx
jmp 0x109030
movb $0x1, 0x88(%rbx)
jmp 0x109048
xorl %ecx, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %r8d
callq 0x108e00
movq %rax, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_extrlist_filename
void de_set_extrlist_filename(deark *c, const char *fn)
{
	if(c->extrlist_filename) de_free(c, c->extrlist_filename);
	c->extrlist_filename = NULL;
	if(fn) {
		c->extrlist_filename = de_strdup(c, fn);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x168(%rdi), %rsi
testq %rsi, %rsi
je 0x109071
movq %rbx, %rdi
callq 0xe8be2
movq $0x0, 0x168(%rbx)
testq %r14, %r14
je 0x109093
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9865
movq %rax, 0x168(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_input_filename
void de_set_input_filename(deark *c, const char *fn, UI flags)
{
	if(c->input_filename && (flags&0x1)) {
		de_add_input_filename_mp(c, fn);
	}
	else {
		c->input_filename = fn;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testb $0x1, %dl
je 0x10918b
cmpq $0x0, 0x50(%r14)
je 0x10918b
movq 0x30(%r14), %rax
testq %rax, %rax
jne 0x109167
movl $0x10, %esi
movq %r14, %rdi
callq 0xe8b2b
movq %rax, 0x30(%r14)
movslq (%rax), %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
jl 0x109191
leaq 0x4376f(%rip), %rsi     # 0x14c8e9
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9295
movb $0x1, 0x4c(%r14)
jmp 0x1091d8
movq %rbx, 0x50(%r14)
jmp 0x1091d8
leal 0x1(%r15), %ebp
cmpl 0x4(%rax), %r15d
jge 0x1091a1
movq 0x8(%rax), %rcx
jmp 0x1091ce
movq %r15, %r12
addq $0x10, %r12
movq 0x8(%rax), %rsi
movl $0x10, %ecx
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %r8
callq 0xe9758
movq %rax, %rcx
movq 0x30(%r14), %rax
movq %rcx, 0x8(%rax)
movl %r12d, 0x4(%rax)
shlq $0x4, %r15
movq %rbx, (%rcx,%r15)
movl %ebp, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_max_output_file_size
void de_set_max_output_file_size(deark *c, i64 n)
{
	if(n<0) n=0;
	c->max_output_file_size = n;
	if(c->max_total_output_size < n) {
		c->max_total_output_size = n;
	}
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
cmovgq %rsi, %rax
movq %rax, 0xb0(%rdi)
cmpq %rax, 0xb8(%rdi)
jge 0x109281
movq %rax, 0xb8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-user.c
// Function: de_set_ext_option
void de_set_ext_option(deark *c, const char *name, const char *val)
{
	int n;

	n = c->num_ext_options;
	if(n>=DE_MAX_EXT_OPTIONS) return;
	if(!name || !val) return;

	c->ext_option[n].name = de_strdup(c, name);
	c->ext_option[n].val = de_strdup(c, val);
	c->num_ext_options++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x1b8(%rdi), %r15
cmpq $0xf, %r15
jg 0x10932e
movq %rdx, %r14
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x10932e
movq %rdi, %rbx
callq 0xe9865
shlq $0x4, %r15
movq %rax, 0x1c0(%rbx,%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9865
movq %rax, 0x1c8(%rbx,%r15)
incl 0x1b8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-unix.c
// Function: de_fopen_for_read
FILE* de_fopen_for_read(deark *c, const char *fn, i64 *len,
	char *errmsg, size_t errmsg_len, unsigned int *returned_flags)
{
	int ret;
	FILE *f;

	f = de_fopen(c, fn, "rb", errmsg, errmsg_len);
	if(!f) {
		return NULL;
	}

	ret = de_examine_file_by_fd(c, fileno(f), len, errmsg, errmsg_len,
		returned_flags);
	if(!ret) {
		de_fclose(f);
		return NULL;
	}

	return f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rdi
leaq 0x18811(%rip), %rsi     # 0x121bba
movq %rcx, %rdx
movq %r8, %rcx
callq 0x10946b
testq %rax, %rax
je 0x109416
movq %rax, %rbx
movq %r12, (%rsp)
movq %rax, %rdi
callq 0x181f0
movl %eax, %ebp
movl $0x0, (%r13)
leaq 0x8(%rsp), %r12
movl $0x90, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x18140
movl %ebp, %edi
movq %r12, %rsi
callq 0x182b0
testl %eax, %eax
je 0x10942d
callq 0x18040
movl (%rax), %edi
callq 0x182c0
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xe8219
movq %rbx, %rdi
callq 0x180d0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
movl %eax, %ecx
negw %cx
jo 0x109451
cmpl $0x1000, %eax           # imm = 0x1000
movq (%rsp), %rcx
jne 0x10945f
orb $0x1, (%r13)
xorl %eax, %eax
jmp 0x10945a
movq 0x38(%rsp), %rax
movq (%rsp), %rcx
movq %rax, (%rcx)
jmp 0x109418
leaq 0x19c7e(%rip), %rsi     # 0x1230e4
movq %r15, %rdi
jmp 0x109406
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-unix.c
// Function: de_fopen
static FILE* de_fopen(deark *c, const char *fn, const char *mode,
	char *errmsg, size_t errmsg_len)
{
	FILE *f;
	int errcode;

	f = fopen(fn, mode);
	if(!f) {
		errcode = errno;
		de_strlcpy(errmsg, strerror(errcode), errmsg_len);
	}
	return f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x181d0
movq %rax, %r15
testq %rax, %rax
jne 0x10949d
callq 0x18040
movl (%rax), %edi
callq 0x182c0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xe8219
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq