LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/misc2.c
// Function: de_identify_pixfolio
static int de_identify_pixfolio(deark *c)
{
	u8 buf[20];
	i64 n1, n2;

	// This probably doesn't identify *every* PixFolio CAT file.
	// It assumes the first item contains an image, which is quite possibly not
	// always true.
	if(de_getbyte(0)<0x20) return 0;
	if(!de_input_file_has_ext(c, "cat")) return 0;
	de_read(buf, 343, 20);
	if(buf[2]!='/' && buf[2]!='-') return 0;
	if(buf[13]!=':') return 0;
	n1 = de_getu16le(369); // Descr len
	n2 = de_getu32le(373+n1+1); // DIB header size
	if(n2 != 40) return 0;
	n2 = de_getu16le(373+n1+1+12); // #planes
	if(n2 != 1) return 0;
	return 80;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $0x20, %al
jb 0x6c82d
leaq 0xb9358(%rip), %rsi     # 0x125b07
movq %r14, %rdi
callq 0xea491
testl %eax, %eax
je 0x6c82d
movq 0x18(%r14), %rdi
movq %rsp, %r15
movl $0x157, %edx            # imm = 0x157
movl $0x14, %ecx
movq %r15, %rsi
callq 0xee8d4
movb 0x2(%r15), %al
andb $-0x3, %al
cmpb $0x2d, %al
jne 0x6c82d
cmpb $0x3a, 0xd(%rsp)
jne 0x6c82d
movq 0x18(%r14), %rdi
movl $0x171, %esi            # imm = 0x171
callq 0xeebc8
movq %rax, %r15
movq 0x18(%r14), %rdi
leaq 0x176(%rax), %rsi
callq 0xeed61
cmpq $0x28, %rax
jne 0x6c82d
movq 0x18(%r14), %rdi
addq $0x182, %r15            # imm = 0x182
movq %r15, %rsi
callq 0xeebc8
xorl %ecx, %ecx
cmpq $0x1, %rax
movl $0x50, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb8b83(%rip), %rax     # 0x1253d1
movq %rax, (%rsi)
leaq 0xb8b85(%rip), %rax     # 0x1253dd
movq %rax, 0x8(%rsi)
leaq 0xd(%rip), %rax         # 0x6c870
movq %rax, 0x18(%rsi)
movq $0x0, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeed0d
movq %rax, (%rbx)
movq 0x18(%r14), %rdi
movl $0x4, %esi
callq 0xeed0d
movq %rax, 0x8(%rbx)
movq 0x18(%r14), %rdi
movl $0x8, %esi
callq 0xeead3
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_O3/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 0x6cdca
movb 0xc(%rbx), %al
xorl %ecx, %ecx
jmp 0x6cde8
movq 0x18(%rdi), %rdi
movq (%rbx), %rsi
callq 0xeead3
incq (%rbx)
movl %eax, %ecx
shrb $0x4, %cl
movb %cl, 0xc(%rbx)
andb $0xf, %al
movl $0x1, %ecx
movl %ecx, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeebeb
movq %rax, %r14
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, %r13
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xeebeb
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 0x6ce6c
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_O3/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
movq 0x18(%r12), %rdi
leaq (%rbx,%rbp), %r13
movl $0x50, %edx
movq %r14, %rsi
movq %r15, %rcx
movq %r13, %r8
callq 0xef82b
movq 0x18(%r12), %rdi
leaq 0x50(%r14), %rsi
leaq (%rbx,%rbp), %r8
addq $0x140, %r8             # imm = 0x140
movl $0x50, %edx
movq %r15, %rcx
callq 0xef82b
movq 0x18(%r12), %rdi
leaq 0x1f40(%r14), %rsi
movl $0xa0, %eax
addq %rax, %r13
movl $0x50, %edx
movq %r15, %rcx
movq %r13, %r8
callq 0xef82b
movq 0x18(%r12), %rdi
leaq 0x1f90(%r14), %rsi
leaq (%rbx,%rbp), %r8
addq $0x1e0, %r8             # imm = 0x1E0
movl $0x50, %edx
movq %r15, %rcx
callq 0xef82b
addq $0x280, %rbp            # imm = 0x280
movl $0xa0, %eax
addq %rax, %r14
cmpq $0x7d00, %rbp           # imm = 0x7D00
jne 0x6ce94
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 %rdi, %r15
movq %rcx, 0x10(%rsp)
movb $0x1, 0x428(%rsi)
movq 0x18(%rdi), %rdi
cmpq %rcx, 0x18(%rdi)
jle 0x6d2f1
movq %rsi, %r14
xorl %ebp, %ebp
cmpq 0x20(%r14), %rbp
jge 0x6d2f1
leaq 0x10(%rsp), %rsi
callq 0xeeb4b
movl %eax, %ecx
shrb $0x4, %cl
movb %cl, 0xf(%rsp)
andb $0xf, %al
movb %al, 0xe(%rsp)
movb $0x1, %r12b
leaq 0xf(%rsp), %r13
movq 0x18(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0xeeb4b
testb %al, %al
je 0x6d2cd
movb (%r13), %cl
cmpb 0x428(%r14), %cl
jbe 0x6d2b8
movb %cl, 0x428(%r14)
movzbl %al, %r13d
movzbl %cl, %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0xf0eba
addq %r13, %rbp
leaq 0xe(%rsp), %r13
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x6d292
movq 0x10(%rsp), %rax
movq 0x18(%r15), %rdi
cmpq 0x18(%rdi), %rax
jl 0x6d267
movq %rbx, %rdi
callq 0xf08ba
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 0x6d33b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0xefaca
movq 0x20(%rbx), %rdi
callq 0xf6753
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8be2
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb8624(%rip), %rax     # 0x125b73
movq %rax, (%rsi)
leaq 0xb8623(%rip), %rax     # 0x125b7c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6d574
movq %rax, 0x18(%rsi)
leaq 0x3b6(%rip), %rax       # 0x6d925
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb8606(%rip), %rsi     # 0x125f39
callq 0xea491
testl %eax, %eax
je 0x6d976
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeed61
addq $-0x10000, %rax         # imm = 0xFFFF0000
cmpq $-0xffff, %rax          # imm = 0xFFFF0001
jb 0x6d979
movq 0x18(%rbx), %rdi
movl $0x1b, %esi
callq 0xeead3
xorl %ecx, %ecx
cmpb $0x3, %al
movl $0x19, %r14d
cmovael %ecx, %r14d
jmp 0x6d979
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb8200(%rip), %rax     # 0x125b8b
movq %rax, (%rsi)
leaq 0xb81fa(%rip), %rax     # 0x125b8f
movq %rax, 0x8(%rsi)
leaq 0x1f(%rip), %rax        # 0x6d9bf
movq %rax, 0x18(%rsi)
leaq 0x677(%rip), %rax       # 0x6e022
movq %rax, 0x20(%rsi)
leaq 0x716(%rip), %rax       # 0x6e0cc
movq %rax, 0x28(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rsi
addq $-0x3, %rsi
leaq 0xb7fec(%rip), %rdx     # 0x12602b
movl $0x3, %ecx
callq 0xefc85
xorl %ebp, %ebp
testl %eax, %eax
jne 0x6e0bf
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rsi
addq $-0x1b, %rsi
callq 0xeebc8
cmpq $0x1b, %rax
jl 0x6e0bf
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rsi
cmpq %rsi, %rax
jg 0x6e0bf
addq $-0x19, %rsi
callq 0xeead3
cmpb $0x1e, %al
jb 0x6e0bf
movl %eax, %r15d
leaq 0xb7afe(%rip), %rsi     # 0x125b8b
movq %rbx, %rdi
callq 0xea491
cmpq $0x1b, %r14
setne %cl
cmpb $0x22, %r15b
setne %dl
orb %cl, %dl
jne 0x6e0b5
testl %eax, %eax
movl $0x3c, %eax
movl $0x64, %ebp
jmp 0x6e0bc
testl %eax, %eax
movl $0xa, %ebp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 0xb7ac5(%rip), %rax     # 0x125ba6
movq %rax, (%rsi)
leaq 0xb7ac4(%rip), %rax     # 0x125baf
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6e106
movq %rax, 0x18(%rsi)
leaq 0x2ac(%rip), %rax       # 0x6e3ad
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb7da6(%rip), %rdx     # 0x126165
xorl %ebx, %ebx
movl $0x7, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x6e3ed
movq 0x18(%r14), %rdi
movl $0x7, %esi
callq 0xeead3
addb $-0x31, %al
xorl %ecx, %ecx
cmpb $0x2, %al
movl $0x64, %ebx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb77c9(%rip), %rax     # 0x125bc7
movq %rax, (%rsi)
leaq 0xb77c3(%rip), %rax     # 0x125bcb
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6e423
movq %rax, 0x18(%rsi)
leaq 0x244(%rip), %rax       # 0x6e662
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeead3
cmpb $0x51, %al
jne 0x6e70f
movq 0x18(%r14), %rdi
movl $0x1, %esi
callq 0xeead3
cmpb $0x44, %al
je 0x6e6e1
movzbl %al, %eax
cmpl $0x50, %eax
jne 0x6e70d
movq 0x18(%r14), %rdi
movl $0x8, %esi
callq 0xeead3
cmpb $0x2, %al
jne 0x6e70f
movq 0x18(%r14), %rdi
movl $0x10, %esi
callq 0xeed61
movq 0x18(%r14), %rdi
cmpq 0x18(%rdi), %rax
jg 0x6e70f
leaq 0xb7abf(%rip), %rdx     # 0x126188
movl $0x2, %ecx
movq %rax, %rsi
callq 0xefc85
testl %eax, %eax
jne 0x6e70d
movl $0x64, %ebx
jmp 0x6e70f
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xeebc8
testq %rax, %rax
jne 0x6e70d
movq 0x18(%r14), %rdi
movl $0x8, %esi
callq 0xeebc8
movl $0x46, %ebx
cmpq $0x1, %rax
je 0x6e70f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb74bd(%rip), %rax     # 0x125bdd
movq %rax, (%rsi)
leaq 0xb74ba(%rip), %rax     # 0x125be4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6e745
movq %rax, 0x18(%rsi)
leaq 0xc(%rip), %rax         # 0x6e74c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb7477(%rip), %rax     # 0x125bf0
movq %rax, (%rsi)
leaq 0xb7473(%rip), %rax     # 0x125bf6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6e79e
movq %rax, 0x18(%rsi)
leaq 0xf(%rip), %rax         # 0x6e7a8
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeeb67
cmpl $0x1ca, %eax            # imm = 0x1CA
jne 0x6e821
movq 0x18(%rbx), %rdi
leaq 0xb79fa(%rip), %rdx     # 0x1261cc
movl $0x2, %esi
movl $0x6, %ecx
callq 0xefc85
movl %eax, %ebp
testl %eax, %eax
sete %r15b
movq 0x18(%rbx), %rdi
movl $0x34, %esi
callq 0xeebc8
movl %eax, %eax
cmpq $0x64, %rax
sete %cl
movl $0x64, %r14d
testb %cl, %r15b
jne 0x6e821
xorl %r14d, %r14d
cmpq $0x64, %rax
movl $0x19, %eax
cmovel %eax, %r14d
testl %ebp, %ebp
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb73cb(%rip), %rax     # 0x125c01
movq %rax, (%rsi)
leaq 0xb73c6(%rip), %rax     # 0x125c06
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6e85b
movq %rax, 0x18(%rsi)
leaq 0x469(%rip), %rax       # 0x6ecbf
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb6f27(%rip), %rax     # 0x125c13
movq %rax, (%rsi)
leaq 0xb6f23(%rip), %rax     # 0x125c19
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6ed11
movq %rax, 0x18(%rsi)
leaq 0x147(%rip), %rax       # 0x6ee53
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfd4b2
movq %rax, %r14
movl $0x1, 0x10(%rax)
movq %rbx, %rdi
movl $0x10, %esi
callq 0xeb499
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd414
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq $0x8, (%r12)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeeb91
movq %rax, %r13
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeed83
movl %eax, 0x48(%r15)
leaq 0xd54c2(%rip), %rsi     # 0x144265
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebeb
cmpl $0x3333, %r13d          # imm = 0x3333
jne 0x6eddb
movl %ebp, %ecx
cmpl $0x1, %ecx
jne 0x6eddb
movl 0x8(%rsp), %ecx
cmpl $0x1, %ecx
jne 0x6eddb
movl %eax, %eax
testq %rax, %rax
je 0x6edec
leaq 0xb746e(%rip), %rsi     # 0x126250
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8faa
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 0xfd7af
testl %eax, %eax
je 0x6ee2e
leaq 0x27de(%rip), %rax      # 0x715f5
movq %rax, 0xa8(%r15)
movb $0x1, 0xa1(%r15)
movq %r15, %rdi
callq 0xfd85e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfd460
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd4cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 0xb6daf(%rip), %rax     # 0x125c2f
movq %rax, (%rsi)
leaq 0xb6da9(%rip), %rax     # 0x125c33
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6eea5
movq %rax, 0x18(%rsi)
leaq 0x271(%rip), %rax       # 0x6f111
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x18(%rdi), %rdi
leaq 0xb71b1(%rip), %rdx     # 0x1262d4
xorl %r14d, %r14d
movl $0x4, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x6f186
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xeed61
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x10, %esi
callq 0xeebc8
testq %r14, %r14
sete %cl
testq %rax, %rax
setg %dl
movl $0x3c, %r14d
testb %dl, %cl
jne 0x6f186
addq $0x14, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x71a8f
testl %eax, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb6ab1(%rip), %rax     # 0x125c49
movq %rax, (%rsi)
leaq 0xb6ab0(%rip), %rax     # 0x125c52
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6f1bd
movq %rax, 0x18(%rsi)
leaq 0x2e3(%rip), %rax       # 0x6f49b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x71acf
cmpl $0x1, %eax
je 0x6f4c4
cmpl $0x2, %eax
jne 0x6f4cb
cmpb $0x0, 0x7(%rsp)
movl $0x50, %ecx
movl $0x28, %eax
cmovel %ecx, %eax
jmp 0x6f4cd
movl $0x3c, %eax
jmp 0x6f4cd
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb679a(%rip), %rax     # 0x125c70
movq %rax, (%rsi)
leaq 0xb6795(%rip), %rax     # 0x125c75
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6f4ff
movq %rax, 0x18(%rsi)
leaq 0x386(%rip), %rax       # 0x6f87c
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeed0d
cmpl $0x41524356, %eax       # imm = 0x41524356
jne 0x6f8b3
movq 0x18(%r14), %rdi
movl $0x5, %esi
callq 0xeead3
decb %al
xorl %ecx, %ecx
cmpb $0x2, %al
movl $0x64, %ebx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xce1ee(%rip), %rax     # 0x13dab2
movq %rax, (%rsi)
leaq 0xb63be(%rip), %rax     # 0x125c8c
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6f8ed
movq %rax, 0x18(%rsi)
leaq 0x22f(%rip), %rax       # 0x6fb13
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb6185(%rip), %rax     # 0x125cbc
movq %rax, (%rsi)
leaq 0xb6183(%rip), %rax     # 0x125cc4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6fb5c
movq %rax, 0x18(%rsi)
leaq 0x35e(%rip), %rax       # 0x6feb5
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
movq 0x18(%rdi), %rdi
movl $0x20, %esi
movl $0x2, %edx
movq %r15, %rcx
callq 0x71d97
xorl %ebx, %ebx
cmpl $0x0, (%r15)
jne 0x6ff1b
addq $-0x4, %rax
cmpq $-0x3, %rax
jb 0x6ff1b
movq 0x18(%r14), %rdi
movl $0x22, %esi
callq 0xeead3
cmpb $0x20, %al
jb 0x6ff1b
movq 0x18(%r14), %rdi
movl $0x35, %esi
callq 0xeead3
testb %al, %al
je 0x6ff29
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
xorl %r12d, %r12d
movq 0x18(%r14), %rdi
movl $0x8, %edx
movq %r12, %rsi
movq %r15, %rcx
callq 0x71d97
movq %rax, 0x10(%rsp,%r12)
cmpl $0x0, 0xc(%rsp)
jne 0x6ff1b
addq $0x8, %r12
cmpq $0x20, %r12
jne 0x6ff33
movq 0x18(%rsp), %rax
addq $0x36, %rax
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rax
jg 0x6ff1b
leaq 0xaed32(%rip), %rsi     # 0x11eca9
movq %r14, %rdi
callq 0xea491
testl %eax, %eax
movl $0xf, %eax
movl $0x2d, %ebx
cmovel %eax, %ebx
jmp 0x6ff1b
// File: /workspace/github_c_makefile_star2_O3/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 0xce520(%rip), %rax     # 0x13e4b7
movq %rax, (%rsi)
leaq 0xb5d53(%rip), %rax     # 0x125cf4
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6ffc0
movq %rax, 0x18(%rsi)
orb $0x1, 0x30(%rsi)
leaq 0x229(%rip), %rax       # 0x701e4
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %rdi, %rbx
callq 0xfd4b2
movq %rax, %r14
movl $0x1, 0x10(%rax)
leaq 0xb5d0d(%rip), %rsi     # 0x125cf4
movq %rbx, %rdi
callq 0xeb125
cmpl $0x1, 0x24(%rbx)
jne 0x70006
leaq 0xb6488(%rip), %rsi     # 0x126484
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9393
movq %rsp, %r15
movq $0x1, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %ebp
movl %ebp, %edx
shrl $0x4, %edx
leaq 0xb648d(%rip), %rsi     # 0x1264b8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
andl $0xf, %ebp
leaq 0xb648c(%rip), %rsi     # 0x1264cb
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
incq (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %edx
leaq 0xc0012(%rip), %rsi     # 0x130076
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeebeb
leaq 0xc2881(%rip), %rsi     # 0x132906
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq $0x8, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeebeb
movq %rax, 0x20(%r14)
leaq 0xa4688(%rip), %rsi     # 0x114737
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
leaq 0xa6ce0(%rip), %rdx     # 0x116da3
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x4, %ecx
movq %r15, %r8
callq 0xfd638
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, %r12
leaq 0xb63f0(%rip), %rsi     # 0x1264de
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %r13
subq %r12, %r13
movq %r15, %rsi
callq 0xeebeb
leaq 0xb63de(%rip), %rsi     # 0x1264f3
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x30, %ecx
callq 0xeb97d
movzwl %ax, %edx
leaq 0xb63dc(%rip), %rsi     # 0x12651b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeebeb
leaq 0xb63e5(%rip), %rsi     # 0x126545
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movl $0x16, %edx
xorl %esi, %esi
movl $0x30, %ecx
callq 0xeb97d
xorl $0x5555, %eax           # imm = 0x5555
leaq 0xb63e0(%rip), %rsi     # 0x12656d
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq (%r15), %rdx
movq %r12, %rcx
subq %rdx, %rcx
leaq 0xc78d2(%rip), %rsi     # 0x137a7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
leaq 0xb63dd(%rip), %rsi     # 0x126597
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd4cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeead3
cmpb $0x21, %al
jne 0x7027d
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xeead3
testb %al, %al
jne 0x7027d
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xeed61
cmpq $0x18, %rax
jl 0x7027d
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jge 0x7027d
movl $0x16, %esi
callq 0xeebc8
movq %rax, %r15
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
movl $0x16, %edx
xorl %esi, %esi
movl $0x30, %ecx
callq 0xeb97d
xorl %r15d, %eax
cmpl $0x5555, %eax           # imm = 0x5555
jne 0x7027d
leaq 0xce253(%rip), %rsi     # 0x13e4b7
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
movl $0x32, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb5a73(%rip), %rax     # 0x125d00
movq %rax, (%rsi)
leaq 0xb5a6d(%rip), %rax     # 0x125d04
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x702b2
movq %rax, 0x18(%rsi)
leaq 0x29a(%rip), %rax       # 0x70547
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb57a2(%rip), %rax     # 0x125d16
movq %rax, (%rsi)
leaq 0xb579c(%rip), %rax     # 0x125d1a
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x7059d
movq %rax, 0x18(%rsi)
orb $0x20, 0x30(%rsi)
leaq 0x301(%rip), %rax       # 0x70899
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb5452(%rip), %rax     # 0x125d26
movq %rax, (%rsi)
leaq 0xb5452(%rip), %rax     # 0x125d30
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x708f9
movq %rax, 0x18(%rsi)
leaq 0x55b(%rip), %rax       # 0x70e4f
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb4ec8(%rip), %rax     # 0x125d3a
movq %rax, (%rsi)
leaq 0xb4ec7(%rip), %rax     # 0x125d43
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x70e97
movq %rax, 0x18(%rsi)
leaq 0x392(%rip), %rax       # 0x71224
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeead3
cmpb $0x1, %al
jne 0x71344
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xeead3
cmpb $0x1, %al
jne 0x71344
movq 0x18(%rbx), %rdi
movl $0x12, %esi
callq 0xeead3
cmpb $0x1, %al
ja 0x71344
movl $0xb, %r12d
xorl %r13d, %r13d
movq 0x18(%rbx), %rdi
subq $0x1, %r12
jb 0x712b3
leaq 0x1(%r13), %r15
movq %r15, %rsi
callq 0xeead3
xorl %r14d, %r14d
cmpb $0x20, %al
jb 0x71344
testq %r13, %r13
sete %cl
cmpb $0x20, %al
sete %al
movq %r15, %r13
testb %al, %cl
je 0x7127b
jmp 0x71344
movl $0xd, %esi
callq 0xeead3
decb %al
xorl %r14d, %r14d
cmpb $-0x2, %al
jb 0x71344
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xeed0d
movq %rax, %r15
andl $0xffffff, %r15d        # imm = 0xFFFFFF
leaq 0x13(%r15), %rsi
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rsi
jge 0x71344
callq 0xeead3
testb %al, %al
je 0x7130b
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x71344
addq $0x27, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%rax), %r15
jg 0x71344
leaq 0xae250(%rip), %rsi     # 0x11f562
movq %rbx, %rdi
callq 0xea491
movl $0x4b, %r14d
testl %eax, %eax
jne 0x71344
leaq 0xd08cd(%rip), %rsi     # 0x141bf8
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
movl $0xf, %eax
movl $0x4b, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7137d
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0x1009eb
jne 0x7139c
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xfa510
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xfa311
// File: /workspace/github_c_makefile_star2_O3/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 0x713f7
cmpl $0x1, %ecx
jne 0x71414
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 0x102400
addq $0x18, %rsp
retq
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xfa510
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xfa311
// File: /workspace/github_c_makefile_star2_O3/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 0x71a64
cmpl $0x1, %ecx
jne 0x71a81
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 0x102400
addq $0x18, %rsp
retq
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xfa510
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xfa311
// File: /workspace/github_c_makefile_star2_O3/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 0xeead3
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x1, %cl
ja 0x71ac7
movq 0x18(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0xeead3
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_O3/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
movl $0xd, %esi
callq 0xeead3
xorl %ebx, %ebx
testb %al, %al
je 0x71b70
movzbl %al, %eax
cmpl $0x74, %eax
jne 0x71bf0
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
testb %al, %al
jne 0x71bf0
movq 0x18(%r14), %rdi
movl $0x10, %esi
callq 0xeead3
cmpb $0x74, %al
jne 0x71bf0
movq 0x18(%r14), %rdi
movl $0x38, %esi
callq 0xeead3
testb %al, %al
je 0x71bf0
movq 0x18(%r14), %rdi
movl $0x4c, %esi
callq 0xeed61
testq %rax, %rax
je 0x71b66
movl $0x68, %esi
movq %r14, %rdi
callq 0x71a8f
testl %eax, %eax
je 0x71bf0
movl $0x1, %ebx
jmp 0x71bf0
movq 0x18(%r14), %rdi
movl $0xe, %esi
callq 0xeebc8
cmpq $0x74, %rax
jne 0x71bf0
movq 0x18(%r14), %rdi
movl $0x12, %esi
callq 0xeebc8
cmpl $0x74, %eax
je 0x71bba
cmpl $0x75, %eax
jne 0x71bf0
movb $0x1, (%r15)
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xeead3
movl $0x2, %ebx
testb %al, %al
je 0x71bf0
movb $0x1, (%r15)
jmp 0x71bf0
movq 0x18(%r14), %rdi
movl $0x3a, %esi
callq 0xeead3
testb %al, %al
je 0x71bf0
movq 0x18(%r14), %rdi
movl $0xc2, %esi
callq 0xeed61
testq %rax, %rax
je 0x71ba0
movl $0xe2, %esi
movq %r14, %rdi
callq 0x71a8f
testl %eax, %eax
jne 0x71ba0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeeb4b
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 0xefbd7
movq 0x58(%r13), %rdi
callq 0xf70f6
leaq 0xca0f5(%rip), %rsi     # 0x13bd4e
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
addq %rbx, (%r15)
movq %r13, %rdi
movq %r15, %rsi
callq 0xfd538
movq %r13, %rdi
movq %r15, %rsi
callq 0xfd57d
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xeed83
movq %r13, %rdi
movl %eax, %esi
callq 0xfd5bd
movq 0x50(%r13), %rsi
addq $0x18, %rsi
leaq 0xa6531(%rip), %rdx     # 0x1181d6
movq %rbp, %rdi
movl $0x4, %ecx
movq %r15, %r8
callq 0xfd638
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xeebeb
movq %rax, %rbx
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xeebeb
leaq 0xb46af(%rip), %rsi     # 0x126388
movq %r12, %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xeebeb
movq %rax, %rbx
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xeebeb
leaq 0xb4691(%rip), %rsi     # 0x12639c
movq %r12, %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xeed83
movl %eax, 0x48(%r13)
leaq 0xd2534(%rip), %rsi     # 0x144265
movq %r12, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
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_O3/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 %rsi, (%rsp)
testq %rdx, %rdx
jle 0x71e01
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
movl $0xffffffa9, %eax       # imm = 0xFFFFFFA9
xorl %r14d, %r14d
movq %rsp, %r13
leaq 0x27(%rax), %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0xeeb4b
movzbl %al, %eax
movl %eax, %edx
addb $-0x30, %dl
movq %rbp, %rcx
cmpb $0xa, %dl
jb 0x71deb
leal -0x61(%rax), %edx
movl $0xffffffa9, %ecx       # imm = 0xFFFFFFA9
cmpb $0x6, %dl
jae 0x71dfb
addl %eax, %ecx
shlq $0x4, %r14
orq %rcx, %r14
decq %r15
jne 0x71dc3
jmp 0x71e04
movl $0x1, (%rbx)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq