LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: de_module_apple2icons
void de_module_apple2icons(deark *c, struct deark_module_info *mi)
{
	mi->id = "apple2icons";
	mi->desc = "Apple II icons archive";
	mi->run_fn = de_run_apple2icons;
	mi->identify_fn = NULL;
}

// Assembly:
leaq 0xaf696(%rip), %rax     # 0x1181d1
movq %rax, (%rsi)
leaq 0xaf698(%rip), %rax     # 0x1181dd
movq %rax, 0x8(%rsi)
leaq 0xa(%rip), %rax         # 0x68b5a
movq %rax, 0x18(%rsi)
andq $0x0, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: xpuzz_read_header
static void xpuzz_read_header(deark *c, struct xpuzzhdr *hdr)
{
	hdr->w = de_getu32be(0);
	hdr->h = de_getu32be(4);
	hdr->palentries = (i64)de_getbyte(8);
	if(hdr->palentries==0) hdr->palentries = 256;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xe404f
movq %rax, (%rbx)
movq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
callq 0xe404f
movq %rax, 0x8(%rbx)
movq 0x18(%r14), %rdi
pushq $0x8
popq %rsi
callq 0xe3eb4
movzbl %al, %eax
testb %al, %al
movl $0x100, %ecx            # imm = 0x100
cmovneq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: lss16_get_nibble
static u8 lss16_get_nibble(deark *c, struct lss16ctx *d)
{
	u8 n;
	if(d->nextnibble_valid) {
		d->nextnibble_valid = 0;
		return d->nextnibble;
	}
	n = de_getbyte(d->pos);
	d->pos++;
	// The low nibble of each byte is interpreted first.
	// Record the high nibble, and return the low nibble.
	d->nextnibble = (n&0xf0)>>4;
	d->nextnibble_valid = 1;
	return n&0x0f;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0x8(%rsi)
je 0x690b8
movb 0xc(%rbx), %al
xorl %ecx, %ecx
jmp 0x690d4
movq 0x18(%rdi), %rdi
movq (%rbx), %rsi
callq 0xe3eb4
incq (%rbx)
movl %eax, %ecx
shrb $0x4, %cl
movb %cl, 0xc(%rbx)
andb $0xf, %al
pushq $0x1
popq %rcx
movl %ecx, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: fp_art_read_hdr_std
static void fp_art_read_hdr_std(deark *c, struct fp_art_stdhdr_data *hd,
	UI fld1)
{
	i64 pos = 2;
	i64 b_left, b_right, b_top, b_bottom;

	b_left = (i64)fld1;
	b_right = de_getu16le_p(&pos);
	b_top = de_getu16le_p(&pos);
	b_bottom = de_getu16le_p(&pos);
	hd->w = b_right - b_left;
	hd->h = b_bottom - b_top;
	if(hd->w<1 || hd->h<1) return;
	hd->rowspan = ((hd->w+15)/16)*2;
	hd->ok = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %r12
movq $0x2, (%r12)
movl %edx, %ebp
movq 0x18(%rdi), %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, %r14
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, %r13
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xe3fc4
subq %r13, %rax
subq %rbp, %r14
movq %r14, 0x8(%rbx)
movq %rax, 0x10(%rbx)
setle %cl
testq %rax, %rax
setle %al
orb %cl, %al
jne 0x69158
addq $0xf, %r14
shrq $0x3, %r14
movabsq $0xffffffffffffffe, %rax # imm = 0xFFFFFFFFFFFFFFE
andq %r14, %rax
movq %rax, 0x18(%rbx)
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: do_dgi_convert_quadrant
static void do_dgi_convert_quadrant(deark *c, dbuf *imgbuf, i64 srcoffs, i64 dstoffs)
{
	i64 j;

	for(j=0; j<50; j++) {
		dbuf_copy_at(c->infile, srcoffs+j*160, 80, imgbuf, dstoffs+j*640);
		dbuf_copy_at(c->infile, srcoffs+j*160+80, 80, imgbuf, dstoffs+j*640+320);
		dbuf_copy_at(c->infile, srcoffs+8000+j*160, 80, imgbuf, dstoffs+j*640+160);
		dbuf_copy_at(c->infile, srcoffs+8000+j*160+80, 80, imgbuf, dstoffs+j*640+480);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
pushq $0x50
popq %r13
cmpq $0x1f40, %rbp           # imm = 0x1F40
je 0x69221
movq 0x18(%r12), %rdi
leaq (%r14,%rbp), %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0xe490d
movq 0x18(%r12), %rdi
leaq (%r14,%rbp), %rsi
addq $0x50, %rsi
leaq 0x140(%rbx), %r8
movq %r13, %rdx
movq %r15, %rcx
callq 0xe490d
movq 0x18(%r12), %rdi
leaq (%r14,%rbp), %rsi
addq $0x1f40, %rsi           # imm = 0x1F40
movl $0xa0, %eax
leaq (%rbx,%rax), %r8
movq %r13, %rdx
movq %r15, %rcx
callq 0xe490d
movq 0x18(%r12), %rdi
leaq (%r14,%rbp), %rsi
addq $0x1f90, %rsi           # imm = 0x1F90
leaq 0x1e0(%rbx), %r8
movq %r13, %rdx
movq %r15, %rcx
callq 0xe490d
movl $0xa0, %eax
addq %rax, %rbp
addq $0x280, %rbx            # imm = 0x280
jmp 0x69184
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: get_cserve_rle_fmt
static int get_cserve_rle_fmt(deark *c)
{
	u8 buf[3];

	de_read(buf, 0, 3);
	if(buf[0]!=0x1b || buf[1]!=0x47) return 0;
	if(buf[2]==0x4d) return 1;
	if(buf[2]==0x48) return 2;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0x5(%rsp), %r14
pushq $0x3
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xe3cb7
cmpb $0x1b, (%r14)
jne 0x6926e
cmpb $0x47, 0x6(%rsp)
jne 0x6926e
movb 0x7(%rsp), %al
xorl %ecx, %ecx
cmpb $0x48, %al
sete %cl
addl %ecx, %ecx
cmpb $0x4d, %al
pushq $0x1
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: decompress_fastgraph_ppr
static void decompress_fastgraph_ppr(deark *c, struct fastgraph_ctx *d,
	dbuf *unc_pixels, i64 pos1)
{
	i64 pos = pos1;
	i64 unc_total = 0;

	d->max_color_used = 1;

	while(1) {
		u8 b;
		u8 clr[2];
		i64 count;
		UI k;

		if(pos >= c->infile->len) break;
		if(unc_total >= d->max_unc_bytes) break;

		b = de_getbyte_p(&pos);
		clr[0] = b>>4;
		clr[1] = b & 0x0f;

		for(k=0; k<2; k++) {
			count = (i64)de_getbyte_p(&pos);
			if(count>0) {
				if(clr[k] > d->max_color_used) {
					d->max_color_used = clr[k];
				}
				dbuf_write_run(unc_pixels, clr[k], count);
				unc_total += count;
			}
		}
	}

	dbuf_flush(unc_pixels);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x428(%rsi)
xorl %ebp, %ebp
movq 0x18(%r15), %rdi
cmpq 0x18(%rdi), %rcx
jge 0x695d5
cmpq 0x20(%r14), %rbp
jge 0x695d5
leaq 0x10(%rsp), %rsi
callq 0xe3f2a
movl %eax, %ecx
shrb $0x4, %cl
movb %cl, 0xe(%rsp)
andb $0xf, %al
movb %al, 0xf(%rsp)
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x695ce
movq 0x18(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe3f2a
testb %al, %al
je 0x695c9
movb 0xe(%rsp,%r12), %cl
cmpb 0x428(%r14), %cl
jbe 0x695b4
movb %cl, 0x428(%r14)
movzbl %al, %r13d
movzbl %cl, %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0xe5e40
addq %r13, %rbp
incq %r12
jmp 0x69587
movq 0x10(%rsp), %rcx
jmp 0x6955b
movq %rbx, %rdi
callq 0xe58e8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc2.c
// Function: thumbsplus_icon_destroy
static void thumbsplus_icon_destroy(deark *c, struct thumbsplus_icon_ctx *md)
{
	if(!md) return;
	de_destroy_stringreaderdata(c, md->orig_name_srd);
	ucstring_destroy(md->name_token);
	de_free(c, md);
}

// Assembly:
testq %rsi, %rsi
je 0x6968f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0xe4b94
movq 0x20(%rbx), %rdi
callq 0xeaf3c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_cpshrink
void de_module_cpshrink(deark *c, struct deark_module_info *mi)
{
	mi->id = "cpshrink";
	mi->desc = "CP Shrink .CPZ";
	mi->run_fn = de_run_cpshrink;
	mi->identify_fn = de_identify_cpshrink;
}

// Assembly:
leaq 0xaf0cc(%rip), %rax     # 0x118973
movq %rax, (%rsi)
leaq 0xaf0cb(%rip), %rax     # 0x11897c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x698cc
movq %rax, 0x18(%rsi)
leaq 0x3a1(%rip), %rax       # 0x69c68
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_cpshrink
static int de_identify_cpshrink(deark *c)
{
	i64 n;

	if(!de_input_file_has_ext(c, "cpz")) return 0;
	n = de_getu32le(0);
	if(n<1 || n>0xffff) return 0;
	if(de_getbyte(27)>2) return 0; // cmpr meth of 1st file
	return 25;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaf0c3(%rip), %rsi     # 0x118d39
callq 0xdfcd5
testl %eax, %eax
je 0x69cb5
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xe409f
addq $-0x10000, %rax         # imm = 0xFFFF0000
cmpq $-0xffff, %rax          # imm = 0xFFFF0001
jb 0x69cb8
movq 0x18(%rbx), %rdi
pushq $0x1b
popq %rsi
callq 0xe3eb4
xorl %ecx, %ecx
cmpb $0x3, %al
pushq $0x19
popq %r14
cmovael %ecx, %r14d
jmp 0x69cb8
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_dwc
void de_module_dwc(deark *c, struct deark_module_info *mi)
{
	mi->id = "dwc";
	mi->desc = "DWC compressed archive";
	mi->run_fn = de_run_dwc;
	mi->identify_fn = de_identify_dwc;
	mi->help_fn = de_help_dwc;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xaecc1(%rip), %rax     # 0x11898b
movq %rax, (%rsi)
leaq 0xaecbb(%rip), %rax     # 0x11898f
movq %rax, 0x8(%rsi)
leaq 0x1f(%rip), %rax        # 0x69cfe
movq %rax, 0x18(%rsi)
leaq 0x655(%rip), %rax       # 0x6a33f
movq %rax, 0x20(%rsi)
leaq 0x6d4(%rip), %rax       # 0x6a3c9
movq %rax, 0x28(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_dwc
static int de_identify_dwc(deark *c)
{
	i64 tsize;
	int has_ext;
	u8 dsize;

	if(!has_dwc_sig(c)) return 0;
	tsize = de_getu16le(c->infile->len-27);
	if(tsize<27 || tsize>c->infile->len) return 0;
	dsize = de_getbyte(c->infile->len-25);
	if(dsize<30) return 0;
	has_ext = de_input_file_has_ext(c, "dwc");
	if(tsize==27 && dsize==34) {
		if(has_ext) return 100;
		return 60;
	}
	if(has_ext) return 10;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6d4a8
xorl %ebx, %ebx
testl %eax, %eax
je 0x6a3bc
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rsi
addq $-0x1b, %rsi
callq 0xe3fa3
cmpq $0x1b, %rax
jl 0x6a3bc
movq %rax, %r15
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rsi
cmpq %rsi, %rax
jg 0x6a3bc
addq $-0x19, %rsi
callq 0xe3eb4
cmpb $0x1e, %al
jb 0x6a3bc
movl %eax, %ebp
leaq 0xae5fa(%rip), %rsi     # 0x11898b
movq %r14, %rdi
callq 0xdfcd5
cmpq $0x1b, %r15
setne %cl
cmpb $0x22, %bpl
setne %dl
orb %cl, %dl
jne 0x6a3b4
testl %eax, %eax
pushq $0x3c
popq %rax
pushq $0x64
jmp 0x6a3b8
testl %eax, %eax
pushq $0xa
popq %rbx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_edi_pack
void de_module_edi_pack(deark *c, struct deark_module_info *mi)
{
	mi->id = "edi_pack";
	mi->desc = "EDI Install packed file";
	mi->run_fn = de_run_edi_pack;
	mi->identify_fn = de_identify_edi_pack;
}

// Assembly:
leaq 0xae5c8(%rip), %rax     # 0x1189a6
movq %rax, (%rsi)
leaq 0xae5c7(%rip), %rax     # 0x1189af
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6a403
movq %rax, 0x18(%rsi)
leaq 0x288(%rip), %rax       # 0x6a686
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_edi_pack
static int de_identify_edi_pack(deark *c)
{
	if(!dbuf_memcmp(c->infile, 0, g_edilzss_sig, 7)) {
		u8 v;

		v = de_getbyte(7);
		if(v=='1' || v=='2') return 100;
		return 0;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xae8cd(%rip), %rdx     # 0x118f65
xorl %ebx, %ebx
pushq $0x7
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
jne 0x6a6c0
movq 0x18(%r14), %rdi
pushq $0x7
popq %rsi
callq 0xe3eb4
addb $-0x31, %al
xorl %ecx, %ecx
cmpb $0x2, %al
pushq $0x64
popq %rbx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_qip
void de_module_qip(deark *c, struct deark_module_info *mi)
{
	mi->id = "qip";
	mi->desc = "QIP (Quarterdeck)";
	mi->run_fn = de_run_qip;
	mi->identify_fn = de_identify_qip;
}

// Assembly:
leaq 0xae2f6(%rip), %rax     # 0x1189c7
movq %rax, (%rsi)
leaq 0xae2f0(%rip), %rax     # 0x1189cb
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6a6f6
movq %rax, 0x18(%rsi)
leaq 0x229(%rip), %rax       # 0x6a91a
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_qip
static int de_identify_qip(deark *c)
{
	u8 b;
	i64 n;

	if(de_getbyte(0)!='Q') return 0;
	b = de_getbyte(1);
	if(b=='P') {
		if(de_getbyte(8)!=0x02) return 0;
		n = de_getu32le(16);
		if(n>c->infile->len) return 0;
		if(!dbuf_memcmp(c->infile, n, "QD", 2)) return 100;
	}
	else if(b=='D') {
		if(de_getu16le(2)==0 &&
			de_getu16le(8)==1)
		{
			return 70;
		}
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3eb4
cmpb $0x51, %al
jne 0x6a9b0
movq 0x18(%r14), %rdi
pushq $0x1
popq %rsi
callq 0xe3eb4
cmpb $0x44, %al
je 0x6a98a
movzbl %al, %eax
cmpl $0x50, %eax
jne 0x6a9b0
movq 0x18(%r14), %rdi
pushq $0x8
popq %rsi
callq 0xe3eb4
cmpb $0x2, %al
jne 0x6a9b0
movq 0x18(%r14), %rdi
pushq $0x10
popq %rsi
callq 0xe409f
movq 0x18(%r14), %rdi
cmpq 0x18(%rdi), %rax
jg 0x6a9b0
leaq 0xae611(%rip), %rdx     # 0x118f88
pushq $0x2
popq %rcx
movq %rax, %rsi
callq 0xe4d48
testl %eax, %eax
jne 0x6a9b0
pushq $0x64
jmp 0x6a9af
movq 0x18(%r14), %rdi
pushq $0x2
popq %rsi
callq 0xe3fa3
testq %rax, %rax
jne 0x6a9b0
movq 0x18(%r14), %rdi
pushq $0x8
popq %rsi
callq 0xe3fa3
cmpq $0x1, %rax
jne 0x6a9b0
pushq $0x46
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_pcxlib
void de_module_pcxlib(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcxlib";
	mi->desc = "PCX Library";
	mi->run_fn = de_run_pcxlib;
	mi->identify_fn = de_identify_pcxlib;
}

// Assembly:
leaq 0xae01c(%rip), %rax     # 0x1189dd
movq %rax, (%rsi)
leaq 0xae019(%rip), %rax     # 0x1189e4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6a9e6
movq %rax, 0x18(%rsi)
leaq 0xc(%rip), %rax         # 0x6a9ed
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_gxlib
void de_module_gxlib(deark *c, struct deark_module_info *mi)
{
	mi->id = "gxlib";
	mi->desc = "GX Library";
	mi->run_fn = de_run_gxlib;
	mi->identify_fn = de_identify_gxlib;
}

// Assembly:
leaq 0xadfda(%rip), %rax     # 0x1189f0
movq %rax, (%rsi)
leaq 0xadfd6(%rip), %rax     # 0x1189f6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6aa3b
movq %rax, 0x18(%rsi)
leaq 0xd(%rip), %rax         # 0x6aa43
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_gxlib
static int de_identify_gxlib(deark *c)
{
	UI n;
	u8 has_copyr, has_ver;

	n = (UI)de_getu16be(0);
	if(n!=0x01ca) return 0;
	has_copyr = !dbuf_memcmp(c->infile, 2, "Copyri", 6);
	n = (UI)de_getu16le(52);
	has_ver = (n==100);
	if(has_copyr && has_ver) return 100;
	if(has_copyr || has_ver) return 25;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xe3f46
cmpl $0x1ca, %eax            # imm = 0x1CA
jne 0x6aab1
movq 0x18(%rbx), %rdi
leaq 0xae562(%rip), %rdx     # 0x118fcc
pushq $0x2
popq %rsi
pushq $0x6
popq %rcx
callq 0xe4d48
movl %eax, %ebp
testl %eax, %eax
sete %r14b
movq 0x18(%rbx), %rdi
pushq $0x34
popq %rsi
callq 0xe3fa3
movl %eax, %eax
cmpq $0x64, %rax
sete %cl
testb %cl, %r14b
je 0x6aa9d
pushq $0x64
popq %r14
jmp 0x6aab1
xorl %r14d, %r14d
cmpq $0x64, %rax
pushq $0x19
popq %rax
cmovel %eax, %r14d
testl %ebp, %ebp
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_mdcd
void de_module_mdcd(deark *c, struct deark_module_info *mi)
{
	mi->id = "mdcd";
	mi->desc = "MDCD archive";
	mi->run_fn = de_run_mdcd;
	mi->identify_fn = de_identify_mdcd;
}

// Assembly:
leaq 0xadf41(%rip), %rax     # 0x118a01
movq %rax, (%rsi)
leaq 0xadf3c(%rip), %rax     # 0x118a06
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6aae5
movq %rax, 0x18(%rsi)
leaq 0x445(%rip), %rax       # 0x6af25
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_cazip
void de_module_cazip(deark *c, struct deark_module_info *mi)
{
	mi->id = "cazip";
	mi->desc = "CAZIP compressed file";
	mi->run_fn = de_run_cazip;
	mi->identify_fn = de_identify_cazip;
}

// Assembly:
leaq 0xadad5(%rip), %rax     # 0x118a13
movq %rax, (%rsi)
leaq 0xadad1(%rip), %rax     # 0x118a19
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6af63
movq %rax, 0x18(%rsi)
leaq 0x145(%rip), %rax       # 0x6b0a3
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_run_cazip
static void de_run_cazip(deark *c, de_module_params *mparams)
{
	de_arch_lctx *d = NULL;
	struct de_arch_member_data *md = NULL;
	i64 pos;
	UI verfield, field10, field12, field18;

	d = de_arch_create_lctx(c);
	d->is_le = 1;
	d->crco = de_crcobj_create(c, DE_CRCOBJ_CRC32_IEEE);

	md = de_arch_create_md(c, d);
	//d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_CP437);

	pos = 8;
	verfield = (UI)de_getu16be_p(&pos);
	field10 = (UI)de_getu16le_p(&pos);
	field12 = (UI)de_getu16le_p(&pos);

	md->crc_reported = (u32)de_getu32le_p(&pos);
	de_dbg(c, "crc (reported): 0x%08x", (UI)md->crc_reported);

	field18 = (UI)de_getu16le_p(&pos);

	if(verfield!=0x3333 || field10!=1 || field12!=1 || field18!=0) {
		de_warn(c, "This version of CAZIP file might not be handled correctly");
	}

	md->cmpr_pos = pos;
	md->cmpr_len = c->infile->len - md->cmpr_pos;
	if(!de_arch_good_cmpr_data_pos(md)) {
		goto done;
	}

	md->dfn = dclimplode_decompressor_fn;
	md->validate_crc = 1;
	de_arch_extract_member_file(md);

done:
	if(md) {
		de_arch_destroy_md(c, md);
		md = NULL;
	}
	if(d) {
		de_arch_destroy_lctx(c, d);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xf16ce
movq %rax, %r14
movl $0x1, 0x10(%rax)
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0xe0ae9
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf1630
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq $0x8, (%r12)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xe3f6e
movq %rax, %r13
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xe40bf
movl %eax, 0x48(%r15)
leaq 0xcbe22(%rip), %rsi     # 0x136e15
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xe3fc4
cmpl $0x3333, %r13d          # imm = 0x3333
jne 0x6b02b
movl %ebp, %ecx
cmpl $0x1, %ecx
jne 0x6b02b
movl 0x8(%rsp), %ecx
cmpl $0x1, %ecx
jne 0x6b02b
movl %eax, %eax
testq %rax, %rax
je 0x6b03c
leaq 0xae01e(%rip), %rsi     # 0x119050
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf05a
movq 0x10(%rsp), %rax
movq %rax, 0x40(%r15)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x30(%r15)
movq %r15, %rdi
callq 0xf19d5
testl %eax, %eax
je 0x6b07e
leaq 0x26a6(%rip), %rax      # 0x6d70d
movq %rax, 0xa8(%r15)
movb $0x1, 0xa1(%r15)
movq %r15, %rdi
callq 0xf1a85
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf167c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf16e7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_cmz
void de_module_cmz(deark *c, struct deark_module_info *mi)
{
	mi->id = "cmz";
	mi->desc = "CMZ installer archive";
	mi->run_fn = de_run_cmz;
	mi->identify_fn = de_identify_cmz;
}

// Assembly:
leaq 0xad963(%rip), %rax     # 0x118a2f
movq %rax, (%rsi)
leaq 0xad95d(%rip), %rax     # 0x118a33
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6b0f1
movq %rax, 0x18(%rsi)
leaq 0x25c(%rip), %rax       # 0x6b348
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_cmz
static int de_identify_cmz(deark *c)
{
	i64 name_len;
	i64 cmpr_len;

	if(!cmz_sig_at(c, 0)) {
		return 0;
	}

	cmpr_len = de_getu32le(4);
	name_len = de_getu16le(16);
	if(cmpr_len==0 && name_len>0) {
		return 60;
	}
	if(dclimplode_header_at(c, 20+name_len)) {
		return 100;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x6dbc4
testl %eax, %eax
je 0x6b3a7
movq 0x18(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0xe409f
movq %rax, %r14
movq 0x18(%rbx), %rdi
pushq $0x10
popq %rsi
callq 0xe3fa3
testq %r14, %r14
sete %cl
testq %rax, %rax
setg %dl
testb %dl, %cl
je 0x6b38e
pushq $0x3c
popq %r14
jmp 0x6b3a7
addq $0x14, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6dbe3
testl %eax, %eax
pushq $0x64
popq %r14
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_pcshrink
void de_module_pcshrink(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcshrink";
	mi->desc = "PC-Install compressed archive";
	mi->run_fn = de_run_pcshrink;
	mi->identify_fn = de_identify_pcshrink;
}

// Assembly:
leaq 0xad690(%rip), %rax     # 0x118a49
movq %rax, (%rsi)
leaq 0xad68f(%rip), %rax     # 0x118a52
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6b3de
movq %rax, 0x18(%rsi)
leaq 0x2de(%rip), %rax       # 0x6b6b7
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_pcshrink
static int de_identify_pcshrink(deark *c)
{
	u8 multipart_flag;
	int ver;

	ver = detect_pcshrink_internal(c, &multipart_flag);
	if(ver==1) {
		return 60;
	}
	else if(ver==2) {
		if(multipart_flag) return 40;
		return 80;
	}

	return 0;
}

// Assembly:
pushq %rax
leaq 0x7(%rsp), %rsi
callq 0x6dc23
cmpl $0x1, %eax
je 0x6b6dc
cmpl $0x2, %eax
jne 0x6b6e1
cmpb $0x0, 0x7(%rsp)
pushq $0x50
popq %rcx
pushq $0x28
popq %rax
cmovel %ecx, %eax
jmp 0x6b6e3
pushq $0x3c
popq %rax
jmp 0x6b6e3
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_arcv
void de_module_arcv(deark *c, struct deark_module_info *mi)
{
	mi->id = "arcv";
	mi->desc = "ARCV installer archive";
	mi->run_fn = de_run_arcv;
	mi->identify_fn = de_identify_arcv;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xad384(%rip), %rax     # 0x118a70
movq %rax, (%rsi)
leaq 0xad37f(%rip), %rax     # 0x118a75
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6b715
movq %rax, 0x18(%rsi)
leaq 0x35c(%rip), %rax       # 0x6ba68
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_arcv
static int de_identify_arcv(deark *c)
{
	u8 ver;

	if((UI)de_getu32be(0) != CODE_ARCV) return 0;
	ver = de_getbyte(5);
	if(ver==1 || ver==2) {
		return 100;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe404f
cmpl $0x41524356, %eax       # imm = 0x41524356
jne 0x6ba9b
movq 0x18(%r14), %rdi
pushq $0x5
popq %rsi
callq 0xe3eb4
decb %al
xorl %ecx, %ecx
cmpb $0x2, %al
pushq $0x64
popq %rbx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_red
void de_module_red(deark *c, struct deark_module_info *mi)
{
	mi->id = "red";
	mi->desc = "RED installer archive (Knowledge Dynamics Corp)";
	mi->run_fn = de_run_red;
	mi->identify_fn = de_identify_red;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xc4cd6(%rip), %rax     # 0x130782
movq %rax, (%rsi)
leaq 0xacfd6(%rip), %rax     # 0x118a8c
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6bad5
movq %rax, 0x18(%rsi)
leaq 0x219(%rip), %rax       # 0x6bce5
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_lif_kdc
void de_module_lif_kdc(deark *c, struct deark_module_info *mi)
{
	mi->id = "lif_kdc";
	mi->desc = "LIF installer archive (Knowledge Dynamics Corp)";
	mi->run_fn = de_run_lif_kdc;
	mi->identify_fn = de_identify_lif_kdc;
}

// Assembly:
leaq 0xacdb5(%rip), %rax     # 0x118abc
movq %rax, (%rsi)
leaq 0xacdb3(%rip), %rax     # 0x118ac4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6bd2c
movq %rax, 0x18(%rsi)
leaq 0x34d(%rip), %rax       # 0x6c074
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_lif_kdc
static int de_identify_lif_kdc(deark *c)
{
	i64 cmprmeth;
	int errflag = 0;
	int has_ext;
	u8 b;
	i64 i;
	i64 n[4];

	cmprmeth = lif_read_field(c->infile, 32, 2, &errflag);
	if(errflag) return 0;
	if(cmprmeth<1 || cmprmeth>3) return 0;

	b = de_getbyte(34); // 1st char of filename
	if(b<32) return 0;
	b = de_getbyte(53); // last char of NUL-padded filename field??
	if(b!=0) return 0;

	for(i=0; i<4; i++) {
		n[i] = lif_read_field(c->infile, 8*i, 8, &errflag);
		if(errflag) return 0;
	}
	if(54+n[1] > c->infile->len) return 0; // File too short

	has_ext = de_input_file_has_ext(c, "lif");
	return has_ext ? 45 : 15;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movq 0x18(%rdi), %rdi
pushq $0x20
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rcx
callq 0x6dece
xorl %ebp, %ebp
cmpl $0x0, (%r14)
jne 0x6c13f
addq $-0x4, %rax
cmpq $-0x3, %rax
jb 0x6c13f
movq 0x18(%rbx), %rdi
pushq $0x22
popq %rsi
callq 0xe3eb4
cmpb $0x20, %al
jb 0x6c13f
movq 0x18(%rbx), %rdi
pushq $0x35
popq %rsi
callq 0xe3eb4
testb %al, %al
jne 0x6c13f
xorl %r14d, %r14d
pushq $0x8
popq %r15
leaq 0xc(%rsp), %r12
cmpq $0x20, %r14
je 0x6c10e
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x6dece
movq %rax, 0x10(%rsp,%r14)
addq $0x8, %r14
cmpl $0x0, 0xc(%rsp)
je 0x6c0e4
jmp 0x6c121
movq 0x18(%rsp), %rax
addq $0x36, %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x6c125
xorl %ebp, %ebp
jmp 0x6c13f
leaq 0xa5aad(%rip), %rsi     # 0x111bd9
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0xf
popq %rax
pushq $0x2d
popq %rbp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_ain
void de_module_ain(deark *c, struct deark_module_info *mi)
{
	mi->id = "ain";
	mi->desc = "AIN archive";
	mi->run_fn = de_run_ain;
	mi->flags |= DE_MODFLAG_HIDDEN;
	mi->identify_fn = de_identify_ain;
}

// Assembly:
leaq 0xc5032(%rip), %rax     # 0x131187
movq %rax, (%rsi)
leaq 0xac995(%rip), %rax     # 0x118af4
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6c17e
movq %rax, 0x18(%rsi)
orb $0x1, 0x30(%rsi)
leaq 0x21e(%rip), %rax       # 0x6c397
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_run_ain
static void de_run_ain(deark *c, de_module_params *mparams)
{
	de_arch_lctx *d = NULL;

	d = de_arch_create_lctx(c);
	d->is_le = 1;
	do_ain_main(c, d);
	de_arch_destroy_lctx(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xf16ce
movq %rax, %r14
movl $0x1, 0x10(%rax)
leaq 0xac94f(%rip), %rsi     # 0x118af4
movq %rbx, %rdi
callq 0xe07f7
cmpl $0x1, 0x24(%rbx)
jne 0x6c1c4
leaq 0xad0ca(%rip), %rsi     # 0x119284
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf37f
leaq 0x10(%rsp), %r15
movq $0x1, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe3f2a
movzbl %al, %ebp
movl %ebp, %edx
shrl $0x4, %edx
leaq 0xad0cd(%rip), %rsi     # 0x1192b8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
andl $0xf, %ebp
leaq 0xad0cc(%rip), %rsi     # 0x1192cb
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xde896
incq (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe3f2a
movzbl %al, %edx
leaq 0xb6bc2(%rip), %rsi     # 0x122de6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe3fc4
leaq 0xb93c1(%rip), %rsi     # 0x125606
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
movq $0x8, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe3fc4
movq %rax, 0x20(%r14)
leaq 0x9b43d(%rip), %rsi     # 0x1076ac
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
leaq 0x9da90(%rip), %rdx     # 0x109d13
leaq 0x18(%rsp), %rsi
pushq $0x4
popq %rcx
movq %r14, %rdi
movq %r15, %r8
callq 0xf1866
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %rax, %r12
leaq 0xad032(%rip), %rsi     # 0x1192de
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %r13
subq %r12, %r13
movq %r15, %rsi
callq 0xe3fc4
leaq 0xad020(%rip), %rsi     # 0x1192f3
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
pushq $0x30
popq %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xe0f6a
movzwl %ax, %edx
leaq 0xad020(%rip), %rsi     # 0x11931b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe3fc4
leaq 0xad029(%rip), %rsi     # 0x119345
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
leaq 0xc(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6df4f
movl (%rbp), %edx
leaq 0xad02b(%rip), %rsi     # 0x11936d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq (%r15), %rdx
movq %r12, %rcx
subq %rdx, %rcx
leaq 0xbe43f(%rip), %rsi     # 0x12a79b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
leaq 0xad02a(%rip), %rsi     # 0x119397
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf16e7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_ain
static int de_identify_ain(deark *c)
{
	UI hdr_checksum_reported;
	UI hdr_checksum_calc;
	int has_ext;
	i64 member_hdrs_pos;

	if(de_getbyte(0)!=0x21) return 0;
	if(de_getbyte(2)!=0x00) return 0;
	member_hdrs_pos = de_getu32le(14);
	if(member_hdrs_pos<24 || member_hdrs_pos>=c->infile->len) return 0;
	hdr_checksum_reported = (UI)de_getu16le(22);
	ain_calc_hdr_checksum(c, &hdr_checksum_calc);
	if(hdr_checksum_calc != hdr_checksum_reported) return 0;
	has_ext = de_input_file_has_ext(c, "ain");
	return has_ext?100:50;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3eb4
cmpb $0x21, %al
jne 0x6c41a
movq 0x18(%r14), %rdi
pushq $0x2
popq %rsi
callq 0xe3eb4
testb %al, %al
jne 0x6c41a
movq 0x18(%r14), %rdi
pushq $0xe
popq %rsi
callq 0xe409f
cmpq $0x18, %rax
jl 0x6c41a
movq 0x18(%r14), %rdi
cmpq 0x18(%rdi), %rax
jge 0x6c41a
pushq $0x16
popq %rsi
callq 0xe3fa3
movq %rax, %r15
leaq 0x4(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x6df4f
cmpl %r15d, (%r12)
jne 0x6c41a
leaq 0xc4d80(%rip), %rsi     # 0x131187
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0x32
popq %rax
pushq $0x64
popq %rbx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_hta
void de_module_hta(deark *c, struct deark_module_info *mi)
{
	mi->id = "hta";
	mi->desc = "Hemera thumbnails";
	mi->run_fn = de_run_hta;
	mi->identify_fn = de_identify_hta;
}

// Assembly:
leaq 0xac6d1(%rip), %rax     # 0x118b00
movq %rax, (%rsi)
leaq 0xac6cb(%rip), %rax     # 0x118b04
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6c454
movq %rax, 0x18(%rsi)
leaq 0x292(%rip), %rax       # 0x6c6e1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_hit
void de_module_hit(deark *c, struct deark_module_info *mi)
{
	mi->id = "hit";
	mi->desc = "HIT archive";
	mi->run_fn = de_run_hit;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
	mi->identify_fn = de_identify_hit;
}

// Assembly:
leaq 0xac40c(%rip), %rax     # 0x118b16
movq %rax, (%rsi)
leaq 0xac406(%rip), %rax     # 0x118b1a
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6c733
movq %rax, 0x18(%rsi)
orb $0x20, 0x30(%rsi)
leaq 0x2ea(%rip), %rax       # 0x6ca18
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_binary_ii
void de_module_binary_ii(deark *c, struct deark_module_info *mi)
{
	mi->id = "binary_ii";
	mi->desc = "Binary II";
	mi->run_fn = de_run_binary_ii;
	mi->identify_fn = de_identify_binary_ii;
}

// Assembly:
leaq 0xac0d5(%rip), %rax     # 0x118b26
movq %rax, (%rsi)
leaq 0xac0d5(%rip), %rax     # 0x118b30
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6ca76
movq %rax, 0x18(%rsi)
leaq 0x50b(%rip), %rax       # 0x6cf7c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_module_tc_trs80
void de_module_tc_trs80(deark *c, struct deark_module_info *mi)
{
	mi->id = "tc_trs80";
	mi->desc = "The Compressor (TRS-80 archive)";
	mi->run_fn = de_run_tc_trs80;
	mi->identify_fn = de_identify_tc_trs80;
}

// Assembly:
leaq 0xabb9d(%rip), %rax     # 0x118b3a
movq %rax, (%rsi)
leaq 0xabb9c(%rip), %rax     # 0x118b43
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6cfc2
movq %rax, 0x18(%rsi)
leaq 0x373(%rip), %rax       # 0x6d330
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: de_identify_tc_trs80
static int de_identify_tc_trs80(deark *c)
{
	int has_ext = 0;
	u8 b;
	i64 n;
	i64 i;

	if(de_getbyte(0)!=1) return 0; // seq num #1
	if(de_getbyte(14)!=1) return 0; // format ver
	if(de_getbyte(18) >= 2) return 0; // cmpr meth

	for(i=0; i<11; i++) { // filename
		b = de_getbyte(1+i);
		if(b<32) return 0;
		if(i==0 && b==32) return 0;
	}

	b = de_getbyte(13); // ascii flag
	if(b!=0 && b!=255) return 0;

	n = (de_getu32be(14) & 0xffffff) + 19; // offset of member #2
	if(n >= c->infile->len) return 0;
	b = de_getbyte(n); // seq num #2
	if(b!=0 && b!=2) return 0;
	if(b!=0) {
		if(n+1+18+1 > c->infile->len) return 0;
	}

	if(de_input_file_has_ext(c, "arc")) has_ext = 1;
	else if(de_input_file_has_ext(c, "tc")) has_ext = 1;
	if(has_ext) return 75;
	else return 15;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xe3eb4
cmpb $0x1, %al
jne 0x6d442
movq 0x18(%rbx), %rdi
pushq $0xe
popq %rsi
callq 0xe3eb4
cmpb $0x1, %al
jne 0x6d442
movq 0x18(%rbx), %rdi
pushq $0x12
popq %rsi
callq 0xe3eb4
cmpb $0x1, %al
ja 0x6d442
pushq $0xb
popq %r12
xorl %r13d, %r13d
movq 0x18(%rbx), %rdi
subq $0x1, %r12
jb 0x6d3b9
leaq 0x1(%r13), %r15
movq %r15, %rsi
callq 0xe3eb4
xorl %r14d, %r14d
cmpb $0x20, %al
jb 0x6d442
testq %r13, %r13
sete %cl
cmpb $0x20, %al
sete %al
movq %r15, %r13
testb %al, %cl
je 0x6d381
jmp 0x6d442
pushq $0xd
popq %rsi
callq 0xe3eb4
decb %al
xorl %r14d, %r14d
cmpb $-0x2, %al
jb 0x6d442
movq 0x18(%rbx), %rdi
pushq $0xe
popq %rsi
callq 0xe404f
movq %rax, %r15
andl $0xffffff, %r15d        # imm = 0xFFFFFF
leaq 0x13(%r15), %rsi
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rsi
jge 0x6d442
callq 0xe3eb4
testb %al, %al
je 0x6d40d
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x6d442
addq $0x27, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%rax), %r15
jg 0x6d442
leaq 0xa507e(%rip), %rsi     # 0x112492
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
je 0x6d426
pushq $0x4b
popq %r14
jmp 0x6d442
leaq 0xc737b(%rip), %rsi     # 0x1347a8
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0xf
popq %rax
pushq $0x4b
popq %r14
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: cpshrink_decompressor_fn
static void cpshrink_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	switch(md->cmpr_meth) {
	case 0:
	case 1:
		fmtutil_dclimplode_codectype1(c, md->dcmpri, md->dcmpro, md->dres, NULL);
		break;
	case 2:
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
		break;
	default:
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
cmpl $0x2, 0x90(%rax)
jae 0x6d47b
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xf4aaa
jne 0x6d49a
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xeea8f
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xee91c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: dwc_decompressor_fn
static void dwc_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	if(md->cmpr_meth==1) {
		struct de_lzw_params delzwp;

		de_zeromem(&delzwp, sizeof(struct de_lzw_params));
		delzwp.fmt = DE_LZWFMT_DWC;
		fmtutil_decompress_lzw(c, md->dcmpri, md->dcmpro, md->dres, &delzwp);
	}
	else if(md->cmpr_meth==2) {
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
	}
	else {
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x90(%rax), %ecx
cmpl $0x2, %ecx
je 0x6d51c
cmpl $0x1, %ecx
jne 0x6d539
subq $0x18, %rsp
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r8
movups %xmm0, 0x4(%r8)
movl $0x8, (%r8)
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
callq 0xf644c
addq $0x18, %rsp
retq
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xeea8f
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xee91c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: mdcd_decompressor_fn
static void mdcd_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	if(md->cmpr_meth==1) {
		struct de_lzw_params delzwp;

		de_zeromem(&delzwp, sizeof(struct de_lzw_params));
		delzwp.fmt = DE_LZWFMT_ZOOLZD;
		fmtutil_decompress_lzw(c, md->dcmpri, md->dcmpro, md->dres, &delzwp);
	}
	else if(md->cmpr_meth==0) {
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
	}
	else {
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x90(%rax), %ecx
testl %ecx, %ecx
je 0x6db99
cmpl $0x1, %ecx
jne 0x6dbb6
subq $0x18, %rsp
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r8
movups %xmm0, 0x4(%r8)
movl $0x4, (%r8)
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
callq 0xf644c
addq $0x18, %rsp
retq
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xeea8f
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xee91c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: dclimplode_header_at
static int dclimplode_header_at(deark *c, i64 pos)
{
	u8 b;

	b = de_getbyte(pos);
	if(b>1) return 0;
	b = de_getbyte(pos+1);
	if(b<4 || b>6) return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0xe3eb4
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x1, %cl
ja 0x6dc1b
movq 0x18(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0xe3eb4
movl %eax, %ecx
addb $-0x4, %cl
xorl %eax, %eax
cmpb $0x3, %cl
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: detect_pcshrink_internal
static int detect_pcshrink_internal(deark *c, u8 *pmultipart_flag)
{
	u8 b;
	UI n;
	i64 cmpr_len;

	*pmultipart_flag = 0;
	b = de_getbyte(13);
	if(b==0x74) { // maybe old format
		if(de_getbyte(0)!=0) return 0;
		if(de_getbyte(16)!=0x74) return 0;
		if(de_getbyte(56)==0) return 0; // 1st byte of filename
		cmpr_len = de_getu32le(76);
		if(cmpr_len!=0) {
			if(!dclimplode_header_at(c, 104)) return 0;
		}
		return 1;
	}
	else if(b==0) { // maybe new format
		if(de_getu16le(14)!=0x74) return 0;
		n = (UI)de_getu16le(18);
		if(n==0x75) {
			*pmultipart_flag = 1;
		}
		else if(n!=0x74) {
			return 0;
		}
		if(n==0x74) {
			if(de_getbyte(58)==0) return 0; // 1st byte of filename
			cmpr_len = de_getu32le(194);
			if(cmpr_len!=0) {
				if(!dclimplode_header_at(c, 226)) return 0;
			}
		}
		if(de_getbyte(0)!=0) {
			*pmultipart_flag = 1;
		}
		return 2;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movb $0x0, (%rsi)
movq 0x18(%rdi), %rdi
pushq $0xd
popq %rsi
callq 0xe3eb4
xorl %ebx, %ebx
testb %al, %al
je 0x6dcb1
movzbl %al, %eax
cmpl $0x74, %eax
jne 0x6dd29
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3eb4
testb %al, %al
jne 0x6dd29
movq 0x18(%r14), %rdi
pushq $0x10
popq %rsi
callq 0xe3eb4
cmpb $0x74, %al
jne 0x6dd29
movq 0x18(%r14), %rdi
pushq $0x38
popq %rsi
callq 0xe3eb4
testb %al, %al
je 0x6dd29
movq 0x18(%r14), %rdi
pushq $0x4c
popq %rsi
callq 0xe409f
testq %rax, %rax
je 0x6dcac
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x6dbe3
testl %eax, %eax
je 0x6dd29
pushq $0x1
popq %rbx
jmp 0x6dd29
movq 0x18(%r14), %rdi
pushq $0xe
popq %rsi
callq 0xe3fa3
cmpq $0x74, %rax
jne 0x6dd29
movq 0x18(%r14), %rdi
pushq $0x12
popq %rsi
callq 0xe3fa3
cmpl $0x74, %eax
je 0x6dcf5
cmpl $0x75, %eax
jne 0x6dd29
movb $0x1, (%r15)
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xe3eb4
pushq $0x2
popq %rbx
testb %al, %al
je 0x6dd29
movb $0x1, (%r15)
jmp 0x6dd29
movq 0x18(%r14), %rdi
pushq $0x3a
popq %rsi
callq 0xe3eb4
testb %al, %al
je 0x6dd29
movq 0x18(%r14), %rdi
movl $0xc2, %esi
callq 0xe409f
testq %rax, %rax
je 0x6dcdd
movl $0xe2, %esi
movq %r14, %rdi
callq 0x6dbe3
testl %eax, %eax
jne 0x6dcdd
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: do_arcv_common_fields
static void do_arcv_common_fields(deark *c, de_arch_lctx *d,
	struct de_arch_member_data *md, i64 pos1, i64 *nbytes_consumed)
{
	i64 fnlen;
	UI fver_maj1, fver_min1;
	UI fver_maj2, fver_min2;
	i64 pos = pos1;
	UI attr;

	fnlen = (i64)de_getbyte_p(&pos);
	dbuf_read_to_ucstring(c->infile, pos, fnlen, md->filename, 0,
		d->input_encoding);
	de_dbg(c, "filename: \"%s\"", ucstring_getpsz_d(md->filename));
	pos += fnlen;

	de_arch_read_field_orig_len_p(md, &pos);
	de_arch_read_field_cmpr_len_p(md, &pos);

	attr = (UI)de_getu32le_p(&pos); // TODO: How big is this field
	de_arch_handle_field_dos_attr(md, attr);

	de_arch_read_field_dttm_p(d, &md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], "mod",
		DE_ARCH_TSTYPE_DOS_TD, &pos);

	fver_min1 = (UI)de_getu16le_p(&pos);
	fver_maj1 = (UI)de_getu16le_p(&pos);
	de_dbg(c, "file ver (1): %u.%u", fver_maj1, fver_min1);
	fver_min2 = (UI)de_getu16le_p(&pos);
	fver_maj2 = (UI)de_getu16le_p(&pos);
	de_dbg(c, "file ver (2): %u.%u", fver_maj2, fver_min2);

	// Algorithm seems to be "CRC-32/JAMCRC".
	// Same as the usual CRC-32, except it doesn't invert the bits as a final step.
	md->crc_reported = (u32)de_getu32le_p(&pos);
	de_dbg(c, "crc (reported): 0x%08x", (UI)md->crc_reported);

	*nbytes_consumed = pos - pos1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
leaq 0x10(%rsp), %r15
movq %rcx, (%r15)
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xe3f2a
movzbl %al, %ebx
movq 0x18(%r12), %rdi
movq (%r15), %rsi
movq 0x58(%r13), %rcx
movl 0x18(%rbp), %r9d
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xe4c9a
movq 0x58(%r13), %rdi
callq 0xeb877
leaq 0xc0ccc(%rip), %rsi     # 0x12ea5e
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
addq %rbx, (%r15)
movq %r13, %rdi
movq %r15, %rsi
callq 0xf1766
movq %r13, %rdi
movq %r15, %rsi
callq 0xf17ab
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %r13, %rdi
movl %eax, %esi
callq 0xf17eb
movq 0x50(%r13), %rsi
addq $0x18, %rsi
leaq 0x9d308(%rip), %rdx     # 0x10b0e6
pushq $0x4
popq %rcx
movq %rbp, %rdi
movq %r15, %r8
callq 0xf1866
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xe3fc4
movq %rax, %rbx
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xe3fc4
leaq 0xab378(%rip), %rsi     # 0x119188
movq %r12, %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xde896
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xe3fc4
movq %rax, %rbx
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xe3fc4
leaq 0xab35a(%rip), %rsi     # 0x11919c
movq %r12, %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xde896
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xe40bf
movl %eax, 0x48(%r13)
leaq 0xc8fad(%rip), %rsi     # 0x136e15
movq %r12, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
movq (%r15), %rax
subq %r14, %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: lif_method2_decompressor_fn
static void lif_method2_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_ZOOLZD;
	fmtutil_decompress_lzw(c, md->dcmpri, md->dcmpro, md->dres, &delzwp);
}

// Assembly:
subq $0x18, %rsp
movq (%rdi), %rax
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r8
movups %xmm0, 0x4(%r8)
movl $0x4, (%r8)
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
movq %rax, %rdi
callq 0xf644c
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: lif_read_field
static i64 lif_read_field(dbuf *f, i64 pos1, i64 len, int *perrflag)
{
	i64 val = 0;
	i64 i;
	i64 pos = pos1;

	for(i=0; i<len; i++) {
		u8 b;
		i64 nv;

		b = dbuf_getbyte_p(f, &pos);
		if(b>='0' && b<='9') {
			nv = b - 48;
		}
		else if(b>='a' && b<='f') {
			nv = b - 87;
		}
		else {
			*perrflag = 1;
			return 0;
		}

		val = (val<<4) | nv;
	}
	return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl $0xffffffa9, %eax       # imm = 0xFFFFFFA9
movq %rsp, %r13
movq %rsi, (%r13)
xorl %ebx, %ebx
testq %rdx, %rdx
cmovleq %rbx, %r15
leaq 0x27(%rax), %rbp
subq $0x1, %r15
jb 0x6df3d
movq %r12, %rdi
movq %r13, %rsi
callq 0xe3f2a
movzbl %al, %eax
movl %eax, %edx
addb $-0x30, %dl
movq %rbp, %rcx
cmpb $0xa, %dl
jb 0x6df29
leal -0x61(%rax), %edx
movl $0xffffffa9, %ecx       # imm = 0xFFFFFFA9
cmpb $0x6, %dl
jae 0x6df34
addl %eax, %ecx
shlq $0x4, %rbx
orq %rcx, %rbx
jmp 0x6defb
movl $0x1, (%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/misc3.c
// Function: binary_ii_is_member_at
static int binary_ii_is_member_at(dbuf *f, i64 pos, u8 check_nr, int nr_expected)
{
	if(dbuf_memcmp(f, pos, (const void*)"\x0a\x47\x4c", 3)) return 0;
	if(dbuf_getbyte(f, pos+18) != 0x02) return 0;
	if(check_nr) {
		int nr;

		nr = (int)dbuf_getbyte(f, pos+127);
		if(nr != nr_expected) return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
leaq 0xab4da(%rip), %rdx     # 0x119461
pushq $0x3
popq %rcx
callq 0xe4d48
xorl %ebp, %ebp
testl %eax, %eax
jne 0x6dfc3
leaq 0x12(%r14), %rsi
movq %r15, %rdi
callq 0xe3eb4
cmpb $0x2, %al
jne 0x6dfc3
testb %r12b, %r12b
je 0x6dfc0
addq $0x7f, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xe3eb4
movzbl %al, %eax
cmpl %ebx, %eax
jne 0x6dfc3
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq