LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/apple2-dsk.c
// Function: do_wozmoof_META
static void do_wozmoof_META(deark *c, struct de_iffctx *ictx,
	const struct de_iffchunkctx *chunkctx)
{
	i64 k;
	int reading_val;
	de_ucstring *s = NULL;
	de_ucstring *name = NULL;
	de_ucstring *val = NULL;

	// Read the entire metadata string.
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(ictx->f, chunkctx->dpos, chunkctx->dlen,
		65536, s, 0, DE_ENCODING_UTF8);

	// Parse out the individual metadata items
	name = ucstring_create(c);
	val = ucstring_create(c);
	reading_val = 0;

	for(k=0; k<s->len; k++) {
		i32 ch = s->str[k];

		if(ch==0x0a) { // End of item
			do_wozmoof_print_metadata_item(c, name, val);
			ucstring_empty(name);
			ucstring_empty(val);
			reading_val = 0;
		}
		else if(ch==0x09 && !reading_val) { // Name/value separator
			reading_val = 1;
		}
		else { // A non-special character
			if(reading_val) {
				ucstring_append_char(val, ch);
			}
			else {
				ucstring_append_char(name, ch);
			}
		}
	}
	do_wozmoof_print_metadata_item(c, name, val);

	ucstring_destroy(s);
	ucstring_destroy(name);
	ucstring_destroy(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x30(%rbp), %r8
movl $0x10000, %ecx          # imm = 0x10000
xorl %r9d, %r9d
movl $0x2, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x3c0b4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
cmpl $0xa, -0x44(%rbp)
jne 0x3c068
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3c170
movq -0x38(%rbp), %rdi
callq 0x171210
movq -0x40(%rbp), %rdi
callq 0x171210
movl $0x0, -0x24(%rbp)
jmp 0x3c0a1
cmpl $0x9, -0x44(%rbp)
jne 0x3c07d
cmpl $0x0, -0x24(%rbp)
jne 0x3c07d
movl $0x1, -0x24(%rbp)
jmp 0x3c09f
cmpl $0x0, -0x24(%rbp)
je 0x3c091
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1714c0
jmp 0x3c09d
movq -0x38(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1714c0
jmp 0x3c09f
jmp 0x3c0a1
jmp 0x3c0a3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3c012
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3c170
movq -0x30(%rbp), %rdi
callq 0x171750
movq -0x38(%rbp), %rdi
callq 0x171750
movq -0x40(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/apple2-dsk.c
// Function: get_moof_disk_type_name
static const char *get_moof_disk_type_name(u8 t)
{
	const char *name = NULL;

	switch(t) {
	case 1: name = "SSDD GCR (400K)"; break;
	case 2: name = "DSDD GCR (800K)"; break;
	case 3: name = "DSHD MFM (1.44M)"; 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)
subl $0x1, %eax
je 0x3c124
jmp 0x3c110
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x3c131
jmp 0x3c11a
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x3c13e
jmp 0x3c149
leaq 0x166623(%rip), %rax    # 0x1a274e
movq %rax, -0x10(%rbp)
jmp 0x3c149
leaq 0x166626(%rip), %rax    # 0x1a275e
movq %rax, -0x10(%rbp)
jmp 0x3c149
leaq 0x166629(%rip), %rax    # 0x1a276e
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3c15a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3c167
leaq 0x17bacc(%rip), %rax    # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0x3c167
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/apple2-dsk.c
// Function: do_wozmoof_print_metadata_item
static void do_wozmoof_print_metadata_item(deark *c, de_ucstring *name, de_ucstring *val)
{
	if(name->len==0 && val->len==0) return;
	de_dbg(c, "item: \"%s\" = \"%s\"",
		ucstring_getpsz_d(name),
		ucstring_getpsz_d(val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3c19c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3c19c
jmp 0x3c1d3
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x172650
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x172650
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x1665b3(%rip), %rsi    # 0x1a277f
movb $0x0, %al
callq 0x15b0d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/apple2-dsk.c
// Function: get_woz_disk_type_name
static const char *get_woz_disk_type_name(u8 t)
{
	switch(t) {
	case 1: return "5.25";
	case 2: return "3.5";
	}
	return "?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x3c4d2
jmp 0x3c4c8
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x3c4df
jmp 0x3c4ec
leaq 0x16632b(%rip), %rax    # 0x1a2804
movq %rax, -0x8(%rbp)
jmp 0x3c4f7
leaq 0x166323(%rip), %rax    # 0x1a2809
movq %rax, -0x8(%rbp)
jmp 0x3c4f7
leaq 0x17b73a(%rip), %rax    # 0x1b7c2d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: de_module_applesd
void de_module_applesd(deark *c, struct deark_module_info *mi)
{
	mi->id = "applesd";
	mi->id_alias[0] = "applesingle";
	mi->id_alias[1] = "appledouble";
	mi->desc = "AppleSingle/AppleDouble";
	mi->run_fn = de_run_applesd;
	mi->identify_fn = de_identify_applesd;
	mi->help_fn = de_help_applesd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x166303(%rip), %rcx    # 0x1a281a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1662fd(%rip), %rcx    # 0x1a2822
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0x1662fa(%rip), %rcx    # 0x1a282e
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
leaq 0x1662f7(%rip), %rcx    # 0x1a283a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2e(%rip), %rcx        # 0x3c580
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xcf(%rip), %rcx        # 0x3c630
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x120(%rip), %rcx       # 0x3c690
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: de_run_applesd
static void de_run_applesd(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = de_malloc(c, sizeof(lctx));
	if(de_getbyte(3)==0x00)
		d->is_appledouble = 0;
	else
		d->is_appledouble = 1;
	// AppleDouble default = decode resource fork
	// AppleSingle default = extract resource fork
	d->extract_rsrc = de_get_ext_option_bool(c, "applesd:extractrsrc", d->is_appledouble?0:1);
	de_run_sd_internal(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 $0x28, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x3, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3c5ce
movq -0x18(%rbp), %rax
movb $0x0, 0x4(%rax)
jmp 0x3c5d6
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
movl $0x1, %edx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
leaq 0x16625c(%rip), %rsi    # 0x1a2852
callq 0x15cbc0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c6d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: de_identify_applesd
static int de_identify_applesd(deark *c)
{
	i64 n;

	n = de_getu32be(0);
	if(n==0x00051607) return 100; // AppleDouble
	if(n==0x00051600) return 100; // AppleSingle
	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 0x165470
movq %rax, -0x18(%rbp)
cmpq $0x51607, -0x18(%rbp)   # imm = 0x51607
jne 0x3c664
movl $0x64, -0x4(%rbp)
jmp 0x3c67e
cmpq $0x51600, -0x18(%rbp)   # imm = 0x51600
jne 0x3c677
movl $0x64, -0x4(%rbp)
jmp 0x3c67e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: my_advfile_cbfn
static int my_advfile_cbfn(deark *c, struct de_advfile *advf,
	struct de_advfile_cbparams *afp)
{
	lctx *d = (lctx*)advf->userdata;

	if(afp->whattodo == DE_ADVFILE_WRITEMAIN) {
		dbuf_copy(c->infile, d->data_fork_pos, advf->mainfork.fork_len, afp->outf);
	}
	else if(afp->whattodo == DE_ADVFILE_WRITERSRC) {
		dbuf_copy(c->infile, d->rsrc_fork_pos, advf->rsrcfork.fork_len, afp->outf);
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3c920
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x166070
jmp 0x3c950
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3c94e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x166070
jmp 0x3c950
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: do_sd_entry
static void do_sd_entry(deark *c, lctx *d, unsigned int idx, i64 pos1)
{
	struct entry_struct e;
	const struct entry_id_struct *eid;
	i64 pos = pos1;

	de_zeromem(&e, sizeof(struct entry_struct));
	e.idx = idx;
	e.id = (unsigned int)de_getu32be_p(&pos);
	eid =  find_entry_id_info(e.id);
	de_dbg(c, "id: %u (%s)", e.id, eid?eid->name:"?");
	e.offset = de_getu32be_p(&pos);
	de_dbg(c, "offset: %"I64_FMT, e.offset);
	e.length = de_getu32be_p(&pos);
	de_dbg(c, "length: %"I64_FMT, e.length);

	if(e.offset > c->infile->len) goto done;
	if(e.offset+e.length > c->infile->len) {
		de_warn(c, "Entry %u goes beyond end of file. Reducing size from %"I64_FMT
			" to %"I64_FMT".", e.idx, e.length, c->infile->len-e.offset);
		e.length = c->infile->len - e.offset;
	}

	if(eid && eid->hfn) {
		e.eid = eid;
		eid->hfn(c, d, &e);
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x19140
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1654b0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
callq 0x3cb00
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3c9d8
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x3c9e5
leaq 0x17b24e(%rip), %rax    # 0x1b7c2d
movq %rax, -0x68(%rbp)
jmp 0x3c9e5
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rcx
leaq 0x17ffd0(%rip), %rsi    # 0x1bc9c7
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1654b0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x18bdc7(%rip), %rsi    # 0x1c87e9
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1654b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x16604a(%rip), %rsi    # 0x1a2a97
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3ca6b
jmp 0x3caf0
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3cabe
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r8
subq -0x38(%rbp), %r8
leaq 0x165e17(%rip), %rsi    # 0x1a28ba
movb $0x0, %al
callq 0x15bc10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3caee
movq -0x48(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3caee
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq *%rax
jmp 0x3caf0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: find_entry_id_info
static const struct entry_id_struct *find_entry_id_info(unsigned int id)
{
	size_t k;

	for(k=0; k<DE_ARRAYCOUNT(entry_id_arr); k++) {
		if(entry_id_arr[k].id==id) return &entry_id_arr[k];
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0xe, -0x18(%rbp)
jae 0x3cb51
leaq 0x1d8c13(%rip), %rax    # 0x215730
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x3cb41
leaq 0x1d8bfd(%rip), %rax    # 0x215730
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x3cb59
jmp 0x3cb43
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3cb0f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: handler_data
static void handler_data(deark *c, lctx *d, struct entry_struct *e)
{
	if(d->is_appledouble) {
		de_warn(c, "AppleDouble header files should not have a data fork.");
	}

	d->advf->mainfork.fork_exists = 1;
	d->data_fork_pos = e->offset;
	d->advf->mainfork.fork_len = e->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x4(%rax)
je 0x3cb90
movq -0x8(%rbp), %rdi
leaq 0x165e0d(%rip), %rsi    # 0x1a2996
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: handler_dates
static void handler_dates(deark *c, lctx *d, struct entry_struct *e)
{
	if(e->length<16) return;
	do_one_date(c, d, e->offset, "creation date", &d->advf->mainfork.fi->timestamp[DE_TIMESTAMPIDX_CREATE]);
	do_one_date(c, d, e->offset+4, "mod date", &d->advf->mainfork.fi->timestamp[DE_TIMESTAMPIDX_MODIFY]);
	do_one_date(c, d, e->offset+8, "backup date", &d->advf->mainfork.fi->timestamp[DE_TIMESTAMPIDX_BACKUP]);
	do_one_date(c, d, e->offset+12, "access date", &d->advf->mainfork.fi->timestamp[DE_TIMESTAMPIDX_ACCESS]);
}

// 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 $0x10, 0x10(%rax)
jge 0x3ce14
jmp 0x3cedc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %r8
addq $0x18, %r8
addq $0x10, %r8
leaq 0x17c3f9(%rip), %rcx    # 0x1b9238
callq 0x3d170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x4, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %r8
addq $0x18, %r8
leaq 0x16f858(%rip), %rcx    # 0x1ac6c7
callq 0x3d170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x8, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %r8
addq $0x18, %r8
addq $0x40, %r8
leaq 0x165b92(%rip), %rcx    # 0x1a2a35
callq 0x3d170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0xc, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %r8
addq $0x18, %r8
addq $0x20, %r8
leaq 0x165b6a(%rip), %rcx    # 0x1a2a41
callq 0x3d170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: handler_finder
static void handler_finder(deark *c, lctx *d, struct entry_struct *e)
{
	int has_orig_finder_info = 0;
	int has_xattr = 0;

	if(e->length>=32 && (de_getbyte(e->offset) || de_getbyte(e->offset+4))) {
		has_orig_finder_info = 1;
	}
	if(e->length>=62 && !dbuf_memcmp(c->infile, e->offset+34, (const void*)"ATTR", 4)) {
		has_xattr = 1;
	}

	if(has_orig_finder_info) {
		do_finder_orig(c, d, e);
	}
	if(has_xattr) {
		do_finder_xattr(c, d, e);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x20, 0x10(%rax)
jl 0x3cf62
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3cf5b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x4, %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3cf62
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x3e, 0x10(%rax)
jl 0x3cf9e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x22, %rsi
leaq 0x165ad2(%rip), %rdx    # 0x1a2a5a
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x3cf9e
movl $0x1, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3cfb5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3d250
cmpl $0x0, -0x20(%rbp)
je 0x3cfcc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3d390
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: do_extract_rsrc
static void do_extract_rsrc(deark *c, lctx *d, struct entry_struct *e)
{
	de_finfo *fi = NULL;
	de_ucstring *fname = NULL;

	if(e->length<1) goto done;

	d->advf->rsrcfork.fork_exists = 1;
	d->rsrc_fork_pos = e->offset;
	d->advf->rsrcfork.fork_len = e->length;

done:
	de_finfo_destroy(c, fi);
	ucstring_destroy(fname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jge 0x3d011
jmp 0x3d041
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15d260
movq -0x28(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: do_decode_rsrc
static void do_decode_rsrc(deark *c, lctx *d, struct entry_struct *e)
{
	if(e->length<1) return;
	de_dbg(c, "decoding as resource format");
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, "macrsrc", NULL, c->infile,
		e->offset, e->length);
	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
cmpq $0x1, 0x10(%rax)
jge 0x3d081
jmp 0x3d0db
movq -0x8(%rbp), %rdi
leaq 0x165940(%rip), %rsi    # 0x1a29cc
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r9
leaq 0x165924(%rip), %rsi    # 0x1a29e8
xorl %eax, %eax
movl %eax, %edx
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: is_pascal_string
static int is_pascal_string(deark *c, lctx *d, struct entry_struct *e, u8 firstbyte)
{
	if(e->length<1) return 0;

	// Assume this field won't be larger than any Pascal string could need.
	if(e->length > 256) return 0;

	if(1+(i64)firstbyte > e->length) return 0; // A Pascal string wouldn't fit.

	// This could be wrong, if a non-Pascal string starts with a nonprintable char.
	if(firstbyte<32) return 1;

	// At this point, we could do more heuristics, such as testing whether the
	// non-NUL bytes stop exactly where they should for a Pascal string.
	// But perfection is impossible.
	// For now, just assume it's not a Pascal string. Worst case, the decoded
	// string will have a garbage character prepended.
	// TODO: Maybe add a user option.
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jge 0x3d119
movl $0x0, -0x4(%rbp)
jmp 0x3d164
movq -0x20(%rbp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jle 0x3d130
movl $0x0, -0x4(%rbp)
jmp 0x3d164
movzbl -0x21(%rbp), %eax
addq $0x1, %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x3d14b
movl $0x0, -0x4(%rbp)
jmp 0x3d164
movzbl -0x21(%rbp), %eax
cmpl $0x20, %eax
jge 0x3d15d
movl $0x1, -0x4(%rbp)
jmp 0x3d164
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: do_one_date
static void do_one_date(deark *c, lctx *d, i64 pos, const char *name,
	struct de_timestamp *returned_ts)
{
	i64 dt;
	struct de_timestamp ts;
	char timestamp_buf[64];

	de_zeromem(&ts, sizeof(struct de_timestamp));
	dt = de_geti32be(pos);
	if(dt == -0x80000000LL) {
		de_strlcpy(timestamp_buf, "unknown", sizeof(timestamp_buf));
	}
	else {
		// Epoch is Jan 1, 2001. There are 30 years, with 7 leap days, between
		// that and the Unix time epoch.
		de_unix_time_to_timestamp(dt + ((365*30 + 7)*86400), &ts, 0x1);
		de_timestamp_to_string(&ts, timestamp_buf, sizeof(timestamp_buf), 0);
	}
	de_dbg(c, "%s: %"I64_FMT" (%s)", name, dt, timestamp_buf);
	if(returned_ts) {
		*returned_ts = ts;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1655d0
movq %rax, -0x30(%rbp)
cmpq $-0x80000000, -0x30(%rbp) # imm = 0x80000000
jne 0x3d1d5
leaq -0x80(%rbp), %rdi
leaq 0x161393(%rip), %rsi    # 0x19e55c
movl $0x40, %edx
callq 0x15aa30
jmp 0x3d202
movq -0x30(%rbp), %rdi
addq $0x386d4380, %rdi       # imm = 0x386D4380
leaq -0x40(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
leaq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x80(%rbp), %r8
leaq 0x165834(%rip), %rsi    # 0x1a2a4d
movb $0x0, %al
callq 0x15b0d0
cmpq $0x0, -0x28(%rbp)
je 0x3d23a
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/applesd.c
// Function: do_finder_orig
static void do_finder_orig(deark *c, lctx *d, struct entry_struct *e)
{
	i64 pos = e->offset;
	struct de_fourcc filetype;
	struct de_fourcc creator;

	// TODO: This entry has a different format if this is an AppleDouble file
	// whose companion data "file" is a directory. But I don't know the proper
	// way to tell if that is the case.

	dbuf_read_fourcc(c->infile, pos, &filetype, 4, 0x0);
	de_dbg(c, "filetype: '%s'", filetype.id_dbgstr);
	de_memcpy(d->advf->typecode, filetype.bytes, 4);
	d->advf->has_typecode = 1;
	pos += 4;
	dbuf_read_fourcc(c->infile, pos, &creator, 4, 0x0);
	de_dbg(c, "creator: '%s'", creator.id_dbgstr);
	de_memcpy(d->advf->creatorcode, creator.bytes, 4);
	d->advf->has_creatorcode = 1;
	pos += 4;

	d->advf->finderflags = (u16)dbuf_getu16be_p(c->infile, &pos);
	d->advf->has_finderflags = 1;
	de_dbg(c, "flags: 0x%04x", (unsigned int)d->advf->finderflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
addq $0x10, %rdx
leaq 0x163464(%rip), %rsi    # 0x1a0707
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x50(%rbp), %ecx
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, 0x7b(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rdx
addq $0x10, %rdx
leaq 0x182a2f(%rip), %rsi    # 0x1bfd32
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x80(%rbp), %ecx
movl %ecx, 0x94(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, 0x7c(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165210
movw %ax, %cx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movw %cx, 0x7e(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, 0x7d(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movzwl 0x7e(%rax), %edx
leaq 0x1778e5(%rip), %rsi    # 0x1b4c5b
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/applesd.c
// Function: do_xattr_entry
static void do_xattr_entry(deark *c, lctx *d, struct de_stringreaderdata *name,
	i64 pos1, i64 len)
{
	if(pos1+len > c->infile->len) return;

	if(len>=8 && !dbuf_memcmp(c->infile, pos1, (const void*)"bplist00", 8)) {
		de_dbg(c, "binary plist");
		de_dbg_indent(c, 1);
		fmtutil_handle_plist(c, c->infile, pos1, len, NULL, 0);
		de_dbg_indent(c, -1);
	}
	else {
		de_dbg_hexdump(c, c->infile, pos1, len, 256, NULL, 0x1);
	}
}

// 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 %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3d707
jmp 0x3d7ac
cmpq $0x8, -0x28(%rbp)
jl 0x3d781
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq 0x1653a7(%rip), %rdx    # 0x1a2ac8
movl $0x8, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x3d781
movq -0x8(%rbp), %rdi
leaq 0x165396(%rip), %rsi    # 0x1a2ad1
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x173c10
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
jmp 0x3d7ac
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
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: de_module_binhex
void de_module_binhex(deark *c, struct deark_module_info *mi)
{
	mi->id = "binhex";
	mi->desc = "Macintosh BinHex (.hqx) archive";
	mi->run_fn = de_run_binhex;
	mi->identify_fn = de_identify_binhex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1653ad(%rip), %rcx    # 0x1a2b84
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1653a6(%rip), %rcx    # 0x1a2b8b
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x3d810
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xad(%rip), %rcx        # 0x3d8b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: de_run_binhex
static void de_run_binhex(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;
	int ret;

	d = de_malloc(c, sizeof(lctx));
	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_MACROMAN);

	ret = find_start(c, &pos);
	if(!ret) {
		de_err(c, "Not a BinHex file, or not a supported type");
		goto done;
	}

	do_binhex(c, d, pos);

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 $0x170, %esi            # imm = 0x170
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x11, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3d980
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x3d87e
movq -0x8(%rbp), %rdi
leaq 0x165336(%rip), %rsi    # 0x1a2bab
movb $0x0, %al
callq 0x15bfb0
jmp 0x3d88f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3db90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: de_identify_binhex
static int de_identify_binhex(deark *c)
{
	u8 b0;
	int ret;
	i64 foundpos;

	b0 = de_getbyte(0);
	if(b0==g_binhex_intro1[0]) {
		if(!dbuf_memcmp(c->infile, 0, g_binhex_intro1, INTRO1_LEN)) {
			return 100;
		}
	}

	if(!de_input_file_has_ext(c, "hqx")) return 0;

	// File has .hqx extension. Try harder to identify it.
	ret = find_start(c, &foundpos);
	if(ret) {
		if(foundpos<=1) {
			// Possible BinHex, but no intro
			if(looks_like_binhex_eof(c)) {
				return 75;
			}
		}
		else {
			return 100;
		}
	}

	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 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movq 0x1e7c0d(%rip), %rcx    # 0x2254e8
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x3d90f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x1e7bf7(%rip), %rdx    # 0x2254e8
xorl %eax, %eax
movl %eax, %esi
movl $0x28, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x3d90d
movl $0x64, -0x4(%rbp)
jmp 0x3d975
jmp 0x3d90f
movq -0x10(%rbp), %rdi
leaq 0x165435(%rip), %rsi    # 0x1a2d4f
callq 0x15d180
cmpl $0x0, %eax
jne 0x3d92d
movl $0x0, -0x4(%rbp)
jmp 0x3d975
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3d980
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x3d96e
cmpq $0x1, -0x20(%rbp)
jg 0x3d963
movq -0x10(%rbp), %rdi
callq 0x3e6c0
cmpl $0x0, %eax
je 0x3d961
movl $0x4b, -0x4(%rbp)
jmp 0x3d975
jmp 0x3d96c
movl $0x64, -0x4(%rbp)
jmp 0x3d975
jmp 0x3d96e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: init_binhex_decoder
static void init_binhex_decoder(deark *c, lctx *d)
{
	UI k;

	static const u8 binhexchars[] =
		"!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr";

	// Default all entries to 255, meaning invalid.
	de_memset(d->dtable, 0xff, 256);

	for(k=0; k<64; k++) {
		d->dtable[(UI)binhexchars[k]] = (u8)k;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movl $0xff, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x19140
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jae 0x3ddee
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
leaq 0x164f87(%rip), %rcx    # 0x1a2d60
movzbl (%rcx,%rsi), %ecx
movl %ecx, %ecx
movb %dl, 0x70(%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ddbe
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: do_pre_extract_fork
static int do_pre_extract_fork(deark *c, lctx *d, dbuf *inf, struct binhex_forkinfo *fki,
	struct de_advfile_forkinfo *advfki)
{
	fki->crc_reported = (u32)dbuf_getu16be(inf, fki->pos + fki->len);
	de_dbg(c, "%s fork crc (reported): 0x%04x", fki->forkname,
		(unsigned int)fki->crc_reported);

	advfki->writelistener_cb = de_writelistener_for_crc;
	advfki->userdata_for_writelistener = (void*)fki->crco;

	if((fki->pos + fki->len > inf->len) && fki->len!=0) {
		de_err(c, "%s fork goes beyond end of file", fki->forkname);
		fki->len = 0;
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rsi
callq 0x1651d0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x16479b(%rip), %rsi    # 0x1a2cd2
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rax
leaq 0x12ad87(%rip), %rcx    # 0x1692d0
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
addq 0x8(%rcx), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3e5b0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3e5b0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x16475d(%rip), %rsi    # 0x1a2cf1
movb $0x0, %al
callq 0x15bfb0
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3e5b7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: my_advfile_cbfn
static int my_advfile_cbfn(deark *c, struct de_advfile *advf,
	struct de_advfile_cbparams *afp)
{
	lctx *d = (lctx*)advf->userdata;

	if(afp->whattodo == DE_ADVFILE_WRITEMAIN) {
		dbuf_copy(d->decompressed, d->fki_data.pos, advf->mainfork.fork_len, afp->outf);
	}
	else if(afp->whattodo == DE_ADVFILE_WRITERSRC) {
		dbuf_copy(d->decompressed, d->fki_rsrc.pos, advf->rsrcfork.fork_len, afp->outf);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3e610
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x166070
jmp 0x3e640
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3e63e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x166070
jmp 0x3e640
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: do_post_extract_fork
static void do_post_extract_fork(deark *c, lctx *d, struct binhex_forkinfo *fki)
{
	u32 crc_calc;

	// Here, the BinHex spec says we should feed two 0x00 bytes to the CRC
	// calculation, to account for the CRC field itself. However, if I do
	// that, none of files I've tested have the correct CRC. If I don't,
	// all of them have the correct CRC.
	//de_crcobj_addbuf(fki->crco, (const u8*)"\0\0", 2);

	crc_calc = de_crcobj_getval(fki->crco);
	de_dbg(c, "%s fork crc (calculated): 0x%04x", fki->forkname,
		(unsigned int)crc_calc);
	if(crc_calc != fki->crc_reported) {
		de_err(c, "CRC check failed for %s fork", fki->forkname);
	}
}

// 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 0x18(%rax), %rdi
callq 0x15f340
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x164687(%rip), %rsi    # 0x1a2d11
movb $0x0, %al
callq 0x15b0d0
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x3e6b7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x164682(%rip), %rsi    # 0x1a2d32
movb $0x0, %al
callq 0x15bfb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/binhex.c
// Function: looks_like_binhex_eof
static int looks_like_binhex_eof(deark *c)
{
	u8 b[3];

	de_read(b, c->infile->len-3, 3);
	if(b[2]==':') return 1;
	if(b[1]==':' && (b[2]==0x0d || b[2]==0x0a)) return 1;
	if(b[0]==':' && b[1]==0x0d && b[2]==0x0a) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x13(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
subq $0x3, %rdx
movl $0x3, %ecx
callq 0x164d10
movzbl -0x11(%rbp), %eax
cmpl $0x3a, %eax
jne 0x3e704
movl $0x1, -0x4(%rbp)
jmp 0x3e753
movzbl -0x12(%rbp), %eax
cmpl $0x3a, %eax
jne 0x3e728
movzbl -0x11(%rbp), %eax
cmpl $0xd, %eax
je 0x3e71f
movzbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x3e728
movl $0x1, -0x4(%rbp)
jmp 0x3e753
movzbl -0x13(%rbp), %eax
cmpl $0x3a, %eax
jne 0x3e74c
movzbl -0x12(%rbp), %eax
cmpl $0xd, %eax
jne 0x3e74c
movzbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x3e74c
movl $0x1, -0x4(%rbp)
jmp 0x3e753
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/bintext.c
// Function: de_module_xbin
void de_module_xbin(deark *c, struct deark_module_info *mi)
{
	mi->id = "xbin";
	mi->desc = "XBIN character graphics";
	mi->run_fn = de_run_xbin;
	mi->identify_fn = de_identify_xbin;
	mi->help_fn = de_help_xbin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x16468f(%rip), %rcx    # 0x1a2e06
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x164686(%rip), %rcx    # 0x1a2e0b
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x3e7c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x68d(%rip), %rcx       # 0x3ee30
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x6ce(%rip), %rcx       # 0x3ee80
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_module_bintext
void de_module_bintext(deark *c, struct deark_module_info *mi)
{
	mi->id = "bintext";
	mi->desc = "Binary Text character graphics";
	mi->run_fn = de_run_bintext;
	mi->identify_fn = de_identify_bintext;
	mi->help_fn = de_help_bintext;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x163f4c(%rip), %rcx    # 0x1a2e23
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x163f46(%rip), %rcx    # 0x1a2e2b
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x3ef20
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x3ad(%rip), %rcx       # 0x3f2b0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x40e(%rip), %rcx       # 0x3f320
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_identify_bintext
static int de_identify_bintext(deark *c)
{
	if(!c->detection_data->SAUCE_detection_attempted) {
		// FIXME?: This is known to happen if "-disablemods sauce" was used.
		de_err(c, "bintext detection requires sauce module");
		return 0;
	}
	if(c->detection_data->sauce.has_SAUCE) {
		if(c->detection_data->sauce.data_type==5)
		{
			return 100;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpb $0x0, 0x5(%rax)
jne 0x3f2e5
movq -0x10(%rbp), %rdi
leaq 0x163ea4(%rip), %rsi    # 0x1a3179
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x4(%rbp)
jmp 0x3f316
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpb $0x0, 0x10(%rax)
je 0x3f30f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movzbl 0x11(%rax), %eax
cmpl $0x5, %eax
jne 0x3f30d
movl $0x64, -0x4(%rbp)
jmp 0x3f316
jmp 0x3f30f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_module_artworx_adf
void de_module_artworx_adf(deark *c, struct deark_module_info *mi)
{
	mi->id = "artworx_adf";
	mi->desc = "ArtWorx Data Format (ADF)";
	mi->run_fn = de_run_artworx_adf;
	mi->identify_fn = de_identify_artworx_adf;
	mi->help_fn = de_help_artworx_adf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x163ac3(%rip), %rcx    # 0x1a2e4a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x163ac1(%rip), %rcx    # 0x1a2e56
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x3f3d0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x27d(%rip), %rcx       # 0x3f630
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x31e(%rip), %rcx       # 0x3f6e0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_identify_artworx_adf
static int de_identify_artworx_adf(deark *c)
{
	u8 ver;

	// TODO: This detection algorithm will fail if there is a SAUCE record.

	if(c->infile->len < 1+192+4096+160) {
		return 0;
	}
	if((c->infile->len - (1+192+4096))%160 != 0) {
		return 0;
	}
	if(!de_input_file_has_ext(c, "adf")) return 0;
	ver = de_getbyte(0);
	// I don't know what version numbers are allowed, but I'll assume the
	// version number should be small.
	if(ver>4) return 0;
	return 75;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x1161, 0x18(%rax)     # imm = 0x1161
jge 0x3f657
movl $0x0, -0x4(%rbp)
jmp 0x3f6cd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq $0x10c1, %rax           # imm = 0x10C1
movl $0xa0, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x3f682
movl $0x0, -0x4(%rbp)
jmp 0x3f6cd
movq -0x10(%rbp), %rdi
leaq 0x197241(%rip), %rsi    # 0x1d68ce
callq 0x15d180
cmpl $0x0, %eax
jne 0x3f6a0
movl $0x0, -0x4(%rbp)
jmp 0x3f6cd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x4, %eax
jle 0x3f6c6
movl $0x0, -0x4(%rbp)
jmp 0x3f6cd
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/bintext.c
// Function: de_module_icedraw
void de_module_icedraw(deark *c, struct deark_module_info *mi)
{
	mi->id = "icedraw";
	mi->desc = "iCEDraw character graphics format";
	mi->run_fn = de_run_icedraw;
	mi->identify_fn = de_identify_icedraw;
	mi->flags |= DE_MODFLAG_NONWORKING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x163729(%rip), %rcx    # 0x1a2e70
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x163723(%rip), %rcx    # 0x1a2e78
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x3f790
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x5d(%rip), %rcx        # 0x3f7d0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_module_thedraw_com
void de_module_thedraw_com(deark *c, struct deark_module_info *mi)
{
	mi->id = "thedraw_com";
	mi->desc = "TheDraw COM file";
	mi->run_fn = de_run_thedraw_com;
	mi->identify_fn = de_identify_thedraw_com;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x163663(%rip), %rcx    # 0x1a2e9a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x163661(%rip), %rcx    # 0x1a2ea6
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x3f870
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x60d(%rip), %rcx       # 0x3fe70
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_module_aciddraw_com
void de_module_aciddraw_com(deark *c, struct deark_module_info *mi)
{
	mi->id = "aciddraw_com";
	mi->desc = "ACiDDraw COM file";
	mi->run_fn = de_run_aciddraw_com;
	mi->identify_fn = de_identify_aciddraw_com;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x162e60(%rip), %rcx    # 0x1a2eb7
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x162e5f(%rip), %rcx    # 0x1a2ec4
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x40090
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x30d(%rip), %rcx       # 0x40390
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_identify_aciddraw_com
static int de_identify_aciddraw_com(deark *c)
{
	u8 n1;
	struct aciddraw_id_data adi;

	if(c->infile->len>65280) return 0;
	n1 = de_getbyte(0);
	if(n1!=0xe9 && n1!=0xeb) return 0;
	aciddraw_id(c, n1, &adi);
	if(adi.is_aciddraw) {
		return 92;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0xff00, 0x18(%rax)     # imm = 0xFF00
jle 0x403b7
movl $0x0, -0x4(%rbp)
jmp 0x40411
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xe9, %eax
je 0x403ea
movzbl -0x11(%rbp), %eax
cmpl $0xeb, %eax
je 0x403ea
movl $0x0, -0x4(%rbp)
jmp 0x40411
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rdx
movzbl -0x11(%rbp), %esi
callq 0x418c0
cmpb $0x0, -0x28(%rbp)
je 0x4040a
movl $0x5c, -0x4(%rbp)
jmp 0x40411
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/bintext.c
// Function: de_module_ldog_com
void de_module_ldog_com(deark *c, struct deark_module_info *mi)
{
	mi->id = "ldog_com";
	mi->desc = "Laughing Dog COM file";
	mi->run_fn = de_run_ldog_com;
	mi->identify_fn = de_identify_ldog_com;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x162a9f(%rip), %rcx    # 0x1a2ed6
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x162a9a(%rip), %rcx    # 0x1a2edf
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x40470
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x24d(%rip), %rcx       # 0x406b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)