LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_CodePageString2
static void do_prop_CodePageString2(deark *c, lctx *d, struct propset_struct *si,
	const char *name, i64 dpos, int is_dict_name, i64 *bytes_consumed,
	de_ucstring *s)
{
	i64 n_raw;
	int is_utf16 = (si->code_page==1200);
	de_encoding encoding = si->encoding;

	if(is_utf16 && is_dict_name && d->asciipropnames) {
		// A hack that the user can enable. Some dictionaries use an 8-bit
		// encoding even though they have CodePage=1200, and I don't know
		// how to detect this.
		is_utf16 = 0;
		encoding = DE_ENCODING_ASCII;
	}

	n_raw = dbuf_getu32le(d->f, dpos);

	if(is_utf16) {
		i64 n;

		if(is_dict_name) {
			n = n_raw*2;
		}
		else {
			n = n_raw;
		}
		dbuf_read_to_ucstring_n(d->f, dpos+4, n, DE_DBG_MAX_STRLEN*2, s,
			0, encoding);
		ucstring_truncate_at_NUL(s);
		if(is_dict_name) {
			*bytes_consumed = 4 + de_pad_to_4(n_raw*2);
		}
		else {
			*bytes_consumed = 4 + de_pad_to_4(n_raw);
		}
	}
	else {
		dbuf_read_to_ucstring_n(d->f, dpos+4, n_raw, DE_DBG_MAX_STRLEN, s,
			DE_CONVFLAG_STOP_AT_NUL, encoding);
		*bytes_consumed = 4 + n_raw;
	}
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r12
movq %rcx, 0x30(%rsp)
movq %rsi, %rbx
movq %rdi, 0x28(%rsp)
movl 0x10(%rdx), %r14d
cmpl $0x4b0, 0xc(%rdx)       # imm = 0x4B0
sete %r15b
setne %al
movl %r9d, 0x14(%rsp)
testl %r9d, %r9d
sete %cl
orb %al, %cl
jne 0x8566b
cmpl $0x0, 0xc(%rbx)
pushq $0x1
popq %rax
sete %r15b
cmovnel %eax, %r14d
movq 0x78(%rsp), %rbp
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rbx), %rdi
movq %r12, %rsi
callq 0xe409f
movq %rax, %r13
testb %r15b, %r15b
je 0x856db
leaq (,%r13,2), %rax
movl 0x14(%rsp), %r15d
testl %r15d, %r15d
movq %r13, %rdx
movq %rax, 0x18(%rsp)
cmovneq %rax, %rdx
movq (%rbx), %rdi
addq $0x4, %r12
movl %r14d, (%rsp)
movl $0x3e8, %ecx            # imm = 0x3E8
movq %r12, %rsi
movq %rbp, %r8
xorl %r9d, %r9d
callq 0xe4ced
movq %rbp, %rdi
callq 0xeacc0
testl %r15d, %r15d
je 0x856ff
movq 0x18(%rsp), %rdi
jmp 0x85702
movq (%rbx), %rdi
addq $0x4, %r12
movl %r14d, (%rsp)
pushq $0x1
popq %r9
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %r8
callq 0xe4ced
jmp 0x8570a
movq %r13, %rdi
callq 0xdfb90
movq %rax, %r13
addq $0x4, %r13
movq 0x20(%rsp), %rax
movq %r13, (%rax)
movq %rbp, %rdi
callq 0xeb7e4
leaq 0x99795(%rip), %rsi     # 0x11eeba
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/olepropset.c
// Function: get_prop_data_type_name
static char *get_prop_data_type_name(char *buf, size_t buf_len, u32 dt)
{
	const char *name = NULL;
	const char *prefix = "";
	size_t k;

	if(dt>=0x1000 && dt<0x2000) {
		prefix = "vector of ";
		dt -= 0x1000;
	}
	else if(dt>=0x2000 && dt<0x3000) {
		prefix = "array of ";
		dt -= 0x2000;
	}

	for(k=0; k<DE_ARRAYCOUNT(prop_data_type_info_arr); k++) {
		if(prop_data_type_info_arr[k].dt == dt) {
			name = prop_data_type_info_arr[k].name;
			break;
		}
	}

	if(name) {
		de_snprintf(buf, buf_len, "%s%s", prefix, name);
	}
	else {
		de_strlcpy(buf, "?", buf_len);
	}

	return buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, %eax
andl $0xfffff000, %eax       # imm = 0xFFFFF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x85768
addl $0xfffff000, %esi       # imm = 0xFFFFF000
leaq 0x9aeae(%rip), %rcx     # 0x120614
jmp 0x8578a
leal -0x2000(%rsi), %edx
cmpl $0x2000, %eax           # imm = 0x2000
cmovnel %esi, %edx
leaq 0x9aea2(%rip), %rax     # 0x12061f
leaq 0xb24dc(%rip), %rcx     # 0x137c60
cmoveq %rax, %rcx
movl %edx, %esi
xorl %edx, %edx
leaq 0x102a8d(%rip), %rax    # 0x188220
leaq 0x10(%rdx), %rdi
cmpq $0x160, %rdi            # imm = 0x160
je 0x857c8
cmpl %esi, (%rdx,%rax)
movq %rdi, %rdx
jne 0x85793
movq -0x8(%rdi,%rax), %r8
testq %r8, %r8
je 0x857c8
leaq 0xb38e4(%rip), %rdx     # 0x13909d
pushq $0x50
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde40c
jmp 0x857da
leaq 0x99712(%rip), %rsi     # 0x11eee1
pushq $0x50
popq %rdx
movq %rbx, %rdi
callq 0xde492
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_any_int
static void do_prop_any_int(deark *c, lctx *d, struct propset_struct *si,
	struct prop_info_struct *pinfo, const char *name, i64 pos,
	unsigned int nbytes, int is_signed)
{
	i64 n;
	char descr[200];

	// FIXME: This doesn't really support uint64.
	n = dbuf_getint_ext(d->f, pos, nbytes, 1, is_signed);

	descr[0] = '\0';

	if(pinfo->prop_id==0x00000001U) { // code page
		// Code page is usually a *signed* 16-bit int, which means the maximum
		// value is 32767, even though code pages can go up to 65535.
		// Apparently, code pages over 32767 are stored as negative numbers.
		if(de_int_in_range(n, -32768, -1)) {
			si->code_page = (int)(n + 65536);
		}
		else {
			si->code_page = (int)n;
		}

		si->encoding = de_windows_codepage_to_encoding(c, si->code_page,
			descr, sizeof(descr), 0x1);
		if(si->encoding==DE_ENCODING_UNKNOWN) {
			si->encoding = DE_ENCODING_ASCII;
		}
	}

	if(descr[0]) {
		de_dbg(c, "%s: %"I64_FMT" (%s)", name, n, descr);
	}
	else {
		de_dbg(c, "%s: %"I64_FMT, name, n);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
movl 0x100(%rsp), %edx
movl 0x108(%rsp), %r8d
movq (%rsi), %rdi
pushq $0x1
popq %rcx
movq %r9, %rsi
callq 0xe424b
movq %rax, %r15
movb $0x0, (%rsp)
cmpl $0x1, (%r13)
jne 0x85f47
pushq $-0x1
popq %rdx
movq %r15, %rdi
movq $-0x8000, %rsi          # imm = 0x8000
callq 0xdfb5b
leal 0x10000(%r15), %esi
testl %eax, %eax
cmovel %r15d, %esi
movl %esi, 0xc(%r12)
movq %rsp, %r13
pushq $0x1
popq %r8
movl $0xc8, %ecx
movq %r14, %rdi
movq %r13, %rdx
callq 0xe206c
cmpl $0x1, %eax
adcl $0x0, %eax
movl %eax, 0x10(%r12)
cmpb $0x0, (%r13)
je 0x85f47
leaq 0x83c6f(%rip), %rsi     # 0x109ba1
movq %rsp, %r8
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xde896
jmp 0x85f5e
leaq 0x8f1a9(%rip), %rsi     # 0x1150f7
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xde896
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: de_module_iso9660
void de_module_iso9660(deark *c, struct deark_module_info *mi)
{
	mi->id = "iso9660";
	mi->desc = "ISO 9660 (CD-ROM) image";
	mi->run_fn = de_run_iso9660;
	mi->identify_fn = de_identify_iso9660;
	mi->help_fn = de_help_iso9660;
}

// Assembly:
leaq 0x9a835(%rip), %rax     # 0x1207e0
movq %rax, (%rsi)
leaq 0x9a833(%rip), %rax     # 0x1207e8
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x85fdb
movq %rax, 0x18(%rsi)
leaq 0x6a4(%rip), %rax       # 0x8666f
movq %rax, 0x20(%rsi)
leaq 0x6b7(%rip), %rax       # 0x8668d
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: de_module_cd_raw
void de_module_cd_raw(deark *c, struct deark_module_info *mi)
{
	mi->id = "cd_raw";
	mi->desc = "Raw CD image";
	mi->run_fn = de_run_cd_raw;
	mi->identify_fn = de_identify_cd_raw;
}

// Assembly:
leaq 0x9a137(%rip), %rax     # 0x120800
movq %rax, (%rsi)
leaq 0x9a134(%rip), %rax     # 0x120807
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x866ee
movq %rax, 0x18(%rsi)
leaq 0x1b9(%rip), %rax       # 0x868a2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: de_run_cd_raw
static void de_run_cd_raw(deark *c, de_module_params *mparams)
{
	struct cdraw_params cdrp;

	cdraw_setdefaults(&cdrp);
	cdraw_detect_params(c->infile, &cdrp);
	if(!cdrp.ok) {
		de_err(c, "Failed to detect raw CD format");
		goto done;
	}

	de_dbg(c, "total bytes/sector: %"I64_FMT, cdrp.sector_total_len);
	de_dbg(c, "data bytes/sector: %"I64_FMT, cdrp.sector_dlen);
	de_dbg(c, "data offset: %"I64_FMT, cdrp.sector_data_offset);

	do_cdraw_convert(c, &cdrp);

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %r14
andl $0x0, (%r14)
movl $0x800, %eax            # imm = 0x800
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
andq $0x0, 0x18(%r14)
movq %rdi, %rbx
leaq 0xa1dbc(%rip), %rax     # 0x1284dd
movq %rax, 0x20(%r14)
movq 0x18(%rdi), %rdi
movq %r14, %rsi
callq 0x88c97
cmpl $0x0, (%r14)
je 0x86883
movq 0x18(%rsp), %r14
leaq 0x9adcc(%rip), %rsi     # 0x121513
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x20(%rsp), %r15
leaq 0x9adc9(%rip), %rsi     # 0x12152b
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x28(%rsp), %r12
leaq 0x9d7a2(%rip), %rsi     # 0x123f1d
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
callq 0xdfd1a
movq %rax, 0x8(%rsp)
movq %r14, %r13
shlq $0x4, %r13
addq %r12, %r13
movq 0x18(%rbx), %rdi
leaq 0x9ad9c(%rip), %rdx     # 0x121546
pushq $0x6
popq %rcx
movq %r13, %rsi
callq 0xe4d48
testl %eax, %eax
jne 0x86823
movq %rbx, %rdi
callq 0xeac74
movq %rax, %rbp
movq 0x18(%rbx), %rdi
addq $0x28, %r13
pushq $0x20
popq %rdx
pushq $0x1
popq %r8
movq %r13, %rsi
movq %rax, %rcx
movl %r8d, %r9d
callq 0xe4c9a
movq %rbp, %rdi
callq 0xead03
movq %rbp, %rdi
callq 0xeaf8a
testl %eax, %eax
je 0x86823
movq %rbp, %rdi
callq 0xeb877
leaq 0x9ad49(%rip), %rsi     # 0x12154d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xdfd55
movq %rbp, %rdi
callq 0xeaf3c
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rbp
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r13
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %r12
jge 0x86862
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xe45f4
addq %r14, %r12
jmp 0x86845
movq %r13, %rdi
callq 0xe5591
movq %rbx, %rdi
movq %rbp, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdfd24
leaq 0x9ac6a(%rip), %rsi     # 0x1214f4
movq %rbx, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf2a5
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: de_module_nrg
void de_module_nrg(deark *c, struct deark_module_info *mi)
{
	mi->id = "nrg";
	mi->desc = "NRG CD-ROM image";
	mi->run_fn = de_run_nrg;
	mi->identify_fn = de_identify_nrg;
}

// Assembly:
leaq 0x99f42(%rip), %rax     # 0x120814
movq %rax, (%rsi)
leaq 0x99f3c(%rip), %rax     # 0x120818
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x868f7
movq %rax, 0x18(%rsi)
leaq 0x1d6(%rip), %rax       # 0x86ac8
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: read_datetime17
static void read_datetime17(deark *c, lctx *d, i64 pos, int fieldlen,
	struct de_timestamp *ts)
{
	i64 yr, mo, da;
	i64 hr, mi, se, hs;
	i64 offs;

	de_zeromem(ts, sizeof(struct de_timestamp));
	yr = read_decimal_substr(c->infile, pos, 4);
	if(yr==0) return;
	mo = read_decimal_substr(c->infile, pos+4, 2);
	da = read_decimal_substr(c->infile, pos+6, 2);
	hr = read_decimal_substr(c->infile, pos+8, 2);
	mi = read_decimal_substr(c->infile, pos+10, 2);
	se = read_decimal_substr(c->infile, pos+12, 2);
	hs = read_decimal_substr(c->infile, pos+14, 2);
	if(fieldlen==16) {
		offs = 0;
	}
	else {
		offs = dbuf_geti8(c->infile, pos+16);
	}
	de_make_timestamp(ts, yr, mo, da, hr, mi, se);
	de_timestamp_set_subsec(ts, ((double)hs)/100.0);
	de_timestamp_cvt_to_utc(ts, -offs*60*15);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rdi), %rdi
pushq $0x4
popq %rdx
callq 0x88751
testq %rax, %rax
je 0x8866e
movq %rax, %r14
movq 0x18(%r12), %rdi
leaq 0x4(%r15), %rsi
pushq $0x2
popq %r13
movq %r13, %rdx
callq 0x88751
movq %rax, 0x30(%rsp)
movq 0x18(%r12), %rdi
leaq 0x6(%r15), %rsi
movq %r13, %rdx
callq 0x88751
movq %rax, 0x28(%rsp)
movq 0x18(%r12), %rdi
leaq 0x8(%r15), %rsi
movq %r13, %rdx
callq 0x88751
movq %rax, 0x20(%rsp)
movq 0x18(%r12), %rdi
leaq 0xa(%r15), %rsi
movq %r13, %rdx
callq 0x88751
movq %rax, 0x18(%rsp)
movq 0x18(%r12), %rdi
leaq 0xc(%r15), %rsi
movq %r13, %rdx
callq 0x88751
movq %rax, 0x10(%rsp)
movq 0x18(%r12), %rdi
leaq 0xe(%r15), %rsi
movq %r13, %rdx
callq 0x88751
movq %rax, %r13
cmpl $0x10, %ebp
jne 0x8867d
xorl %r15d, %r15d
jmp 0x88695
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0xe3f12
imulq $-0x384, %rax, %r15     # imm = 0xFC7C
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0xe0174
cvtsi2sd %r13, %xmm0
divsd 0x8a34e(%rip), %xmm0    # 0x112a18
movq %rbx, %rdi
callq 0xe0071
movq %rbx, %rdi
movq %r15, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe0491
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: dbg_timestamp
static void dbg_timestamp(deark *c, struct de_timestamp *ts, const char *field_name)
{
	char timestamp_buf[64];

	if(ts->is_valid) {
		de_dbg_timestamp_to_string(c, ts, timestamp_buf, sizeof(timestamp_buf), 0);
		de_dbg(c, "%s: %s", field_name, timestamp_buf);
	}
	else {
		de_dbg(c, "%s: (not set)", field_name);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x0, (%rsi)
je 0x88734
movq %rsp, %r15
pushq $0x40
popq %rcx
movq %r14, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xe07a8
leaq 0xb3798(%rip), %rsi     # 0x13beb2
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xde896
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x96714(%rip), %rsi     # 0x11ee4f
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: free_dir_record
static void free_dir_record(deark *c, struct dir_record *dr)
{
	if(!dr) return;
	ucstring_destroy(dr->fname);
	ucstring_destroy(dr->rr_name);
	de_free(c, dr);
}

// Assembly:
testq %rsi, %rsi
je 0x887b3
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rdi
callq 0xeaf3c
movq 0x40(%rbx), %rdi
callq 0xeaf3c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: read_datetime7
static void read_datetime7(deark *c, lctx *d, i64 pos, int fieldlen,
	struct de_timestamp *ts)
{
	i64 yr, mo, da;
	i64 hr, mi, se;
	i64 offs;

	ts->is_valid = 0;

	yr = de_getbyte(pos);
	mo = de_getbyte(pos+1);
	if(mo==0) return;
	da = de_getbyte(pos+2);
	hr = de_getbyte(pos+3);
	mi = de_getbyte(pos+4);
	se = de_getbyte(pos+5);
	if(fieldlen==6) {
		offs = 0;
	}
	else {
		offs = dbuf_geti8(c->infile, pos+6);
	}

	de_make_timestamp(ts, 1900+yr, mo, da, hr, mi, se);
	de_timestamp_cvt_to_utc(ts, -offs*60*15);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
movb $0x0, (%rcx)
movq 0x18(%rdi), %rdi
callq 0xe3eb4
movl %eax, %r15d
movq 0x18(%r13), %rdi
leaq 0x1(%r14), %rsi
callq 0xe3eb4
testb %al, %al
je 0x88850
movzbl %r15b, %r15d
movzbl %al, %eax
movq %rax, 0x20(%rsp)
movq 0x18(%r13), %rdi
leaq 0x2(%r14), %rsi
callq 0xe3eb4
movzbl %al, %eax
movq %rax, 0x18(%rsp)
movq 0x18(%r13), %rdi
leaq 0x3(%r14), %rsi
callq 0xe3eb4
movzbl %al, %eax
movq %rax, 0x10(%rsp)
movq 0x18(%r13), %rdi
leaq 0x4(%r14), %rsi
callq 0xe3eb4
movzbl %al, %r12d
movq 0x18(%r13), %rdi
leaq 0x5(%r14), %rsi
callq 0xe3eb4
movl %ebp, %ecx
movzbl %al, %ebp
cmpl $0x6, %ecx
jne 0x8885f
xorl %r14d, %r14d
jmp 0x88876
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r13), %rdi
addq $0x6, %r14
movq %r14, %rsi
callq 0xe3f12
imulq $-0x384, %rax, %r14     # imm = 0xFC7C
addq $0x76c, %r15            # imm = 0x76C
movq %rbp, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq %r12, %r9
callq 0xe0174
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe0491
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: do_Apple_AA_HFS
static void do_Apple_AA_HFS(deark *c, lctx *d, struct dir_record *dr, i64 pos1, i64 len)
{
	unsigned int finder_flags;
	struct de_fourcc type4cc;
	struct de_fourcc creator4cc;
	i64 pos = pos1+4;

	de_dbg(c, "Apple AA/HFS extension at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	dbuf_read_fourcc(c->infile, pos, &type4cc, 4, 0x0);
	de_dbg(c, "type: '%s'", type4cc.id_dbgstr);
	pos += 4;
	dbuf_read_fourcc(c->infile, pos, &creator4cc, 4, 0x0);
	de_dbg(c, "creator: '%s'", creator4cc.id_dbgstr);
	pos += 4;
	finder_flags = (unsigned int)de_getu16be_p(&pos);
	de_dbg(c, "finder flags: 0x%04x", finder_flags);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsi), %r15
leaq 0x98610(%rip), %rsi     # 0x121152
movq %r14, %rdx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq 0x18(%rbx), %rdi
leaq 0x38(%rsp), %rdx
pushq $0x4
popq %rbp
movq %r15, %rsi
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xe657c
leaq 0x48(%rsp), %rdx
leaq 0x8c1de(%rip), %rsi     # 0x114d5a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
leaq 0x8(%r14), %rsi
movq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xe657c
leaq 0x18(%rsp), %rdx
leaq 0x9e46a(%rip), %rsi     # 0x127013
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
addq $0xc, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq 0x18(%rbx), %rdi
callq 0xe3f6e
leaq 0x7ecf2(%rip), %rsi     # 0x1078bf
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: cdsig_at
static int cdsig_at(dbuf *f, i64 pos)
{
	u8 buf[14];
	u8 ty;

	dbuf_read(f, buf, pos, sizeof(buf));
	if(!de_memcmp(&buf[1], g_sig_CD001, 5)) {
		ty = buf[0];
	}
	else if(!de_memcmp(&buf[1], g_sig_CD_I, 5)) {
		ty = buf[0];
	}
	else if(!de_memcmp(&buf[9], g_sig_CDROM, 5)) {
		ty = buf[8];
	}
	else {
		return 0;
	}
	if(ty>3 && ty<255) return 0;
	return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
leaq 0x2(%rsp), %rsi
pushq $0xe
popq %rcx
callq 0xe3cb7
leaq 0x3(%rsp), %rbx
leaq 0x9890b(%rip), %rsi     # 0x121547
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x18230
testl %eax, %eax
je 0x88c83
leaq 0x97db3(%rip), %rsi     # 0x120a05
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x18230
testl %eax, %eax
je 0x88c83
leaq 0xb(%rsp), %rdi
leaq 0x97d9e(%rip), %rsi     # 0x120a0b
pushq $0x5
popq %rdx
callq 0x18230
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x88c91
movb 0xa(%rsp), %cl
jmp 0x88c87
movb 0x2(%rsp), %cl
incb %cl
xorl %eax, %eax
cmpb $0x5, %cl
setb %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: cdraw_detect_params
static void cdraw_detect_params(dbuf *f, struct cdraw_params *cdrp)
{
	if(cdsig_at2(f, 2336*16+8, 2336*17+8)) {
		cdrp->ok = 1;
		cdrp->sector_total_len = 2336;
		cdrp->sector_data_offset = 8;
		cdrp->ext = "iso";
		return;
	}
	if(cdsig_at2(f, 2352*16+16, 2352*17+16)) {
		cdrp->ok = 1;
		cdrp->sector_total_len = 2352;
		cdrp->sector_data_offset = 16;
		cdrp->ext = "iso";
		return;
	}
	if(cdsig_at2(f, 2352*16+24, 2352*17+24)) {
		cdrp->ok = 1;
		cdrp->sector_total_len = 2352;
		cdrp->sector_data_offset = 24;
		cdrp->ext = "iso";
		return;
	}
	if(cdsig_at2(f, 2448*16+16, 2448*17+16)) {
		cdrp->ok = 1;
		cdrp->sector_total_len = 2448;
		cdrp->sector_data_offset = 16;
		cdrp->ext = "iso";
		return;
	}
	if(cdsig_at2(f, 2448*16+24, 2448*17+24)) {
		cdrp->ok = 1;
		cdrp->sector_total_len = 2448;
		cdrp->sector_data_offset = 24;
		cdrp->ext = "iso";
		return;
	}
	if(syncbytes_at(f, 0)) {
		if(syncbytes_at(f, 2352)) {
			if(!dbuf_memcmp(f, 512+16, "PM", 2)) {
				cdrp->ok = 1;
				cdrp->sector_total_len = 2352;
				cdrp->sector_data_offset = 16;
				cdrp->ext = "apm";
				return;
			}
		}
	}
	// TODO: More formats?
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x9208, %esi           # imm = 0x9208
movl $0x9b28, %edx           # imm = 0x9B28
callq 0x88bef
leaq 0x98884(%rip), %r12     # 0x121542
testl %eax, %eax
je 0x88ccd
pushq $0x8
popq %rbp
movl $0x920, %r13d           # imm = 0x920
jmp 0x88d0b
movl $0x9310, %esi           # imm = 0x9310
movl $0x9c40, %edx           # imm = 0x9C40
movq %r14, %rdi
callq 0x88bef
pushq $0x10
popq %r15
movl $0x930, %r13d           # imm = 0x930
testl %eax, %eax
je 0x88cf2
movq %r15, %rbp
jmp 0x88d0b
movl $0x9318, %esi           # imm = 0x9318
movl $0x9c48, %edx           # imm = 0x9C48
movq %r14, %rdi
callq 0x88bef
pushq $0x18
popq %rbp
testl %eax, %eax
je 0x88d2c
movl $0x1, (%rbx)
movq %r13, 0x8(%rbx)
movq %rbp, 0x18(%rbx)
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x9910, %esi           # imm = 0x9910
movl $0xa2a0, %edx           # imm = 0xA2A0
movq %r14, %rdi
callq 0x88bef
movl $0x990, %r13d           # imm = 0x990
testl %eax, %eax
jne 0x88ced
movl $0x9918, %esi           # imm = 0x9918
movl $0xa2a8, %edx           # imm = 0xA2A8
movq %r14, %rdi
callq 0x88bef
testl %eax, %eax
jne 0x88d0b
movq %r14, %rdi
xorl %esi, %esi
callq 0x88dae
testl %eax, %eax
je 0x88d1d
movl $0x930, %r13d           # imm = 0x930
movl $0x930, %esi            # imm = 0x930
movq %r14, %rdi
callq 0x88dae
testl %eax, %eax
je 0x88d1d
leaq 0x9b634(%rip), %rdx     # 0x1243be
pushq $0x2
popq %rcx
movl $0x210, %esi            # imm = 0x210
movq %r14, %rdi
callq 0xe4d48
testl %eax, %eax
jne 0x88d1d
leaq 0x7e4dd(%rip), %r12     # 0x107286
jmp 0x88ced
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/iso9660.c
// Function: my_nrg_chunk_handler
static int my_nrg_chunk_handler(struct de_iffctx *ictx)
{
	deark *c = ictx->c;
	struct nrg_ctx *nrg = (struct nrg_ctx*)ictx->userdata;

	switch(ictx->chunkctx->chunk4cc.id) {
	case CODE_ETNF:
		do_nrg_ETNF(c, ictx, ictx->chunkctx);
		ictx->handled = 1;
		break;
	case CODE_DAOX:
		do_nrg_DAOX(c, ictx, nrg);
		ictx->handled = 1;
		break;
	case CODE_END_:
		return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x128(%rdi), %rbx
movl 0x4(%rbx), %eax
cmpl $0x44414f58, %eax       # imm = 0x44414F58
je 0x88fa2
cmpl $0x454e4421, %eax       # imm = 0x454E4421
je 0x88f9e
cmpl $0x45544e46, %eax       # imm = 0x45544E46
jne 0x88ffb
movq %rdi, (%rsp)
movq 0x40(%rbx), %rax
movq %rax, %r15
negq %r15
xorl %ebp, %ebp
movq %rax, %r12
addq 0x48(%rbx), %rax
addq %r15, %rax
cmpq $0x14, %rax
jl 0x88fed
movq %r14, %rdi
leaq 0x87fd1(%rip), %rsi     # 0x110ec6
movl %ebp, %edx
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
pushq $0x1
popq %rsi
callq 0xdeba7
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0xe404f
movq %rax, %r13
movq 0x18(%r14), %rdi
leaq 0x4(%r12), %rsi
callq 0xe404f
movq %r14, %rdi
leaq 0x986d6(%rip), %rsi     # 0x121606
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq 0x18(%r14), %rdi
leaq 0x8(%r12), %rsi
callq 0xe404f
movq %r14, %rdi
leaq 0x93947(%rip), %rsi     # 0x11c89c
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
movq 0x18(%r14), %rdi
leaq 0xc(%r12), %rsi
callq 0xe404f
movq %r14, %rdi
leaq 0x986a6(%rip), %rsi     # 0x12161c
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
pushq $-0x1
popq %rsi
callq 0xdeba7
incl %ebp
movq 0x40(%rbx), %rax
addq $-0x14, %r15
addq $0x14, %r12
jmp 0x88eda
xorl %eax, %eax
jmp 0x88ffe
movq %rdi, (%rsp)
movq 0x40(%rbx), %rsi
cmpq $0x38, %rsi
jl 0x88fed
movq (%rsp), %rax
movq 0x10(%rax), %rbx
movq 0x18(%rax), %rdi
addq $0x30, %rsi
callq 0xe4143
movq %rax, 0x18(%rbx)
addq $0x18, %rbx
leaq 0x98657(%rip), %rsi     # 0x12162b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xe3c84
movq (%rsp), %rax
movl $0x1, 0x130(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macbinary.c
// Function: de_module_macbinary
void de_module_macbinary(deark *c, struct deark_module_info *mi)
{
	mi->id = "macbinary";
	mi->desc = "MacBinary";
	mi->run_fn = de_run_macbinary;
	mi->identify_fn = de_identify_macbinary;
	mi->flags = DE_MODFLAG_SHAREDDETECTION;
}

// Assembly:
leaq 0x99736(%rip), %rax     # 0x12274d
movq %rax, (%rsi)
leaq 0x98617(%rip), %rax     # 0x121638
movq %rax, 0x8(%rsi)
leaq 0x17(%rip), %rax        # 0x89043
movq %rax, 0x18(%rsi)
leaq 0x73e(%rip), %rax       # 0x89775
movq %rax, 0x20(%rsi)
movl $0x10, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macbinary.c
// Function: do_prepare_one_fork
static void do_prepare_one_fork(deark *c, lctx *d, struct de_advfile_forkinfo *advfki,
	struct fork_info *fki)
{
	de_dbg(c, "%s fork at %"I64_FMT", len=%"I64_FMT, fork_name(fki->is_rsrc, 0),
		fki->pos, advfki->fork_len);

	if(fki->pos+advfki->fork_len>c->infile->len) {
		de_err(c, "%s fork at %"I64_FMT" goes beyond end of file.",
			fork_name(fki->is_rsrc, 1), fki->pos);
		if(fki->pos+advfki->fork_len > c->infile->len+1024) {
			fki->extract_error_flag = 1;
			goto done;
		}
	}

done:
	;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, (%rdx)
leaq 0xa35a0(%rip), %rax     # 0x12d031
leaq 0x99bd5(%rip), %rdx     # 0x12366d
cmoveq %rax, %rdx
movq 0x8(%rbx), %rcx
movq 0x8(%rsi), %r8
leaq 0x97d9d(%rip), %rsi     # 0x121848
xorl %eax, %eax
callq 0xde896
movq 0x8(%rbx), %rcx
movq 0x8(%r15), %rax
addq %rcx, %rax
movq 0x18(%r14), %rdx
cmpq 0x18(%rdx), %rax
jle 0x89b0b
cmpb $0x0, (%rbx)
leaq 0x9d28b(%rip), %rax     # 0x126d5c
leaq 0x97db0(%rip), %rdx     # 0x121888
cmoveq %rax, %rdx
leaq 0x97d7d(%rip), %rsi     # 0x121860
movq %r14, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq 0x8(%r15), %rax
addq 0x8(%rbx), %rax
movq 0x18(%r14), %rcx
movl $0x400, %edx            # imm = 0x400
addq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jle 0x89b0b
movb $0x1, 0x1(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macrsrc.c
// Function: de_module_macrsrc
void de_module_macrsrc(deark *c, struct deark_module_info *mi)
{
	mi->id = "macrsrc";
	mi->desc = "Macintosh Resource Manager";
	mi->run_fn = de_run_macrsrc;
	mi->identify_fn = de_identify_macrsrc;
	mi->help_fn = de_help_macrsrc;
}

// Assembly:
leaq 0x7ffe1(%rip), %rax     # 0x109b3c
movq %rax, (%rsi)
leaq 0x97d31(%rip), %rax     # 0x121896
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x89b8b
movq %rax, 0x18(%rsi)
leaq 0x1b41(%rip), %rax      # 0x8b6bc
movq %rax, 0x20(%rsi)
leaq 0x1be4(%rip), %rax      # 0x8b76a
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macrsrc.c
// Function: de_identify_macrsrc
static int de_identify_macrsrc(deark *c)
{
	u8 b[16];
	i64 n[4];
	size_t k;

	if(de_getu32be(0)!=256) return 0;
	de_read(b, 0, 16);
	for(k=0; k<4; k++) {
		n[k] = de_getu32be_direct(&b[4*k]);
	}
	if(n[0]+n[2]>n[1]) return 0; // data can't go past map start
	if(n[3]<30) return 0; // minimum map len
	if(n[1]+n[3]>c->infile->len) return 0; // map can't go past eof
	// map should start with a copy of the header
	if(dbuf_memcmp(c->infile, n[1], (const void*)b, 16)) return 0;
	if(n[1]+n[3]==c->infile->len) return 100;
	return 75;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xe404f
cmpq $0x100, %rax            # imm = 0x100
jne 0x8b75d
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
movq %rsp, %rsi
pushq $0x10
popq %rcx
xorl %edx, %edx
callq 0xe3cb7
cmpq $0x10, %r14
je 0x8b70c
leaq (%rsp,%r14), %rdi
callq 0xe404a
movq %rax, 0x10(%rsp,%r14,2)
addq $0x4, %r14
jmp 0x8b6f2
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
addq 0x10(%rsp), %rax
xorl %r14d, %r14d
cmpq %rsi, %rax
jg 0x8b75d
movq 0x28(%rsp), %r15
cmpq $0x1e, %r15
jl 0x8b75d
addq %rsi, %r15
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %r15
jg 0x8b75d
movq %rsp, %rdx
pushq $0x10
popq %rcx
callq 0xe4d48
testl %eax, %eax
jne 0x8b75d
movq 0x18(%rbx), %rax
cmpq 0x18(%rax), %r15
pushq $0x64
popq %rax
pushq $0x4b
popq %r14
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macrsrc.c
// Function: set_resource_filename
static void set_resource_filename(deark *c, lctx *d, de_finfo *fi,
	struct rsrctypeinfo *rti, struct rsrcinstanceinfo *rii, const char *token)
{
	de_ucstring *tmpname = NULL;

	tmpname = ucstring_create(c);
	if(c->filenames_from_file && ucstring_isnonempty(rii->name)) {
		ucstring_append_ucstring(tmpname, rii->name);
		ucstring_append_sz(tmpname, ".", DE_ENCODING_LATIN1);
	}

	if(token) {
		ucstring_append_sz(tmpname, token, DE_ENCODING_LATIN1);
	}
	else {
		ucstring_append_sz(tmpname, rti->fcc.id_sanitized_sz, DE_ENCODING_LATIN1);
	}
	de_finfo_set_name_from_ucstring(c, fi, tmpname, 0);
	ucstring_destroy(tmpname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
callq 0xeac74
movq %rax, %r14
cmpb $0x0, 0xd0(%r15)
je 0x8b7e5
movq 0x28(%rbp), %rdi
callq 0xeaf8a
testl %eax, %eax
je 0x8b7e5
movq 0x28(%rbp), %rsi
movq %r14, %rdi
callq 0xead71
leaq 0xa2ea4(%rip), %rsi     # 0x12e67e
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0xeae42
addq $0x8, %r12
testq %r13, %r13
cmovneq %r13, %r12
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xeae42
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xdfd55
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lzexe.c
// Function: de_module_lzexe
void de_module_lzexe(deark *c, struct deark_module_info *mi)
{
	mi->id = "lzexe";
	mi->desc = "LZEXE-compressed EXE";
	mi->run_fn = de_run_lzexe;
	mi->help_fn = de_help_lzexe;
}

// Assembly:
leaq 0x96654(%rip), %rax     # 0x121e7f
movq %rax, (%rsi)
leaq 0x96650(%rip), %rax     # 0x121e85
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x8b850
movq %rax, 0x18(%rsi)
leaq 0xa53(%rip), %rax       # 0x8c29e
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lzexe.c
// Function: fill_bitbuf
static void fill_bitbuf(deark *c, lctx *d)
{
	UI i;

	if(d->errflag) return;
	if(d->dcmpr_cur_ipos+2 > d->ephdr_pos)
	{
		d->errflag = 1;
		return;
	}

	for(i=0; i<2; i++) {
		u8 b;
		b = de_getbyte_p(&d->dcmpr_cur_ipos);
		de_bitbuf_lowlevel_add_byte(&d->bbll, b);
	}
}

// Assembly:
cmpl $0x0, 0x4(%rsi)
je 0x8c334
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x90(%rsi), %rax
addq $0x2, %rax
cmpq 0x28(%rsi), %rax
jle 0x8c361
movl $0x1, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
leaq 0x90(%rbx), %r15
addq $0x98, %rbx
pushq $0x2
popq %rbp
subl $0x1, %ebp
jb 0x8c356
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xe3f2a
movzbl %al, %esi
movq %rbx, %rdi
callq 0xe69c4
jmp 0x8c375
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: de_module_nufx
void de_module_nufx(deark *c, struct deark_module_info *mi)
{
	mi->id = "nufx";
	mi->desc = "NuFX / ShrinkIt";
	mi->run_fn = de_run_nufx;
	mi->identify_fn = de_identify_nufx;
}

// Assembly:
leaq 0x95d5d(%rip), %rax     # 0x1220f8
movq %rax, (%rsi)
leaq 0x95d58(%rip), %rax     # 0x1220fd
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x8c3c0
movq %rax, 0x18(%rsi)
leaq 0xdcf(%rip), %rax       # 0x8d18a
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: destroy_record
static void destroy_record(deark *c, struct nufx_record *rec)
{
	if(!rec) return;
	ucstring_destroy(rec->filename);
	ucstring_destroy(rec->filename_old);
	de_free(c, rec->threads);
	de_free(c, rec);
}

// Assembly:
testq %rsi, %rsi
je 0x8d1f4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x98(%rsi), %rdi
callq 0xeaf3c
movq 0x90(%rbx), %rdi
callq 0xeaf3c
movq 0xa0(%rbx), %rsi
movq %r14, %rdi
callq 0xded32
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: nufx_read_datetime_to_timestamp_p
static void nufx_read_datetime_to_timestamp_p(dbuf *f, i64 *ppos,
	struct de_timestamp *ts)
{
	i64 yr, mo, da, hr, mi, se;
	i64 pos;

	pos = *ppos;
	*ppos += 8;

	se = (i64)dbuf_getbyte_p(f, &pos);
	mi = (i64)dbuf_getbyte_p(f, &pos);
	hr = (i64)dbuf_getbyte_p(f, &pos);
	yr = 1900 + (i64)dbuf_getbyte_p(f, &pos);
	da = 1 + (i64)dbuf_getbyte_p(f, &pos);
	mo = 1 + (i64)dbuf_getbyte_p(f, &pos);

	if(yr==1900) {
		de_zeromem(ts, sizeof(struct de_timestamp));
		ts->is_valid = 0;
		return;
	}
	de_make_timestamp(ts, yr, mo, da, hr, mi, se);
	ts->precision = DE_TSPREC_1SEC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq (%rsi), %rax
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
addq $0x8, %rax
movq %rax, (%rsi)
movq %r12, %rsi
callq 0xe3f2a
movb %al, 0xf(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3f2a
movb %al, 0xe(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3f2a
movl %eax, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3f2a
movl %eax, %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3f2a
movl %eax, %ebp
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3f2a
testb %r14b, %r14b
je 0x8d2a9
movzbl %r14b, %esi
addq $0x76c, %rsi            # imm = 0x76C
movzbl %al, %edx
incq %rdx
movzbl %bpl, %ecx
incq %rcx
movzbl %r13b, %r8d
movzbl 0xe(%rsp), %r9d
movzbl 0xf(%rsp), %eax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0xe0174
movb $0x1e, 0x2(%rbx)
jmp 0x8d2af
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: nufx_filename_to_ucstring
static void nufx_filename_to_ucstring(deark *c, struct nufx_ctx *d,
	struct nufx_record *rec, dbuf *inf, i64 pos1, i64 fnlen1,
	de_ucstring *s)
{
	i64 fnlen;
	u8 strip_high_bit = 0;
	dbuf *tmpdbuf = NULL;

	fnlen = de_min_int(fnlen1, 255);
	if(fnlen<1) return;

	// Documentation says only 7 bits are significant in ProDOS pathnames.
	// This is probably not the best we could do. I suspect filesys_id is not
	// always set correctly.
	if(d->using_default_encoding && rec->filesys_id==0x0001) { // 0x0001 = ProDOS
		strip_high_bit = 1;
	}

	if(strip_high_bit) {
		i64 i;
		i64 pos = pos1;

		tmpdbuf = dbuf_create_membuf(c, fnlen, 0);
		for(i=0; i<fnlen; i++) {
			u8 b;

			b = dbuf_getbyte_p(inf, &pos);
			b &= 0x7f;
			dbuf_writebyte(tmpdbuf, b);
		}
		dbuf_read_to_ucstring(tmpdbuf, 0, fnlen, s, 0, d->input_encoding);
	}
	else {
		dbuf_read_to_ucstring(inf, pos1, fnlen, s, 0, d->input_encoding);
	}

	dbuf_close(tmpdbuf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r13
movl $0xff, %esi
movq %r9, %rdi
callq 0xdfb45
testq %rax, %rax
jle 0x8d3b3
movq %rax, %r14
movq 0x40(%rsp), %rcx
cmpb $0x0, 0x3(%r15)
je 0x8d380
cmpl $0x1, 0x30(%rbp)
jne 0x8d380
movq %rsp, %rbp
movq %r12, (%rbp)
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xe59cd
movq %rax, %r13
movq %r14, %r12
subq $0x1, %r12
jb 0x8d392
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xe3f2a
andb $0x7f, %al
movzbl %al, %esi
movq %r13, %rdi
callq 0xe5bc5
jmp 0x8d360
movl 0x8(%r15), %r9d
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
jmp 0x8d3a3
movl 0x8(%r15), %r9d
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
xorl %r8d, %r8d
callq 0xe4c9a
movq %r13, %rdi
callq 0xe5591
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: decompress_chunk_rle_layer
static void decompress_chunk_rle_layer(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres, u8 rlechar)
{
	i64 srcpos = dcmpri->pos;
	i64 endpos;
	i64 nbytes_written = 0;
	const char *modname = "rle";

	endpos = dcmpri->pos + dcmpri->len;
	while(srcpos < endpos) {
		u8 x;

		if(nbytes_written >= dcmpro->expected_len) break;
		x = dbuf_getbyte_p(dcmpri->f, &srcpos);
		if(x==rlechar) {
			i64 count;
			u8 val;

			val = dbuf_getbyte_p(dcmpri->f, &srcpos);
			count = 1 + (i64)dbuf_getbyte_p(dcmpri->f, &srcpos);
			if(nbytes_written+count > dcmpro->expected_len) {
				goto done;
			}
			dbuf_write_run(dcmpro->f, val, count);
			nbytes_written += count;
		}
		else {
			dbuf_writebyte(dcmpro->f, x);
			nbytes_written++;
		}
	}

done:
	if(nbytes_written != dcmpro->expected_len) {
		de_dfilter_set_generic_error(c, dres, modname);
	}
	dres->bytes_consumed = srcpos - dcmpri->pos;
	dres->bytes_consumed_valid = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x8(%rsi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq 0x10(%rsi), %rcx
addq %rax, %rcx
movq %rcx, 0x20(%rsp)
xorl %r13d, %r13d
movq 0x10(%r12), %rcx
cmpq 0x20(%rsp), %rax
jge 0x8e154
cmpq %rcx, %r13
jge 0x8e154
movq %rbx, %rbp
movq (%r14), %rdi
movq %rbp, %rsi
callq 0xe3f2a
cmpb 0x4(%rsp), %al
jne 0x8e13e
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xe3f2a
movl %eax, %r15d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xe3f2a
movzbl %al, %edx
leaq (%rdx,%r13), %rbx
incq %rbx
movq 0x10(%r12), %rcx
cmpq %rcx, %rbx
jg 0x8e154
incq %rdx
movq (%r12), %rdi
movzbl %r15b, %esi
callq 0xe5e40
movq %rbx, %r13
movq %rbp, %rbx
jmp 0x8e14d
movq (%r12), %rdi
movzbl %al, %esi
callq 0xe5bc5
incq %r13
movq 0x8(%rsp), %rax
jmp 0x8e0d4
cmpq %rcx, %r13
movq 0x18(%rsp), %rbx
je 0x8e172
leaq 0x89f2e(%rip), %rdx     # 0x118093
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xee91c
movq 0x8(%rsp), %rax
subq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movb $0x1, 0x4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: my_advfile_cbfn_diskimage
static int my_advfile_cbfn_diskimage(deark *c, struct de_advfile *advf,
	struct de_advfile_cbparams *afp)
{
	struct nufx_record *rec = (struct nufx_record*)advf->userdata;
	struct nufx_ctx *d = rec->d;

	if(afp->whattodo == DE_ADVFILE_WRITEMAIN) {
		decompress_thread(c, d, rec, rec->disk_image_thread_ptr, afp->outf);
	}

	return 1;
}

// Assembly:
cmpl $0x1, (%rdx)
jne 0x8e1b6
pushq %rax
movq 0x8(%rsi), %rax
movq (%rax), %rsi
movq 0xc0(%rax), %rcx
movq 0x8(%rdx), %r8
movq %rax, %rdx
callq 0x8d3c2
addq $0x8, %rsp
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nufx.c
// Function: my_advfile_cbfn
static int my_advfile_cbfn(deark *c, struct de_advfile *advf,
	struct de_advfile_cbparams *afp)
{
	struct nufx_record *rec = (struct nufx_record*)advf->userdata;
	struct nufx_ctx *d = rec->d;

	if(afp->whattodo == DE_ADVFILE_WRITEMAIN) {
		decompress_thread(c, d, rec, rec->data_thread_ptr, afp->outf);
	}
	else if(afp->whattodo == DE_ADVFILE_WRITERSRC) {
		decompress_thread(c, d, rec, rec->resource_thread_ptr, afp->outf);
	}

	return 1;
}

// Assembly:
movq %rdx, %rax
movq 0x8(%rsi), %rdx
movq (%rdx), %rsi
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x8e1d7
cmpl $0x2, %ecx
jne 0x8e1ee
movl $0xb8, %ecx
jmp 0x8e1dc
movl $0xb0, %ecx
pushq %rax
movq (%rdx,%rcx), %rcx
movq 0x8(%rax), %r8
callq 0x8d3c2
addq $0x8, %rsp
pushq $0x1
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macpaint.c
// Function: de_module_macpaint
void de_module_macpaint(deark *c, struct deark_module_info *mi)
{
	mi->id = "macpaint";
	mi->desc = "MacPaint image";
	mi->run_fn = de_run_macpaint;
	mi->identify_fn = de_identify_macpaint;
	mi->help_fn = de_help_macpaint;
}

// Assembly:
leaq 0x94531(%rip), %rax     # 0x12272c
movq %rax, (%rsi)
leaq 0x94530(%rip), %rax     # 0x122735
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x8e22b
movq %rax, 0x18(%rsi)
leaq 0xa7d(%rip), %rax       # 0x8ec98
movq %rax, 0x20(%rsi)
leaq 0xb14(%rip), %rax       # 0x8ed3a
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/macpaint.c
// Function: de_identify_macpaint
static int de_identify_macpaint(deark *c)
{
	u8 buf[8];

	if(is_fmac2com(c)) return 85;
	de_read(buf, 65, 8);

	// Not all MacPaint files can be easily identified, but this will work
	// for some of them.
	if(!de_memcmp(buf, "PNTG", 4)) {
		if(c->detection_data->is_macbinary) return 100;
		if(!de_memcmp(&buf[4], "MPNT", 4)) return 80;
		return 70;
	}

	if(de_input_file_has_ext(c, "mac")) return 10;
	if(de_input_file_has_ext(c, "macp")) return 15;
	if(de_input_file_has_ext(c, "pntg")) return 15;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8ed5e
testb %al, %al
je 0x8ecb3
pushq $0x55
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rbx), %rdi
movq %rsp, %r14
pushq $0x41
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rsi
callq 0xe3cb7
cmpl $0x47544e50, (%r14)     # imm = 0x47544E50
je 0x8ece8
leaq 0x788e7(%rip), %rsi     # 0x1075bf
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
je 0x8ecf6
pushq $0xa
jmp 0x8ecaa
movq 0x28(%rbx), %rax
cmpb $0x0, 0x4(%rax)
je 0x8ed0d
pushq $0x64
jmp 0x8ecaa
leaq 0x93e23(%rip), %rsi     # 0x122b20
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
je 0x8ed1c
pushq $0xf
jmp 0x8ecaa
cmpl $0x544e504d, 0x4(%rsp)  # imm = 0x544E504D
pushq $0x50
popq %rcx
pushq $0x46
jmp 0x8ed31
leaq 0x93e02(%rip), %rsi     # 0x122b25
movq %rbx, %rdi
callq 0xdfcd5
movl %eax, %ecx
testl %eax, %eax
pushq $0xf
popq %rax
cmovel %ecx, %eax
jmp 0x8ecab
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/makichan.c
// Function: de_module_makichan
void de_module_makichan(deark *c, struct deark_module_info *mi)
{
	mi->id = "makichan";
	mi->desc = "MAKIchan graphics";
	mi->run_fn = de_run_makichan;
	mi->identify_fn = de_identify_makichan;
	mi->help_fn = de_help_makichan;
}

// Assembly:
leaq 0x93c69(%rip), %rax     # 0x122be0
movq %rax, (%rsi)
leaq 0x93c68(%rip), %rax     # 0x122be9
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x8efa7
movq %rax, 0x18(%rsi)
leaq 0xc49(%rip), %rax       # 0x8fbe0
movq %rax, 0x20(%rsi)
leaq 0xc60(%rip), %rax       # 0x8fc02
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/makichan.c
// Function: read_palette
static void read_palette(deark *c, lctx *d, i64 pos)
{
	i64 k;
	u8 cr, cg, cb;

	de_dbg(c, "palette at %d", (int)pos);
	de_dbg_indent(c, 1);

	for(k=0; k<d->num_colors; k++) {
		cg = de_getbyte(pos+3*k);
		cr = de_getbyte(pos+3*k+1);
		cb = de_getbyte(pos+3*k+2);
		d->pal[k] = DE_MAKE_RGB(cr,cg,cb);
		de_dbg_pal_entry(c, k, d->pal[k]);
	}

	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9359d(%rip), %rsi     # 0x1231c8
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
cmpq 0x48(%r15), %r12
jge 0x8fca8
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xe3eb4
movl %eax, %ebp
movq 0x18(%rbx), %rdi
leaq 0x1(%r14), %rsi
callq 0xe3eb4
movl %eax, %r13d
movq 0x18(%rbx), %rdi
leaq 0x2(%r14), %rsi
callq 0xe3eb4
movzbl %r13b, %ecx
shll $0x10, %ecx
movzbl %bpl, %esi
shll $0x8, %esi
orl %ecx, %esi
movzbl %al, %edx
orl %esi, %edx
orl $0xff000000, %edx       # imm = 0xFF000000
movl %edx, 0x90(%r15,%r12,4)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdf23b
incq %r12
addq $0x3, %r14
jmp 0x8fc40
pushq $-0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdeba7
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/makichan.c
// Function: do_create_image
static void do_create_image(deark *c, lctx *d)
{
	de_bitmap *img = NULL;
	de_finfo *fi = NULL;

	img = de_bitmap_create(c, d->width, d->height, 3);

	fi = de_finfo_create(c);

	if(d->aspect_ratio_flag) {
		fi->density.code = DE_DENSITY_UNK_UNITS;
		fi->density.xdens = 2.0;
		fi->density.ydens = 1.0;
	}

	de_convert_image_paletted(d->unc_pixels, 0,
		d->bits_per_pixel, d->rowspan, d->pal, img, 0);

	de_bitmap_write_to_file_finfo(img, fi, 0);
	de_bitmap_destroy(img);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
pushq $0x3
popq %rcx
callq 0xe7437
movq %rax, %r15
movq %rbx, %rdi
callq 0xdfd1a
movq %rax, %r12
cmpb $0x0, 0x70(%r14)
je 0x8fd0d
movl $0x1, 0x78(%r12)
movaps 0x880ac(%rip), %xmm0    # 0x117db0
movups %xmm0, 0x80(%r12)
movq 0x88(%r14), %rdi
movq 0x50(%r14), %rdx
movq 0x58(%r14), %rcx
addq $0x90, %r14
andl $0x0, (%rsp)
xorl %esi, %esi
movq %r14, %r8
movq %r15, %r9
callq 0xe7cbc
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xe70ab
movq %r15, %rdi
callq 0xe7084
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xdfd24
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_module_mbk
void de_module_mbk(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos";
	mi->desc = "STOS Memory Bank (.MBK)";
	mi->run_fn = de_run_mbk_mbs;
	mi->identify_fn = de_identify_mbk;
	mi->help_fn = de_help_mbk;
	mi->id_alias[0] = "mbk";
}

// Assembly:
leaq 0x931a8(%rip), %rax     # 0x122f0f
movq %rax, (%rsi)
leaq 0x931a3(%rip), %rax     # 0x122f14
movq %rax, 0x8(%rsi)
leaq 0x26(%rip), %rax        # 0x8fda2
movq %rax, 0x18(%rsi)
leaq 0x22(%rip), %rax        # 0x8fda9
movq %rax, 0x20(%rsi)
leaq 0x94(%rip), %rax        # 0x8fe26
movq %rax, 0x28(%rsi)
leaq 0x9318f(%rip), %rax     # 0x122f2c
movq %rax, 0x38(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_identify_mbk
static int de_identify_mbk(deark *c)
{
	u8 buf[10];
	UI id;

	de_read(buf, 0, sizeof(buf));
	if(!de_memcmp(buf, g_lion_sig, 10))
		return 99;
	id = (UI)de_getu32be_direct(buf);
	if(id==BANKID_SPRITE) {
		return 100;
	}
	else if(id==BANKID_PKSCREEN) {
		int is_pkscr;
		UI res;

		is_pkscr = is_stos_packedscreen(c, &res);
		if(is_pkscr) {
			return 99;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xe(%rsp), %r14
pushq $0xa
popq %r15
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xe3cb7
leaq 0x93253(%rip), %rsi     # 0x12302a
movq %r14, %rdi
movq %r15, %rdx
callq 0x18230
pushq $0x63
popq %rbp
testl %eax, %eax
je 0x8fe19
leaq 0xe(%rsp), %rdi
callq 0xe404a
cmpl $0x19861987, %eax       # imm = 0x19861987
je 0x8fe16
cmpl $0x6071963, %eax        # imm = 0x6071963
jne 0x8fe12
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9153f
testl %eax, %eax
jne 0x8fe19
xorl %ebp, %ebp
jmp 0x8fe19
pushq $0x64
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq