LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/atari-img.c
// Function: de_run_falcon_xga
static void de_run_falcon_xga(deark *c, de_module_params *mparams)
{
	struct atari_img_decode_data *adata = NULL;
	de_finfo *fi = NULL;

	adata = de_malloc(c, sizeof(struct atari_img_decode_data));
	if(c->infile->len==153600) {
		adata->bpp = 16;
		adata->w = 320;
		adata->h = 240;
	}
	else {
		adata->bpp = 16;
		adata->w = 384;
		adata->h = 480;
	}
	de_dbg_dimensions(c, adata->w, adata->h);
	adata->unc_pixels = c->infile;
	adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
	fi = de_finfo_create(c);
	if(adata->w==384 && adata->h == 480) {
		fi->density.code = DE_DENSITY_UNK_UNITS;
		fi->density.xdens = 384;
		fi->density.ydens = 640;
	}
	fmtutil_atari_decode_image(c, adata);
	de_bitmap_write_to_file_finfo(adata->img, fi, 0);
	de_bitmap_destroy(adata->img);
	de_finfo_destroy(c, fi);
	de_free(c, adata);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x40, %esi
callq 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rax
xorl %esi, %esi
cmpq $0x25800, 0x18(%rax)    # imm = 0x25800
setne %sil
movl $0xf0, %eax
movl $0x1e0, %edx            # imm = 0x1E0
cmoveq %rax, %rdx
shll $0x6, %esi
addq $0x140, %rsi            # imm = 0x140
movq $0x10, (%r14)
movq %rsi, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rbx, %rdi
callq 0xe8f88
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movl $0x3, %ecx
callq 0xf266a
movq %rax, 0x38(%r14)
movq %rbx, %rdi
callq 0xea504
movq %rax, %r15
cmpq $0x180, 0x10(%r14)      # imm = 0x180
jne 0x236a3
cmpq $0x1e0, 0x18(%r14)      # imm = 0x1E0
jne 0x236a3
movl $0x1, 0x78(%r15)
movaps 0xefc35(%rip), %xmm0    # 0x1132d0
movups %xmm0, 0x80(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf8b10
movq 0x38(%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xf22d0
movq 0x38(%r14), %rdi
callq 0xf228d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xea50e
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/atari-img.c
// Function: de_module_coke
void de_module_coke(deark *c, struct deark_module_info *mi)
{
	mi->id = "coke";
	mi->desc = "Atari Falcon COKE image (.TG1)";
	mi->run_fn = de_run_coke;
	mi->identify_fn = de_identify_coke;
}

// Assembly:
leaq 0xefece(%rip), %rax     # 0x1135ee
movq %rax, (%rsi)
leaq 0xefec9(%rip), %rax     # 0x1135f3
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x23745
movq %rax, 0x18(%rsi)
leaq 0x10f(%rip), %rax       # 0x2384f
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/atari-img.c
// Function: de_run_coke
static void de_run_coke(deark *c, de_module_params *mparams)
{
	i64 imgdatapos;
	struct atari_img_decode_data *adata = NULL;
	de_finfo *fi = NULL;

	adata = de_malloc(c, sizeof(struct atari_img_decode_data));
	adata->bpp = 16;
	adata->w = de_getu16be(12);
	adata->h = de_getu16be(14);
	de_dbg_dimensions(c, adata->w, adata->h);
	imgdatapos = de_getu16be(16);
	de_dbg(c, "image data pos: %d", (int)imgdatapos);

	adata->unc_pixels = dbuf_open_input_subfile(c->infile,
		imgdatapos, c->infile->len-imgdatapos);
	adata->img = de_bitmap_create(c, adata->w, adata->h, 3);

	fi = de_finfo_create(c);
	fi->density.code = DE_DENSITY_UNK_UNITS;
	fi->density.xdens = 288;
	fi->density.ydens = 240;

	fmtutil_atari_decode_image(c, adata);
	de_bitmap_write_to_file_finfo(adata->img, fi, 0);

	if(adata) {
		dbuf_close(adata->unc_pixels);
		de_bitmap_destroy(adata->img);
		de_free(c, adata);
	}
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x40, %esi
callq 0xe8b2b
movq %rax, %r14
movq $0x10, (%rax)
movq 0x18(%rbx), %rdi
movl $0xc, %esi
callq 0xeeb67
movq %rax, 0x10(%r14)
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xeeb67
movq %rax, 0x18(%r14)
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe8f88
movq 0x18(%rbx), %rdi
movl $0x10, %esi
callq 0xeeb67
movq %rax, %r15
leaq 0xf03c9(%rip), %rsi     # 0x113b75
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
subq %r15, %rdx
movq %r15, %rsi
callq 0xf1388
movq %rax, 0x20(%r14)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movl $0x3, %ecx
callq 0xf266a
movq %rax, 0x38(%r14)
movq %rbx, %rdi
callq 0xea504
movq %rax, %r15
movl $0x1, 0x78(%rax)
movaps 0xefa7e(%rip), %xmm0    # 0x113280
movups %xmm0, 0x80(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf8b10
movq 0x38(%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xf22d0
movq 0x20(%r14), %rdi
callq 0xf052b
movq 0x38(%r14), %rdi
callq 0xf228d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xea50e
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/atari-img.c
// Function: de_module_videomaster
void de_module_videomaster(deark *c, struct deark_module_info *mi)
{
	mi->id = "videomaster";
	mi->desc = "Video Master (.flm/.vid/.vsq)";
	mi->run_fn = de_run_videomaster;
	mi->identify_fn = de_identify_videomaster;
}

// Assembly:
leaq 0xefd96(%rip), %rax     # 0x113612
movq %rax, (%rsi)
leaq 0xefd98(%rip), %rax     # 0x11361e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x238a1
movq %rax, 0x18(%rsi)
leaq 0x204(%rip), %rax       # 0x23aa0
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/atari-img.c
// Function: fix_dark_pal
static void fix_dark_pal(deark *c, struct atari_img_decode_data *adata)
{
	u32 ap[2];

	if(adata->bpp!=1) return;

	ap[0] = adata->pal[0]&0xffffff;
	ap[1] = adata->pal[1]&0xffffff;

	// Always respect white/black and black/white palettes.
	if(ap[0]==0xffffff && ap[1]==0x000000) return; // The usual palette
	if(ap[0]==0x000000 && ap[1]==0xffffff) return;

	// Otherwise assume white/black, unless the user told us not to.
	if(de_get_ext_option(c, "atari:respectpal")) return;

	adata->pal[0] = DE_STOCKCOLOR_WHITE;
	adata->pal[1] = DE_STOCKCOLOR_BLACK;
}

// Assembly:
cmpq $0x1, (%rsi)
jne 0x23b14
pushq %rbx
movq %rsi, %rbx
movq 0x30(%rsi), %rdx
movl $0xffffff, %eax         # imm = 0xFFFFFF
movl (%rdx), %ecx
andl %eax, %ecx
movl %ecx, %esi
xorl %eax, %esi
andl 0x4(%rdx), %eax
orl %eax, %esi
je 0x23b13
xorl $0xffffff, %eax         # imm = 0xFFFFFF
orl %eax, %ecx
je 0x23b13
leaq 0xefc2b(%rip), %rsi     # 0x113723
callq 0xe9b74
testq %rax, %rax
jne 0x23b13
movq 0x30(%rbx), %rax
movabsq $-0xffffff00000001, %rcx # imm = 0xFF000000FFFFFFFF
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/atari-img.c
// Function: tiny_setword
static void tiny_setword(deark *c, tinyctx *d, struct atari_img_decode_data *adata, const u8 *wordbuf)
{
	i64 dstpos;

	// As each word is emitted from the decompressor, we store it in the unc_pixels buffer
	// in a particular location. The location is chosen so as to make the pixel data more
	// contiguous, but (for 2bpp and 4bpp images) more work will still have to be done when
	// the image is generated.

	if(d->stopflag) return;
	d->dcmpr_word_count++;
	dstpos = d->stripe * 8 + d->column*2 + (d->ypos * d->numscans + d->scan)*d->dst_rowspan;
	dbuf_write_at(adata->unc_pixels, dstpos, wordbuf, 2);
	d->ypos++;
	if(d->ypos >= 200) {
		d->ypos = 0;
		d->stripe++;
		if(d->stripe >= d->numstripes) {
			d->stripe = 0;
			d->scan++;
			if(d->scan >= d->numscans) {
				d->scan = 0;
				d->column++;
				if(d->column >= 4) {
					d->stopflag = 1;
					return;
				}
			}
		}
	}
}

// Assembly:
cmpl $0x0, 0x78(%rdi)
je 0x23b1c
retq
pushq %rbx
movq %rdi, %rbx
incq 0xa0(%rdi)
movq 0x68(%rdi), %rax
movq 0x88(%rdi), %rcx
shlq $0x3, %rcx
movq 0x98(%rdi), %rdi
leaq (%rcx,%rdi,2), %rcx
imulq 0x80(%rbx), %rax
addq 0x90(%rbx), %rax
imulq 0x70(%rbx), %rax
addq %rcx, %rax
movq 0x20(%rsi), %rdi
movl $0x2, %ecx
movq %rax, %rsi
callq 0xf0c11
movq 0x80(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x80(%rbx)
cmpq $0xc7, %rax
jl 0x23bf1
movq $0x0, 0x80(%rbx)
movq 0x88(%rbx), %rax
incq %rax
movq %rax, 0x88(%rbx)
cmpq 0x60(%rbx), %rax
jl 0x23bf1
movq $0x0, 0x88(%rbx)
movq 0x90(%rbx), %rax
incq %rax
movq %rax, 0x90(%rbx)
cmpq 0x68(%rbx), %rax
jl 0x23bf1
movq $0x0, 0x90(%rbx)
movq 0x98(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x98(%rbx)
cmpq $0x3, %rax
jl 0x23bf1
movl $0x1, 0x78(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/autocad.c
// Function: de_module_autocad_slb
void de_module_autocad_slb(deark *c, struct deark_module_info *mi)
{
	mi->id = "autocad_slb";
	mi->desc = "AutoCAD Slide Library";
	mi->run_fn = de_run_autocad_slb;
	mi->identify_fn = de_identify_autocad_slb;
}

// Assembly:
leaq 0xefd8a(%rip), %rax     # 0x113bd5
movq %rax, (%rsi)
leaq 0xefd8c(%rip), %rax     # 0x113be1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x23e70
movq %rax, 0x18(%rsi)
leaq 0x256(%rip), %rax       # 0x240c1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/awbm.c
// Function: de_module_awbm
void de_module_awbm(deark *c, struct deark_module_info *mi)
{
	mi->id = "awbm";
	mi->desc = "Award BIOS logo";
	mi->run_fn = de_run_awbm;
	mi->identify_fn = de_identify_awbm;
	mi->help_fn = de_help_awbm;
}

// Assembly:
leaq 0xefbd1(%rip), %rax     # 0x113cc0
movq %rax, (%rsi)
leaq 0xefbcc(%rip), %rax     # 0x113cc5
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x2411f
movq %rax, 0x18(%rsi)
leaq 0x330(%rip), %rax       # 0x2443f
movq %rax, 0x20(%rsi)
leaq 0x3b9(%rip), %rax       # 0x244d3
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/awbm.c
// Function: de_identify_awbm
static int de_identify_awbm(deark *c)
{
	u8 buf[4];
	i64 nblocks;
	int epa_ext;

	de_read(buf, 0, 4);
	if(!de_memcmp(buf, "AWBM", 4)) return 100;

	nblocks = (i64)buf[0] * (i64)buf[1];
	if(nblocks<1 || nblocks>256) return 0;
	if(c->infile->len == 2 + nblocks*15 + 70) {
		epa_ext = de_input_file_has_ext(c, "epa");
		if(epa_ext) return 100;
		return 20;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
movl $0x4, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
cmpl $0x4d425741, (%r15)     # imm = 0x4D425741
je 0x244c2
movzbl 0xc(%rsp), %ecx
movzbl 0xd(%rsp), %eax
imulq %rcx, %rax
leaq -0x101(%rax), %rcx
cmpq $-0x100, %rcx
jb 0x244c7
movq 0x18(%r14), %rcx
leaq (%rax,%rax,4), %rax
leaq (%rax,%rax,2), %rax
addq $0x48, %rax
cmpq %rax, 0x18(%rcx)
jne 0x244c7
leaq 0xef89e(%rip), %rsi     # 0x113d47
movq %r14, %rdi
callq 0xea491
testl %eax, %eax
movl $0x14, %eax
movl $0x64, %ebx
cmovel %eax, %ebx
jmp 0x244c7
movl $0x64, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/basic-c64.c
// Function: de_module_basic_c64
void de_module_basic_c64(deark *c, struct deark_module_info *mi)
{
	mi->id = "basic_c64";
	mi->desc = "Detokenize C64 BASIC";
	mi->run_fn = de_run_basic_c64;
	mi->identify_fn = de_identify_basic_c64;
}

// Assembly:
leaq 0xef614(%rip), %rax     # 0x113d9f
movq %rax, (%rsi)
leaq 0xef614(%rip), %rax     # 0x113da9
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x247b0
movq %rax, 0x18(%rsi)
leaq 0x1c1(%rip), %rax       # 0x2496c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/basic-c64.c
// Function: de_run_basic_c64
static void de_run_basic_c64(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 file_pos;
	i64 mem_start;
	i64 mem_pos;
	i64 next_line_ptr;
	i64 line_size;

	d = de_malloc(c, sizeof(lctx));

	d->outf = dbuf_create_output_file(c, "c64.bas", NULL, 0);

	// TODO: What if the first two bytes are not 0x01 0x08?
	mem_start = 0x0801;

	file_pos = 2;

	while(file_pos < c->infile->len) {
		mem_pos = file_pos - 2 + mem_start;

		next_line_ptr = de_getu16le(file_pos);
		if(next_line_ptr==0x0000) {
			break;
		}

		line_size = next_line_ptr - mem_pos - 2;
		if(line_size<1) {
			break;
		}
		process_line(c, d, file_pos+2, mem_pos+2, line_size);
		file_pos += 2 + line_size;
	}

	dbuf_close(d->outf);
	de_free(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0xe8b2b
movq %rax, %r13
leaq 0xef5ec(%rip), %rsi     # 0x113dbe
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, (%r13)
movq 0x18(%rbx), %rdi
cmpq $0x3, 0x18(%rdi)
jl 0x2494b
movl $0x2, %ebp
movq %r13, (%rsp)
movq %rbp, %r15
movq %rbp, %rsi
callq 0xeebc8
testq %rax, %rax
je 0x24947
movq %rax, %rbp
movq %rax, %r12
subq %r15, %r12
leaq -0x7ff(%r12), %rax
cmpq $0x3, %rax
jl 0x24947
addq $-0x801, %r12           # imm = 0xF7FF
leaq 0x2(%r15), %r13
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0xeebc8
movq %rax, %r14
leal 0x801(%r15), %r8d
movq %rbx, %rdi
leaq 0xef572(%rip), %rsi     # 0x113dc6
movl %r14d, %edx
movl %r13d, %ecx
movq (%rsp), %r13
movl %r12d, %r9d
xorl %eax, %eax
callq 0xe8617
movq (%r13), %rdi
leaq 0xef576(%rip), %rsi     # 0x113de9
movl %r14d, %edx
xorl %eax, %eax
callq 0xf08da
addq $-0x7ff, %rbp           # imm = 0xF801
cmpq $0x3, %r12
jb 0x24929
addq $0x4, %r15
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeead3
movl %eax, %r12d
testl %r14d, %r14d
je 0x248c4
cmpb $0x22, %r12b
je 0x248c4
movq (%r13), %rdi
movzbl %r12b, %esi
callq 0xf0bd6
movl $0x1, %r14d
jmp 0x2491d
testb %r12b, %r12b
js 0x248eb
je 0x24929
movq (%r13), %rdi
movzbl %r12b, %esi
callq 0xf0bd6
cmpb $0x22, %r12b
jne 0x2491d
xorl %eax, %eax
testl %r14d, %r14d
sete %al
movl %eax, %r14d
jmp 0x2491d
cmpb $-0x35, %r12b
ja 0x2490d
andb $0x7f, %r12b
movzbl %r12b, %eax
leaq 0xef5f8(%rip), %rcx     # 0x113ef8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq (%r13), %rdi
jmp 0x24918
movq (%r13), %rdi
leaq 0xef4d5(%rip), %rsi     # 0x113ded
callq 0xf10ed
incq %r15
cmpq %rbp, %r15
jl 0x24895
movq (%r13), %rdi
leaq 0xeb853(%rip), %rsi     # 0x110187
callq 0xf10ed
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rbp
jl 0x247fa
movq (%r13), %rax
movq %rax, %rdi
callq 0xf052b
movq %rbx, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arcfs.c
// Function: de_module_arcfs
void de_module_arcfs(deark *c, struct deark_module_info *mi)
{
	mi->id = "arcfs";
	mi->desc = "ArcFS (RISC OS archive)";
	mi->run_fn = de_run_arcfs;
	mi->identify_fn = de_identify_arcfs;
}

// Assembly:
leaq 0xef696(%rip), %rax     # 0x114051
movq %rax, (%rsi)
leaq 0xef692(%rip), %rax     # 0x114057
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x249e0
movq %rax, 0x18(%rsi)
leaq 0xa3c(%rip), %rax       # 0x25417
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arcfs.c
// Function: de_module_squash
void de_module_squash(deark *c, struct deark_module_info *mi)
{
	mi->id = "squash";
	mi->desc = "Squash (RISC OS compressed file)";
	mi->run_fn = de_run_squash;
	mi->identify_fn = de_identify_squash;
}

// Assembly:
leaq 0xeec2b(%rip), %rax     # 0x11406f
movq %rax, (%rsi)
leaq 0xeec28(%rip), %rax     # 0x114076
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x25469
movq %rax, 0x18(%rsi)
leaq 0x286(%rip), %rax       # 0x256ea
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arcfs.c
// Function: de_run_squash
static void de_run_squash(deark *c, de_module_params *mparams)
{
	sqctx *d = NULL;

	d = de_malloc(c, sizeof(sqctx));

	do_squash_header(c, d, 0);
	do_squash_main(c, d);

	de_free(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe8b2b
movq %rax, %r14
leaq 0x11425d(%rip), %rsi    # 0x1396ee
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
leaq 0x68(%rsp), %r15
movq $0x4, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, (%r14)
leaq 0xeec9e(%rip), %rsi     # 0x11416a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rsi
leaq 0x8(%r14), %r13
movq (%r15), %rcx
movq %rbx, %rdi
movq %r13, %rdx
callq 0xf9284
addq $0x8, (%r15)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xe8a1c
leaq 0x30(%rsp), %r15
leaq 0x18(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfa1dc
movq 0x18(%rbx), %rax
movq %rax, (%r15)
movq $0x14, 0x8(%r15)
movq 0x18(%rax), %rax
addq $-0x14, %rax
movq %rax, 0x10(%r15)
leaq 0x10cce3(%rip), %rsi    # 0x13222c
movl $0x14, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq %rbx, %rdi
callq 0xea504
movq %rax, %r15
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r12
movb $0x1, 0x10(%r15)
movl 0x14(%r14), %eax
movl %eax, 0xa0(%r15)
movq 0xc(%r14), %rax
movq %rax, 0xa4(%r15)
leaq 0x110220(%rip), %rsi    # 0x1357bd
movq %r12, %rdi
movl $0x5, %edx
callq 0xf65e3
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xf93ff
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xea53f
cmpb $0x0, 0x28(%r14)
je 0x255e7
leaq 0x28(%r14), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%r15)
movq %r14, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r13
movq %rax, %rdi
callq 0xf0855
leaq 0x18(%rsp), %rbp
movq %r13, (%rbp)
movb $0x0, 0x8(%rbp)
leaq 0x54(%rsp), %r8
movq $0x0, 0x8(%r8)
movl $0x0, 0x10(%r8)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%r8)
leaq 0x30(%rsp), %rsi
leaq 0x68(%rsp), %r14
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x102400
movq (%rbp), %rdi
callq 0xf08ba
cmpl $0x0, (%r14)
je 0x25684
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa1a4
leaq 0xef6ef(%rip), %rsi     # 0x114d5f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9295
movq 0x10(%rsp), %r14
jmp 0x256a6
movq 0x18(%r13), %rcx
movq 0x10(%rsp), %r14
movq (%r14), %rdx
cmpq %rdx, %rcx
je 0x256a6
leaq 0xeec14(%rip), %rsi     # 0x1142b0
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %r13, %rdi
callq 0xf052b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xea50e
movq %r12, %rdi
callq 0xf6753
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0xe8a25
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
addq $0xc8, %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/apm.c
// Function: de_module_apm
void de_module_apm(deark *c, struct deark_module_info *mi)
{
	mi->id = "apm";
	mi->desc = "Apple Partition Map";
	mi->run_fn = de_run_apm;
	mi->identify_fn = de_identify_apm;
}

// Assembly:
leaq 0xeebcf(%rip), %rax     # 0x1142e6
movq %rax, (%rsi)
leaq 0xeebc9(%rip), %rax     # 0x1142ea
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x2573c
movq %rax, 0x18(%rsi)
leaq 0x6a(%rip), %rax        # 0x257a1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/apm.c
// Function: de_run_apm
static void de_run_apm(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 i;
	int ret;

	d = de_malloc(c, sizeof(lctx));

	d->secsize = 512;

	// Read the first map entry (should set d->npartitions)
	ret = do_entry_at_sector(c, d, 1);
	if(!ret) goto done;

	// Read the rest of the entries
	for(i=1; i<d->npartitions; i++) {
		ret = do_entry_at_sector(c, d, 1+i);
		if(!ret) goto done;
	}

done:
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x10, %esi
callq 0xe8b2b
movq %rax, %r14
movq $0x200, (%rax)          # imm = 0x200
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x257ea
testl %eax, %eax
je 0x25791
movl $0x2, %r15d
leaq -0x1(%r15), %rax
cmpq 0x8(%r14), %rax
jge 0x25791
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x257ea
incq %r15
testl %eax, %eax
jne 0x25772
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/afcp.c
// Function: de_module_afcp
void de_module_afcp(deark *c, struct deark_module_info *mi)
{
	mi->id = "afcp";
	mi->desc = "AXS File Concatenation Protocol";
	mi->run_fn = de_run_afcp;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
leaq 0xee89a(%rip), %rax     # 0x114455
movq %rax, (%rsi)
leaq 0xee895(%rip), %rax     # 0x11445a
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x25bd9
movq %rax, 0x18(%rsi)
orb $0x1, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_module_arc
void de_module_arc(deark *c, struct deark_module_info *mi)
{
	mi->id = "arc";
	mi->desc = "ARC compressed archive";
	mi->run_fn = de_run_arc;
	mi->identify_fn = de_identify_arc;
	mi->help_fn = de_help_arc;
}

// Assembly:
leaq 0xf9427(%rip), %rax     # 0x11f562
movq %rax, (%rsi)
leaq 0xee4d7(%rip), %rax     # 0x11461c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x2616b
movq %rax, 0x18(%rsi)
leaq 0x125(%rip), %rax       # 0x26280
movq %rax, 0x20(%rsi)
leaq 0x426(%rip), %rax       # 0x2658c
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_run_arc
static void de_run_arc(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	const char *s;

	d = de_malloc(c, sizeof(lctx));
	d->fmt = FMT_ARC;
	d->fmtname = "ARC";
	// TODO: Make 'recurse' configurable. Would require us to make the embedded
	// archives end with the correct marker.
	d->recurse_subdirs = 1;
	d->input_encoding_for_filenames = de_get_input_encoding(c, NULL, DE_ENCODING_CP437);
	d->input_encoding_for_comments = DE_EXTENC_MAKE(d->input_encoding_for_filenames,
		DE_ENCSUBTYPE_HYBRID);

	// TODO: It would probably be worth it to have a separate module for PAK, so we
	// can take the .PAK file extension into account when guessing what method #10
	// is. It's complicated, though, and not very useful until we support Crushed
	// decompression.

	s = de_get_ext_option(c, "arc:method10");
	if(s) {
		if(!de_strcmp(s, "trimmed")) {
			d->method10 = 1;
		}
		else if(!de_strcmp(s, "crushed")) {
			d->method10 = 2;
		}
	}

	if(de_havemodcode(c, mparams, '6')) {
		do_convert_pak16sfx(c, d);
		goto done;
	}

	do_run_arc_spark_internal(c, d);

done:
	destroy_lctx(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x68, %esi
callq 0xe8b2b
movq %rax, %r14
movl $0x1, %eax
movl %eax, (%r14)
leaq 0xfe5d1(%rip), %rcx     # 0x124766
movq %rcx, 0x8(%r14)
movl %eax, 0x20(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movl $0xd, %edx
callq 0xeb220
movl %eax, 0x10(%r14)
movzbl %al, %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, 0x14(%r14)
leaq 0xee4a5(%rip), %rsi     # 0x114668
movq %rbx, %rdi
callq 0xe9b74
testq %rax, %rax
je 0x26203
movq %rax, %r12
leaq 0xee49b(%rip), %rsi     # 0x114675
movq %rax, %rdi
callq 0x181a0
testl %eax, %eax
je 0x261fd
leaq 0xee863(%rip), %rsi     # 0x114a50
movq %r12, %rdi
callq 0x181a0
testl %eax, %eax
jne 0x26203
movb $0x2, %al
jmp 0x261ff
movb $0x1, %al
movb %al, 0x1c(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x36, %edx
callq 0xea4d9
testl %eax, %eax
je 0x2625f
movl $0x4, (%r14)
movl $0x0, 0x20(%r14)
movb $0x1a, 0x24(%r14)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
leaq 0x1134(%rip), %r9       # 0x2736e
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2714c
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x2626a
movl $0xfe00, %esi           # imm = 0xFE00
callq 0xf0fad
jmp 0x2626a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26826
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x270b4
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_module_spark
void de_module_spark(deark *c, struct deark_module_info *mi)
{
	mi->id = "spark";
	mi->desc = "Spark archive";
	mi->run_fn = de_run_spark;
	mi->identify_fn = de_identify_spark;
	mi->help_fn = de_help_spark;
}

// Assembly:
leaq 0xee092(%rip), %rax     # 0x114633
movq %rax, (%rsi)
leaq 0xee08e(%rip), %rax     # 0x114639
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x265d1
movq %rax, 0x18(%rsi)
leaq 0x89(%rip), %rax        # 0x2664a
movq %rax, 0x20(%rsi)
leaq 0x140(%rip), %rax       # 0x2670c
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_run_spark
static void de_run_spark(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = de_malloc(c, sizeof(lctx));
	d->fmt = FMT_SPARK;
	d->fmtname = "Spark";
	d->input_encoding_for_filenames = de_get_input_encoding(c, NULL, DE_ENCODING_RISCOS);
	d->input_encoding_for_comments = DE_EXTENC_MAKE(d->input_encoding_for_filenames,
		DE_ENCSUBTYPE_HYBRID);
	d->recurse_subdirs = de_get_ext_option_bool(c, "spark:recurse", 1);

	do_run_arc_spark_internal(c, d);
	destroy_lctx(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x68, %esi
callq 0xe8b2b
movq %rax, %r14
movl $0x2, (%rax)
leaq 0xee6c5(%rip), %rax     # 0x114cb7
movq %rax, 0x8(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0xeb220
movl %eax, 0x10(%r14)
movzbl %al, %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, 0x14(%r14)
leaq 0xee6a1(%rip), %rsi     # 0x114cbd
movq %rbx, %rdi
movl $0x1, %edx
callq 0xe9bd0
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26826
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x270b4
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_identify_spark
static int de_identify_spark(deark *c)
{
	u8 b;
	u32 load_addr;
	int ldaddrcheck = 0;
	int has_trailer = 0;

	if(de_getbyte(0) != 0x1a) return 0;
	b = de_getbyte(1); // compression method
	if(b==0x82 || b==0x83 || b==0x88 || b==0x89 || b==0xff) {
		;
	}
	else if(b==0x81 || b==0x84 || b==0x85 || b==0x86) {
		; // TODO: Verify that these are possible in Spark.
	}
	else {
		return 0;
	}

	load_addr = (u32)de_getu32le(29);
	if((load_addr & 0xfff00000) == 0xfff00000) {
		ldaddrcheck = 1;
	}

	if(de_getu16be(c->infile->len-2) == 0x1a80) {
		has_trailer = 1;
	}

	if(has_trailer && ldaddrcheck) return 85;
	if(ldaddrcheck) return 30;
	if(has_trailer) return 10;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeead3
cmpb $0x1a, %al
jne 0x266f4
movq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0xeead3
movzbl %al, %eax
leal -0x81(%rax), %ecx
cmpl $0x8, %ecx
ja 0x26703
cmpl $0x6, %ecx
je 0x26703
movq 0x18(%rbx), %rdi
movl $0x1d, %esi
callq 0xeed61
movq %rax, %r15
andl $0xfff00000, %r15d      # imm = 0xFFF00000
movl $0xfff00000, %r12d      # imm = 0xFFF00000
xorq %r15, %r12
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rsi
addq $-0x2, %rsi
callq 0xeeb67
movq %rax, %rcx
xorq $0x1a80, %rcx           # imm = 0x1A80
movl $0x55, %r14d
orq %r12, %rcx
je 0x266f4
xorl %ecx, %ecx
cmpq $0x1a80, %rax           # imm = 0x1A80
movl $0xa, %eax
cmovnel %ecx, %eax
cmpl $0xfff00000, %r15d      # imm = 0xFFF00000
movl $0x1e, %r14d
cmovnel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0xff, %eax
je 0x2668c
jmp 0x266f4
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_module_arcmac
void de_module_arcmac(deark *c, struct deark_module_info *mi)
{
	mi->id = "arcmac";
	mi->desc = "ArcMac compressed archive";
	mi->run_fn = de_run_arcmac;
	mi->identify_fn = de_identify_arcmac;
}

// Assembly:
leaq 0xedf26(%rip), %rax     # 0x114647
movq %rax, (%rsi)
leaq 0xedf23(%rip), %rax     # 0x11464e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x26746
movq %rax, 0x18(%rsi)
leaq 0x70(%rip), %rax        # 0x267b1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_run_arcmac
static void de_run_arcmac(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = de_malloc(c, sizeof(lctx));
	d->fmt = FMT_ARCMAC;
	d->fmtname = "ArcMac";
	d->recurse_subdirs = 1;
	d->input_encoding_for_arcmac_fn = de_get_input_encoding(c, NULL, DE_ENCODING_MACROMAN);
	d->input_encoding_for_filenames = DE_ENCODING_CP437;
	d->input_encoding_for_comments = DE_EXTENC_MAKE(d->input_encoding_for_filenames,
		DE_ENCSUBTYPE_HYBRID);

	do_run_arc_spark_internal(c, d);
	destroy_lctx(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x68, %esi
callq 0xe8b2b
movq %rax, %r14
movl $0x3, (%rax)
leaq 0xee59a(%rip), %rax     # 0x114d01
movq %rax, 0x8(%r14)
movl $0x1, 0x20(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0xeb220
movl %eax, 0x18(%r14)
movabsq $0x30d0000000d, %rax    # imm = 0x30D0000000D
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26826
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x270b4
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: de_identify_arcmac
static int de_identify_arcmac(deark *c)
{
	u8 buf1[2];
	u8 buf2[2];

	de_read(buf1, 0, 2);
	if(buf1[0]!=0x1b) return 0;
	if(!(buf1[1]>=1 && buf1[1]<=9)) return 0;
	de_read(buf2, 59, 2);
	if(buf2[0]!=0x1a) return 0;
	if(buf2[1]!=buf1[1]) return 0;
	return 80;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
movl $0x2, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
cmpb $0x1b, (%r15)
jne 0x2681a
movb 0xd(%rsp), %al
decb %al
cmpb $0x8, %al
ja 0x2681a
movq 0x18(%r14), %rdi
leaq 0xe(%rsp), %r14
movl $0x3b, %edx
movl $0x2, %ecx
movq %r14, %rsi
callq 0xee8d4
cmpb $0x1a, (%r14)
jne 0x2681a
movb 0xf(%rsp), %al
xorl %ecx, %ecx
cmpb 0xd(%rsp), %al
movl $0x50, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: destroy_lctx
static void destroy_lctx(deark *c, lctx *d)
{
	if(!d) return;
	de_crcobj_destroy(d->crco);
	de_strarray_destroy(d->curpath);
	if(d->pak16sfx_outf) {
		dbuf_close(d->pak16sfx_outf);
	}
	if(d->persistent_md) {
		i64 i;

		for(i=0; i<d->num_top_level_members; i++) {
			ucstring_destroy(d->persistent_md[i].comment);
			ucstring_destroy(d->persistent_md[i].path);
		}
		de_free(c, d->persistent_md);
	}
	de_free(c, d);
}

// Assembly:
testq %rsi, %rsi
je 0x2714b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rdi
callq 0xeb858
movq 0x50(%rbx), %rdi
callq 0xf7228
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x270eb
callq 0xf052b
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x27135
cmpq $0x0, 0x38(%rbx)
jle 0x2712d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0xf6753
movq 0x58(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
callq 0xf6753
incq %r12
addq $0x10, %r15
cmpq 0x38(%rbx), %r12
jl 0x27101
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8be2
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: member_cb_for_pak16sfx
static void member_cb_for_pak16sfx(deark *c, lctx *d, struct member_parser_data *mpd)
{
	de_dbg2(c, "pak16sfx member at %"I64_FMT", type=0x%02x", mpd->member_pos,
		(UI)mpd->magic);
	de_dbg_indent(c, 1);

	// This is not perfect. We throw away the extended info, instead of converting
	// it to extended records.
	if(mpd->magic==0x1a) {
		if(!d->pak16sfx_outf) {
			d->pak16sfx_outf = dbuf_create_output_file(c, "pak", NULL, 0);
		}
		dbuf_copy(c->infile, mpd->member_pos, mpd->member_len, d->pak16sfx_outf);
	}
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rdx
movzbl 0x8(%r14), %ecx
leaq 0xed2f1(%rip), %rsi     # 0x11467d
xorl %eax, %eax
callq 0xe87e4
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
cmpb $0x1a, 0x8(%r14)
jne 0x273db
movq 0x60(%r15), %rcx
testq %rcx, %rcx
jne 0x273ca
leaq 0xed2ea(%rip), %rsi     # 0x1146a1
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %rcx
movq %rax, 0x60(%r15)
movq 0x18(%rbx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
callq 0xef481
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0xe8a15
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: do_sequence_of_members
static void do_sequence_of_members(deark *c, lctx *d, i64 pos1, i64 len, int nesting_level)
{
	if(nesting_level >= MAX_NESTING_LEVEL) {
		de_err(c, "Max subdir nesting level exceeded");
		return;
	}

	de_dbg(c, "archive at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	parse_member_sequence(c, d, pos1, len, nesting_level, member_cb_main);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x18, %r8d
jl 0x27417
leaq 0xed445(%rip), %rsi     # 0x11484a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe9295
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xed442(%rip), %rsi     # 0x11486c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
leaq 0xef(%rip), %r9         # 0x27537
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x2714c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe8a15
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: member_cb_for_prescan
static void member_cb_for_prescan(deark *c, lctx *d, struct member_parser_data *mpd)
{
	if(mpd->magic!=d->sig_byte) return;
	if(mpd->cmpr_meth_masked==0x00) { // end of archive
		d->prescan_found_eoa = 1;
		d->prescan_pos_after_eoa = mpd->member_pos + mpd->member_len;
		de_dbg2(c, "end of member sequence at %"I64_FMT, d->prescan_pos_after_eoa);
		return;
	}
	if(mpd->cmpr_meth==20 || mpd->cmpr_meth==21 || mpd->cmpr_meth==30) {
		// Features we're pretty sure aren't used by PAK.
		d->has_arc_extensions = 1;
	}
	d->num_top_level_members++;
	de_dbg2(c, "member at %"I64_FMT, mpd->member_pos);
}

// Assembly:
movb 0x8(%rdx), %al
cmpb 0x24(%rsi), %al
jne 0x274a7
cmpb $0x0, 0xa(%rdx)
je 0x274a8
movzbl 0x9(%rdx), %eax
cmpl $0x1e, %eax
ja 0x27496
movl $0x40300000, %ecx       # imm = 0x40300000
btl %eax, %ecx
jae 0x27496
movb $0x1, 0x28(%rsi)
incq 0x38(%rsi)
movq 0x10(%rdx), %rdx
leaq 0x1146b8(%rip), %rsi    # 0x13bb5d
jmp 0x274c2
retq
movb $0x1, 0x25(%rsi)
movq 0x18(%rdx), %rax
addq 0x10(%rdx), %rax
movq %rax, 0x30(%rsi)
leaq 0xed28f(%rip), %rsi     # 0x11474e
movq %rax, %rdx
xorl %eax, %eax
jmp 0xe87e4
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: is_pkcomment_sig_at
static int is_pkcomment_sig_at(deark *c, lctx *d, i64 pos)
{
	i64 comments_descr_pos;

	if(!d->prescan_found_eoa) return 0;
	if(pos < d->prescan_pos_after_eoa) return 0;
	if(pos > c->infile->len-8) return 0;
	if((UI)de_getu32be(pos) != 0x504baa55U) {
		return 0;
	}
	comments_descr_pos = de_getu32le(pos+4);
	if((comments_descr_pos < d->prescan_pos_after_eoa) ||
		(comments_descr_pos > pos-4))
	{
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpb $0x0, 0x25(%rsi)
je 0x2752a
movq %rdx, %rbx
movq %rsi, %r14
cmpq %rdx, 0x30(%rsi)
jg 0x2752a
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rax
addq $-0x8, %rax
cmpq %rbx, %rax
jl 0x2752a
movq %rbx, %rsi
callq 0xeed0d
cmpl $0x504baa55, %eax       # imm = 0x504BAA55
jne 0x2752a
movq 0x18(%r15), %rdi
leaq 0x4(%rbx), %rsi
callq 0xeed61
cmpq 0x30(%r14), %rax
setge %cl
addq $-0x4, %rbx
cmpq %rbx, %rax
setle %al
andb %cl, %al
movzbl %al, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: decompressor_squeezed
static void decompressor_squeezed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dcmpr_two_layer_params tlp;

	de_zeromem(&tlp, sizeof(struct de_dcmpr_two_layer_params));
	tlp.codec1_type1 = fmtutil_huff_squeeze_codectype1;
	tlp.codec2 = dfilter_rle90_codec;
	tlp.dcmpri = dcmpri;
	tlp.dcmpro = dcmpro;
	tlp.dres = dres;
	de_dfilter_decompress_two_layer(c, &tlp);
}

// Assembly:
subq $0x58, %rsp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rsi
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x28(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x48(%rsi)
leaq 0xd2eb9(%rip), %rax     # 0xfb314
movq %rax, (%rsi)
leaq 0xd2494(%rip), %rax     # 0xfa8f9
movq %rax, 0x18(%rsi)
movq %rcx, 0x28(%rsi)
movq %r8, 0x30(%rsi)
movq %r9, 0x38(%rsi)
callq 0xfb10b
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: decompressor_crunched6
static void decompressor_crunched6(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dcmpr_two_layer_params tlp;
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_ARC5;

	de_zeromem(&tlp, sizeof(struct de_dcmpr_two_layer_params));
	tlp.codec1_pushable = dfilter_lzw_codec;
	tlp.codec1_private_params = (void*)&delzwp;

	tlp.codec2 = dfilter_rle90_codec;

	tlp.dcmpri = dcmpri;
	tlp.dcmpro = dcmpro;
	tlp.dres = dres;

	de_dfilter_decompress_two_layer(c, &tlp);
}

// Assembly:
subq $0x78, %rsp
xorps %xmm0, %xmm0
leaq 0xc(%rsp), %rax
movups %xmm0, 0x4(%rax)
movl $0x7, (%rax)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
leaq 0xd9f3c(%rip), %rdx     # 0x10241b
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
leaq 0xd240b(%rip), %rax     # 0xfa8f9
movq %rax, 0x18(%rsi)
movq %rcx, 0x28(%rsi)
movq %r8, 0x30(%rsi)
movq %r9, 0x38(%rsi)
callq 0xfb10b
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: decompressor_squashed
static void decompressor_squashed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_UNIXCOMPRESS;
	delzwp.max_code_size = 13;
	fmtutil_decompress_lzw(c, dcmpri, dcmpro, dres, &delzwp);
}

// Assembly:
subq $0x18, %rsp
movq %r8, %rdx
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r8
movups %xmm0, 0x4(%r8)
movl $0x1, (%r8)
movl $0xd, 0xc(%r8)
movq %rcx, %rsi
movq %r9, %rcx
callq 0x102400
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arc.c
// Function: decompressor_trimmed
static void decompressor_trimmed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dcmpr_two_layer_params tlp;
	struct de_lh1_params lh1p;

	de_zeromem(&lh1p, sizeof(struct de_lh1_params));
	lh1p.is_arc_trimmed = 1;
	lh1p.history_fill_val = 0x00;

	de_zeromem(&tlp, sizeof(struct de_dcmpr_two_layer_params));
	tlp.codec1_pushable = dfilter_lh1_codec;
	tlp.codec1_private_params = (void*)&lh1p;

	tlp.codec2 = dfilter_rle90_codec;

	tlp.dcmpri = dcmpri;
	tlp.dcmpro = dcmpro;
	tlp.dres = dres;

	de_dfilter_decompress_two_layer(c, &tlp);
}

// Assembly:
subq $0x68, %rsp
leaq 0x8(%rsp), %rax
movl $0x0, (%rax)
movb $0x1, 0x2(%rax)
movb $0x0, 0x4(%rax)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
leaq 0xde1e1(%rip), %rdx     # 0x1067c5
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
leaq 0xd2306(%rip), %rax     # 0xfa8f9
movq %rax, 0x18(%rsi)
movq %rcx, 0x28(%rsi)
movq %r8, 0x30(%rsi)
movq %r9, 0x38(%rsi)
callq 0xfb10b
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/amiga-dsk.c
// Function: de_module_amiga_adf
void de_module_amiga_adf(deark *c, struct deark_module_info *mi)
{
	mi->id = "amiga_adf";
	mi->desc = "Amiga disk image";
	mi->run_fn = de_run_amiga_adf;
	mi->identify_fn = de_identify_amiga_adf;
}

// Assembly:
leaq 0xec4d1(%rip), %rax     # 0x114d10
movq %rax, (%rsi)
leaq 0xec4d1(%rip), %rax     # 0x114d1a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x28864
movq %rax, 0x18(%rsi)
leaq 0x292(%rip), %rax       # 0x28af1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/amiga-dsk.c
// Function: de_identify_amiga_adf
static int de_identify_amiga_adf(deark *c)
{
	int has_size;
	int has_ext;

	if(dbuf_memcmp(c->infile, 0, "DOS", 3)) return 0;
	if(de_getbyte(3)>0x05) return 0;
	has_ext = de_input_file_has_ext(c, "adf");
	has_size = (c->infile->len==901120 || c->infile->len==1802240);
	if(has_ext && has_size) return 100;
	if(has_size) return 90;
	if(has_ext) return 60;
	return 20;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x11af08(%rip), %rdx    # 0x143a0b
xorl %ebx, %ebx
movl $0x3, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x28b87
movq 0x18(%r14), %rdi
movl $0x3, %esi
callq 0xeead3
cmpb $0x5, %al
ja 0x28b87
leaq 0x122324(%rip), %rsi    # 0x14ae52
movq %r14, %rdi
callq 0xea491
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
cmpq $0xdc000, %rcx          # imm = 0xDC000
sete %dl
cmpq $0x1b8000, %rcx         # imm = 0x1B8000
sete %sil
testl %eax, %eax
je 0x28b61
orb %sil, %dl
movl $0x64, %ebx
jne 0x28b87
movl $0x5a, %ebx
cmpq $0xdc000, %rcx          # imm = 0xDC000
je 0x28b87
cmpq $0x1b8000, %rcx         # imm = 0x1B8000
je 0x28b87
testl %eax, %eax
movl $0x3c, %eax
movl $0x14, %ebx
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/amiga-dsk.c
// Function: test_root_block
static int test_root_block(deark *c, lctx *d, i64 blknum)
{
	i64 pos;

	pos = blocknum_to_offset(d, blknum);
	if(de_getu32be(pos) != ADF_T_HEADER) return 0;
	if(de_getu32be(pos+d->bsize-4) != ADF_ST_ROOT) return 0;
	d->root_block = blknum;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rsi), %r15
imulq %rdx, %r15
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xeed0d
xorl %ebp, %ebp
cmpq $0x2, %rax
jne 0x299eb
movq 0x18(%r12), %rdi
movq 0x8(%r14), %rax
leaq (%r15,%rax), %rsi
addq $-0x4, %rsi
callq 0xeed0d
cmpq $0x1, %rax
jne 0x299eb
movq %rbx, 0x10(%r14)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/amiga-dsk.c
// Function: claim_block
static int claim_block(deark *c, lctx *d, i64 blknum)
{
	if(blknum<0 || blknum>=d->num_blocks) {
		de_err(c, "Bad block number: %"I64_FMT, blknum);
		return 0;
	}
	if(!d->block_used_flags) {
		d->block_used_flags = de_malloc(c, d->num_blocks);
	}
	if(d->block_used_flags[blknum]) {
		de_err(c, "Attempt to reuse block #%"I64_FMT, blknum);
		return 0;
	}
	d->block_used_flags[blknum] = 1;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x29a38
movq %rsi, %r15
movq 0x18(%rsi), %rsi
cmpq %rbx, %rsi
jle 0x29a38
movq 0x28(%r15), %rax
testq %rax, %rax
jne 0x29a29
movq %r14, %rdi
callq 0xe8b2b
movq %rax, 0x28(%r15)
cmpb $0x0, (%rax,%rbx)
je 0x29a5b
leaq 0xeb419(%rip), %rsi     # 0x114e4f
jmp 0x29a3f
leaq 0xeb3fa(%rip), %rsi     # 0x114e39
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xe9295
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, (%rax,%rbx)
movl $0x1, %ebp
jmp 0x29a4e
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/amiga-dsk.c
// Function: read_protection_flags
static void read_protection_flags(deark *c, lctx *d, struct member_data *md, i64 pos)
{
	UI n;

	n = (UI)de_getu32be(pos);
	de_dbg(c, "protection flags: 0x%08x", n);
	if(md->fi && !md->is_dir) {
		// Some disks use the 0x2 bit to mean "non executable", but I don't think
		// there's a good way to tell *which* disks.
		if((n & 0x0000ff0f)!=0) { // If these flags seem to be used...
			if(n & 0x00000002) {
				md->fi->mode_flags |= DE_MODEFLAG_NONEXE;
			}
			else {
				md->fi->mode_flags |= DE_MODEFLAG_EXE;
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
callq 0xeed0d
movq %rax, %r14
leaq 0xeb47b(%rip), %rsi     # 0x114f02
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x29abc
testl $0xff0f, %r14d          # imm = 0xFF0F
je 0x29abc
cmpb $0x0, 0x10(%rbx)
jne 0x29abc
andl $0x2, %r14d
xorl %ecx, %ecx
cmpl $0x1, %r14d
adcl $0x1, %ecx
orl %ecx, 0x14(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/amiga-dsk.c
// Function: read_ofs_timestamp
static void read_ofs_timestamp(deark *c, i64 pos1, struct de_timestamp *ts,
	const char *name)
{
	i64 pos = pos1;
	i64 days, mins, ticks;
	i64 ut;
	char timestamp_buf[64];

	ts->is_valid = 0;
	days = de_getu32be_p(&pos);
	mins = de_getu32be_p(&pos);
	ticks = de_getu32be_p(&pos);
	ut = (6*365 + 2*366) * 86400; // 1970-01-01 to 1978-01-01
	ut += days * 86400;
	ut += mins * 60;
	ut += ticks / 50;

	if(days!=0) {
		de_unix_time_to_timestamp(ut, ts, 0);
		de_timestamp_set_subsec(ts, (double)(ticks%50) / 50.0);
		de_timestamp_to_string(ts, timestamp_buf, sizeof(timestamp_buf), 0);
	}
	else {
		de_strlcpy(timestamp_buf, "none", sizeof(timestamp_buf));
	}

	de_dbg(c, "%s: [%"I64_FMT",%"I64_FMT",%"I64_FMT"] (%s)",
		name, days, mins, ticks, timestamp_buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %rbp
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %rsi, (%r13)
movb $0x0, (%rdx)
movq 0x18(%rdi), %rdi
movq %r13, %rsi
callq 0xeed31
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %r13, %rsi
callq 0xeed31
movq %rax, %r12
movq 0x18(%r14), %rdi
movq %r13, %rsi
callq 0xeed31
movq %rax, %r13
testq %r15, %r15
je 0x29ba1
imulq $0x15180, %r15, %rcx    # imm = 0x15180
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0xA3D70A3D70A3D70B
movq %r13, %rax
imulq %rdx
movq %rbx, 0x10(%rsp)
movq %rdx, %rbx
imulq $0x3c, %r12, %rax
addq %rcx, %rax
addq %r13, %rbx
movq %rbx, %rcx
shrq $0x3f, %rcx
sarq $0x5, %rbx
addq %rcx, %rbx
leaq (%rax,%rbx), %rdi
addq $0xf0c3f00, %rdi        # imm = 0xF0C3F00
movq %rbp, %rsi
xorl %edx, %edx
callq 0xea7f5
imulq $0x32, %rbx, %rax
movq 0x10(%rsp), %rbx
movq %r13, %rcx
subq %rax, %rcx
cvtsi2sd %rcx, %xmm0
divsd 0xeb185(%rip), %xmm0    # 0x114d08
movq %rbp, %rdi
callq 0xea849
leaq 0x20(%rsp), %rsi
movl $0x40, %edx
movq %rbp, %rdi
xorl %ecx, %ecx
callq 0xeaf46
jmp 0x29bb7
leaq 0xe6b69(%rip), %rsi     # 0x110711
leaq 0x20(%rsp), %rdi
movl $0x40, %edx
callq 0xe8219
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0xeb354(%rip), %rsi     # 0x114f1b
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0xe8617
addq $0x68, %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/amiga-dsk.c
// Function: read_blocks_table
static void read_blocks_table(deark *c, lctx *d, i64 pos, struct block_ptrs_tbl *bpt)
{
	i64 k;

	for(k=0; k<bpt->blocks_tbl_capacity; k++) {
		bpt->blocks_tbl[k] = de_getu32be(pos + 4*k);
		if(c->debug_level>=2 && bpt->blocks_tbl[k]!=0) {
			de_dbg2(c, "blktbl[%d]: %u", (int)k, (UI)bpt->blocks_tbl[k]);
		}
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdx)
jle 0x29c5c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xeb43f(%rip), %r12     # 0x11504b
xorl %r13d, %r13d
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xeed0d
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
cmpl $0x2, (%r15)
setl %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x29c46
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe87e4
incq %r13
addq $0x4, %r14
cmpq 0x8(%rbx), %r13
jl 0x29c0f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq