LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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), %r12
movl 0x4(%r12), %eax
cmpl $0x44414f58, %eax       # imm = 0x44414F58
je 0x8e26d
cmpl $0x454e4421, %eax       # imm = 0x454E4421
je 0x8e269
cmpl $0x45544e46, %eax       # imm = 0x45544E46
jne 0x8e2c7
movq %rdi, (%rsp)
cmpq $0x14, 0x48(%r12)
jl 0x8e2b9
movq 0x40(%r12), %r15
movq %r15, %rbx
negq %rbx
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x8fdf1(%rip), %rsi     # 0x11df9a
movl %r13d, %edx
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xeed0d
movq %rax, %rbp
movq 0x18(%r14), %rdi
leaq 0x4(%r15), %rsi
callq 0xeed0d
movq %r14, %rdi
leaq 0xa0690(%rip), %rsi     # 0x12e876
movq %rbp, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
leaq 0x8(%r15), %rsi
callq 0xeed0d
movq %r14, %rdi
leaq 0x9b8e2(%rip), %rsi     # 0x129aec
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
leaq 0xc(%r15), %rsi
callq 0xeed0d
movq %r14, %rdi
leaq 0xa0662(%rip), %rsi     # 0x12e88c
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
incl %r13d
movq 0x40(%r12), %rax
addq 0x48(%r12), %rax
addq %rbx, %rax
addq $-0x14, %rax
addq $-0x14, %rbx
addq $0x14, %r15
cmpq $0x14, %rax
jge 0x8e19f
jmp 0x8e2b9
xorl %eax, %eax
jmp 0x8e2cc
movq %rdi, (%rsp)
movq 0x40(%r12), %rsi
cmpq $0x38, %rsi
jl 0x8e2b9
movq (%rsp), %rax
movq 0x10(%rax), %r15
movq 0x18(%rax), %rdi
addq $0x30, %rsi
callq 0xeee96
movq %rax, 0x18(%r15)
addq $0x18, %r15
leaq 0xa05fb(%rip), %rsi     # 0x12e89b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xee89c
movq (%rsp), %rax
movl $0x1, 0x130(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xa16f2(%rip), %rax     # 0x12f9d5
movq %rax, (%rsi)
leaq 0xa05d3(%rip), %rax     # 0x12e8c0
movq %rax, 0x8(%rsi)
leaq 0x17(%rip), %rax        # 0x8e30f
movq %rax, 0x18(%rsi)
leaq 0x75d(%rip), %rax       # 0x8ea60
movq %rax, 0x20(%rsi)
movl $0x10, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xab59f(%rip), %rax     # 0x13a325
leaq 0xa1bc3(%rip), %rdx     # 0x130950
cmoveq %rax, %rdx
movq 0x8(%rbx), %rcx
movq 0x8(%rsi), %r8
leaq 0x9fd30(%rip), %rsi     # 0x12ead0
xorl %eax, %eax
callq 0xe8617
movq 0x8(%rbx), %rcx
movq 0x8(%r15), %rax
addq %rcx, %rax
movq 0x18(%r14), %rdx
cmpq 0x18(%rdx), %rax
jle 0x8ee00
cmpb $0x0, (%rbx)
leaq 0xa526e(%rip), %rax     # 0x134034
leaq 0x9fd43(%rip), %rdx     # 0x12eb10
cmoveq %rax, %rdx
leaq 0x9fd10(%rip), %rsi     # 0x12eae8
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9295
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 0x8ee00
movb $0x1, 0x1(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x87d71(%rip), %rax     # 0x116bcc
movq %rax, (%rsi)
leaq 0x9fcb9(%rip), %rax     # 0x12eb1e
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x8ee8b
movq %rax, 0x18(%rsi)
leaq 0x1b1b(%rip), %rax      # 0x90996
movq %rax, 0x20(%rsi)
leaq 0x1bc8(%rip), %rax      # 0x90a4e
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeed0d
cmpq $0x100, %rax            # imm = 0x100
jne 0x90a41
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
movq %rsp, %rsi
movl $0x10, %ecx
xorl %edx, %edx
callq 0xee8d4
leaq (%rsp,%r14), %rdi
callq 0xeed08
movq %rax, 0x10(%rsp,%r14,2)
addq $0x4, %r14
cmpq $0x10, %r14
jne 0x909d2
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
addq 0x10(%rsp), %rax
xorl %r14d, %r14d
cmpq %rsi, %rax
jg 0x90a41
movq 0x28(%rsp), %r15
cmpq $0x1e, %r15
jl 0x90a41
addq %rsi, %r15
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %r15
jg 0x90a41
movq %rsp, %rdx
movl $0x10, %ecx
callq 0xefc85
testl %eax, %eax
jne 0x90a41
movq 0x18(%rbx), %rax
cmpq 0x18(%rax), %r15
movl $0x64, %eax
movl $0x4b, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf6410
movq %rax, %r14
cmpb $0x0, 0xd0(%r15)
je 0x90acb
movq 0x28(%rbp), %rdi
callq 0xf67a3
testl %eax, %eax
je 0x90acb
movq 0x28(%rbp), %rsi
movq %r14, %rdi
callq 0xf6509
leaq 0xaaeb0(%rip), %rsi     # 0x13b96e
movq %r14, %rdi
movl $0x5, %edx
callq 0xf65e3
addq $0x8, %r12
testq %r13, %r13
cmovneq %r13, %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0xf65e3
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xea53f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/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 0x9e5f4(%rip), %rax     # 0x12f107
movq %rax, (%rsi)
leaq 0x9e5f0(%rip), %rax     # 0x12f10d
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x90b38
movq %rax, 0x18(%rsi)
leaq 0x524(%rip), %rax       # 0x91057
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/lzexe.c
// Function: read_reloc_tbl
static void read_reloc_tbl(deark *c, lctx *d)
{
	d->end_of_reloc_tbl = d->ephdr_pos + d->ephdr.field6;
	if(d->end_of_reloc_tbl > c->infile->len) {
		d->errflag = 1;
		goto done;
	}
	if(d->ver==LZEXE_VER_090) {
		do_decode_reloc_tbl_v090(c, d);
	}
	else {
		do_decode_reloc_tbl_v091(c, d);
	}
done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x28(%rsi), %r15
movq 0x68(%rsi), %rdx
addq %r15, %rdx
movq %rdx, 0x30(%rsi)
movq 0x18(%rdi), %rax
cmpq 0x18(%rax), %rdx
jle 0x910af
movl $0x1, 0x4(%r14)
jmp 0x911c3
movq %rdi, %rbx
cmpl $0x1, (%r14)
jne 0x910db
addq $0x19d, %r15            # imm = 0x19D
movq 0x80(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfb90a
testl %eax, %eax
jne 0x911c3
jmp 0x910a2
addq $0x158, %r15            # imm = 0x158
movq %r15, (%rsp)
leaq 0x9e192(%rip), %rsi     # 0x12f27f
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
cmpq 0x30(%r14), %r15
jge 0x911ae
movq %rsp, %r15
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeeb4b
testb %al, %al
je 0x9112f
movzbl %al, %r13d
jmp 0x9114d
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeebeb
movq %rax, %r13
testl %r13d, %r13d
je 0x911a5
cmpl $0x1, %r13d
je 0x911d2
addl %r12d, %r13d
movq %rbx, %rdi
leaq 0x9e145(%rip), %rsi     # 0x12f29f
movl %r13d, %edx
xorl %eax, %eax
callq 0xe87e4
movq 0x80(%r14), %rdi
movl %r13d, %esi
andl $0xf, %esi
callq 0xf0f95
movq 0x80(%r14), %rdi
movl %r13d, %esi
shrl $0x4, %esi
callq 0xf0f95
incl %ebp
movl %r13d, %r12d
movq (%rsp), %rax
cmpq 0x30(%r14), %rax
jge 0x911ae
cmpl $0xffff, %ebp           # imm = 0xFFFF
jle 0x91119
jmp 0x911ae
addl $0xfff0, %r12d          # imm = 0xFFF0
jmp 0x9118d
movl $0x1, 0x4(%r14)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9e0d2(%rip), %rsi     # 0x12f2ab
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
jmp 0x911b6
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x4(%rsi)
jne 0x916e5
movq %rsi, %rbx
movq 0x90(%rsi), %rax
addq $0x2, %rax
cmpq 0x28(%rsi), %rax
jle 0x916eb
movl $0x1, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %r14
leaq 0x90(%rbx), %r15
addq $0x98, %rbx
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %esi
movq %rbx, %rdi
callq 0xf1b5e
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf1b5e
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9dc49(%rip), %rax     # 0x12f380
movq %rax, (%rsi)
leaq 0x9dc44(%rip), %rax     # 0x12f385
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x9175c
movq %rax, 0x18(%rsi)
leaq 0xeae(%rip), %rax       # 0x92605
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x92673
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x98(%rsi), %rdi
callq 0xf6753
movq 0x90(%rbx), %rdi
callq 0xf6753
movq 0xa0(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8be2
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeeb4b
movb %al, 0xf(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeeb4b
movb %al, 0xe(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeeb4b
movl %eax, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0xeeb4b
movl %eax, %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0xeeb4b
movl %eax, %ebp
movq %r15, %rdi
movq %r12, %rsi
callq 0xeeb4b
testb %r14b, %r14b
je 0x92728
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 0xea98e
movb $0x1e, 0x2(%rbx)
jmp 0x9272e
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_O3/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, %rbp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movl $0xff, %esi
movq %r9, %rdi
callq 0xe9c3b
testq %rax, %rax
jle 0x927ee
movq %rax, %r14
movq 0x40(%rsp), %rcx
cmpb $0x0, 0x3(%r15)
je 0x927ce
cmpl $0x1, 0x30(%r12)
jne 0x927ce
movq %rsp, %r12
movq %rbp, (%r12)
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf09c5
movq %rax, %r13
movq %r14, %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0xeeb4b
andb $0x7f, %al
movzbl %al, %esi
movq %r13, %rdi
callq 0xf0bd6
decq %rbp
jne 0x9279e
movl 0x8(%r15), %r9d
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
jmp 0x927de
movl 0x8(%r15), %r9d
xorl %r13d, %r13d
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0xefbd7
movq %r13, %rdi
callq 0xf052b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x14(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rbx
testq %rbx, %rbx
jle 0x935b6
addq %rax, %rbx
xorl %r13d, %r13d
cmpq 0x10(%r12), %r13
jge 0x935b9
movq (%r14), %rdi
leaq 0x8(%rsp), %rbp
movq %rbp, %rsi
callq 0xeeb4b
cmpb 0x14(%rsp), %al
jne 0x9359e
movq (%r14), %rdi
movq %rbp, %rsi
callq 0xeeb4b
movl %eax, %r15d
movq (%r14), %rdi
movq %rbp, %rsi
callq 0xeeb4b
movzbl %al, %edx
leaq (%rdx,%r13), %rbp
incq %rbp
cmpq 0x10(%r12), %rbp
jg 0x935b9
incq %rdx
movq (%r12), %rdi
movzbl %r15b, %esi
callq 0xf0eba
movq %rbp, %r13
jmp 0x935ad
movq (%r12), %rdi
movzbl %al, %esi
callq 0xf0bd6
incq %r13
cmpq %rbx, 0x8(%rsp)
jl 0x93542
jmp 0x935b9
xorl %r13d, %r13d
cmpq 0x10(%r12), %r13
movq 0x20(%rsp), %rbx
je 0x935d9
leaq 0x91cc7(%rip), %rdx     # 0x125293
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xfa311
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_O3/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 0x9361d
pushq %rax
movq 0x8(%rsi), %rax
movq (%rax), %rsi
movq 0xc0(%rax), %rcx
movq 0x8(%rdx), %r8
movq %rax, %rdx
callq 0x927fd
addq $0x8, %rsp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x93640
cmpl $0x2, %ecx
jne 0x93657
movl $0xb8, %ecx
jmp 0x93645
movl $0xb0, %ecx
pushq %rax
movq (%rdx,%rcx), %rcx
movq 0x8(%rax), %r8
callq 0x927fd
addq $0x8, %rsp
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x9c34d(%rip), %rax     # 0x12f9b4
movq %rax, (%rsi)
leaq 0x9c34c(%rip), %rax     # 0x12f9bd
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x93697
movq %rax, 0x18(%rsi)
leaq 0xadc(%rip), %rax       # 0x94163
movq %rax, 0x20(%rsi)
leaq 0xb8d(%rip), %rax       # 0x9421f
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x94243
movl %eax, %ecx
movl $0x55, %eax
testb %cl, %cl
je 0x94182
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movl $0x41, %edx
movl $0x8, %ecx
movq %r14, %rsi
callq 0xee8d4
cmpl $0x47544e50, (%r14)     # imm = 0x47544E50
je 0x941f2
leaq 0x8049f(%rip), %rsi     # 0x11464a
movq %rbx, %rdi
callq 0xea491
movl %eax, %ecx
movl $0xa, %eax
testl %ecx, %ecx
jne 0x9417a
leaq 0x9bbe3(%rip), %rsi     # 0x12fda8
movq %rbx, %rdi
callq 0xea491
movl %eax, %ecx
movl $0xf, %eax
testl %ecx, %ecx
jne 0x9417a
leaq 0x9bbce(%rip), %rsi     # 0x12fdad
movq %rbx, %rdi
callq 0xea491
movl %eax, %ecx
testl %eax, %eax
movl $0xf, %eax
jmp 0x94217
movq 0x28(%rbx), %rcx
movl $0x64, %eax
cmpb $0x0, 0x4(%rcx)
jne 0x9417a
cmpl $0x544e504d, 0x4(%rsp)  # imm = 0x544E504D
movl $0x50, %ecx
movl $0x46, %eax
cmovel %ecx, %eax
jmp 0x9417a
// File: /workspace/github_c_makefile_star2_O3/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 0x9b9f5(%rip), %rax     # 0x12fe70
movq %rax, (%rsi)
leaq 0x9b9f4(%rip), %rax     # 0x12fe79
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x944ab
movq %rax, 0x18(%rsi)
leaq 0xc50(%rip), %rax       # 0x950eb
movq %rax, 0x20(%rsi)
leaq 0xc6b(%rip), %rax       # 0x95111
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x9b32f(%rip), %rsi     # 0x130469
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
movl $0x1, %esi
callq 0xe8a15
cmpq $0x0, 0x48(%r15)
jle 0x951be
xorl %r12d, %r12d
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xeead3
movl %eax, %ebp
movq 0x18(%r14), %rdi
leaq 0x1(%rbx), %rsi
callq 0xeead3
movl %eax, %r13d
movq 0x18(%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0xeead3
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 %r14, %rdi
movq %r12, %rsi
callq 0xe91fc
incq %r12
addq $0x3, %rbx
cmpq 0x48(%r15), %r12
jl 0x95158
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe8a15
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
movl $0x3, %ecx
callq 0xf266a
movq %rax, %r14
movq %rbx, %rdi
callq 0xea504
movq %rax, %r12
cmpb $0x0, 0x70(%r15)
je 0x95227
movl $0x1, 0x78(%r12)
movaps 0x8fd92(%rip), %xmm0    # 0x124fb0
movups %xmm0, 0x80(%r12)
movq 0x88(%r15), %rdi
movq 0x50(%r15), %rdx
movq 0x58(%r15), %rcx
addq $0x90, %r15
movl $0x0, (%rsp)
xorl %esi, %esi
movq %r15, %r8
movq %r14, %r9
callq 0xf2f79
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xf22d0
movq %r14, %rdi
callq 0xf228d
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xea50e
// File: /workspace/github_c_makefile_star2_O3/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 0x9af2d(%rip), %rax     # 0x1301b0
movq %rax, (%rsi)
leaq 0x9af28(%rip), %rax     # 0x1301b5
movq %rax, 0x8(%rsi)
leaq 0x26(%rip), %rax        # 0x952be
movq %rax, 0x18(%rsi)
leaq 0x22(%rip), %rax        # 0x952c5
movq %rax, 0x20(%rsi)
leaq 0x99(%rip), %rax        # 0x95347
movq %rax, 0x28(%rsi)
leaq 0x9af14(%rip), %rax     # 0x1301cd
movq %rax, 0x38(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x6(%rsp), %r14
movl $0xa, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movabsq $0x62756f706e6f694c, %rax # imm = 0x62756F706E6F694C
xorq (%r14), %rax
movzwl 0x8(%r14), %ecx
xorq $0x6b6e, %rcx           # imm = 0x6B6E
movl $0x63, %ebp
orq %rax, %rcx
je 0x9533c
leaq 0x6(%rsp), %rdi
callq 0xeed08
cmpl $0x19861987, %eax       # imm = 0x19861987
je 0x95337
cmpl $0x6071963, %eax        # imm = 0x6071963
jne 0x95333
movq 0x18(%rbx), %rdi
movq %rsp, %rsi
callq 0x96bb8
testl %eax, %eax
jne 0x9533c
xorl %ebp, %ebp
jmp 0x9533c
movl $0x64, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_pp1
void de_module_stos_pp1(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_pp1";
	mi->desc = "Picture Packer low res";
	mi->run_fn = de_run_stos_pp1;
	mi->identify_fn = de_identify_stos_pp1;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x9ae57(%rip), %rax     # 0x1301d1
movq %rax, (%rsi)
leaq 0x9ae56(%rip), %rax     # 0x1301da
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x953aa
movq %rax, 0x18(%rsi)
leaq 0x1a(%rip), %rax        # 0x953b4
movq %rax, 0x20(%rsi)
leaq -0x5e(%rip), %rax       # 0x95347
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_pp1
static int de_identify_stos_pp1(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "pp1");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && res==1) return 100;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9ae13(%rip), %rsi     # 0x1301d6
callq 0xea491
testl %eax, %eax
je 0x953f1
movq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x96bb8
xorl %edx, %edx
cmpl $0x1, (%rbx)
movl $0x64, %ecx
cmovnel %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x953f3
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_pp2
void de_module_stos_pp2(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_pp2";
	mi->desc = "Picture Packer med res";
	mi->run_fn = de_run_stos_pp2;
	mi->identify_fn = de_identify_stos_pp2;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x9adef(%rip), %rax     # 0x1301f1
movq %rax, (%rsi)
leaq 0x9adee(%rip), %rax     # 0x1301fa
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x95432
movq %rax, 0x18(%rsi)
leaq 0x1a(%rip), %rax        # 0x9543c
movq %rax, 0x20(%rsi)
leaq -0xe6(%rip), %rax       # 0x95347
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_pp2
static int de_identify_stos_pp2(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "pp2");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && res==1) return 100;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9adab(%rip), %rsi     # 0x1301f6
callq 0xea491
testl %eax, %eax
je 0x95479
movq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x96bb8
xorl %edx, %edx
cmpl $0x1, (%rbx)
movl $0x64, %ecx
cmovnel %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x9547b
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_pp3
void de_module_stos_pp3(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_pp3";
	mi->desc = "Picture Packer high res";
	mi->run_fn = de_run_stos_pp3;
	mi->identify_fn = de_identify_stos_pp3;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x9ad87(%rip), %rax     # 0x130211
movq %rax, (%rsi)
leaq 0x9ad86(%rip), %rax     # 0x13021a
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x954ba
movq %rax, 0x18(%rsi)
leaq 0x1a(%rip), %rax        # 0x954c4
movq %rax, 0x20(%rsi)
leaq -0x16e(%rip), %rax      # 0x95347
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_pp3
static int de_identify_stos_pp3(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "pp3");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && res==1) return 100;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9ad43(%rip), %rsi     # 0x130216
callq 0xea491
testl %eax, %eax
je 0x95501
movq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x96bb8
xorl %edx, %edx
cmpl $0x1, (%rbx)
movl $0x64, %ecx
cmovnel %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x95503
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_daj
void de_module_stos_daj(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_daj";
	mi->desc = "Picture Packer DAJ";
	mi->run_fn = de_run_stos_daj;
	mi->identify_fn = de_identify_stos_daj;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x9ad20(%rip), %rax     # 0x130232
movq %rax, (%rsi)
leaq 0x9ad1f(%rip), %rax     # 0x13023b
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x95542
movq %rax, 0x18(%rsi)
leaq 0x17(%rip), %rax        # 0x95549
movq %rax, 0x20(%rsi)
leaq -0x1f6(%rip), %rax      # 0x95347
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_daj
static int de_identify_stos_daj(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "daj");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && (res==0 || res==1)) return 100;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9acdf(%rip), %rsi     # 0x130237
callq 0xea491
testl %eax, %eax
je 0x95586
movq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x96bb8
xorl %edx, %edx
cmpl $0x2, (%rbx)
movl $0x64, %ecx
cmovael %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x95588
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mbk.c
// Function: is_stos_packedscreen
static int is_stos_packedscreen(deark *c, UI *res)
{
	u8 buf[24];
	u8 is_mbk = 0;
	UI id = 0;
	UI field14;
	UI field18;
	i64 bpos = 0;

	*res = 0;
	de_read(buf, 0, sizeof(buf));

	if(!de_memcmp(buf, g_lion_sig, 10)) is_mbk = 1;
	if(is_mbk) {
		if((UI)de_getu32be_direct(&buf[10]) == 0) return 0; // screen out MBS
		if(buf[14] != 0x81) return 0; // must be type 'data'
		bpos = 18;
	}

	id = (UI)de_getu32be_direct(&buf[bpos]);
	if(id!=BANKID_PKSCREEN) return 0;
	*res = (UI)de_getu16be_direct(&buf[bpos+4]);
	if(*res > 2) return 0;

	field14 = (UI)de_getu16be_direct(&buf[bpos+14]);
	if(field14>=1 && field14<=6) {
		// It's likely that this is the AMOS format, not the STOS format.
		field18 = (UI)de_getu16be_direct(&buf[bpos+18]);
		// Expecting STOS flags to be small
		if(field18>=8) return 0;
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl $0x0, (%rsi)
xorl %ebx, %ebx
movq %rsp, %r15
movl $0x18, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
movabsq $0x62756f706e6f694c, %rax # imm = 0x62756F706E6F694C
xorq (%r15), %rax
movzwl 0x8(%r15), %ecx
xorq $0x6b6e, %rcx           # imm = 0x6B6E
orq %rax, %rcx
movl $0x0, %r12d
jne 0x96c24
leaq 0xa(%rsp), %rdi
callq 0xeed08
testl %eax, %eax
je 0x96c78
cmpb $-0x7f, 0xe(%rsp)
jne 0x96c78
leaq 0x12(%rsp), %r15
movl $0x12, %r12d
movq %r15, %rdi
callq 0xeed08
cmpl $0x6071963, %eax        # imm = 0x6071963
jne 0x96c78
leaq (%rsp,%r12), %rdi
addq $0x4, %rdi
callq 0xeeb5c
movl %eax, (%r14)
cmpl $0x2, %eax
ja 0x96c78
movq %rsp, %r14
leaq (%r12,%r14), %rdi
addq $0xe, %rdi
callq 0xeeb5c
decl %eax
cmpl $0x5, %eax
ja 0x96c73
leaq (%r12,%r14), %rdi
addq $0x12, %rdi
callq 0xeeb5c
testl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
jne 0x96c78
movl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mmm.c
// Function: de_module_mmm
void de_module_mmm(deark *c, struct deark_module_info *mi)
{
	mi->id = "mmm";
	mi->desc = "RIFF Multimedia Movie";
	mi->run_fn = de_run_mmm;
	mi->identify_fn = de_identify_mmm;
	mi->help_fn = de_help_mmm;
}

// Assembly:
leaq 0x99a81(%rip), %rax     # 0x130710
movq %rax, (%rsi)
leaq 0x99a7b(%rip), %rax     # 0x130714
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x96cbf
movq %rax, 0x18(%rsi)
leaq 0x378(%rip), %rax       # 0x97027
movq %rax, 0x20(%rsi)
leaq 0x3af(%rip), %rax       # 0x97069
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mmm.c
// Function: my_mmm_handle_nonchunk_data_fn
static int my_mmm_handle_nonchunk_data_fn(struct de_iffctx *ictx,
	i64 pos, i64 *plen)
{
	u8 buf[6];

	dbuf_read(ictx->f, buf, pos, sizeof(buf));

	if(buf[0]<65 || buf[1]<65) {
		if(looks_like_a_4cc_b(&buf[2])) {
			*plen = 2;
			de_dbg(ictx->c, "[%"I64_FMT" non-RIFF bytes at %"I64_FMT"]", *plen, pos);
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
leaq 0x2(%rsp), %r12
movl $0x6, %ecx
movq %r12, %rsi
movq %rbx, %rdx
callq 0xee8d4
cmpb $0x41, (%r12)
jb 0x974f0
xorl %eax, %eax
cmpb $0x40, 0x3(%rsp)
ja 0x9752e
xorl %eax, %eax
xorl %ecx, %ecx
movb 0x4(%rsp,%rcx), %dl
addb $-0x7f, %dl
cmpb $-0x5f, %dl
jb 0x9752e
incq %rcx
cmpq $0x4, %rcx
jne 0x974f4
movq $0x2, (%r14)
movq (%r15), %rdi
leaq 0x993f3(%rip), %rsi     # 0x13090d
movl $0x2, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe8617
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mmm.c
// Function: do_mmm_cftc
static void do_mmm_cftc(deark *c, struct mmm_ctx *d, struct de_iffctx *ictx,
	i64 dpos1, i64 dlen)
{
	i64 nentries;
	i64 i;
	i64 pos;
	struct de_fourcc tmp4cc;

	if(dlen<4) goto done;
	nentries = (dlen-4)/16;

	pos = dpos1+4;
	for(i=0; i<nentries; i++) {
		int chk_id;
		i64 chk_pos;
		i64 chk_dlen;
		de_zeromem(&tmp4cc, sizeof(struct de_fourcc));
		dbuf_read_fourcc(ictx->f, pos, &tmp4cc, 4, 0);
		pos += 4;
		if(tmp4cc.id==0) break;
		chk_dlen = dbuf_getu32le_p(ictx->f, &pos);
		chk_id = (int)dbuf_geti32le_p(ictx->f, &pos);
		chk_pos = dbuf_getu32le_p(ictx->f, &pos);
		de_dbg(c, "toc entry '%s' id=%d pos=%"I64_FMT" dlen=%"I64_FMT,
			tmp4cc.id_sanitized_sz, chk_id, chk_pos, chk_dlen);
	}

done:
	;
}

// Assembly:
cmpq $0x4, %rcx
jl 0x97654
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
addq $-0x4, %rbx
addq $0x4, %rdx
movq %rdx, 0x8(%rsp)
cmpq $0x10, %rbx
jb 0x97646
movq %rsi, %r14
movq %rdi, %r15
shrq $0x4, %rbx
leaq 0x8(%rsp), %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1762
addq $0x4, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x97646
movq 0x18(%r14), %rdi
movq %rbp, %rsi
callq 0xeed83
movq %rax, %r13
movq 0x18(%r14), %rdi
movq %rbp, %rsi
callq 0xeee2f
movq %rax, %r12
movq 0x18(%r14), %rdi
movq %rbp, %rsi
callq 0xeed83
movq %r15, %rdi
leaq 0x991b7(%rip), %rsi     # 0x1307df
leaq 0x18(%rsp), %rdx
movl %r12d, %ecx
movq %rax, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0xe8617
decq %rbx
jne 0x975ba
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mmm.c
// Function: mmm_read_name_p
static void mmm_read_name_p(deark *c, struct mmm_ctx *d, struct de_iffctx *ictx,
	i64 *ppos, const char *name)
{
	i64 pos = *ppos;
	i64 namelen;

	ucstring_empty(d->tmp_namestr);
	namelen = (i64)dbuf_getbyte(ictx->f, pos);
	if(namelen) {
		dbuf_read_to_ucstring(ictx->f, pos+1, namelen, d->tmp_namestr, 0, d->input_encoding);
		de_dbg(c, "%s: \"%s\"", (name ? name : "name"), ucstring_getpsz_d(d->tmp_namestr));
	}
	*ppos += de_pad_to_2(1+namelen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, (%rsp)
movq (%rcx), %rbp
movq 0x28(%rsi), %rdi
callq 0xf6423
movq 0x18(%r14), %rdi
movq %rbp, %rsi
callq 0xeead3
movzbl %al, %r15d
testb %r15b, %r15b
je 0x9805f
movq 0x18(%r14), %rdi
incq %rbp
movq 0x28(%r13), %rcx
movl 0xc(%r13), %r9d
movq %rbp, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xefbd7
testq %r12, %r12
leaq 0x90818(%rip), %r14     # 0x128852
cmovneq %r12, %r14
movq 0x28(%r13), %rdi
callq 0xf70f6
leaq 0x940dc(%rip), %rsi     # 0x12c12a
movq (%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
leaq 0x1(%r15), %rdi
callq 0xe9c7e
addq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mp3.c
// Function: de_module_apetag
void de_module_apetag(deark *c, struct deark_module_info *mi)
{
	mi->id = "apetag";
	mi->desc = "APE tag";
	mi->run_fn = de_run_apetag;
	mi->identify_fn = NULL;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
leaq 0x98a4e(%rip), %rax     # 0x130ad1
movq %rax, (%rsi)
leaq 0x98a4b(%rip), %rax     # 0x130ad8
movq %rax, 0x8(%rsi)
leaq 0x11(%rip), %rax        # 0x980a9
movq %rax, 0x18(%rsi)
movq $0x0, 0x20(%rsi)
orb $0x1, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mp3.c
// Function: de_module_mpegaudio
void de_module_mpegaudio(deark *c, struct deark_module_info *mi)
{
	mi->id = "mpegaudio";
	mi->id_alias[0] = "mp3";
	mi->desc = "MP3 / MPEG audio";
	mi->run_fn = de_run_mpegaudio;
	mi->identify_fn = de_identify_mpegaudio;
}

// Assembly:
leaq 0x9843a(%rip), %rax     # 0x130ae0
movq %rax, (%rsi)
leaq 0x9843a(%rip), %rax     # 0x130aea
movq %rax, 0x38(%rsi)
leaq 0x98433(%rip), %rax     # 0x130aee
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x986d6
movq %rax, 0x18(%rsi)
leaq 0x59e(%rip), %rax       # 0x98c6f
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mp3.c
// Function: de_module_monkeys_audio
void de_module_monkeys_audio(deark *c, struct deark_module_info *mi)
{
	mi->id = "monkeys_audio";
	mi->desc = "Monkey's Audio (.ape)";
	mi->run_fn = de_run_monkeys_audio;
	mi->identify_fn = de_identify_monkeys_audio;
}

// Assembly:
leaq 0x97d02(%rip), %rax     # 0x130aff
movq %rax, (%rsi)
leaq 0x97d06(%rip), %rax     # 0x130b0d
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x98e22
movq %rax, 0x18(%rsi)
leaq 0x85(%rip), %rax        # 0x98ea2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mp3.c
// Function: de_run_monkeys_audio
static void de_run_monkeys_audio(deark *c, de_module_params *mparams)
{
	i64 endpos = c->infile->len;

	if(is_apetag_sig_at(c->infile, endpos-32)) {
		de_dbg(c, "APE tag found, ending at %"I64_FMT, endpos);
		de_dbg_indent(c, 1);
		de_run_module_by_id_on_slice2(c, "apetag", NULL, c->infile, 0, endpos);
		de_dbg_indent(c, -1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %r14
leaq -0x20(%r14), %rsi
leaq 0x97d10(%rip), %rdx     # 0x130b4c
movl $0x8, %ecx
callq 0xefc85
testl %eax, %eax
je 0x98e52
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x97e2d(%rip), %rsi     # 0x130c86
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%rbx), %rcx
leaq 0x97c53(%rip), %rsi     # 0x130ad1
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
movq %r14, %r9
callq 0xe9b13
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8a15
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mp3.c
// Function: de_identify_monkeys_audio
static int de_identify_monkeys_audio(deark *c)
{
	unsigned int n;

	if(dbuf_memcmp(c->infile, 0, "MAC ", 4)) return 0;
	n = (unsigned int)de_getu16le(6);
	if(ma_is_known_cmpr(n)) return 100;
	n = (unsigned int)de_getu16le(52);
	if(ma_is_known_cmpr(n)) return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x980b8(%rip), %rdx     # 0x130f6c
xorl %r14d, %r14d
movl $0x4, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x98f3b
movq 0x18(%rbx), %rdi
movl $0x6, %esi
callq 0xeebc8
leal -0x3e8(%rax), %ecx
cmpl $0xfa0, %ecx            # imm = 0xFA0
ja 0x98f05
movzwl %ax, %ecx
shrl $0x3, %ecx
imull $0x20c5, %ecx, %ecx     # imm = 0x20C5
shrl $0x14, %ecx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
movl $0x64, %r14d
testw %ax, %ax
je 0x98f3b
movq 0x18(%rbx), %rdi
movl $0x34, %esi
callq 0xeebc8
imull $0x78d5, %eax, %ecx     # imm = 0x78D5
addl $0xfffffc18, %eax       # imm = 0xFFFFFC18
rorw $0x3, %cx
xorl %edx, %edx
cmpw $0x42, %cx
movl $0x64, %r14d
cmovael %edx, %r14d
cmpl $0xfa1, %eax            # imm = 0xFA1
cmovael %edx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mscompress.c
// Function: de_module_mscompress
void de_module_mscompress(deark *c, struct deark_module_info *mi)
{
	mi->id = "mscompress";
	mi->desc = "MS-DOS Installation Compression";
	mi->run_fn = de_run_mscompress;
	mi->identify_fn = de_identify_mscompress;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
leaq 0x981aa(%rip), %rax     # 0x1310f9
movq %rax, (%rsi)
leaq 0x981ab(%rip), %rax     # 0x131104
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x98f78
movq %rax, 0x18(%rsi)
leaq 0x114d(%rip), %rax      # 0x9a0bc
movq %rax, 0x20(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mscompress.c
// Function: de_module_is_ibt
void de_module_is_ibt(deark *c, struct deark_module_info *mi)
{
	mi->id = "is_ibt";
	mi->desc = "InstallShield IBT archive";
	mi->run_fn = de_run_is_ibt;
	mi->identify_fn = de_identify_is_ibt;
}

// Assembly:
leaq 0x9704b(%rip), %rax     # 0x131124
movq %rax, (%rsi)
leaq 0x97048(%rip), %rax     # 0x13112b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x9a0fe
movq %rax, 0x18(%rsi)
leaq 0x30d(%rip), %rax       # 0x9a406
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mscompress.c
// Function: de_module_mrnz
void de_module_mrnz(deark *c, struct deark_module_info *mi)
{
	mi->id = "mrnz";
	mi->desc = "MRNZ obfuscated file";
	mi->run_fn = de_run_mrnz;
	mi->identify_fn = de_identify_mrnz;
}

// Assembly:
leaq 0x96d12(%rip), %rax     # 0x131145
movq %rax, (%rsi)
leaq 0x96d0d(%rip), %rax     # 0x13114a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x9a458
movq %rax, 0x18(%rsi)
leaq 0xb9(%rip), %rax        # 0x9a50c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/mscompress.c
// Function: de_run_mrnz
static void de_run_mrnz(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;
	i64 ipos;
	i64 i;
	i64 ocount;
	u8 errflag = 0;

	ipos = 8;
	// Guessing that this is the number of obfuscated bytes
	ocount = de_getu32le_p(&ipos);
	if(ocount>0xff) {
		errflag = 1;
		goto done;
	}

	outf = dbuf_create_output_file(c, "bin", NULL, 0);
	for(i=0; i<ocount; i++) {
		u8 b;

		if(ipos >= c->infile->len) goto done;
		b = de_getbyte_p(&ipos);
		dbuf_writebyte(outf, b^0xae);
	}

	dbuf_copy(c->infile, ipos, c->infile->len-ipos, outf);

done:
	dbuf_close(outf);
	if(errflag) {
		de_err(c, "Failed to decode MRNZ file");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x8, (%rsi)
movq 0x18(%rdi), %rdi
callq 0xeed83
cmpq $0xff, %rax
jg 0x9a4e8
movq %rax, %r15
leaq 0x9b335(%rip), %rsi     # 0x1357bd
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r14
testq %r15, %r15
jle 0x9a4c7
movq %rsp, %r12
movq (%rsp), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jge 0x9a4de
movq %r12, %rsi
callq 0xeeb4b
xorb $-0x52, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0xf0bd6
decq %r15
jne 0x9a49f
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
movq 0x18(%rdi), %rdx
subq %rsi, %rdx
movq %r14, %rcx
callq 0xef481
movq %r14, %rdi
callq 0xf052b
jmp 0x9a500
xorl %edi, %edi
callq 0xf052b
leaq 0x96f5d(%rip), %rsi     # 0x131453
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq