LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jbf.c
// Function: de_module_jbf
void de_module_jbf(deark *c, struct deark_module_info *mi)
{
	mi->id = "jbf";
	mi->desc = "PaintShop Pro Browser Cache (pspbrwse.jbf)";
	mi->run_fn = de_run_jbf;
	mi->identify_fn = de_identify_jbf;
}

// Assembly:
leaq 0xaa96d(%rip), %rax     # 0x12a3b0
movq %rax, (%rsi)
leaq 0xaa967(%rip), %rax     # 0x12a3b4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x7fa68
movq %rax, 0x18(%rsi)
leaq 0x8cd(%rip), %rax       # 0x80330
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jovianvi.c
// Function: de_module_jovianvi
void de_module_jovianvi(deark *c, struct deark_module_info *mi)
{
	mi->id = "jovianvi";
	mi->desc = "Jovian Logic VI";
	mi->run_fn = de_run_jovianvi;
	mi->identify_fn = de_identify_jovianvi;
}

// Assembly:
leaq 0xaa229(%rip), %rax     # 0x12a588
movq %rax, (%rsi)
leaq 0xaa228(%rip), %rax     # 0x12a591
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x80384
movq %rax, 0x18(%rsi)
leaq 0x60d(%rip), %rax       # 0x8098c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jovianvi.c
// Function: de_identify_jovianvi
static int de_identify_jovianvi(deark *c)
{
	u8 t;

	if(dbuf_memcmp(c->infile, 0, "VI", 2)) return 0;
	t = de_getbyte(2);
	if((t>=0x10 && t<=0x11) ||
		(t>=0x20 && t<=0x23) ||
		(t>=0x30 && t<=0x31))
	{
		return 100;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xa9c00(%rip), %rdx     # 0x12a59e
xorl %ebx, %ebx
movl $0x2, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x809db
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xef0d5
movl %eax, %ecx
andb $-0x4, %cl
movl $0x64, %ebx
cmpb $0x20, %cl
je 0x809db
addb $-0x10, %al
xorl %ecx, %ecx
testb $-0x22, %al
movl $0x64, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_module_jpeg
void de_module_jpeg(deark *c, struct deark_module_info *mi)
{
	mi->id = "jpeg";
	mi->desc = "JPEG image";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_jpeg;
	mi->identify_fn = de_identify_jpeg;
}

// Assembly:
leaq 0x96e49(%rip), %rax     # 0x117838
movq %rax, (%rsi)
leaq 0xa9d47(%rip), %rax     # 0x12a740
movq %rax, 0x8(%rsi)
leaq 0x948dd(%rip), %rax     # 0x1152e1
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x80a1f
movq %rax, 0x18(%rsi)
leaq 0x9e8(%rip), %rax       # 0x81402
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_module_syberia_syj
void de_module_syberia_syj(deark *c, struct deark_module_info *mi)
{
	mi->id = "syberia_syj";
	mi->desc = "Syberia texture";
	mi->run_fn = de_run_syberia_syj;
	mi->identify_fn = de_identify_syberia_syj;
}

// Assembly:
leaq 0xa90a9(%rip), %rax     # 0x12a786
movq %rax, (%rsi)
leaq 0xa90ab(%rip), %rax     # 0x12a792
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x81702
movq %rax, 0x18(%rsi)
leaq 0x54(%rip), %rax        # 0x81751
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_run_syberia_syj
static void de_run_syberia_syj(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "jpg", NULL, 0);
	dbuf_write(outf, (const u8*)"\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49\x46", 10);
	dbuf_copy(c->infile, 0, c->infile->len, outf);
	dbuf_close(outf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb1daa(%rip), %rsi     # 0x1334ba
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r14
leaq 0xa8fd4(%rip), %rsi     # 0x12a6f7
movl $0xa, %edx
movq %rax, %rdi
callq 0xefb82
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
xorl %esi, %esi
movq %r14, %rcx
callq 0xefabc
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf0b13
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_identify_syberia_syj
static int de_identify_syberia_syj(deark *c)
{
	if(de_getu16be(0) != 0x0001) return 0;
	if(!de_input_file_has_ext(c, "syj")) return 0;
	if(dbuf_memcmp(c->infile, 8, (const void*)"\0\0\xff", 3)) {
		return 0;
	}
	if(de_getu16be(c->infile->len-2) != 0xffd9) return 0;
	return 80;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef169
cmpq $0x1, %rax
jne 0x817bd
leaq 0xa901c(%rip), %rsi     # 0x12a78e
movq %r14, %rdi
callq 0xea936
testl %eax, %eax
je 0x817bd
movq 0x18(%r14), %rdi
leaq 0xaa0a7(%rip), %rdx     # 0x12b830
movl $0x8, %esi
movl $0x3, %ecx
callq 0xf025e
testl %eax, %eax
jne 0x817bd
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rsi
addq $-0x2, %rsi
callq 0xef169
xorl %ecx, %ecx
cmpq $0xffd9, %rax           # imm = 0xFFD9
movl $0x50, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_module_esm_pix
void de_module_esm_pix(deark *c, struct deark_module_info *mi)
{
	mi->id = "esm_pix";
	mi->desc = "Esm Software PIX";
	mi->run_fn = de_run_esm_pix;
	mi->identify_fn = de_identify_esm_pix;
}

// Assembly:
leaq 0xa8fd4(%rip), %rax     # 0x12a7a2
movq %rax, (%rsi)
leaq 0xa8fd2(%rip), %rax     # 0x12a7aa
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x817f3
movq %rax, 0x18(%rsi)
leaq 0x47(%rip), %rax        # 0x81835
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_identify_esm_pix
static int de_identify_esm_pix(deark *c)
{
	if(dbuf_memcmp(c->infile, 0, (const void*)"Esm ", 4)) {
		return 0;
	}
	if(dbuf_memcmp(c->infile, 13, (const void*)"PIX ", 4)) {
		return 0;
	}
	if((UI)de_getu16be(21) != 0xffd8) return 0;
	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xa9fb1(%rip), %rdx     # 0x12b7f8
xorl %ebx, %ebx
movl $0x4, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x81894
movq 0x18(%r14), %rdi
leaq 0xa9f99(%rip), %rdx     # 0x12b7fd
movl $0xd, %esi
movl $0x4, %ecx
callq 0xf025e
testl %eax, %eax
jne 0x81894
movq 0x18(%r14), %rdi
movl $0x15, %esi
callq 0xef169
xorl %ecx, %ecx
cmpl $0xffd8, %eax           # imm = 0xFFD8
movl $0x64, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_module_pegasus_pic2
void de_module_pegasus_pic2(deark *c, struct deark_module_info *mi)
{
	mi->id = "pegasus_pic2";
	mi->desc = "Pegasus PIC2";
	mi->run_fn = de_run_pegasus_pic2;
	mi->identify_fn = de_identify_pegasus_pic2;
}

// Assembly:
leaq 0xa8f16(%rip), %rax     # 0x12a7bb
movq %rax, (%rsi)
leaq 0xa8f19(%rip), %rax     # 0x12a7c8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x818ca
movq %rax, 0x18(%rsi)
leaq 0x227(%rip), %rax       # 0x81aec
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_run_pegasus_pic2
static void de_run_pegasus_pic2(deark *c, de_module_params *mparams)
{
	struct pic2_ctx *d = NULL;

	d = de_malloc(c, sizeof(struct pic2_ctx));
	de_declare_fmt(c, "Pegasus PIC2");
	pic2_main(c, d);
	de_free(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0xe969b
movq %rax, %r14
leaq 0xa8ed9(%rip), %rsi     # 0x12a7c8
movq %rbx, %rdi
callq 0xeb6d6
movq $0x4, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0xe958c
movq 0x8(%rsp), %rdx
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq $-0x4, %rax
cmpq %rax, %rdx
jge 0x81ad2
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
leaq 0xc40a7(%rip), %rsi     # 0x1459dd
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef14d
movzbl %al, %r15d
cmpl $0x5, %r15d
jg 0x8197b
testl %r15d, %r15d
je 0x81997
leaq 0xaa4fd(%rip), %rcx     # 0x12be69
cmpl $0x5, %r15d
jne 0x819a7
leaq 0xa9e8d(%rip), %rcx     # 0x12b806
jmp 0x819a7
cmpl $0x6, %r15d
je 0x819a0
leaq 0xaa4e1(%rip), %rcx     # 0x12be69
cmpl $0x16, %r15d
jne 0x819a7
leaq 0xa9e7c(%rip), %rcx     # 0x12b811
jmp 0x819a7
leaq 0xa9e64(%rip), %rcx     # 0x12b802
jmp 0x819a7
leaq 0xb5a96(%rip), %rcx     # 0x13743d
movq %rbx, %rdi
leaq 0x90d71(%rip), %rsi     # 0x112722
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
testl %r15d, %r15d
je 0x81ad2
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef3a0
movq %rax, %rbp
movq 0x8(%rsp), %r13
movq %rbx, %rdi
leaq 0xc3a0a(%rip), %rsi     # 0x1453ec
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
movq %r13, %rax
addq %rbp, %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x81ad2
cmpl $0x6, %r15d
je 0x81a2e
cmpl $0x5, %r15d
jne 0x81a84
movl $0x3, %ecx
movq %r13, %rsi
leaq 0xa8e9a(%rip), %rdx     # 0x12a8b5
callq 0xf025e
testl %eax, %eax
jne 0x81a28
movb $0x1, (%r14)
cmpl $0x6, %r15d
jne 0x81a84
cmpb $0x0, (%r14)
je 0x81aa6
movq %rbx, %rdi
leaq 0xa9ddc(%rip), %rsi     # 0x12b81a
movq %r13, %rdx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%rbx), %rcx
movq %rbx, %rdi
leaq 0x95dd5(%rip), %rsi     # 0x117838
leaq 0xbf5dd(%rip), %rdx     # 0x141047
movq %r13, %r8
movq %rbp, %r9
callq 0xea66a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
jmp 0x81aa6
movq 0x18(%rbx), %rsi
movl $0x1, (%rsp)
movl $0x100, %r8d            # imm = 0x100
movq %rbx, %rdi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r9d, %r9d
callq 0xe975a
addq %rbp, 0x8(%rsp)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
movq 0x8(%rsp), %rdx
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq $-0x4, %rax
cmpq %rax, %rdx
jl 0x8192c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9752
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: de_identify_pegasus_pic2
static int de_identify_pegasus_pic2(deark *c)
{
	UI n;
	u8 b;

	n = (UI)de_getu32be(0);
#define CODE_PIC2 0x50494332U
	if(n!=CODE_PIC2) return 0;
	b = de_getbyte(4); // segment type, expecting 1
	if(b!=1) return 0;
	n = (UI)de_getu32le(5); // segment len, expecting 8
	if(n<4 || n>32) return 0;
	return 87;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef32a
cmpl $0x50494332, %eax       # imm = 0x50494332
jne 0x81b37
movq 0x18(%r14), %rdi
movl $0x4, %esi
callq 0xef0d5
cmpb $0x1, %al
jne 0x81b37
movq 0x18(%r14), %rdi
movl $0x5, %esi
callq 0xef37e
addl $-0x21, %eax
xorl %ecx, %ecx
cmpl $-0x1d, %eax
movl $0x57, %ebx
cmovbl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: do_afcp_segment
static void do_afcp_segment(deark *c, lctx *d, i64 endpos)
{
	d->has_afcp = 1;
	de_dbg(c, "AFCP segment found at end of file");

	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice(c, "afcp", NULL, c->infile, 0, endpos);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movb $0x1, 0x9(%rsi)
leaq 0xa9b1c(%rip), %rsi     # 0x12b672
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%r14), %rcx
leaq 0x92830(%rip), %rsi     # 0x1143a5
movq %r14, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0xea5fa
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9585
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: handler_dac
static void handler_dac(deark *c, lctx *d,
	const struct marker_info *mi, i64 pos1, i64 data_size)
{
	i64 ntables;
	i64 i;
	u8 b;
	u8 cs;
	u8 table_class;
	u8 table_id;

	ntables = data_size/2;
	for(i=0; i<ntables; i++) {
		b = de_getbyte(pos1+i*2);
		table_class = b>>4;
		table_id = b&0x0f;
		de_dbg(c, "table: %s%u", table_class==0?"DC":"AC",
			(unsigned int)table_id);
		cs = de_getbyte(pos1+i*2+1);
		de_dbg_indent(c, 1);
		de_dbg(c, "conditioning value: %d", (int)cs);
		de_dbg_indent(c, -1);
	}
}

// Assembly:
cmpq $0x2, %r8
jl 0x83e12
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq %r8, %r13
shrq $0x3f, %r13
addq %r8, %r13
sarq %r13
leaq 0xa6cb6(%rip), %r15     # 0x12aa3b
leaq 0xa6cbb(%rip), %r12     # 0x12aa47
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xef0d5
movl %eax, %ecx
andb $0xf, %cl
cmpb $0x10, %al
leaq 0xa6b14(%rip), %rdx     # 0x12a8ba
leaq 0x9750e(%rip), %rax     # 0x11b2bb
cmovbq %rax, %rdx
movzbl %cl, %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%r14), %rdi
leaq 0x1(%rbx), %rsi
callq 0xef0d5
movl %eax, %ebp
movq %r14, %rdi
movl $0x1, %esi
callq 0xe9585
movzbl %bpl, %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
addq $0x2, %rbx
decq %r13
jne 0x83d8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: handler_sos
static void handler_sos(deark *c, lctx *d,
	const struct marker_info *mi, i64 pos, i64 data_size)
{
	i64 ncomp;
	i64 i;
	u8 cs;
	u8 b;
	u8 ss, se, ax;
	u8 actable, dctable;

	if(data_size<1) goto done;

	d->scan_count++;
	ncomp = (i64)de_getbyte(pos);
	de_dbg(c, "number of components in scan: %d", (int)ncomp);
	if(data_size < 4 + 2*ncomp) goto done;

	for(i=0; i<ncomp; i++) {
		cs = de_getbyte(pos+1+i*2);
		de_dbg(c, "component #%d id: %d", (int)i, (int)cs);
		de_dbg_indent(c, 1);
		b = de_getbyte(pos+1+i*2+1);
		dctable = b>>4;
		actable = b&0x0f;
		de_dbg(c, "tables to use: DC%d, AC%d", (int)dctable, (int)actable);
		de_dbg_indent(c, -1);
	}

	ss = de_getbyte(pos+1+ncomp*2);
	se = de_getbyte(pos+1+ncomp*2+1);
	ax = de_getbyte(pos+1+ncomp*2+2);
	de_dbg(c, "spectral selection start/end: %d, %d", (int)ss, (int)se);
	de_dbg(c, "successive approx. bit pos high/low: %u, %u",
		(unsigned int)(ax>>4), (unsigned int)(ax&0x0f));

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %r8, %r8
jle 0x83e63
movq %r8, %r14
movq %rcx, %r12
movq %rdi, %rbx
incl 0x24(%rsi)
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xef0d5
movzbl %al, %r15d
leaq 0xa6c15(%rip), %rsi     # 0x12aa5e
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
leal (%r15,%r15), %ecx
leaq 0x4(%rcx), %rax
cmpq %r14, %rax
jle 0x83e72
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, 0x10(%rsp)
movq %r12, 0x8(%rsp)
testq %r15, %r15
je 0x83f0c
movq 0x8(%rsp), %rax
leaq 0x2(%rax), %r12
leaq 0xa6bea(%rip), %r13     # 0x12aa7f
leaq 0xa6bf8(%rip), %rbp     # 0x12aa94
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0xef0d5
movzbl %al, %ecx
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef0d5
movl %eax, %ecx
shrb $0x4, %cl
andb $0xf, %al
movzbl %cl, %edx
movzbl %al, %ecx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
incq %r14
addq $0x2, %r12
cmpq %r14, %r15
jne 0x83e9f
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
leaq (%r15,%r12), %rsi
incq %rsi
callq 0xef0d5
movl %eax, %ebp
movq 0x18(%rbx), %rdi
leaq (%r15,%r12), %rsi
addq $0x2, %rsi
callq 0xef0d5
movl %eax, %r14d
movq 0x18(%rbx), %rdi
leaq (%r15,%r12), %rsi
addq $0x3, %rsi
callq 0xef0d5
movl %eax, %r15d
movzbl %bpl, %edx
movzbl %r14b, %ecx
leaq 0xa6b4f(%rip), %rsi     # 0x12aaae
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movzbl %r15b, %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0xf, %ecx
leaq 0xa6b57(%rip), %rsi     # 0x12aad3
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9226
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: handler_dri
static void handler_dri(deark *c, lctx *d,
	const struct marker_info *mi, i64 pos, i64 data_size)
{
	i64 ri;
	if(data_size!=2) return;
	ri = de_getu16be(pos);
	de_dbg(c, "restart interval: %d", (int)ri);
	if(ri!=0) d->has_restart_markers = 1;
}

// Assembly:
cmpq $0x2, %r8
jne 0x841c5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xef169
movq %rax, %r15
leaq 0xa6987(%rip), %rsi     # 0x12ab31
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
testq %r15, %r15
je 0x841c0
movb $0x1, 0x1b(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: handler_jpg8
static void handler_jpg8(deark *c, lctx *d,
	const struct marker_info *mi, i64 seg_data_pos, i64 seg_data_size)
{
	u8 id;
	const char *name = "?";

	if(seg_data_size<1) return;
	id = de_getbyte(seg_data_pos);
	if(id==0x0d) {
		d->has_revcolorxform = 1;
		name="inverse color transform specification";
	}
	de_dbg(c, "id: 0x%02x (%s)", (unsigned int)id, name);
}

// Assembly:
testq %r8, %r8
jle 0x841f7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xef0d5
movzbl %al, %edx
cmpb $0xd, %dl
jne 0x841f8
movb $0x1, 0x1f(%r14)
leaq 0xa6951(%rip), %rcx     # 0x12ab46
jmp 0x841ff
retq
leaq 0xa7c6a(%rip), %rcx     # 0x12be69
leaq 0xa6966(%rip), %rsi     # 0x12ab6c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9226
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: handler_com
static void handler_com(deark *c, lctx *d,
	const struct marker_info *mi, i64 pos, i64 data_size)
{
	// Note that a JPEG COM-segment comment is an arbitrary sequence of bytes, so
	// there's no way to know what text encoding it uses, or even whether it is text.
	// We'll use the user's "-inenc" encoding, or DE_ENCODING_UNKNOWN by default.
	handle_comment(c, d, pos, data_size, c->input_encoding);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
movl 0x90(%rdi), %r13d
movl 0xfc(%rdi), %eax
cmpl $0x1, %r13d
jg 0x84257
testq %r15, %r15
jle 0x84248
cmpl $0x0, (%rbx)
jg 0x8425c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
jle 0x84248
cmpl $0x2, %r13d
setl %cl
testl %eax, %eax
setne %dl
orb %cl, %dl
jne 0x84293
movq 0x18(%rbx), %rdi
leaq 0x94184(%rip), %rcx     # 0x1183fb
xorl %r14d, %r14d
movq %r12, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xf0321
jmp 0x84318
testl %eax, %eax
movl $0x401, %ebp            # imm = 0x401
cmovnel %eax, %ebp
movq %rbx, %rdi
callq 0xf6870
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0xf01b0
cmpl $0x2, %r13d
jl 0x842fc
leaq 0x9412e(%rip), %rsi     # 0x1183fb
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xf037a
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0xf71f7
movq %r15, %rdi
callq 0xf0b13
jmp 0x84318
movq %r14, %rdi
callq 0xf7557
leaq 0x9049a(%rip), %rsi     # 0x1147a5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6bb0
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: do_jpeghdr_segment
static void do_jpeghdr_segment(deark *c, lctx *d, i64 pos1,
	i64 data_size1, int is_ext)
{
	int ret;
	i64 pos = 0;
	i64 data_size;

	// Payload should begin after the first NUL byte. Search for it.
	ret = dbuf_search_byte(c->infile, 0x00, pos1, data_size1, &pos);
	if(!ret) {
		de_warn(c, "Bad or unsupported JPEG-HDR data");
		return;
	}
	pos++;
	data_size = pos1+data_size1 - pos;

	if(is_ext) {
		de_dbg(c, "JPEG-HDR residual image continuation, pos=%d size=%d",
			(int)pos, (int)data_size);
	}
	else {
		de_dbg(c, "JPEG-HDR residual image start, pos=%d size=%d",
			(int)pos, (int)data_size);

		// Close any previous file
		if(d->hdr_residual_file) {
			dbuf_close(d->hdr_residual_file);
			d->hdr_residual_file = NULL;
		}

		// Make sure it looks like an embedded JPEG file
		if(dbuf_memcmp(c->infile, pos, "\xff\xd8", 2)) {
			de_warn(c, "Bad or unsupported JPEG-HDR format");
			return;
		}

		d->hdr_residual_file = dbuf_create_output_file(c, "residual.jpg", NULL, DE_CREATEFLAG_IS_AUX);
	}

	if(!d->hdr_residual_file) return;
	dbuf_copy(c->infile, pos, data_size, d->hdr_residual_file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r8
movq $0x0, (%r8)
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xf0057
testl %eax, %eax
je 0x843a9
movq (%rsp), %r15
leaq 0x1(%r15), %rdx
movq %rdx, (%rsp)
addq %r13, %r12
notq %r15
addq %r12, %r15
testl %ebp, %ebp
je 0x843b2
leaq 0xa6f00(%rip), %rsi     # 0x12b281
movq %rbx, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0xe9226
movq 0x50(%r14), %rcx
testq %rcx, %rcx
je 0x8440a
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq 0xefabc
jmp 0x8440a
leaq 0xa6eb0(%rip), %rsi     # 0x12b260
jmp 0x84400
leaq 0xa6efd(%rip), %rsi     # 0x12b2b6
movq %rbx, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0xe9226
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x843dc
callq 0xf0b13
movq $0x0, 0x50(%r14)
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
leaq 0xa6ef9(%rip), %rdx     # 0x12b2e4
movl $0x2, %ecx
callq 0xf025e
testl %eax, %eax
je 0x84419
leaq 0xa6ee7(%rip), %rsi     # 0x12b2e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9b27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa6eea(%rip), %rsi     # 0x12b30a
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xf037a
movq %rax, 0x50(%r14)
jmp 0x8438e
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: decode_app_id
static void decode_app_id(struct app_id_decode_struct *ad)
{
	i64 k;

	if(ad->nraw_bytes<2) return;
	if(ad->raw_bytes[0]<32 || ad->raw_bytes[0]>126) return;

	// Might have an app id.
	for(k=0; k<ad->nraw_bytes; k++) {
		if(ad->raw_bytes[k]==0) {
			ad->has_app_id = 1;
			ad->app_id_orig_strlen = k;
			break;
		}
	}

	if(ad->has_app_id) {
		// We'll assume this is an app id
		de_strlcpy(ad->app_id_orig, (const char*)ad->raw_bytes, sizeof(ad->app_id_orig));
		normalize_app_id(ad->app_id_orig, ad->app_id_normalized, sizeof(ad->app_id_normalized));
	}
}

// Assembly:
movq 0x50(%rdi), %rax
cmpq $0x2, %rax
jl 0x84509
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %cl
addb $-0x7f, %cl
cmpb $-0x5f, %cl
jb 0x84504
xorl %ecx, %ecx
cmpb $0x0, (%rbx,%rcx)
je 0x8446e
incq %rcx
cmpq %rcx, %rax
jne 0x8445e
jmp 0x8447f
movl $0x1, 0x100(%rbx)
movq %rcx, 0xf8(%rbx)
cmpl $0x0, 0x100(%rbx)
je 0x84504
leaq 0x58(%rbx), %r15
movl $0x50, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe8ded
leaq 0xa8(%rbx), %r14
movl $0x50, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe8ded
movq %r14, %rdi
callq 0x180e0
testq %rax, %rax
jle 0x844e1
cmpb $0x20, 0xa7(%rbx,%rax)
jne 0x844e1
movb $0x0, 0xa7(%rbx,%rax)
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x844c0
xorl %eax, %eax
testq %rax, %rax
jle 0x84504
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x844fc
addb $-0x20, %dl
movb %dl, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x844e8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: extract_unc_jfif_thumbnail
static void extract_unc_jfif_thumbnail(deark *c, lctx *d,
	i64 pos1, i64 len, i64 w, i64 h, int has_pal,
	const char *token)
{
	i64 i, j;
	i64 pos = pos1;
	de_bitmap *img = NULL;
	u32 clr;
	i64 rowspan;

	img = de_bitmap_create(c, w, h, 3);

	if(has_pal) {
		u32 pal[256];
		de_read_palette_rgb(c->infile, pos, 256, 3, pal, 256, 0);
		pos += 768;
		de_convert_image_paletted(c->infile, pos, 8, w, pal, img, 0);
	}
	else {
		rowspan = 3*w;
		for(j=0; j<h; j++) {
			for(i=0; i<w; i++) {
				clr = dbuf_getRGB(c->infile, pos + j*rowspan + i*3, 0);
				de_bitmap_setpixel_rgb(img, i, j, clr);
			}
		}
	}

	de_bitmap_write_to_file(img, token, DE_CREATEFLAG_IS_AUX);

	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %r9, 0x18(%rsp)
movl %r8d, %ebx
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rdx, %rsi
movq %rcx, %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %r14
testl %ebx, %ebx
je 0x84595
movq 0x18(%r13), %rdi
xorl %ebp, %ebp
movl %ebp, (%rsp)
leaq 0x30(%rsp), %rbx
movl $0x100, %edx            # imm = 0x100
movl $0x3, %ecx
movl $0x100, %r9d            # imm = 0x100
movq %r12, %rsi
movq %rbx, %r8
callq 0xf328f
addq $0x300, %r12            # imm = 0x300
movq 0x18(%r13), %rdi
movl %ebp, (%rsp)
movl $0x8, %edx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xf35b8
jmp 0x845fc
testq %rbp, %rbp
jle 0x845fc
leaq (%r15,%r15,2), %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
movq %rbp, 0x28(%rsp)
movq %r12, 0x10(%rsp)
testq %r15, %r15
jle 0x845e5
movq 0x10(%rsp), %r12
xorl %ebp, %ebp
movq 0x18(%r13), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xefa60
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xf2afd
incq %rbp
addq $0x3, %r12
cmpq %rbp, %r15
jne 0x845bb
incq %rbx
movq 0x10(%rsp), %r12
addq 0x20(%rsp), %r12
movq 0x28(%rsp), %rbp
cmpq %rbp, %rbx
jne 0x845aa
movq %r14, %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0xf2923
movq %r14, %rdi
callq 0xf28d4
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: destroy_fpxr_data
static void destroy_fpxr_data(deark *c, lctx *d)
{
	size_t k;
	if(!d->fpxr_data) return;

	for(k=0; k<d->fpxr_data->num_entities; k++) {
		if(d->fpxr_data->entities[k].name_srd) {
			de_destroy_stringreaderdata(c, d->fpxr_data->entities[k].name_srd);
			d->fpxr_data->entities[k].name_srd = NULL;
		}

		dbuf_close(d->fpxr_data->entities[k].stream);
		d->fpxr_data->entities[k].stream = NULL;
	}

	de_free(c, d->fpxr_data->entities);
	de_free(c, d->fpxr_data);
	d->fpxr_data = NULL;
}

// Assembly:
cmpq $0x0, 0xa8(%rsi)
je 0x846e7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rsi), %rax
cmpq $0x0, (%rax)
je 0x846b6
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rax), %rax
movq 0x8(%rax,%r15), %rsi
testq %rsi, %rsi
je 0x84681
movq %r14, %rdi
callq 0xf00aa
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax,%r15)
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax,%r15), %rdi
callq 0xf0b13
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rcx
movq $0x0, 0x10(%rcx,%r15)
incq %r12
addq $0x28, %r15
cmpq (%rax), %r12
jb 0x84657
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xe9752
movq 0xa8(%rbx), %rsi
movq %r14, %rdi
callq 0xe9752
movq $0x0, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/jpeg.c
// Function: do_ducky_stringblock
static void do_ducky_stringblock(deark *c, lctx *d,
	i64 pos1, i64 len, const char *name)
{
	i64 pos = pos1;
	i64 nchars;
	de_ucstring *s = NULL;

	if(len<4) goto done;
	nchars = de_getu32be_p(&pos);
	if(nchars*2 > len-4) goto done;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, nchars*2, DE_DBG_MAX_STRLEN, s,
		0, DE_ENCODING_UTF16BE);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));
done:
	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
cmpq $0x4, %rdx
jl 0x8495f
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x10(%rsp), %rsi
callq 0xef34e
movq %rax, %r12
addq %rax, %r12
addq $-0x4, %r15
cmpq %r15, %r12
jle 0x84964
xorl %r15d, %r15d
jmp 0x849b1
movq %r14, %rdi
callq 0xf6870
movq %rax, %r15
movq 0x18(%r14), %rdi
movq 0x10(%rsp), %rsi
movl $0x4, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rdx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %r15, %rdi
callq 0xf74bd
leaq 0xa74a1(%rip), %rsi     # 0x12be42
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9226
movq %r15, %rdi
callq 0xf6bb0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_lha
void de_module_lha(deark *c, struct deark_module_info *mi)
{
	mi->id = "lha";
	mi->desc = "LHA/LZH/PMA archive";
	mi->run_fn = de_run_lha;
	mi->identify_fn = de_identify_lha;
	mi->help_fn = de_help_lha;
}

// Assembly:
leaq 0xa6fb7(%rip), %rax     # 0x12b986
movq %rax, (%rsi)
leaq 0xa6f5f(%rip), %rax     # 0x12b938
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x849ff
movq %rax, 0x18(%rsi)
leaq 0x48(%rip), %rax        # 0x84a37
movq %rax, 0x20(%rsi)
leaq 0x1d4(%rip), %rax       # 0x84bce
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_run_lha
static void de_run_lha(deark *c, de_module_params *mparams)
{
	lctx *d;

	d = lha_create_lctx(c);
	d->basefmt = BASEFMT_LHA;
	do_run_lha_internal(c, d, mparams);
	lha_destroy_lctx(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe969b
movq %rax, %r14
movl $0x0, 0xc(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x85e79
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x86f88
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_identify_lha
static int de_identify_lha(deark *c)
{
	int has_ext = 0;
	u8 b[22];
	struct cmpr_meth_info cmi;

	de_read(b, 0, sizeof(b));
	if(b[20]>3) return 0; // header level

	if(!is_possible_cmpr_meth(&b[2])) return 0;
	if(is_swg_sig(&b[2])) return 0; // Handled by the swg module

	if(b[20]==0) {
		if(b[0]<22) return 0;
		if(22 + (int)b[21] + 2 > 2 + (int)b[0]) return 0;
	}
	else if(b[20]==1) {
		if(b[0]<25) return 0;
		if(22 + (int)b[21] + 5 > 2 + (int)b[0]) return 0;
	}
	else if(b[20]==2) {
		i64 hsize = de_getu16le_direct(&b[0]);
		if(hsize < 26) return 0;
	}
	else if(b[20]==3) {
		if((b[0]!=4 && b[0]!=8) || b[1]!=0) return 0;
	}

	de_zeromem(&cmi, sizeof(struct cmpr_meth_info));
	get_cmpr_meth_info(&b[2], BASEFMT_LHA, &cmi);
	if(!cmi.is_recognized) {
		return 0;
	}

	if(de_input_file_has_ext(c, "lzh") ||
		de_input_file_has_ext(c, "lha") ||
		((b[4]=='z') && de_input_file_has_ext(c, "lzs")))
	{
		has_ext = 1;
	}

	if(has_ext) return 100;
	return 80; // Must be less than car_lha
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
movq %rsp, %r15
movl $0x16, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xeeee8
movzbl 0x14(%r15), %ebp
cmpl $0x3, %ebp
ja 0x84b99
leaq 0x2(%rsp), %r15
movq %r15, %rdi
callq 0x87a66
testl %eax, %eax
je 0x84b99
cmpb $0x2d, 0x2(%rsp)
jne 0x84aaf
cmpb $0x73, 0x3(%rsp)
jne 0x84aaf
cmpb $0x77, 0x4(%rsp)
jne 0x84aaf
movb 0x5(%rsp), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x84aaf
cmpb $0x2d, 0x6(%rsp)
je 0x84b99
cmpl $0x3, %ebp
ja 0x84b25
movl %ebp, %eax
leaq 0xa6d83(%rip), %rcx     # 0x12b840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl (%rsp), %eax
cmpl $0x16, %eax
jb 0x84b99
movzbl 0x15(%rsp), %ecx
addl $0x18, %ecx
jmp 0x84b1e
movq %rsp, %rdi
callq 0xef1c6
cmpq $0x19, %rax
jg 0x84b25
jmp 0x84b99
movb (%rsp), %al
addb $-0x4, %al
testb $-0x5, %al
jne 0x84b99
cmpb $0x0, 0x1(%rsp)
je 0x84b25
jmp 0x84b99
movzbl (%rsp), %eax
cmpl $0x19, %eax
jb 0x84b99
movzbl 0x15(%rsp), %ecx
addl $0x1b, %ecx
addl $0x2, %eax
cmpl %eax, %ecx
ja 0x84b99
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, 0x60(%r12)
movaps %xmm0, 0x50(%r12)
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x87049
cmpb $0x0, (%r12)
je 0x84b99
leaq 0xc002e(%rip), %rsi     # 0x144ba2
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
jne 0x84b93
leaq 0xa6dff(%rip), %rsi     # 0x12b986
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
je 0x84bac
movl $0x64, %r14d
movl %r14d, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %r14d
cmpb $0x7a, 0x4(%rsp)
jne 0x84b99
leaq 0xa7678(%rip), %rsi     # 0x12c238
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
jne 0x84b93
jmp 0x84b99
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_swg
void de_module_swg(deark *c, struct deark_module_info *mi)
{
	mi->id = "swg";
	mi->desc = "SWAG packet";
	mi->run_fn = de_run_swg;
	mi->identify_fn = de_identify_swg;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xa6d69(%rip), %rax     # 0x12b94c
movq %rax, (%rsi)
leaq 0xa6d63(%rip), %rax     # 0x12b950
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x84c0c
movq %rax, 0x18(%rsi)
leaq 0x5b(%rip), %rax        # 0x84c5e
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_run_swg
static void de_run_swg(deark *c, de_module_params *mparams)
{
	lctx *d;

	d = lha_create_lctx(c);
	d->basefmt = BASEFMT_SWG;
	d->basefmt_name = "SWG";
	de_declare_fmt(c, "SWAG packet");
	do_run_lha_internal(c, d, mparams);
	lha_destroy_lctx(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe969b
movq %rax, %r14
movl $0x1, 0xc(%rax)
leaq 0xa7648(%rip), %rax     # 0x12c276
movq %rax, 0x10(%r14)
leaq 0xa6d17(%rip), %rsi     # 0x12b950
movq %rbx, %rdi
callq 0xeb6d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85e79
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x86f88
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_identify_swg
static int de_identify_swg(deark *c)
{
	u8 b[5];

	de_read(b, 2, sizeof(b));
	if(is_swg_sig(b)) {
		if(de_input_file_has_ext(c, "swg")) return 100;
		return 90;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x3(%rsp), %r14
movl $0x2, %edx
movl $0x5, %ecx
movq %r14, %rsi
callq 0xeeee8
xorl %eax, %eax
cmpb $0x2d, (%r14)
jne 0x84cc7
cmpb $0x73, 0x4(%rsp)
jne 0x84cc7
cmpb $0x77, 0x5(%rsp)
jne 0x84cc7
movb 0x6(%rsp), %cl
andb $-0x2, %cl
cmpb $0x30, %cl
jne 0x84cc7
cmpb $0x2d, 0x7(%rsp)
jne 0x84cc7
leaq 0xa6c9c(%rip), %rsi     # 0x12b94c
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0x5a, %ecx
movl $0x64, %eax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_tpk
void de_module_tpk(deark *c, struct deark_module_info *mi)
{
	mi->id = "tpk";
	mi->desc = "TPK archive";
	mi->run_fn = de_run_tpk;
	mi->identify_fn = de_identify_tpk;
}

// Assembly:
leaq 0xa6c86(%rip), %rax     # 0x12b95c
movq %rax, (%rsi)
leaq 0xa6c80(%rip), %rax     # 0x12b960
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x84cfb
movq %rax, 0x18(%rsi)
leaq 0x50(%rip), %rax        # 0x84d46
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_run_tpk
static void de_run_tpk(deark *c, de_module_params *mparams)
{
	lctx *d;

	d = lha_create_lctx(c);
	d->basefmt = BASEFMT_TPK;
	d->basefmt_name = "TPK";
	de_declare_fmt(c, "TPK");
	do_run_lha_internal(c, d, mparams);
	lha_destroy_lctx(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe969b
movq %rax, %r14
movl $0x2, 0xc(%rax)
leaq 0xa755d(%rip), %rsi     # 0x12c27a
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xeb6d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85e79
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x86f88
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_identify_tpk
static int de_identify_tpk(deark *c)
{
	u8 b[5];

	de_read(b, 2, sizeof(b));
	if(is_tpk_sig(b)) {
		if(de_input_file_has_ext(c, "tpk")) return 100;
		return 75;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x3(%rsp), %r14
movl $0x2, %edx
movl $0x5, %ecx
movq %r14, %rsi
callq 0xeeee8
xorl %eax, %eax
cmpb $0x2d, (%r14)
jne 0x84daf
cmpb $0x54, 0x4(%rsp)
jne 0x84daf
cmpb $0x4b, 0x5(%rsp)
jne 0x84daf
movb 0x6(%rsp), %cl
andb $-0x2, %cl
cmpb $0x30, %cl
jne 0x84daf
cmpb $0x2d, 0x7(%rsp)
jne 0x84daf
leaq 0xa6bc4(%rip), %rsi     # 0x12b95c
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0x4b, %ecx
movl $0x64, %eax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_pakleo
void de_module_pakleo(deark *c, struct deark_module_info *mi)
{
	mi->id = "pakleo";
	mi->desc = "PAKLEO archive";
	mi->run_fn = de_run_pakleo;
	mi->identify_fn = de_identify_pakleo;
}

// Assembly:
leaq 0xa6bae(%rip), %rax     # 0x12b96c
movq %rax, (%rsi)
leaq 0xa6bab(%rip), %rax     # 0x12b973
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x84de3
movq %rax, 0x18(%rsi)
leaq 0x50(%rip), %rax        # 0x84e2e
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_run_pakleo
static void de_run_pakleo(deark *c, de_module_params *mparams)
{
	lctx *d;

	d = lha_create_lctx(c);
	d->basefmt = BASEFMT_PAKLEO;
	d->basefmt_name = "PAKLEO";
	de_declare_fmt(c, "PAKLEO");
	do_run_lha_internal(c, d, mparams);
	lha_destroy_lctx(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe969b
movq %rax, %r14
movl $0x3, 0xc(%rax)
leaq 0xa7479(%rip), %rsi     # 0x12c27e
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xeb6d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85e79
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x86f88
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_car_lha
void de_module_car_lha(deark *c, struct deark_module_info *mi)
{
	mi->id = "car_lha";
	mi->desc = "CAR (MylesHi!) LHA-like archive";
	mi->run_fn = de_run_car_lha;
	mi->identify_fn = de_identify_car_lha;
}

// Assembly:
leaq 0xa6af9(%rip), %rax     # 0x12b982
movq %rax, (%rsi)
leaq 0xa6af7(%rip), %rax     # 0x12b98a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x84eae
movq %rax, 0x18(%rsi)
leaq 0x395(%rip), %rax       # 0x8523e
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_arx
void de_module_arx(deark *c, struct deark_module_info *mi)
{
	mi->id = "arx";
	mi->desc = "ARX LHA-like archive";
	mi->run_fn = de_run_arx;
	mi->identify_fn = de_identify_arx;
}

// Assembly:
leaq 0xa6735(%rip), %rax     # 0x12b9aa
movq %rax, (%rsi)
leaq 0xa672f(%rip), %rax     # 0x12b9ae
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x8529a
movq %rax, 0x18(%rsi)
leaq 0x4d4(%rip), %rax       # 0x85769
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_identify_arx
static int de_identify_arx(deark *c)
{
	if(dbuf_memcmp(c->infile, 2, "-lh1-", 5)) return 0;
	if(de_getbyte(20)!=0x20 || de_getbyte(21)!=0x00) return 0;
	if(de_input_file_has_ext(c, "arx")) return 100;
	return 70;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xa6bcd(%rip), %rdx     # 0x12c347
movl $0x2, %esi
movl $0x5, %ecx
callq 0xf025e
xorl %ebp, %ebp
testl %eax, %eax
jne 0x857d1
movq 0x18(%rbx), %rdi
movl $0x14, %esi
callq 0xef0d5
cmpb $0x20, %al
jne 0x857d1
movq 0x18(%rbx), %rdi
movl $0x15, %esi
callq 0xef0d5
testb %al, %al
jne 0x857d1
leaq 0xa61f0(%rip), %rsi     # 0x12b9aa
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0x46, %eax
movl $0x64, %ebp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_ar001
void de_module_ar001(deark *c, struct deark_module_info *mi)
{
	mi->id = "ar001";
	mi->desc = "ar001 archive (Okumura)";
	mi->run_fn = de_run_ar001;
	mi->identify_fn = de_identify_ar001;
}

// Assembly:
leaq 0xa61e2(%rip), %rax     # 0x12b9c3
movq %rax, (%rsi)
leaq 0xa61de(%rip), %rax     # 0x12b9c9
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x85806
movq %rax, 0x18(%rsi)
leaq 0x3c8(%rip), %rax       # 0x85bc9
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_identify_ar001
static int de_identify_ar001(deark *c)
{
	i64 n;
	i64 bhlen;
	i64 nlen;
	u32 bhcrc_r, bhcrc_c;
	u8 b;
	int conf = 0;
	struct de_crcobj *crco = NULL;

	bhlen = de_getu16le(0); // basic header size
	if(bhlen<(18+1) || bhlen>(18+1024)) goto done;
	if(c->infile->len < bhlen+8) goto done;
	nlen = bhlen-18;
	n = de_getu16le(2); // cmpr method
	if(n>1) goto done;
	b = de_getbyte(4); // file type
	if(b!=0) goto done; // 1 (text) is also defined, but not used by ar001
	n = de_getu16le(2+bhlen+2); // first ext hdr len
	if(n!=0) goto done;
	if(!slice_is_printable_ascii(c->infile, 20, nlen)) goto done;
	bhcrc_r = (u32)de_getu16le(2+bhlen);
	crco = de_crcobj_create(c, DE_CRCOBJ_CRC16_IBMSDLC);
	de_crcobj_addslice(crco, c->infile, 2, bhlen);
	bhcrc_c = de_crcobj_getval(crco);
	if(bhcrc_c == bhcrc_r) conf = 91;

done:
	if(crco) de_crcobj_destroy(crco);
	return conf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0xef1ca
movq %rax, %r14
addq $-0x413, %rax           # imm = 0xFBED
movl $0x0, %r12d
cmpq $-0x400, %rax           # imm = 0xFC00
jb 0x85c42
movq 0x18(%rbx), %rdi
leaq 0x8(%r14), %rax
cmpq %rax, 0x18(%rdi)
jl 0x85c3c
movl $0x2, %esi
callq 0xef1ca
cmpq $0x1, %rax
jg 0x85c3c
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef0d5
testb %al, %al
jne 0x85c3c
movq 0x18(%rbx), %rdi
leaq 0x4(%r14), %rsi
callq 0xef1ca
testq %rax, %rax
je 0x85c5c
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %r12, %r12
je 0x85c4f
movq %r12, %rdi
callq 0xebe1d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x13, %r14
jl 0x85c96
movq 0x18(%rbx), %r15
movl $0x12, %r13d
subq %r14, %r13
movl $0x14, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0xef0d5
addb $-0x20, %al
cmpb $0x5f, %al
jae 0x85c3c
leaq (%r12,%r13), %rax
incq %rax
incq %r12
cmpq $0x14, %rax
jne 0x85c75
movq %r14, %rsi
addq $0x2, %rsi
movq 0x18(%rbx), %rdi
callq 0xef1ca
movq %rax, %r15
movq %rbx, %rdi
movl $0x22, %esi
callq 0xeba56
movq %rax, %r12
movq 0x18(%rbx), %rsi
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rcx
callq 0xebf09
movq %r12, %rdi
callq 0xebe2a
xorl %ecx, %ecx
cmpl %r15d, %eax
movl $0x5b, %r15d
cmovnel %ecx, %r15d
jmp 0x85c42
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_module_lharc_sfx_com
void de_module_lharc_sfx_com(deark *c, struct deark_module_info *mi)
{
	mi->id = "lharc_sfx_com";
	mi->desc = "LHarc/LArc self-extracting archive (COM)";
	mi->run_fn = de_run_lharc_sfx_com;
	mi->identify_fn = de_identify_lharc_sfx_com;
}

// Assembly:
leaq 0xa5cf1(%rip), %rax     # 0x12b9e1
movq %rax, (%rsi)
leaq 0xa5cf5(%rip), %rax     # 0x12b9ef
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x85d15
movq %rax, 0x18(%rsi)
leaq 0x138(%rip), %rax       # 0x85e48
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_run_lharc_sfx_com
static void de_run_lharc_sfx_com(deark *c, de_module_params *mparams)
{
	struct lhasfx_context *d = NULL;
	int ret;

	d = de_malloc(c, sizeof(struct lhasfx_context));

	ret = looks_like_lharc_sfx_com(c, &d->sfx_container_is_larc);
	if(!ret) {
		d->errflag = 1;
		d->need_errmsg = 1;
		goto done;
	}

	de_declare_fmtf(c, "%s self-extracting archive (COM)",
		(d->sfx_container_is_larc ? "LArc":"LHarc"));

	lhasfx_find_payload(c, d);
	if(d->errflag) goto done;

	de_dbg(c, "payload found at: %"I64_FMT, d->payload_offs);

	// Note: Our practice is to use the .lzh extension if we think the file
	// is for the DOS platform, as it was near universal there.
	// If we were to support certain other platforms, e.g. Amiga, we might
	// use .lha instead.
	dbuf_create_file_from_slice(c->infile, d->payload_offs,
		c->infile->len-d->payload_offs,
		(d->sfx_container_is_larc ? "lzs" : "lzh"), NULL, 0);

done:
	if(d->errflag && d->need_errmsg) {
		de_err(c, "Not a known LHarc/LArc SFX format");
	}
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x10, %esi
callq 0xe969b
movq %rax, %r15
movq %rax, %r14
leaq 0x4(%rax), %rsi
movq %rbx, %rdi
callq 0x885cd
testl %eax, %eax
je 0x85d82
cmpl $0x0, 0x4(%r14)
leaq 0xa66df(%rip), %rax     # 0x12c428
leaq 0xa66d3(%rip), %rdx     # 0x12c423
cmoveq %rax, %rdx
leaq 0xa66a7(%rip), %rsi     # 0x12c402
movq %rbx, %rdi
xorl %eax, %eax
callq 0xeb703
addq $0x8, %r15
cmpl $0x0, 0x4(%r14)
movl $0x252, %esi            # imm = 0x252
je 0x85d8d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x88678
jmp 0x85db9
movw $0x101, (%r14)          # imm = 0x101
jmp 0x85e10
movl $0x4ec, %esi            # imm = 0x4EC
movq %rbx, %rdi
movq %r15, %rdx
callq 0x88678
testl %eax, %eax
jne 0x85db9
movl $0x4ef, %esi            # imm = 0x4EF
movq %rbx, %rdi
movq %r15, %rdx
callq 0x88678
testl %eax, %eax
je 0x85e3e
movq 0x8(%r14), %rdx
testq %rdx, %rdx
jne 0x85dc8
movw $0x101, (%r14)          # imm = 0x101
cmpb $0x0, (%r14)
jne 0x85e10
leaq 0xa6659(%rip), %rsi     # 0x12c42e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
movq 0x18(%rdi), %rdx
subq %rsi, %rdx
cmpl $0x0, 0x4(%r14)
leaq 0xbeda8(%rip), %rax     # 0x144ba2
leaq 0xa6437(%rip), %rcx     # 0x12c238
cmoveq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf0321
cmpb $0x0, (%r14)
je 0x85e2e
cmpb $0x0, 0x1(%r14)
je 0x85e2e
leaq 0xa6620(%rip), %rsi     # 0x12c444
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe9752
movl $0x50a, %esi            # imm = 0x50A
jmp 0x85d75
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: de_identify_lharc_sfx_com
static int de_identify_lharc_sfx_com(deark *c)
{
	int is_larc = 0;
	int ret;

	if(c->infile->len>65280) return 0;
	ret = looks_like_lharc_sfx_com(c, &is_larc);
	if(ret) return 70;
	return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq $0xff00, 0x18(%rcx)     # imm = 0xFF00
jg 0x85e77
leaq 0x4(%rsp), %rsi
callq 0x885cd
movl %eax, %ecx
testl %eax, %eax
movl $0x46, %eax
cmovel %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: lha_destroy_lctx
static void lha_destroy_lctx(deark *c, lctx *d)
{
	if(!d) return;
	de_crcobj_destroy(d->crco);
	de_crcobj_destroy(d->crco_cksum);
	de_free(c, d);
}

// Assembly:
testq %rsi, %rsi
je 0x86fbb
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rdi
callq 0xebe1d
movq 0x30(%rbx), %rdi
callq 0xebe1d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9752
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/lha.c
// Function: destroy_member_data
static void destroy_member_data(deark *c, struct member_data *md)
{
	if(!md) return;
	ucstring_destroy(md->dirname);
	ucstring_destroy(md->filename);
	ucstring_destroy(md->fullfilename);
	de_free(c, md->cmi);
	de_free(c, md);
}

// Assembly:
testq %rsi, %rsi
je 0x87004
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rsi), %rdi
callq 0xf6bb0
movq 0x70(%rbx), %rdi
callq 0xf6bb0
movq 0x78(%rbx), %rdi
callq 0xf6bb0
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xe9752
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9752
retq