LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-img.c
// Function: do_tinystuff_image
static void do_tinystuff_image(deark *c, tinyctx *d, struct atari_img_decode_data *adata)
{
	switch(adata->bpp) {
	case 1:
		do_tinystuff_1bpp(c, d, adata);
		break;
	case 2:
	case 4:
		do_tinystuff_2or4bpp(c, d, adata);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
subq $0x1, %rax
je 0x2b5df
jmp 0x2b5c7
movq -0x20(%rbp), %rax
subq $0x2, %rax
je 0x2b5f2
jmp 0x2b5d3
movq -0x20(%rbp), %rax
subq $0x4, %rax
je 0x2b5f2
jmp 0x2b603
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2b7b0
jmp 0x2b603
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2b810
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0x2b637
jmp 0x2b79b
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
shlq $0x3, %rax
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rcx
shlq %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq 0x68(%rdx), %rcx
movq -0x10(%rbp), %rdx
addq 0x90(%rdx), %rcx
movq -0x10(%rbp), %rdx
imulq 0x70(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %ecx
callq 0x1683f0
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
cmpq $0xc8, 0x80(%rax)
jl 0x2b79b
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jl 0x2b799
movq -0x10(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x68(%rcx), %rax
jl 0x2b797
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x4, 0x98(%rax)
jl 0x2b795
movq -0x10(%rbp), %rax
movl $0x1, 0x78(%rax)
jmp 0x2b79b
jmp 0x2b797
jmp 0x2b799
jmp 0x2b79b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-img.c
// Function: do_tinystuff_2or4bpp
static void do_tinystuff_2or4bpp(deark *c, tinyctx *d, struct atari_img_decode_data *adata)
{
	i64 x, y;
	i64 pos = 0;
	i64 width;
	UI bpp;

	bpp = (UI)adata->bpp;
	if(bpp!=2 && bpp!=4) return;

	if(bpp==2) width = 640;
	else width = 320;

	for(y=0; y<200; y++) {
		for(x=0; x<width; x+=16) {
			UI n[4];
			UI b_idx;
			UI k;

			// 2bpp: Every 2 words (4 bytes; 32 bits) makes 16 pixels
			// 4bpp: Every 4 words (8 bytes; 64 bits) makes 16 pixels
			for(b_idx=0; b_idx<bpp; b_idx++) {
				n[b_idx] = (UI)dbuf_getu16be_p(adata->unc_pixels, &pos);
			}

			for(k=0; k<16; k++) {
				UI v = 0;

				for(b_idx=0; b_idx<bpp; b_idx++) {
					if(n[b_idx]&(1U<<(15-k))) v += (1U<<b_idx);
				}
				de_bitmap_setpixel_rgb(adata->img, x+(i64)k, y, adata->pal[v]);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x3c(%rbp)
cmpl $0x2, -0x3c(%rbp)
je 0x2b847
cmpl $0x4, -0x3c(%rbp)
je 0x2b847
jmp 0x2b97f
cmpl $0x2, -0x3c(%rbp)
jne 0x2b857
movq $0x280, -0x38(%rbp)     # imm = 0x280
jmp 0x2b85f
movq $0x140, -0x38(%rbp)     # imm = 0x140
movq $0x0, -0x28(%rbp)
cmpq $0xc8, -0x28(%rbp)
jge 0x2b97f
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x2b96c
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x2b8bf
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165210
movl %eax, %ecx
movl -0x54(%rbp), %eax
movl %ecx, -0x50(%rbp,%rax,4)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2b892
movl $0x0, -0x58(%rbp)
cmpl $0x10, -0x58(%rbp)
jae 0x2b959
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x2b922
movl -0x54(%rbp), %eax
movl -0x50(%rbp,%rax,4), %eax
movl $0xf, %ecx
subl -0x58(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2b915
movl -0x54(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x5c(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x2b917
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2b8de
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x58(%rbp), %eax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x5c(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
callq 0x16b310
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x2b8c6
jmp 0x2b95b
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x2b87d
jmp 0x2b96e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2b867
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-img.c
// Function: do_atari_falcon_8bit_img
static void do_atari_falcon_8bit_img(deark *c, i64 width, i64 height)
{
	struct atari_img_decode_data *adata = NULL;
	i64 k;
	u8 cr, cg, cb;
	u32 pal[256];

	adata = de_malloc(c, sizeof(struct atari_img_decode_data));
	de_zeromem(pal, sizeof(pal));
	adata->pal = pal;
	adata->bpp = 8;
	adata->ncolors = 256;
	adata->w = width;
	adata->h = height;
	de_dbg_dimensions(c, adata->w, adata->h);

	for(k=0; k<256; k++) {
		cr = de_getbyte(k*4+0);
		cg = de_getbyte(k*4+1);
		cb = de_getbyte(k*4+3);
		pal[k] = DE_MAKE_RGB(cr, cg, cb);
		de_dbg_pal_entry(c, k, pal[k]);
	}

	decode_falcon_8bit_image(c, adata, 1024);

	de_free(c, adata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
leaq -0x430(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x19140
leaq -0x430(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x8, (%rax)
movq -0x20(%rbp), %rax
movq $0x100, 0x8(%rax)       # imm = 0x100
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x15bba0
movq $0x0, -0x28(%rbp)
cmpq $0x100, -0x28(%rbp)     # imm = 0x100
jge 0x2bae5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x2, %rsi
addq $0x0, %rsi
callq 0x165060
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x2, %rsi
addq $0x1, %rsi
callq 0x165060
movb %al, -0x2a(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x2, %rsi
addq $0x3, %rsi
callq 0x165060
movb %al, -0x2b(%rbp)
movzbl -0x29(%rbp), %ecx
shll $0x10, %ecx
orl $0xff000000, %ecx       # imm = 0xFF000000
movzbl -0x2a(%rbp), %eax
shll $0x8, %eax
orl %eax, %ecx
movzbl -0x2b(%rbp), %eax
orl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x430(%rbp,%rax,4)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rax
movl -0x430(%rbp,%rax,4), %edx
callq 0x15bf00
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2ba33
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2bb10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x173dc3(%rip), %rcx    # 0x19fb0a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x173dc1(%rip), %rcx    # 0x19fb16
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x2bd80
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x40d(%rip), %rcx       # 0x2c180
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x173a0e(%rip), %rcx    # 0x19fbf5
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x173a05(%rip), %rcx    # 0x19fbfa
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x2c230
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x9d(%rip), %rcx        # 0x2c2b0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x15e(%rip), %rcx       # 0x2c380
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/awbm.c
// Function: de_run_awbm
static void de_run_awbm(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	if(!dbuf_memcmp(c->infile, 0, "AWBM", 4)) {
		do_v2(c, d);
	}
	else {
		do_v1(c, d);
	}

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x418, %esi            # imm = 0x418
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x17399d(%rip), %rdx    # 0x19fc0a
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x2c28b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c3c0
jmp 0x2c298
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c6a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x4, %ecx
callq 0x164d10
leaq -0x14(%rbp), %rax
movl (%rax), %eax
subl $0x4d425741, %eax       # imm = 0x4D425741
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2c2f5
movl $0x64, -0x4(%rbp)
jmp 0x2c36f
movzbl -0x14(%rbp), %eax
movzbl -0x13(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jl 0x2c316
cmpq $0x100, -0x20(%rbp)     # imm = 0x100
jle 0x2c31f
movl $0x0, -0x4(%rbp)
jmp 0x2c36f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
imulq $0xf, -0x20(%rbp), %rcx
addq $0x2, %rcx
addq $0x46, %rcx
cmpq %rcx, %rax
jne 0x2c368
movq -0x10(%rbp), %rdi
leaq 0x173934(%rip), %rsi    # 0x19fc7c
callq 0x15d180
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2c35f
movl $0x64, -0x4(%rbp)
jmp 0x2c36f
movl $0x14, -0x4(%rbp)
jmp 0x2c36f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/awbm.c
// Function: do_v1
static void do_v1(deark *c, lctx *d)
{
	i64 w_blocks, h_blocks;
	i64 after_bitmap;

	de_declare_fmt(c, "Award BIOS logo v1");

	w_blocks = (i64)de_getbyte(0);
	h_blocks = (i64)de_getbyte(1);

	if(!do_v1_image(c, d, 2, w_blocks, h_blocks, 0, 0)) goto done;

	after_bitmap = 2 + w_blocks*h_blocks + h_blocks*EPA_CH*w_blocks;
	if(c->infile->len >= after_bitmap+70) {
		// The file usually contains a second image: a small Award logo.
		do_v1_image(c, d, after_bitmap, 3, 2, 1, DE_CREATEFLAG_IS_AUX);
	}
done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1735ae(%rip), %rsi    # 0x19fc69
callq 0x15e380
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x2, %edx
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0x2c810
cmpl $0x0, %eax
jne 0x2c71c
jmp 0x2c77e
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
addq $0x2, %rax
imulq $0xe, -0x20(%rbp), %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
addq $0x46, %rcx
cmpq %rcx, %rax
jl 0x2c77c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0x1, %r9d
movl $0x1, (%rsp)
callq 0x2c810
jmp 0x2c77e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1731bd(%rip), %rcx    # 0x19fcd4
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1731b9(%rip), %rcx    # 0x19fcde
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x2cb50
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x11d(%rip), %rcx       # 0x2cc60
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x17316e(%rip), %rsi    # 0x19fcf3
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq $0x801, -0x28(%rbp)     # imm = 0x801
movq $0x2, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jge 0x2cc39
movq -0x20(%rbp), %rax
subq $0x2, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165280
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2cbea
jmp 0x2cc39
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x40(%rbp)
jge 0x2cc03
jmp 0x2cc39
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x2, %rdx
movq -0x30(%rbp), %rcx
addq $0x2, %rcx
movq -0x40(%rbp), %r8
callq 0x2ccd0
movq -0x40(%rbp), %rax
addq $0x2, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2cbaa
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/basic-c64.c
// Function: de_identify_basic_c64
static int de_identify_basic_c64(deark *c)
{
	u8 buf[8];

	if(de_input_file_has_ext(c, "prg")) {
		de_read(buf, 0, 2);
		if(!de_memcmp(buf, "\x01\x08", 2)) return 20;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19a6a8(%rip), %rsi    # 0x1c731f
callq 0x15d180
cmpl $0x0, %eax
je 0x2ccbc
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %ecx
callq 0x164d10
leaq -0x18(%rbp), %rax
movw (%rax), %ax
subw $0x801, %ax             # imm = 0x801
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2ccba
movl $0x14, -0x4(%rbp)
jmp 0x2ccc3
jmp 0x2ccbc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x172f56(%rip), %rcx    # 0x19fe2d
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x172f4e(%rip), %rcx    # 0x19fe33
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x2cf10
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xdd(%rip), %rcx        # 0x2cfe0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: de_run_arcfs
static void de_run_arcfs(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;

	d = de_malloc(c, sizeof(lctx));
	pos = 0;
	if(!do_arcfs_file_header(c, d, pos)) goto done;
	pos += 96;

	d->curpath = de_strarray_create(c, MAX_NESTING_LEVEL+10);
	d->crco = de_crcobj_create(c, DE_CRCOBJ_CRC16_ARC);
	do_arcfs_members(c, d, pos);

done:
	if(d) {
		de_crcobj_destroy(d->crco);
		de_strarray_destroy(d->curpath);
		de_free(c, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2d130
cmpl $0x0, %eax
jne 0x2cf5a
jmp 0x2cfa9
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x1727a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0x21, %esi
callq 0x15eac0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2d300
cmpq $0x0, -0x18(%rbp)
je 0x2cfd7
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x15f2e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1727f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x172e04(%rip), %rcx    # 0x19fe4b
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x172dfd(%rip), %rcx    # 0x19fe52
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x2d080
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x6d(%rip), %rcx        # 0x2d0e0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2e010
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2e0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: do_arcfs_members
static void do_arcfs_members(deark *c, lctx *d, i64 pos1)
{
	i64 k;
	i64 pos = pos1;

	for(k=0; k<d->nmembers; k++) {
		int ret;

		if(pos>=c->infile->len) break;
		de_dbg(c, "member[%d]", (int)k);
		de_dbg_indent(c, 1);
		ret = do_arcfs_member(c, d, k, pos);
		de_dbg_indent(c, -1);
		if(!ret) break;
		pos += 36;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x2d3bb
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x2d34a
jmp 0x2d3bb
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x172bab(%rip), %rsi    # 0x19ff06
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2d3d0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
cmpl $0x0, -0x2c(%rbp)
jne 0x2d39e
jmp 0x2d3bb
movq -0x28(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2d324
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: get_info_byte_name
static const char *get_info_byte_name(u8 t)
{
	const char *name = NULL;
	switch(t) {
	case 0x00: name="end of dir marker"; break;
	case 0x01: name="deleted object"; break;
	case 0x82: name="stored"; break;
	case 0x83: name="packed (RLE)"; break;
	case 0x88: name="crunched"; break;
	case 0x89: name="squashed"; break;
	case 0xff: name="compressed"; break;
	}
	return name?name:"?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq $0x0, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x2d835
jmp 0x2d7ef
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x2d842
jmp 0x2d7f9
movl -0x14(%rbp), %eax
subl $0x82, %eax
je 0x2d84f
jmp 0x2d805
movl -0x14(%rbp), %eax
subl $0x83, %eax
je 0x2d85c
jmp 0x2d811
movl -0x14(%rbp), %eax
subl $0x88, %eax
je 0x2d869
jmp 0x2d81d
movl -0x14(%rbp), %eax
subl $0x89, %eax
je 0x2d876
jmp 0x2d829
movl -0x14(%rbp), %eax
subl $0xff, %eax
je 0x2d883
jmp 0x2d88e
leaq 0x172776(%rip), %rax    # 0x19ffb2
movq %rax, -0x10(%rbp)
jmp 0x2d88e
leaq 0x17277b(%rip), %rax    # 0x19ffc4
movq %rax, -0x10(%rbp)
jmp 0x2d88e
leaq 0x17277d(%rip), %rax    # 0x19ffd3
movq %rax, -0x10(%rbp)
jmp 0x2d88e
leaq 0x172777(%rip), %rax    # 0x19ffda
movq %rax, -0x10(%rbp)
jmp 0x2d88e
leaq 0x172777(%rip), %rax    # 0x19ffe7
movq %rax, -0x10(%rbp)
jmp 0x2d88e
leaq 0x172773(%rip), %rax    # 0x19fff0
movq %rax, -0x10(%rbp)
jmp 0x2d88e
leaq 0x180ca4(%rip), %rax    # 0x1ae52e
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d89f
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d8ac
leaq 0x18a387(%rip), %rax    # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0x2d8ac
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: do_arcfs_extract_member
static void do_arcfs_extract_member(deark *c, lctx *d, struct arcfs_member_data *md)
{
	de_finfo *fi = NULL;

	fi = de_finfo_create(c);
	fi->original_filename_flag = 1;
	if(md->rfa.mod_time.is_valid) {
		fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = md->rfa.mod_time;
	}

	fi->has_riscos_data = 1;
	fi->riscos_attribs = md->rfa.attribs;
	fi->load_addr = md->rfa.load_addr;
	fi->exec_addr = md->rfa.exec_addr;

	if(md->is_regular_file) {
		do_arcfs_extract_member_file(c, d, md, fi);
	}
	else if(md->is_dir) {
		do_arcfs_extract_member_dir(c, d, md, fi);
	}

	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x20(%rax)
je 0x2d913
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa0(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa4(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x2d96f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2d9f0
jmp 0x2d990
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x2d98e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2de30
jmp 0x2d990
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15d260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: do_arcfs_extract_member_dir
static void do_arcfs_extract_member_dir(deark *c, lctx *d, struct arcfs_member_data *md,
	de_finfo *fi)
{
	dbuf *outf = NULL;
	de_ucstring *fullfn = NULL;

	fullfn = ucstring_create(c);
	// Note that md->fn has already been added to d->curpath
	de_strarray_make_path(d->curpath, fullfn, DE_MPFLAG_NOTRAILINGSLASH);

	fi->is_directory = 1;
	de_finfo_set_name_from_ucstring(c, fi, fullfn, DE_SNFLAG_FULLPATH);

	outf = dbuf_create_output_file(c, NULL, fi, 0x0);
	dbuf_close(outf);
	ucstring_destroy(fullfn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x1729c0
movq -0x20(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x1, %ecx
callq 0x15d2c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1676a0
movq -0x30(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: do_arcfs_compressed
static void do_arcfs_compressed(deark *c, lctx *d, struct arcfs_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 = md->rfa.lzwmaxbits;
	if(!dcmpro->len_known) {
		delzwp.flags |= DE_LZWFLAG_TOLERATETRAILINGJUNK;
	}
	fmtutil_decompress_lzw(c, dcmpri, dcmpro, dres, &delzwp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x44(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x19140
movl $0x1, -0x44(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x8(%rax)
jne 0x2df24
movl -0x40(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x44(%rbp), %r8
callq 0x1843b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: do_arcfs_crunched
static void do_arcfs_crunched(deark *c, lctx *d, struct arcfs_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;

	// "Crunched" means "packed", then "compressed".
	// So we have to "uncompress" (LZW), then "unpack" (RLE90).

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_UNIXCOMPRESS;
	delzwp.max_code_size = md->rfa.lzwmaxbits;

	// This flag tells the LZW decompressor to stop, instead of reporting failure,
	// if bad LZW compressed data is encountered.
	// The problem is that some ArcFS files have garbage at the end of the
	// compressed data.
	// Apparently, we're expected to have a single decompression algorithm that
	// handles both layers of compression simultaneously, without any buffering
	// between them. That way, we could stop immediately when we've decompressed
	// a sufficient number of bytes, and never encounter the garbage. But we
	// don't have that.
	delzwp.flags |= DE_LZWFLAG_TOLERATETRAILINGJUNK;

	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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x94(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x19140
movl $0x1, -0x94(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x88(%rbp)
movl -0x90(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x19140
leaq 0x15643d(%rip), %rax    # 0x184400
movq %rax, -0x78(%rbp)
leaq -0x94(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x14a007(%rip), %rax    # 0x177fe0
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x178cf0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/arcfs.c
// Function: do_squash_header
static void do_squash_header(deark *c, sqctx *d, i64 pos1)
{
	i64 pos = pos1;

	de_dbg(c, "header at %d", (int)pos1);

	de_dbg_indent(c, 1);
	pos += 4; // signature
	d->orig_len = de_getu32le_p(&pos);
	de_dbg(c, "orig file length: %"I64_FMT, d->orig_len);

	fmtutil_riscos_read_load_exec(c, c->infile, &d->rfa, pos);
	pos += 8;
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x196f51(%rip), %rsi    # 0x1c4f8e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165580
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x171ebb(%rip), %rsi    # 0x19ff46
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movq -0x20(%rbp), %rcx
callq 0x1755e0
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x171d34(%rip), %rcx    # 0x1a00cb
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x171d2a(%rip), %rcx    # 0x1a00cf
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x2e3d0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbd(%rip), %rcx        # 0x2e480
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x200, (%rax)          # imm = 0x200
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x2e500
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2e422
jmp 0x2e46a
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x2e468
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x2e500
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2e458
jmp 0x2e46a
jmp 0x2e45a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e42a
jmp 0x2e46a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/apm.c
// Function: de_identify_apm
static int de_identify_apm(deark *c)
{
	i64 i;

	for(i=0; i<2; i++) {
		if(dbuf_memcmp(c->infile, 512+i*512, "PM\x00\x00", 4))
			return 0;
	}
	return 75;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jge 0x2e4e1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
shlq $0x9, %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x171d7c(%rip), %rdx    # 0x1a0235
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x2e4d1
movl $0x0, -0x4(%rbp)
jmp 0x2e4e8
jmp 0x2e4d3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2e494
movl $0x4b, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/apm.c
// Function: destroy_partition_info
static void destroy_partition_info(deark *c, struct partition_info *pi)
{
	if(!pi) return;
	ucstring_destroy(pi->pname);
	de_destroy_stringreaderdata(c, pi->ptype);
	de_free(c, pi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ea89
jmp 0x2eab4
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x166830
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x171763(%rip), %rcx    # 0x1a023a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x17175a(%rip), %rcx    # 0x1a023f
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x2eb10
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/afcp.c
// Function: de_run_afcp
static void de_run_afcp(deark *c, de_module_params *mparams)
{
	struct afcpctx *d = NULL;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);
	d = de_malloc(c, sizeof(struct afcpctx));
	d->endpos = c->infile->len;
	de_dbg(c, "AFCP data, ending at %"I64_FMT, d->endpos);
	de_dbg_indent(c, 1);

	if(!do_afcp_eofrec(c, d)) goto done;
	if(!do_afcp_starttagrec(c, d)) goto done;
	do_afcp_recordlist(c, d);

done:
	de_free(c, d);
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x15b580
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x1716f1(%rip), %rsi    # 0x1a025f
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ebe0
cmpl $0x0, %eax
jne 0x2eb97
jmp 0x2ebb8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ed20
cmpl $0x0, %eax
jne 0x2ebab
jmp 0x2ebb8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ee70
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15b5a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/afcp.c
// Function: do_afcp_eofrec
static int do_afcp_eofrec(deark *c, struct afcpctx *d)
{
	i64 eofrecpos;
	int retval = 0;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);

	eofrecpos = d->endpos - 12;
	de_dbg(c, "EOF record at %"I64_FMT, eofrecpos);
	de_dbg_indent(c, 1);
	d->endian_code = de_getbyte(eofrecpos+3);
	if(d->endian_code=='*') d->is_le = 1;
	else if(d->endian_code=='!') d->is_le = 0;
	else {
		de_err(c, "Invalid AFCP format");
		goto done;
	}
	de_dbg(c, "is-little-endian: %d", d->is_le);

	d->start_tag_offs = dbuf_getu32x(c->infile, eofrecpos+4, d->is_le);
	de_dbg(c, "start tag offset: %"I64_FMT, d->start_tag_offs);

	retval = 1;
done:
	de_dbg_indent_restore(c, saved_indent_level);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x15b580
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x171655(%rip), %rsi    # 0x1a0278
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x3, %rsi
callq 0x165060
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x2a, %eax
jne 0x2ec6f
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x2ec9e
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x21, %eax
jne 0x2ec88
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2ec9c
movq -0x8(%rbp), %rdi
leaq 0x1715f7(%rip), %rsi    # 0x1a028a
movb $0x0, %al
callq 0x15bfb0
jmp 0x2ecfd
jmp 0x2ec9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x1715ef(%rip), %rsi    # 0x1a029e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x1658c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1715c4(%rip), %rsi    # 0x1a02b3
movb $0x0, %al
callq 0x15b0d0
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x15b5a0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/afcp.c
// Function: do_afcp_starttagrec
static int do_afcp_starttagrec(deark *c, struct afcpctx *d)
{
	int retval = 0;
	int saved_indent_level;
	unsigned int version;

	de_dbg_indent_save(c, &saved_indent_level);
	de_dbg(c, "start tag record at %"I64_FMT, d->start_tag_offs);
	de_dbg_indent(c, 1);
	if(de_getbyte(d->start_tag_offs+3)!=d->endian_code) {
		de_err(c, "AFCP start tag not found at %"I64_FMT, d->start_tag_offs);
		goto done;
	}
	version = (unsigned int)dbuf_getu16x(c->infile, d->start_tag_offs+4, d->is_le);
	de_dbg(c, "version: %u", version);
	d->record_count = dbuf_getu16x(c->infile, d->start_tag_offs+6, d->is_le);
	de_dbg(c, "record count: %d", (int)d->record_count);

	if(version>1) {
		de_warn(c, "Unexpected AFCP version number: %u", version);
	}

	retval = 1;
done:
	de_dbg_indent_restore(c, saved_indent_level);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15b580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x171572(%rip), %rsi    # 0x1a02c9
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x3, %rsi
callq 0x165060
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
je 0x2edb3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x17153a(%rip), %rsi    # 0x1a02e1
movb $0x0, %al
callq 0x15bfb0
jmp 0x2ee52
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x165820
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x1938a3(%rip), %rsi    # 0x1c2686
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x6, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x165820
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, %edx
leaq 0x16fcbb(%rip), %rsi    # 0x19eae4
movb $0x0, %al
callq 0x15b0d0
cmpl $0x1, -0x1c(%rbp)
jbe 0x2ee4b
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x1714bd(%rip), %rsi    # 0x1a0301
movb $0x0, %al
callq 0x15bc10
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x15b5a0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/afcp.c
// Function: do_afcp_recordlist
static void do_afcp_recordlist(deark *c, struct afcpctx *d)
{
	int saved_indent_level;
	i64 pos;
	i64 i;

	de_dbg_indent_save(c, &saved_indent_level);
	pos = d->start_tag_offs + 12;
	de_dbg(c, "record list at %"I64_FMT, pos);

	de_dbg_indent(c, 1);
	for(i=0; i<d->record_count; i++) {
		if(i+12 > d->endpos) goto done;
		de_dbg(c, "record[%d] at %"I64_FMT, (int)i, pos);
		de_dbg_indent(c, 1);
		do_afcp_record(c, d, pos);
		de_dbg_indent(c, -1);
		pos += 12;
	}

done:
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15b580
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x171478(%rip), %rsi    # 0x1a0324
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x2ef51
movq -0x28(%rbp), %rax
addq $0xc, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x2eeeb
jmp 0x2ef53
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rcx
leaq 0x16fc01(%rip), %rsi    # 0x19eb01
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2ef70
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x20(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2eec9
jmp 0x2ef53
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15b5a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x17bd84(%rip), %rcx    # 0x1ab10b
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x171053(%rip), %rcx    # 0x1a03e8
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x2f3d0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x14d(%rip), %rcx       # 0x2f500
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x43e(%rip), %rcx       # 0x2f800
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)