LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
movq %rdx, %rbx
cmpq $0x1b, 0x50(%rsi)
jl 0xf96fd
movq %rsi, %r14
cmpq $0x2d2e, 0x40(%rsi)     # imm = 0x2D2E
jne 0xf96fd
cmpq $0x3d2, 0x10(%r14)      # imm = 0x3D2
jne 0xf96fd
movq (%r14), %rdi
leaq 0x455ee(%rip), %rdx     # 0x13ec9b
pushq $0x10
popq %rcx
movl $0x2bf8, %esi           # imm = 0x2BF8
callq 0xe4d48
testl %eax, %eax
jne 0xf96fd
movq 0x48(%r14), %rsi
pushq $0x68
popq %rdx
movq %rsp, %rcx
movq %r14, %rdi
callq 0xf955f
testl %eax, %eax
je 0xf96fd
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 0x25c56(%rip), %rax     # 0x11f34f
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0xf9720
addq $0x50, %rbx
leaq 0x4559e(%rip), %rsi     # 0x13ecac
pushq $0x28
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde492
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf946d
testl %eax, %eax
je 0xf9770
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 0xf9770
movb $0x64, 0x1(%rbx)
movb $0x1, 0x3(%rbx)
leaq 0x3e4c6(%rip), %rax     # 0x137c32
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0xf9793
addq $0x50, %rbx
leaq 0x25691(%rip), %rsi     # 0x11ee12
pushq $0x28
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde492
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
callq 0xf9044
movabsq $-0x7e97e7ad2c77d4e8, %rax # imm = 0x81681852D3882B18
cmpq %rax, 0x68(%r14)
jne 0xf99ea
movl $0x20d, %esi            # imm = 0x20D
addq 0x40(%r14), %rsi
pushq $0x7a
popq %rdx
movq %rsp, %rcx
movq %r14, %rdi
callq 0xf955f
testl %eax, %eax
je 0xf99ea
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 0xf99ea
movb $0x64, 0x1(%rbx)
movb $0x1, 0x3(%rbx)
leaq 0x258ca(%rip), %rax     # 0x11f2b0
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0xf9a0d
addq $0x50, %rbx
leaq 0x25aa0(%rip), %rsi     # 0x11f49b
pushq $0x28
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde492
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0xf9427
movzbl 0xb0(%r14), %ebp
cmpl $0xfe, %ebp
je 0xf9b4f
cmpl $0x1a, %ebp
jne 0xf9bc8
leaq 0x70(%r14), %r15
leaq 0x4516a(%rip), %rsi     # 0x13ecc4
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x18230
testl %eax, %eax
je 0xf9b7c
movabsq $0x6516892e0353bafb, %rax # imm = 0x6516892E0353BAFB
cmpq %rax, (%r15)
jne 0xf9bc8
movb $0x1, %al
jmp 0xf9b87
cmpq $0xa60, 0x40(%r14)      # imm = 0xA60
setne %al
cmpb $0x1a, %bpl
sete %cl
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 0xf9bc8
testb %al, %al
je 0xf9bc4
andb %al, %cl
movb $0x64, 0x1(%rbx)
movb %cl, 0x3(%rbx)
leaq 0xda58(%rip), %rax      # 0x107616
movq %rax, 0x40(%rbx)
jmp 0xf9bc8
movb $0x67, 0x1(%rbx)
movzbl 0x1(%rbx), %eax
cmpl $0x67, %eax
je 0xf9bd6
cmpl $0x64, %eax
jne 0xf9bf6
addq $0x50, %rbx
leaq 0x450f3(%rip), %rsi     # 0x13ecd4
pushq $0x28
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xde492
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpq $0x8, 0x50(%rsi)
jl 0xf9c76
movq %rsi, %r14
movq %rsi, %rdi
callq 0xf9427
leaq 0xb0(%r14), %r15
leaq 0x450af(%rip), %rsi     # 0x13ecd8
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x18230
testl %eax, %eax
je 0xf9c41
cmpl $0x5e7e4552, (%r15)     # imm = 0x5E7E4552
jne 0xf9c76
movq (%r14), %rdi
leaq 0x45094(%rip), %rdx     # 0x13ecdf
pushq $0x1c
popq %rsi
pushq $0x4
popq %rcx
callq 0xe4d48
testl %eax, %eax
jne 0xf9c76
movups 0x48(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x3(%rbx)
movb $0x64, 0x1(%rbx)
leaq 0x3e136(%rip), %rax     # 0x137da8
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0xf9c97
addq $0x50, %rbx
leaq 0x4505d(%rip), %rsi     # 0x13ece4
pushq $0x28
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xde492
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf9d06
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xf9427
leaq 0xc4(%r14), %rdi
callq 0xe409c
cmpl $0xfdc4a7dc, %eax       # imm = 0xFDC4A7DC
jne 0xf9d06
movq %r15, %rdi
movq %r14, %rsi
callq 0xf9044
movl 0x6c(%r14), %eax
cmpl $0x6d384fa1, %eax       # imm = 0x6D384FA1
je 0xf9cea
cmpl $0xec5138de, %eax       # imm = 0xEC5138DE
jne 0xf9d06
movups 0x48(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x3(%rbx)
movb $0x64, 0x1(%rbx)
leaq 0x3d996(%rip), %rax     # 0x137698
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0xf9d27
addq $0x50, %rbx
leaq 0x44fd1(%rip), %rsi     # 0x13ece8
pushq $0x28
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xde492
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
movq %rdx, %rbx
cmpq $0x54, 0x50(%rsi)
jl 0xf9d79
movq %rsi, %r14
movq (%rsi), %rdi
movq 0x48(%rsi), %rsi
pushq $0x10
popq %rdx
movq %rsp, %r8
xorl %ecx, %ecx
callq 0xee14d
testl %eax, %eax
je 0xf9d79
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 0xf9d95
addq $0x50, %rbx
leaq 0x110d1(%rip), %rsi     # 0x10ae5b
pushq $0x28
popq %rdx
movq %rbx, %rdi
callq 0xde492
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf9427
cmpl $0x4e494246, 0xb0(%r14) # imm = 0x4E494246
jne 0xf9e7a
leaq 0xb4(%r14), %rdi
callq 0xe409c
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 0xf9e7a
leaq 0x44ef6(%rip), %rdx     # 0x13ecf1
pushq $0x4
popq %rcx
movq %r15, %rsi
callq 0xe4d48
testl %eax, %eax
jne 0xf9e7a
addq $0x4, %r15
movq %rsp, %r12
movq %r15, (%r12)
movq (%r14), %rdi
movq %r12, %rsi
callq 0xe40bf
movq %rax, 0x18(%rbx)
movq (%r12), %rsi
movq %rsi, 0x10(%rbx)
cmpq $0x20, %rax
jl 0xf9e7a
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 0xf9e7a
leaq 0x44e9b(%rip), %rdx     # 0x13ecf6
pushq $0x2
popq %rcx
callq 0xe4d48
testl %eax, %eax
jne 0xf9e7a
movb $0x1, 0x3(%rbx)
movb $0x64, 0x1(%rbx)
leaq 0x1c8ff(%rip), %rax     # 0x116775
movq %rax, 0x40(%rbx)
cmpb $0x64, 0x1(%rbx)
jne 0xf9e96
addq $0x50, %rbx
leaq 0x44e6e(%rip), %rsi     # 0x13ecf9
pushq $0x28
popq %rdx
movq %rbx, %rdi
callq 0xde492
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf9ef4
pushq $0x3
popq %rax
xorl %edi, %edi
jmp 0xf9f44
cmpl $0x4f, %edi
ja 0xf9f03
addl $-0x10, %edi
shrl $0x4, %edi
pushq $0x4
jmp 0xf9f43
cmpl $0x8f, %edi
ja 0xf9f15
addl $-0x30, %edi
shrl $0x3, %edi
pushq $0x5
jmp 0xf9f43
cmpl $0xbf, %edi
ja 0xf9f27
addl $-0x60, %edi
shrl $0x2, %edi
pushq $0x6
jmp 0xf9f43
cmpl $0xef, %edi
ja 0xf9f3b
addl $0xffffff70, %edi       # imm = 0xFFFFFF70
shrl %edi
pushq $0x7
jmp 0xf9f43
addl $0xffffff40, %edi       # imm = 0xFFFFFF40
pushq $0x8
popq %rax
movl %edi, (%rsi)
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfa2c8
cmpl $0x0, 0x54(%r14)
jne 0xfa2c8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xfa3e5
cmpl $0x0, 0x54(%r14)
je 0xfa2d3
movb $0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xfa3e5
leaq 0x70(%rbx), %rdi
movl 0x74(%rbx), %eax
shrl $0x3, %eax
subq %rax, 0x58(%rbx)
callq 0xe6a40
movq 0x58(%rbx), %rax
movq 0x8(%r14), %rsi
movq %rax, 0x8(%rsi)
movb $0x1, 0x4(%rsi)
cmpl $0x0, 0x54(%rbx)
je 0xfa331
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xee91c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfa380
cmpl $0x3, %esi
jne 0xfa38f
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xfa3e5
leaq 0x70(%rbx), %rdi
movl 0x74(%rbx), %eax
shrl $0x3, %eax
subq %rax, 0x58(%rbx)
callq 0xe6a40
cmpb $0x0, 0x14(%rbx)
je 0xfa38f
movq 0x68(%rbx), %rdi
movl 0x10(%rdi), %esi
addl $0x3c, %esi
popq %rbx
jmp 0xef6f0
xorps %xmm0, %xmm0
movups %xmm0, 0x54(%rbx)
andl $0x0, 0x64(%rbx)
movb $0x0, 0x20(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfa3bd
movq (%r14), %rdi
movq 0x68(%r14), %rsi
callq 0xef395
andq $0x0, 0x68(%r14)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xded32
andq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/lzhuf.h
// Function: lzhuf_getbits
static UI lzhuf_getbits(struct lzahuf_ctx *cctx, UI nbits)
{
	if(cctx->bbll.nbits_in_bitbuf < nbits) {
		cctx->errflag = 1;
		return 0;
	}
	return (UI)de_bitbuf_lowlevel_get_bits(&cctx->bbll, nbits);
}

// Assembly:
cmpl %esi, 0x74(%rdi)
jae 0xfabee
movl $0x1, 0x54(%rdi)
xorl %eax, %eax
retq
pushq %rax
addq $0x70, %rdi
callq 0xe69f9
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0xfabbd
testl %eax, %eax
jne 0xfac25
movq 0x20(%rbx), %rax
movq (%rax), %rdi
movzbl %bpl, %esi
callq 0xe5bc5
incq 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %r12d
movq %rdi, %rbx
movl %r12d, %r13d
movzwl 0xcd6(%rbx,%r13,2), %r12d
cmpl %r12d, 0x3c(%rbx)
jbe 0xfac7a
leaq (%r15,%r15), %rdx
incl %ebp
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %ecx
movq %r14, %r8
callq 0xfac2c
incl %r12d
leaq 0x1(,%r15,2), %r15
jmp 0xfac45
movq (%rbx), %r12
pushq $0x48
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xdfc03
movzwl 0xcd6(%rbx,%r13,2), %ecx
movl %ecx, %r8d
subl 0x3c(%rbx), %r8d
leaq 0x44133(%rip), %rsi     # 0x13edd7
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 0xde896
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xfad8b
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0xfad8b
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 0xfad2e
movq $0x2, 0x48(%rbx)
cmpq $0x0, 0x50(%rbx)
jne 0xfad3d
movq $0x4, 0x50(%rbx)
cmpl $0x0, 0x60(%rbx)
jne 0xfad4a
movl $0x1, 0x60(%rbx)
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0xdecaf
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 0xfad95
andq $0x0, 0x8(%rbx)
movq %r12, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xded32
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfb611
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 0xeac74
movq %rax, %r15
movq 0x18(%rbp), %rdi
movl 0x60(%rbp), %eax
movl %eax, (%rsp)
pushq $0x1
popq %r9
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %r8
callq 0xe4ced
movq %r15, %rdi
callq 0xeb7e4
leaq 0x238cf(%rip), %rsi     # 0x11eeba
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xfb704
movslq 0x1a8(%rbx), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0xdf66f
movq %rax, %r14
movslq 0x1a8(%rbx), %rsi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
leaq 0x8(%r14), %rdx
cmpq %rax, %rcx
je 0xfb667
movq %rbx, -0x8(%rdx)
movl %eax, (%rdx)
incq %rax
addq $0x10, %rdx
jmp 0xfb653
leaq 0xb2(%rip), %rcx        # 0xfb720
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x18070
movq %r14, %r12
addq $0x8, %r12
leaq 0x23d58(%rip), %r13     # 0x11f3df
leaq 0x438d6(%rip), %r15     # 0x13ef64
xorl %ebp, %ebp
movslq 0x1a8(%rbx), %rax
cmpq %rax, %rbp
jge 0xfb6eb
movslq (%r12), %rcx
movq 0x1b0(%rbx), %rax
imulq $0x48, %rcx, %rdx
movq (%rax,%rdx), %rcx
testq %rcx, %rcx
je 0xfb6e2
cmpl $0x1, 0x90(%rbx)
jg 0xfb6c7
leaq (%rax,%rdx), %rsi
testb $0x23, 0x30(%rsi)
jne 0xfb6e2
movq 0x8(%rax,%rdx), %r8
testq %r8, %r8
cmoveq %r13, %r8
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0xde7db
incq %rbp
addq $0x10, %r12
jmp 0xfb690
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq %rsi, %r12
movq (%rsi), %rdx
leaq 0x430ae(%rip), %rsi     # 0x13f09f
xorl %eax, %eax
callq 0xdf42e
pushq $0x7
popq %r15
leaq 0x4330a(%rip), %r14     # 0x13f30d
cmpq $0x9, %r15
movq %r12, %rcx
je 0xfc027
movq (%rcx,%r15,8), %rdx
testq %rdx, %rdx
je 0xfc027
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xdf42e
incq %r15
jmp 0xfc003
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xfc044
leaq 0x432e0(%rip), %rsi     # 0x13f317
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
movq %r12, %rcx
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0xfc066
pushq $0x1
popq %rbp
leaq 0x432d0(%rip), %rsi     # 0x13f327
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
movq %r12, %rcx
jmp 0xfc068
xorl %ebp, %ebp
movl 0x30(%rcx), %eax
testb $0x40, %al
je 0xfc08b
leaq 0x432c1(%rip), %rsi     # 0x13f337
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
movq %r12, %rcx
movl 0x30(%r12), %eax
pushq $0x1
popq %rbp
testb %al, %al
js 0xfc0c6
cmpq $0x0, 0x28(%rcx)
jne 0xfc0e2
testl %ebp, %ebp
leaq 0x3bbc1(%rip), %rax     # 0x137c60
leaq 0x43326(%rip), %rdx     # 0x13f3cc
cmoveq %rax, %rdx
movq (%rcx), %rcx
leaq 0x432f3(%rip), %rsi     # 0x13f3a7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xdf42e
leaq 0x432ab(%rip), %rsi     # 0x13f378
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
movq %r12, %rcx
cmpq $0x0, 0x28(%r12)
je 0xfc10a
movq (%rcx), %rdx
movq %rcx, %r14
leaq 0x432e4(%rip), %rsi     # 0x13f3d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
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_O2/jsummers[P]deark/src/deark-user.c
// Function: de_create_internal
deark *de_create_internal(void)
{
	deark *c;
	c = de_malloc(NULL,sizeof(deark));
	c->show_infomessages = 1;
	c->show_warnings = 1;
	c->write_bom = 1;
	c->write_density = 1;
	c->filenames_from_file = 1;
	c->append_riscos_type = 0xff;
	c->preserve_file_times = 1;
	c->preserve_file_times_archives = 1;
	c->preserve_file_times_internal = 1;
	c->max_output_files = DE_MAX_OUTPUT_FILES_HARD_LIMIT;
	c->max_image_dimension = DE_DEFAULT_MAX_IMAGE_DIMENSION;
	c->max_output_file_size = DE_DEFAULT_MAX_FILE_SIZE;
	c->max_total_output_size = DE_DEFAULT_MAX_TOTAL_OUTPUT_SIZE;
	c->current_time.is_valid = 0;
	c->can_decode_fltpt = -1; // = unknown
	c->host_is_le = -1; // = unknown
	c->input_encoding = DE_ENCODING_UNKNOWN;
	return c;
}

// Assembly:
pushq %rax
movl $0x2f0, %esi            # imm = 0x2F0
xorl %edi, %edi
callq 0xdecaf
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0xc0(%rax)
movw $0x101, %cx             # imm = 0x101
movw %cx, 0xcc(%rax)
movb $0x1, %dl
movb %dl, 0xd0(%rax)
movb $-0x1, 0xd4(%rax)
movw %cx, 0xdc(%rax)
movb %dl, 0xde(%rax)
movl $0x3d090, 0x9c(%rax)    # imm = 0x3D090
movq $0x2710, 0xa8(%rax) # imm = 0x2710
movabsq $0x280000000, %rcx      # imm = 0x280000000
movq %rcx, 0xb0(%rax)
movabsq $0x3c0000000, %rcx      # imm = 0x3C0000000
movq %rcx, 0xb8(%rax)
movb $0x0, 0x190(%rax)
orq $-0x1, 0xf0(%rax)
andl $0x0, 0xfc(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc308
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x138(%rdi)
je 0xfc1ca
movq %rbx, %rdi
callq 0xe2dec
cmpq $0x0, 0x140(%rbx)
je 0xfc1dc
movq %rbx, %rdi
callq 0xe312a
movq 0x148(%rbx), %rdi
testq %rdi, %rdi
je 0xfc1ed
callq 0xe5591
leaq 0x1c8(%rbx), %r14
xorl %r15d, %r15d
movslq 0x1b8(%rbx), %rax
cmpq %rax, %r15
jge 0xfc223
movq -0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xded32
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xded32
incq %r15
addq $0x10, %r14
jmp 0xfc1f7
movq 0x150(%rbx), %rsi
testq %rsi, %rsi
je 0xfc237
movq %rbx, %rdi
callq 0xded32
movq 0x158(%rbx), %rsi
testq %rsi, %rsi
je 0xfc24b
movq %rbx, %rdi
callq 0xded32
movq 0x160(%rbx), %rsi
testq %rsi, %rsi
je 0xfc25f
movq %rbx, %rdi
callq 0xded32
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0xfc273
movq %rbx, %rdi
callq 0xded32
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0xfc284
movq %rbx, %rdi
callq 0xded32
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xfc2ca
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq (%rax), %rcx
movq 0x8(%rax), %rsi
cmpq %rcx, %r15
jge 0xfc2b6
movq (%rsi,%r14), %rdi
callq 0xe5591
incq %r15
movq 0x30(%rbx), %rax
addq $0x10, %r14
jmp 0xfc294
movq %rbx, %rdi
callq 0xded32
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
callq 0xded32
pushq $0x58
popq %r14
cmpq $0x5e, %r14
je 0xfc2ea
movq (%rbx,%r14,8), %rsi
testq %rsi, %rsi
je 0xfc2e5
movq %rbx, %rdi
callq 0xded32
incq %r14
jmp 0xfc2ce
movq 0x1b0(%rbx), %rsi
movq %rbx, %rdi
callq 0xded32
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc351
movq %rbx, %rdi
callq 0xded32
andq $0x0, 0x150(%rbx)
movq %r14, %rax
orq %r15, %rax
je 0xfc392
testq %r15, %r15
leaq 0x423b7(%rip), %rdx     # 0x13e722
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 0xfc39d
movq %rax, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc514
movq %rbx, %rdi
callq 0xded32
andq $0x0, 0x158(%rbx)
testq %r14, %r14
je 0xfc53f
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 0xfc39d
movq %rax, 0x158(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc56b
movq %rbx, %rdi
callq 0xded32
testb $0x10, %bpl
jne 0xfc5a8
testb $0x20, %bpl
je 0xfc5b1
cmpl $0x1, 0x7c(%rbx)
jne 0xfc5b1
movl 0x80(%rbx), %eax
cmpl $0x2, %eax
leaq 0x3f6a3(%rip), %rcx     # 0x13bc30
leaq 0x42d1c(%rip), %rdx     # 0x13f2b0
cmoveq %rcx, %rdx
cmpl $0x1, %eax
leaq 0x3f4f4(%rip), %rcx     # 0x13ba96
cmovneq %rdx, %rcx
jmp 0xfc5b3
movb $0x1, 0x88(%rbx)
jmp 0xfc5cb
xorl %ecx, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %r8d
callq 0xfc39d
movq %rax, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc5f4
movq %rbx, %rdi
callq 0xded32
andq $0x0, 0x168(%rbx)
testq %r14, %r14
je 0xfc613
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdf791
movq %rax, 0x168(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc709
cmpq $0x0, 0x50(%r14)
je 0xfc709
movq 0x30(%r14), %rax
testq %rax, %rax
jne 0xfc6e5
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0xdecaf
movq %rax, 0x30(%r14)
movslq (%rax), %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
jl 0xfc70f
leaq 0x42cf1(%rip), %rsi     # 0x13f3e9
movq %r14, %rdi
xorl %eax, %eax
callq 0xdf2a5
movb $0x1, 0x4c(%r14)
jmp 0xfc754
movq %rbx, 0x50(%r14)
jmp 0xfc754
leal 0x1(%r15), %ebp
cmpl 0x4(%rax), %r15d
jge 0xfc71f
movq 0x8(%rax), %rcx
jmp 0xfc74a
movq %r15, %r12
addq $0x10, %r12
movq 0x8(%rax), %rsi
pushq $0x10
popq %rcx
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %r8
callq 0xdf6b6
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_O2/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 0xfc7fb
movq %rax, 0xb8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc8a8
movq %rdx, %r14
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0xfc8a8
movq %rdi, %rbx
callq 0xdf791
shlq $0x4, %r15
movq %rax, 0x1c0(%rbx,%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdf791
movq %rax, 0x1c8(%rbx,%r15)
incl 0x1b8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x181a9(%rip), %rsi     # 0x114aca
movq %rcx, %rdx
movq %r8, %rcx
callq 0xfc9e0
testq %rax, %rax
je 0xfc98b
movq %rax, %rbx
movq %r12, (%rsp)
movq %rax, %rdi
callq 0x181f0
movl %eax, %ebp
andl $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 0xfc9a2
callq 0x18040
movl (%rax), %edi
callq 0x182c0
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xde492
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 0xfc9c6
cmpl $0x1000, %eax           # imm = 0x1000
movq (%rsp), %rcx
jne 0xfc9d4
orb $0x1, (%r13)
xorl %eax, %eax
jmp 0xfc9cf
movq 0x38(%rsp), %rax
movq (%rsp), %rcx
movq %rax, (%rcx)
jmp 0xfc98d
leaq 0x19549(%rip), %rsi     # 0x115f24
movq %r15, %rdi
jmp 0xfc97b
// File: /workspace/github_c_makefile_star2_O2/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 0xfca12
callq 0x18040
movl (%rax), %edi
callq 0x182c0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xde492
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-unix.c
// Function: de_fopen_for_write
FILE* de_fopen_for_write(deark *c, const char *fn,
	char *errmsg, size_t errmsg_len, int overwrite_mode,
	unsigned int flags)
{
	const char *mode;

	// A simple check to make it harder to accidentally overwrite the input
	// file. (But it can easily be defeated.)
	// TODO?: Make this more robust.
	if(c->input_filename && !de_strcmp(fn, c->input_filename)) {
		de_err(c, "Refusing to write to %s: Same as input filename", fn);
		de_fatalerror(c);
		de_strlcpy(errmsg, "", errmsg_len);
		return NULL;
	}

	if(overwrite_mode!=DE_OVERWRITEMODE_STANDARD) {
		// Check if the file already exists.
		struct stat stbuf;
		int s_ret;

		de_zeromem(&stbuf, sizeof(struct stat));
#if DE_USE_LSTAT
		s_ret = lstat(fn, &stbuf);
#else
		s_ret = stat(fn, &stbuf);
#endif

		 // s_ret==0 = "success"
		if(s_ret==0 && overwrite_mode==DE_OVERWRITEMODE_NEVER) {
			de_strlcpy(errmsg, "Output file already exists", errmsg_len);
			return NULL;
		}

		if(s_ret==0 && overwrite_mode==DE_OVERWRITEMODE_DEFAULT) {
			if(S_ISLNK(stbuf.st_mode)) {
				de_strlcpy(errmsg, "Output file is a symlink", errmsg_len);
				return NULL;
			}
		}
	}

	mode = (flags&0x1) ? "ab" : "wb";
	return de_fopen(c, fn, mode, errmsg, errmsg_len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %ebp
movl %r8d, %r12d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0xfca58
movq %rdi, %r13
movq %r15, %rdi
callq 0x181a0
testl %eax, %eax
je 0xfca94
cmpl $0x2, %r12d
je 0xfcaf4
leaq 0x8(%rsp), %r13
movl $0x90, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x18140
movq %r15, %rdi
movq %r13, %rsi
callq 0x180c0
movl %r12d, %ecx
xorl $0x1, %ecx
orl %eax, %ecx
jne 0xfcad6
leaq 0x429a6(%rip), %rsi     # 0x13f438
jmp 0xfcab7
leaq 0x4296d(%rip), %rsi     # 0x13f408
movq %r13, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xdf2a5
movq %r13, %rdi
callq 0xdf4d0
leaq 0x3b1a9(%rip), %rsi     # 0x137c60
movq %r14, %rdi
movq %rbx, %rdx
callq 0xde492
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
orl %r12d, %eax
jne 0xfcaf4
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0xa000, %eax           # imm = 0xA000
jne 0xfcaf4
leaq 0x42961(%rip), %rsi     # 0x13f453
jmp 0xfcab7
testb $0x1, %bpl
leaq 0x4296d(%rip), %rax     # 0x13f46c
leaq 0x35183(%rip), %rsi     # 0x131c89
cmoveq %rax, %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfc9e0
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-unix.c
// Function: de_update_file_attribs
void de_update_file_attribs(dbuf *f, u8 preserve_file_times)
{
	struct upd_attr_ctx uactx;

	de_zeromem(&uactx, sizeof(struct upd_attr_ctx));

	update_file_perms(&uactx, f);
	if(preserve_file_times) {
		update_file_time(&uactx, f);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
xorl %ebp, %ebp
movl $0x98, %edx
xorl %esi, %esi
callq 0x18140
movb $0x1, %cl
cmpl $0x2, (%rbx)
jne 0xfcbfc
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0xfcbfc
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xfcbfc
testb $0x3, 0x14(%rax)
je 0xfcbfc
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x180f0
movl %eax, -0x4(%r15)
movl $0x1, -0x8(%r15)
xorl %ebp, %ebp
testl %eax, %eax
je 0xfcba8
xorl %ecx, %ecx
movl %eax, %ebp
jmp 0xfcbfc
movl 0x40(%rsp), %edx
movl %edx, %eax
andl $-0x4a, %eax
movq 0xd0(%rbx), %rcx
movl 0x14(%rcx), %ecx
shll $0x1e, %ecx
sarl $0x1f, %ecx
movl %edx, %r15d
shrl $0x2, %r15d
andl %ecx, %r15d
andl $0x49, %r15d
orl %eax, %r15d
cmpl %edx, %r15d
je 0xfcbfa
movq 0x8(%rbx), %rdi
leaq 0x4288d(%rip), %rsi     # 0x13f46f
xorl %ebp, %ebp
movl %r15d, %ecx
xorl %eax, %eax
callq 0xde9f1
movq 0x68(%rbx), %rdi
movl %r15d, %esi
callq 0x18260
xorl %ecx, %ecx
testb %r14b, %r14b
je 0xfcca4
cmpl $0x2, (%rbx)
jne 0xfcca4
movq 0xd0(%rbx), %r15
testq %r15, %r15
je 0xfcca4
cmpb $0x0, 0x18(%r15)
je 0xfcca4
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xfcca4
leaq 0x18(%r15), %r14
testb %cl, %cl
je 0xfcc42
leaq 0x28(%rsp), %rsi
callq 0x180f0
movl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0xe0461
movq %rax, 0x10(%rsp)
cmpb $0x1f, 0x1a(%r15)
jb 0xfcc77
movq %r14, %rdi
callq 0xe00c9
pushq $0xa
popq %rcx
cqto
idivq %rcx
movq %rax, 0x18(%rsp)
testl %ebp, %ebp
je 0xfcc89
leaq 0x10(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm0, -0x10(%rax)
jmp 0xfcc98
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
andq $0x0, 0x8(%rsp)
movq 0x68(%rbx), %rdi
movq %rsp, %rsi
callq 0x18180
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq