LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/hlp.c
// Function: phrdecompress
static void phrdecompress(deark *c, lctx *d, i64 pos1, i64 len, UI BitCount)
{
	UI n;
	UI i;
	struct de_bitreader bitrd;

	de_zeromem(&bitrd, sizeof(struct de_bitreader));
	bitrd.f = c->infile;
	bitrd.curpos = pos1;
	bitrd.endpos = pos1 + len;
	bitrd.bbll.is_lsb = 1;

	d->phrase_info[0].pos = 0;

	for(i=0; i<d->num_phrases; i++) {
		UI num1bits = 0;

		while(de_bitreader_getbits(&bitrd, 1)) {
			if(bitrd.eof_flag) goto done;
			num1bits++;
		}
		n = num1bits<<BitCount;
		n += (UI)de_bitreader_getbits(&bitrd, BitCount) + 1;
		if(bitrd.eof_flag) goto done;

		d->phrase_info[i].len = n;
		if(i+1<d->num_phrases) {
			d->phrase_info[i+1].pos = d->phrase_info[i].pos+n;
		}
	}

done:
	if(c->debug_level>=2) {
		dump_phrase_offset_table(c, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movl $0x0, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xf8(%rcx), %eax
jae 0x7edc5
movl $0x0, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x16a390
cmpq $0x0, %rax
je 0x7ed3c
cmpb $0x0, -0x48(%rbp)
je 0x7ed31
jmp 0x7edc7
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x7ed12
movl -0x64(%rbp), %eax
movl -0x24(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %esi
leaq -0x60(%rbp), %rdi
callq 0x16a390
addl $0x1, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpb $0x0, -0x48(%rbp)
je 0x7ed64
jmp 0x7edc7
movl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0xf8(%rcx), %eax
jae 0x7edb5
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,8), %edx
addl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,8)
jmp 0x7edb7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7ecf8
jmp 0x7edc7
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jl 0x7eddd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7eb50
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/hlp.c
// Function: do_display_and_store_STRINGZ
static void do_display_and_store_STRINGZ(deark *c, lctx *d, i64 pos1, i64 len,
	const char *name, de_ucstring *s1)
{
	de_ucstring *s_tmp = NULL;
	de_ucstring *s;

	if(s1) {
		s = s1;
	}
	else {
		s_tmp = ucstring_create(c);
		s = s_tmp;
	}

	ucstring_empty(s);
	if(len<1) return;

	dbuf_read_to_ucstring_n(c->infile,
		pos1, len, DE_DBG_MAX_STRLEN,
		s, DE_CONVFLAG_STOP_AT_NUL, d->input_encoding);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));

	if(s_tmp) ucstring_destroy(s_tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7f0b9
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x7f0ce
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x171210
cmpq $0x1, -0x20(%rbp)
jge 0x7f0e0
jmp 0x7f14f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %r8
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl $0x1f4, %ecx            # imm = 0x1F4
movl $0x1, %r9d
movl %eax, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x172500
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
leaq 0x138ace(%rip), %rsi    # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
cmpq $0x0, -0x38(%rbp)
je 0x7f14f
movq -0x38(%rbp), %rdi
callq 0x171750
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/hlp.c
// Function: do_file_SYSTEM_SYSTEMRECS
static void do_file_SYSTEM_SYSTEMRECS(deark *c, lctx *d, i64 pos1, i64 len,
	int systemrecs_pass)
{
	i64 pos = pos1;

	while((pos1+len)-pos >=4) {
		UI recordtype;
		i64 datasize;
		i64 systemrec_startpos;
		const struct systemrec_info *sti;

		systemrec_startpos = pos;

		recordtype = (UI)de_getu16le_p(&pos);
		datasize = de_getu16le_p(&pos);

		sti = find_sysrec_info(c, d, recordtype);
		de_dbg(c, "SYSTEMREC type %u (%s) at %"I64_FMT", dpos=%"I64_FMT", dlen=%"I64_FMT"",
			recordtype, sti->name,
			systemrec_startpos, pos, datasize);

		if(pos+datasize > pos1+len) break; // bad data
		de_dbg_indent(c, 1);
		do_SYSTEMREC(c, d, recordtype, pos, datasize, sti);
		de_dbg_indent(c, -1);
		pos += datasize;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
cmpq $0x4, %rax
jl 0x7f26c
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x7f2c0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %edx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x40(%rbp), %rax
leaq 0x12e47f(%rip), %rsi    # 0x1ad680
movq %rax, (%rsp)
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jle 0x7f223
jmp 0x7f26c
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x50(%rbp), %r9
callq 0x7f340
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7f184
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/hlp.c
// Function: find_sysrec_info
static const struct systemrec_info *find_sysrec_info(deark *c, lctx *d, UI t)
{
	size_t i;

	for(i=0; i<DE_ARRAYCOUNT(systemrec_info_arr); i++) {
		const struct systemrec_info *sti;
		sti = &systemrec_info_arr[i];
		if(sti->rectype==t &&
			(sti->flags&0x0f)==0)
		{
			return sti;
		}
	}
	return &systemrec_info_default;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x10, -0x28(%rbp)
jae 0x7f328
movq -0x28(%rbp), %rcx
leaq 0x198ac7(%rip), %rax    # 0x217db0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x7f318
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x7f318
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f333
jmp 0x7f31a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7f2d7
leaq 0x198b81(%rip), %rax    # 0x217eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/hlp.c
// Function: do_SYSTEMREC
static void do_SYSTEMREC(deark *c, lctx *d, UI recordtype,
	i64 pos1, i64 len, const struct systemrec_info *sti)
{
	if(recordtype==1) { // title
		if(!d->help_file_title) {
			d->help_file_title = ucstring_create(c);
		}
		do_SYSTEMREC_STRINGZ(c, d, recordtype, pos1, len, sti, d->help_file_title);
	}
	else if(recordtype==2) { // copyright
		if(!d->help_file_copyright) {
			d->help_file_copyright = ucstring_create(c);
		}
		do_SYSTEMREC_STRINGZ(c, d, recordtype, pos1, len, sti, d->help_file_copyright);
	}
	else if(recordtype==3 && len==4) { // contents
		do_SYSTEMREC_uint32_hex(c, d, recordtype, pos1, len);
	}
	else if(recordtype==5) { // Icon
		d->has_ico = 1;
		extract_system_icon(c, d, pos1, len);
	}
	else if(sti->flags&0x10) {
		do_SYSTEMREC_STRINGZ(c, d, recordtype, pos1, len, sti, NULL);
	}
	else {
		if(c->debug_level>=2) {
			de_dbg_hexdump(c, c->infile, pos1, len, 256, NULL, 0x1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x7f3ba
movq -0x10(%rbp), %rax
cmpq $0x0, 0x110(%rax)
jne 0x7f38a
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, (%rsp)
callq 0x7f4f0
jmp 0x7f4df
cmpl $0x2, -0x14(%rbp)
jne 0x7f415
movq -0x10(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jne 0x7f3e5
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
callq 0x7f4f0
jmp 0x7f4dd
cmpl $0x3, -0x14(%rbp)
jne 0x7f43f
cmpq $0x4, -0x28(%rbp)
jne 0x7f43f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x7f540
jmp 0x7f4db
cmpl $0x5, -0x14(%rbp)
jne 0x7f46a
movq -0x10(%rbp), %rax
movl $0x1, 0xac(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x7f5a0
jmp 0x7f4d9
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7f4a1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x7f4f0
jmp 0x7f4d7
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jl 0x7f4d5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, (%rsp)
callq 0x15b840
jmp 0x7f4d7
jmp 0x7f4d9
jmp 0x7f4db
jmp 0x7f4dd
jmp 0x7f4df
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/hlp.c
// Function: extract_system_icon
static void extract_system_icon(deark *c, lctx *d, i64 pos, i64 len)
{
	de_finfo *fi = NULL;

	fi = de_finfo_create(c);
	fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = d->gendate;
	dbuf_create_file_from_slice(c->infile, pos, len, "ico", fi, DE_CREATEFLAG_IS_AUX);
	de_finfo_destroy(c, fi);
}

// 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 -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x120(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x128(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq 0x12d6f8(%rip), %rcx    # 0x1accfe
movl $0x1, %r9d
callq 0x166be0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dsstore.c
// Function: de_module_dsstore
void de_module_dsstore(deark *c, struct deark_module_info *mi)
{
	mi->id = "dsstore";
	mi->desc = "Mac Finder .DS_Store format";
	mi->run_fn = de_run_dsstore;
	mi->identify_fn = de_identify_dsstore;
	mi->help_fn = de_help_dsstore;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x12e19e(%rip), %rcx    # 0x1ad7e5
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x12e198(%rip), %rcx    # 0x1ad7ed
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x7f690
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x14d(%rip), %rcx       # 0x7f7c0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x18e(%rip), %rcx       # 0x7f810
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dsstore.c
// Function: de_run_dsstore
static void de_run_dsstore(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;

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

	pos = 8;
	d->infoblk_offs = de_getu32be_p(&pos);
	de_dbg(c, "info block offset: (%d+)%"I64_FMT, HDRSIZE, d->infoblk_offs);
	d->infoblk_offs += HDRSIZE;
	d->infoblk_size = de_getu32be_p(&pos);
	de_dbg(c, "info block size: %"I64_FMT, d->infoblk_size);

	do_info_block(c, d);

	if(!d->found_dsdb) {
		de_err(c, "DSDB block not found. This file is probably corrupted, or "
			"an unsupported version.");
		goto done;
	}
	if(!do_dsdb(c, d)) goto done;

	do_one_node(c, d, d->root_node_block_id);

done:
	if(d) {
		de_free(c, d->block_addr_table);
		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, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1654b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x12e11a(%rip), %rsi    # 0x1ad809
movl $0x4, %edx
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1654b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x12e0ed(%rip), %rsi    # 0x1ad825
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7f840
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x7f76a
movq -0x8(%rbp), %rdi
leaq 0x12e0d9(%rip), %rsi    # 0x1ad83a
movb $0x0, %al
callq 0x15bfb0
jmp 0x7f792
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7fab0
cmpl $0x0, %eax
jne 0x7f77e
jmp 0x7f792
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x7fc10
cmpq $0x0, -0x18(%rbp)
je 0x7f7b7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x15b820
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/dsstore.c
// Function: do_dsdb
static int do_dsdb(deark *c, lctx *d)
{
	i64 dsdb_offs, dsdb_size;
	i64 pos;
	i64 n;
	int retval = 0;

	if(!d->found_dsdb) goto done;
	if(!block_id_to_offset_and_size(c, d, d->dsdb_block_id, &dsdb_offs,
		&dsdb_size))
	{
		goto done;
	}

	de_dbg(c, "DSDB block: id=%u, offs=%d, len=%d", (unsigned int)d->dsdb_block_id,
		(int)dsdb_offs, (int)dsdb_size);

	de_dbg_indent(c, 1);
	pos = dsdb_offs;
	d->root_node_block_id = (u32)de_getu32be_p(&pos);
	de_dbg(c, "root node block id: %u", (unsigned int)d->root_node_block_id);

	n = de_getu32be_p(&pos);
	de_dbg(c, "num levels: %d", (int)n);
	n = de_getu32be_p(&pos);
	de_dbg(c, "num records in tree: %d", (int)n);
	n = de_getu32be_p(&pos);
	de_dbg(c, "num blocks in tree: %d", (int)n);
	de_dbg_indent(c, -1);

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x7fad6
jmp 0x7fc07
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x7ff50
cmpl $0x0, %eax
jne 0x7fafc
jmp 0x7fc07
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %eax, %r8d
leaq 0x12dde7(%rip), %rsi    # 0x1ad902
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1654b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x12ddc1(%rip), %rsi    # 0x1ad925
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1654b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
leaq 0x12ddab(%rip), %rsi    # 0x1ad93c
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1654b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
leaq 0x12dd8d(%rip), %rsi    # 0x1ad94b
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1654b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
leaq 0x12dd78(%rip), %rsi    # 0x1ad963
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dsstore.c
// Function: do_dir_entry
static void do_dir_entry(deark *c, lctx *d, i64 pos1, i64 *bytes_consumed)
{
	u32 blk_id;
	i64 pos = pos1;
	i64 nlen;
	struct de_stringreaderdata *name_srd = NULL;

	nlen = (i64)de_getbyte_p(&pos);
	*bytes_consumed = 1 + nlen + 4;
	name_srd = dbuf_read_string(c->infile, pos, nlen, nlen, 0, DE_ENCODING_MACROMAN);
	pos += nlen;
	de_dbg(c, "name: \"%s\"", ucstring_getpsz(name_srd->str));
	blk_id = (u32)de_getu32be_p(&pos);
	de_dbg(c, "block id: %u", (unsigned int)blk_id);

	if(!de_strcmp(name_srd->sz, "DSDB")) {
		d->found_dsdb = 1;
		d->dsdb_block_id = blk_id;
	}

	de_destroy_stringreaderdata(c, name_srd);
}

// 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 -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
addq $0x1, %rcx
addq $0x4, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %r8d, %r8d
movl $0x11, %r9d
callq 0x1664c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x172500
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x12e2f8(%rip), %rsi    # 0x1ae1d0
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1654b0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x12da2e(%rip), %rsi    # 0x1ad92f
movb $0x0, %al
callq 0x15b0d0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x12d9e6(%rip), %rsi    # 0x1ad8fd
callq 0x191a0
cmpl $0x0, %eax
jne 0x7ff36
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x166830
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dsstore.c
// Function: block_id_to_offset_and_size
static int block_id_to_offset_and_size(deark *c, lctx *d, u32 blk_id,
	i64 *poffs, i64 *psize)
{
	int retval = 0;
	u32 addr_code;
	unsigned int size_indicator;

	if((i64)blk_id>=d->blkcount) {
		goto done;
	}

	addr_code = d->block_addr_table[blk_id].addr_code;
	size_indicator = addr_code&0x1f;
	*psize = de_pow2((i64)size_indicator);
	*poffs = HDRSIZE+(i64)(addr_code-size_indicator);

	retval = 1;
done:
	if(!retval) {
		*poffs = c->infile->len;
		*psize = 0;
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jl 0x7ff81
jmp 0x7ffcb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %edi
callq 0x15ce50
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x30(%rbp), %eax
subl -0x34(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
addq $0x4, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x7ffef
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dsstore.c
// Function: do_record_date
static void do_record_date(deark *c, lctx *d, struct record_info *ri)
{
	u64 val1;
	i64 val2;
	struct de_timestamp ts;
	char timestamp_buf[64];

	val1 = dbuf_getu64be(c->infile, ri->dpos);
	val2 = (i64)(val1>>16);
	de_mac_time_to_timestamp(val2, &ts);
	ts.tzcode = DE_TZCODE_UTC;
	de_timestamp_to_string(&ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "date: %"U64_FMT" (%s)", val1, timestamp_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1659b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x15d720
movb $0x1, -0x37(%rbp)
leaq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq 0x12d3ec(%rip), %rsi    # 0x1ada5f
movb $0x0, %al
callq 0x15b0d0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dsstore.c
// Function: do_ustr
static void do_ustr(deark *c, lctx *d, struct record_info *ri)
{
	i64 len;
	de_ucstring *s = NULL;

	len = de_getu32be(ri->dpos);
	ri->dlen = 4+len;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, ri->dpos+4, len*2, DE_DBG_MAX_STRLEN*2, s, 0,
		DE_ENCODING_UTF16BE);
	de_dbg(c, "value: \"%s\"", ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x165470
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
addq $0x4, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x4, %rsi
movq -0x20(%rbp), %rdx
shlq %rdx
movq -0x28(%rbp), %r8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %r9d, %r9d
movl $0x4, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x172650
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x11e0f9(%rip), %rsi    # 0x19e82b
movb $0x0, %al
callq 0x15b0d0
movq -0x28(%rbp), %rdi
callq 0x171750
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: de_module_fli
void de_module_fli(deark *c, struct deark_module_info *mi)
{
	mi->id = "fli";
	mi->desc = "FLI/FLC animation";
	mi->run_fn = de_run_fli;
	mi->identify_fn = de_identify_fli;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x12d351(%rip), %rcx    # 0x1adab8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x12d347(%rip), %rcx    # 0x1adabc
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x807a0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x8d(%rip), %rcx        # 0x80820
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: de_run_fli
static void de_run_fli(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 bytes_consumed = 0;

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

	(void)do_chunk(c, d, NULL, 0, c->infile->len, 0, &bytes_consumed);

	if(d) {
		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 $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x50, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r8
xorl %eax, %eax
movl %eax, %ecx
xorl %r9d, %r9d
leaq -0x20(%rbp), %rax
movq %rcx, %rdx
movq %rax, (%rsp)
callq 0x808f0
cmpq $0x0, -0x18(%rbp)
je 0x80811
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: de_identify_fli
static int de_identify_fli(deark *c)
{
	UI ct;
	int has_ext;

	ct = (UI)de_getu16le(4);
	if((ct>>8) != 0xaf) return 0;
	has_ext = de_input_file_has_ext(c, "fli") ||
		de_input_file_has_ext(c, "flc");
	if(ct==CHUNKTYPE_FLI || ct==CHUNKTYPE_FLC) {
		if(has_ext) return 100;
		return 20;
	}
	if(has_ext) return 9;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x165280
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
cmpl $0xaf, %eax
je 0x8085a
movl $0x0, -0x4(%rbp)
jmp 0x808da
movq -0x10(%rbp), %rdi
leaq 0x12d253(%rip), %rsi    # 0x1adab8
callq 0x15d180
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x8088f
movq -0x10(%rbp), %rdi
leaq 0x12d5a0(%rip), %rsi    # 0x1ade21
callq 0x15d180
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xaf11, -0x14(%rbp)    # imm = 0xAF11
je 0x808ac
cmpl $0xaf12, -0x14(%rbp)    # imm = 0xAF12
jne 0x808c4
cmpl $0x0, -0x18(%rbp)
je 0x808bb
movl $0x64, -0x4(%rbp)
jmp 0x808da
movl $0x14, -0x4(%rbp)
jmp 0x808da
cmpl $0x0, -0x18(%rbp)
je 0x808d3
movl $0x9, -0x4(%rbp)
jmp 0x808da
movl $0x0, -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/fli.c
// Function: do_chunk_copy
static void do_chunk_copy(deark *c, lctx *d, struct chunk_info_type *ci)
{
	if(!ci->ictx) return;
	ci->ictx->use_count++;
	de_convert_image_paletted(c->infile, ci->dpos, 8, ci->ictx->w, ci->ictx->pal,
		ci->ictx->img, 0);
}

// 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
cmpq $0x0, 0x48(%rax)
jne 0x81fb1
jmp 0x82008
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %r8
addq $0x38, %r8
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x30(%rax), %r9
movl $0x8, %edx
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x16c520
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: read_timestamp
static void read_timestamp(deark *c, lctx *d, i64 pos, struct de_timestamp *ts,
	const char *name)
{
	i64 datetime_raw;
	i64 date_raw, time_raw;
	struct de_timestamp tmp_timestamp;
	char timestamp_buf[64];

	de_zeromem(ts, sizeof(struct de_timestamp));

	// The timestamp is said to be "MS-DOS formatted", but that's uncomfortably
	// vague, and bogus timestamps seem to be common.

	datetime_raw = de_getu32le_p(&pos);
	de_dbg(c, "%s time: %"I64_FMT, name, datetime_raw);
	if(datetime_raw==0) return;

	de_dbg_indent(c, 1);
	time_raw = datetime_raw & 0xffff;
	date_raw = (datetime_raw >> 16) & 0xffff;

	de_zeromem(&tmp_timestamp, sizeof(struct de_timestamp));
	de_dos_datetime_to_timestamp(&tmp_timestamp, date_raw, time_raw);
	tmp_timestamp.tzcode = DE_TZCODE_LOCAL;
	de_timestamp_to_string(&tmp_timestamp, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "... if DOS time/date: %s", timestamp_buf);

	// Autodesk animator was first released in 1989. Assume timestamps older than
	// the middle of 1988 are bogus.
	if(de_timestamp_to_unix_time(&tmp_timestamp) >= 583718400) {
		*ts = tmp_timestamp;
	}

	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x165580
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x12b9a2(%rip), %rsi    # 0x1adcf9
movb $0x0, %al
callq 0x15b0d0
cmpq $0x0, -0x30(%rbp)
jne 0x8236a
jmp 0x8241f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x30(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
sarq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x15d750
movb $0x2, -0x4f(%rbp)
leaq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
leaq 0x12b920(%rip), %rsi    # 0x1add06
movb $0x0, %al
callq 0x15b0d0
leaq -0x50(%rbp), %rdi
callq 0x15dd00
cmpq $0x22cad600, %rax       # imm = 0x22CAD600
jl 0x82411
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: dbg_id
static void dbg_id(deark *c, lctx *d, i64 pos, const char *name)
{
	i64 n;
	struct de_fourcc id4cc;

	n = de_getu32le(pos);
	if(n<0x01000000) {
		de_dbg(c, "%s: %"I64_FMT,name, n);
		return;
	}
	dbuf_read_fourcc(c->infile, pos, &id4cc, 4, 0x0);
	de_dbg(c, "%s: %"I64_FMT" (0x%08x, '%s')", name, n, (UI)n,
		id4cc.id_dbgstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165540
movq %rax, -0x28(%rbp)
cmpq $0x1000000, -0x28(%rbp) # imm = 0x1000000
jge 0x82483
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x12b8a5(%rip), %rsi    # 0x1add1f
movb $0x0, %al
callq 0x15b0d0
jmp 0x824c9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movl %eax, %r8d
leaq -0x58(%rbp), %r9
addq $0x10, %r9
leaq 0x12b865(%rip), %rsi    # 0x1add27
movb $0x0, %al
callq 0x15b0d0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: create_image_ctx
static struct image_ctx_type *create_image_ctx(deark *c, lctx *d, i64 w, i64 h)
{
	struct image_ctx_type *ictx;

	ictx = de_malloc(c, sizeof(struct image_ctx_type));
	ictx->w = w;
	ictx->h = h;
	ictx->img = de_bitmap_create(c, w, h, 3);
	return ictx;
}

// 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 -0x8(%rbp), %rdi
movl $0x438, %esi            # imm = 0x438
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x3, %ecx
callq 0x16b750
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: do_sequence_of_chunks
static void do_sequence_of_chunks(deark *c, lctx *d, struct chunk_info_type *parent_ci,
	i64 pos1, i64 max_nchunks)
{
	i64 pos = pos1;
	i64 endpos = parent_ci->pos + parent_ci->len;
	i64 chunk_idx = 0;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);

	if(!parent_ci) goto done;
	if(parent_ci->level > 10) goto done;
	if(pos+6 >= endpos) goto done;
	de_dbg(c, "sequence of chunks at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);

	while(1) {
		i64 bytes_avail;
		i64 bytes_consumed = 0;
		int ret;

		if(max_nchunks>=0 && chunk_idx>=max_nchunks) break;
		bytes_avail = endpos - pos;
		if(bytes_avail<6) break;

		ret = do_chunk(c, d, parent_ci, pos, bytes_avail, parent_ci->level+1, &bytes_consumed);
		if(!ret || bytes_consumed<1) break;
		pos += bytes_consumed;
		chunk_idx++;
	}

done:
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x15b580
cmpq $0x0, -0x18(%rbp)
jne 0x82599
jmp 0x8266d
movq -0x18(%rbp), %rax
cmpl $0xa, 0x4(%rax)
jle 0x825a8
jmp 0x8266d
movq -0x30(%rbp), %rax
addq $0x6, %rax
cmpq -0x38(%rbp), %rax
jl 0x825bb
jmp 0x8266d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x12b774(%rip), %rsi    # 0x1add3e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x58(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x825fa
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0x825fa
jmp 0x8266b
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x6, -0x50(%rbp)
jge 0x8260f
jmp 0x8266b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x18(%rbp), %rax
movl 0x4(%rax), %r9d
addl $0x1, %r9d
leaq -0x58(%rbp), %rax
movq %rax, (%rsp)
callq 0x808f0
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x8264c
cmpq $0x1, -0x58(%rbp)
jge 0x8264e
jmp 0x8266b
movq -0x58(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x825df
jmp 0x8266d
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x15b5a0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: destroy_image_ctx
static void destroy_image_ctx(deark *c, struct image_ctx_type *ictx)
{
	if(!ictx) return;
	if(ictx->img) {
		de_bitmap_destroy(ictx->img);
	}
	de_free(c, ictx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x82699
jmp 0x826be
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x826b1
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16af60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fli.c
// Function: make_6cube_pal
static void make_6cube_pal(u32 *pal)
{
	UI r, g, b;
	UI k;

	for(k=0; k<216; k++) {
		b = (k%6) * 51;
		g = ((k/6)%6) * 51;
		r = (k/36) * 51;
		pal[k] = DE_MAKE_RGB(r, g, b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0xd8, -0x18(%rbp)
jae 0x82753
movl -0x18(%rbp), %eax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
imull $0x33, %edx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
imull $0x33, %edx, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl $0x24, %ecx
xorl %edx, %edx
divl %ecx
imull $0x33, %eax, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
shll $0x10, %edx
orl $0xff000000, %edx       # imm = 0xFF000000
movl -0x10(%rbp), %eax
shll $0x8, %eax
orl %eax, %edx
orl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x826df
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: de_module_fat
void de_module_fat(deark *c, struct deark_module_info *mi)
{
	mi->id = "fat";
	mi->desc = "FAT disk image";
	mi->run_fn = de_run_fat;
	mi->identify_fn = de_identify_fat;
	mi->help_fn = de_help_fat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11c6c6(%rip), %rcx    # 0x19ee3d
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x12b6a0(%rip), %rcx    # 0x1ade25
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x827c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2fd(%rip), %rcx       # 0x82aa0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x58e(%rip), %rcx       # 0x82d40
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: de_module_loaddskf
void de_module_loaddskf(deark *c, struct deark_module_info *mi)
{
	mi->id = "loaddskf";
	mi->desc = "LoadDskF/SaveDskF disk image";
	mi->run_fn = de_run_loaddskf;
	mi->identify_fn = de_identify_loaddskf;
	mi->help_fn = de_help_loaddskf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x12b09d(%rip), %rcx    # 0x1ade34
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x12b098(%rip), %rcx    # 0x1ade3d
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x82de0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1cd(%rip), %rcx       # 0x82f90
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x23e(%rip), %rcx       # 0x83010
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: de_identify_loaddskf
static int de_identify_loaddskf(deark *c)
{
	UI sig;

	sig = (UI)de_getu16be(0);
	if(sig==0xaa58 || sig==0xaa59 || sig==0xaa5a) {
		if((UI)de_getu16be(2)==0xf000) {
			return 100;
		}
		return 9;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1651d0
movl %eax, -0x14(%rbp)
cmpl $0xaa58, -0x14(%rbp)    # imm = 0xAA58
je 0x82fcb
cmpl $0xaa59, -0x14(%rbp)    # imm = 0xAA59
je 0x82fcb
cmpl $0xaa5a, -0x14(%rbp)    # imm = 0xAA5A
jne 0x82ff6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x1651d0
cmpl $0xf000, %eax           # imm = 0xF000
jne 0x82fed
movl $0x64, -0x4(%rbp)
jmp 0x82ffd
movl $0x9, -0x4(%rbp)
jmp 0x82ffd
movl $0x0, -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/fat.c
// Function: do_root_dir
static void do_root_dir(deark *c, lctx *d)
{
	i64 pos1;
	struct dirctx *dctx = NULL;

	dctx = de_malloc(c, sizeof(struct dirctx));
	pos1 = sectornum_to_offset(c, d, d->root_dir_sector);
	de_dbg(c, "dir at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	if(pos1<d->bytes_per_sector) goto done;
	if(d->prescan_root_dir) {
		de_dbg(c, "[scanning root dir]");
		// This feature causes us to intentionally read some clusters more than once,
		// so we have to work around our protections against doing that.
		fat_save_cluster_use_flags(c, d);
		de_dbg_indent(c, 1);
		(void)do_dir_entries(c, d, dctx, pos1, d->max_root_dir_entries16 * 32, 0, 1);
		de_dbg_indent(c, -1);
		fat_restore_cluster_use_flags(c, d);
		de_dbg(c, "[done scanning root dir]");
	}
	(void)do_dir_entries(c, d, dctx, pos1, d->max_root_dir_entries16 * 32, 0, 0);
done:
	destroy_dirctx(c, dctx);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x220, %esi            # imm = 0x220
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdx
callq 0x83e80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x14c888(%rip), %rsi    # 0x1d04ba
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x83c5a
jmp 0x83d18
movq -0x10(%rbp), %rax
cmpb $0x0, 0x5(%rax)
je 0x83ced
movq -0x8(%rbp), %rdi
leaq 0x12a5c0(%rip), %rsi    # 0x1ae233
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x83ea0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x68(%rax), %r8
shlq $0x5, %r8
xorl %r9d, %r9d
movl $0x1, (%rsp)
callq 0x83f20
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x83ff0
movq -0x8(%rbp), %rdi
leaq 0x12a561(%rip), %rsi    # 0x1ae247
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x68(%rax), %r8
shlq $0x5, %r8
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0x83f20
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x84050
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: do_oem_name
static void do_oem_name(deark *c, lctx *d, i64 pos, i64 len)
{
	struct de_stringreaderdata *srd;
	i64 i;

	srd = dbuf_read_string(c->infile, pos, len, len, 0, DE_ENCODING_ASCII);

	// Require printable ASCII.
	for(i=0; i<len; i++) {
		if(srd->sz[i]<32 || srd->sz[i]>126) {
			goto done;
		}
	}

	de_dbg(c, "OEM name: \"%s\"", ucstring_getpsz_d(srd->str));

done:
	de_destroy_stringreaderdata(c, srd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x1664c0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x83dcc
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jl 0x83dba
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7e, %eax
jle 0x83dbc
jmp 0x83df6
jmp 0x83dbe
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x83d86
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x172650
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x12a3dd(%rip), %rsi    # 0x1ae1cc
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x166830
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: do_atarist_boot_checksum
static void do_atarist_boot_checksum(deark *c, lctx *d, i64 pos1)
{
	UI ck;

	ck = de_calccrc_oneshot(c->infile, pos1, 512, DE_CRCOBJ_SUM_U16BE);
	ck &= 0xffff;
	de_dbg(c, "Atari ST checksum: 0x%04x", ck);
	if(ck==0x1234) {
		d->has_atarist_checksum = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
movl $0x32, %ecx
callq 0x15f580
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x12a380(%rip), %rsi    # 0x1ae1db
movb $0x0, %al
callq 0x15b0d0
cmpl $0x1234, -0x1c(%rbp)    # imm = 0x1234
jne 0x83e73
movq -0x10(%rbp), %rax
movb $0x1, 0x15(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: fat_save_cluster_use_flags
static void fat_save_cluster_use_flags(deark *c, lctx *d)
{
	if(!d->cluster_used_flags) return;
	if(!d->cluster_used_flags_saved) {
		d->cluster_used_flags_saved = de_malloc(c, d->num_fat_entries);
	}
	de_memcpy(d->cluster_used_flags_saved, d->cluster_used_flags,
		(size_t)d->num_fat_entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x83ec0
jmp 0x83f16
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
jne 0x83ef0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0x15b780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdx
callq 0x191e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fat.c
// Function: do_dir_entries
static int do_dir_entries(deark *c, lctx *d, struct dirctx *dctx,
	i64 pos1, i64 len, int nesting_level, int scanmode)
{
	i64 num_entries;
	i64 i;
	int retval = 0;

	num_entries = len/32;
	de_dbg(c, "num entries: %"I64_FMT, num_entries);

	for(i=0; i<num_entries; i++) {
		if(!do_dir_entry(c, d, dctx, pos1+32*i, nesting_level, scanmode)) {
			goto done;
		}
		dctx->dir_entry_count++;
	}

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x28(%rbp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x14affb(%rip), %rsi    # 0x1cef66
movb $0x0, %al
callq 0x15b0d0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x83fd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
movl -0x2c(%rbp), %r8d
movl 0x10(%rbp), %r9d
callq 0x84080
cmpl $0x0, %eax
jne 0x83fb3
jmp 0x83fd8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x83f7a
movl $0x1, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)