LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xdecaf
movq %rax, 0x10(%rsp)
leaq 0xa10fe(%rip), %rsi     # 0x11d828
movq %rbx, %rdi
callq 0xe07f7
leaq 0x18(%rsp), %r15
movq $0x4, (%r15)
leaq 0x24(%rsp), %rsi
movq %rbx, %rdi
callq 0xdebae
pushq $0x4
popq %rdx
pushq $0x1
popq %rbp
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq $-0x4, %rax
cmpq %rax, %rdx
jge 0x7c8e3
movq %rbx, %rdi
leaq 0xbc32d(%rip), %rsi     # 0x138a9d
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
movl %ebp, %esi
callq 0xdeba7
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe3f2a
movzbl %al, %r12d
cmpb $0x16, %r12b
je 0x7c7ca
cmpl $0x5, %r12d
je 0x7c7b8
cmpl $0x6, %r12d
je 0x7c7c1
leaq 0xa2737(%rip), %rcx     # 0x11eee1
testl %r12d, %r12d
jne 0x7c7d1
leaq 0xa20ac(%rip), %rcx     # 0x11e862
jmp 0x7c7d1
leaq 0xa20a7(%rip), %rcx     # 0x11e866
jmp 0x7c7d1
leaq 0xadd1d(%rip), %rcx     # 0x12a4e5
jmp 0x7c7d1
leaq 0xa20a0(%rip), %rcx     # 0x11e871
movq %rbx, %rdi
leaq 0x88f37(%rip), %rsi     # 0x105712
movl %r12d, %edx
xorl %eax, %eax
callq 0xde896
testl %r12d, %r12d
je 0x7c8e3
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %rax, %r13
movq 0x18(%rsp), %r14
movq %rbx, %rdi
leaq 0xbbc70(%rip), %rsi     # 0x13847c
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
leaq (%r14,%r13), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x7c8e3
cmpl $0x6, %r12d
je 0x7c876
cmpl $0x5, %r12d
jne 0x7c852
movq %r14, %rsi
leaq 0xa10d7(%rip), %rdx     # 0x11d915
pushq $0x3
popq %rcx
callq 0xe4d48
testl %eax, %eax
jne 0x7c852
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movq 0x18(%rbx), %rsi
movl $0x1, (%rsp)
movl $0x100, %r8d            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rdx
movq %r13, %rcx
xorl %r9d, %r9d
callq 0xded3a
jmp 0x7c8c9
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x7c8c9
movq %rbx, %rdi
leaq 0xa1ff0(%rip), %rsi     # 0x11e87a
movq %r14, %rdx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
movl %ebp, %esi
callq 0xdeba7
movq 0x18(%rbx), %rcx
movq %rbx, %rdi
leaq 0x8dfd4(%rip), %rsi     # 0x10a880
leaq 0xb7824(%rip), %rdx     # 0x1340d7
movq %r14, %r8
movq %r13, %r9
callq 0xdfa28
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0xdeba7
addq %r13, 0x18(%rsp)
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0xdeba7
movq 0x18(%rsp), %rdx
jmp 0x7c751
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xded32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/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 0xe404f
cmpl $0x50494332, %eax       # imm = 0x50494332
jne 0x7c944
movq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
callq 0xe3eb4
cmpb $0x1, %al
jne 0x7c944
movq 0x18(%r14), %rdi
pushq $0x5
popq %rsi
callq 0xe409f
addl $-0x21, %eax
xorl %ecx, %ecx
cmpl $-0x1d, %eax
pushq $0x57
popq %rbx
cmovbl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rax
movq %rcx, %rbx
movq %rdi, %r14
pushq $0x2
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
xorl %eax, %eax
testq %r15, %r15
cmovleq %rax, %r15
leaq 0x9f0e9(%rip), %r13     # 0x11daa7
pushq $-0x1
popq %r12
subq $0x1, %r15
jb 0x7ea3d
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xe3eb4
movl %eax, %ecx
andb $0xf, %cl
cmpb $0x10, %al
leaq 0x9ef38(%rip), %rdx     # 0x11d91a
leaq 0x8f90a(%rip), %rax     # 0x10e2f3
cmovbq %rax, %rdx
movzbl %cl, %ecx
movq %r14, %rdi
leaq 0x9f0a1(%rip), %rsi     # 0x11da9b
xorl %eax, %eax
callq 0xde896
movq 0x18(%r14), %rdi
leaq 0x1(%rbx), %rsi
callq 0xe3eb4
movl %eax, %ebp
movq %r14, %rdi
pushq $0x1
popq %rsi
callq 0xdeba7
movzbl %bpl, %edx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
movl %r12d, %esi
callq 0xdeba7
addq $0x2, %rbx
jmp 0x7e9c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/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 0x7ea9c
movq %r8, %r12
movq %rcx, %r14
movq %rdi, %rbx
incl 0x24(%rsi)
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xe3eb4
movzbl %al, %r15d
leaq 0x9f03c(%rip), %rsi     # 0x11dabe
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xde896
leal (%r15,%r15), %ecx
leaq 0x4(%rcx), %rax
cmpq %r12, %rax
jbe 0x7eaab
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, 0x10(%rsp)
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rsp)
addq $0x2, %r14
leaq 0x9f030(%rip), %r13     # 0x11daf4
pushq $-0x1
popq %r12
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
cmpq %rbp, %r15
je 0x7eb37
leaq -0x1(%r14), %rsi
callq 0xe3eb4
movzbl %al, %ecx
movq %rbx, %rdi
leaq 0x9eff6(%rip), %rsi     # 0x11dadf
movl %ebp, %edx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0xdeba7
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xe3eb4
movl %eax, %ecx
shrb $0x4, %cl
andb $0xf, %al
movzbl %cl, %edx
movzbl %al, %ecx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
movl %r12d, %esi
callq 0xdeba7
incq %rbp
addq $0x2, %r14
jmp 0x7eaca
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r12
leaq (%r12,%r15), %rsi
callq 0xe3eb4
movl %eax, %ebp
movq 0x18(%rbx), %rdi
leaq (%r12,%r15), %rsi
incq %rsi
callq 0xe3eb4
movl %eax, %r14d
movq 0x18(%rbx), %rdi
leaq (%r12,%r15), %rsi
addq $0x2, %rsi
callq 0xe3eb4
movl %eax, %r15d
movzbl %bpl, %edx
movzbl %r14b, %ecx
leaq 0x9ef8c(%rip), %rsi     # 0x11db0e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movzbl %r15b, %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0xf, %ecx
leaq 0x9ef94(%rip), %rsi     # 0x11db33
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/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 0x7eddd
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xe3f46
movq %rax, %r15
leaq 0x9edcf(%rip), %rsi     # 0x11db91
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xde896
testq %r15, %r15
je 0x7edd8
movb $0x1, 0x1b(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ee0f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rcx, %rsi
callq 0xe3eb4
movzbl %al, %edx
cmpb $0xd, %dl
jne 0x7ee10
movb $0x1, 0x1f(%r14)
leaq 0x9ed99(%rip), %rcx     # 0x11dba6
jmp 0x7ee17
retq
leaq 0xa00ca(%rip), %rcx     # 0x11eee1
leaq 0x9edae(%rip), %rsi     # 0x11dbcc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/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), %ebp
cmpl $0x1, %r13d
jle 0x7ee88
testq %r15, %r15
jle 0x7eef8
testl %ebp, %ebp
jne 0x7ee9c
movq 0x18(%rbx), %rdi
leaq 0x8c5d5(%rip), %rcx     # 0x10b443
xorl %r14d, %r14d
pushq $0x1
popq %r9
movq %r12, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xe4e0b
jmp 0x7ef23
testq %r15, %r15
jle 0x7eef8
cmpl $0x0, (%rbx)
jle 0x7eef8
testl %ebp, %ebp
movl $0x401, %eax            # imm = 0x401
cmovel %eax, %ebp
movq %rbx, %rdi
callq 0xeac74
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0xe4c9a
cmpl $0x2, %r13d
jl 0x7ef07
leaq 0x8c577(%rip), %rsi     # 0x10b443
pushq $0x1
popq %rbp
movq %rbx, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0xe4e62
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0xeb576
movq %r15, %rdi
callq 0xe5591
jmp 0x7ef23
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xeb877
leaq 0x888df(%rip), %rsi     # 0x1077f5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%r8)
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xe4b21
testl %eax, %eax
je 0x7efb1
movq (%rsp), %r15
leaq 0x1(%r15), %rdx
movq %rdx, (%rsp)
addq %r13, %r12
notq %r15
addq %r12, %r15
testl %ebp, %ebp
je 0x7efba
leaq 0x9f358(%rip), %rsi     # 0x11e2e1
movq %rbx, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0xde896
movq 0x50(%r14), %rcx
testq %rcx, %rcx
je 0x7f00d
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq 0xe45f4
jmp 0x7f00d
leaq 0x9f308(%rip), %rsi     # 0x11e2c0
jmp 0x7f003
leaq 0x9f355(%rip), %rsi     # 0x11e316
movq %rbx, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0xde896
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x7efe1
callq 0xe5591
andq $0x0, 0x50(%r14)
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
leaq 0x9f354(%rip), %rdx     # 0x11e344
pushq $0x2
popq %rcx
callq 0xe4d48
testl %eax, %eax
je 0x7f01c
leaq 0x9f344(%rip), %rsi     # 0x11e347
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf05a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9f347(%rip), %rsi     # 0x11e36a
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe4e62
movq %rax, %rcx
movq %rax, 0x50(%r14)
jmp 0x7ef9a
// File: /workspace/github_c_makefile_star2_O2/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 0x7f066
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
addb $-0x7f, %cl
cmpb $-0x5f, %cl
jae 0x7f067
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x7f079
cmpb $0x0, (%rbx,%rcx)
je 0x7f084
incq %rcx
jmp 0x7f069
cmpl $0x0, 0x100(%rbx)
jne 0x7f095
jmp 0x7f05b
movl $0x1, 0x100(%rbx)
movq %rcx, 0xf8(%rbx)
leaq 0x58(%rbx), %r15
pushq $0x50
popq %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xde492
leaq 0xa8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xde492
movq %r14, %rdi
callq 0x180e0
testq %rax, %rax
jle 0x7f0e4
cmpb $0x20, 0xa7(%rbx,%rax)
jne 0x7f0e4
movb $0x0, 0xa7(%rbx,%rax)
decq %rax
jmp 0x7f0c8
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
cmpq %rcx, %rax
je 0x7f05b
movb (%r14,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x7f10a
addb $-0x20, %dl
movb %dl, (%r14,%rcx)
incq %rcx
jmp 0x7f0ed
// File: /workspace/github_c_makefile_star2_O2/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, 0x10(%rsp)
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
pushq $0x3
popq %rcx
movq %rdx, %rsi
movq %r15, %rdx
callq 0xe7437
movq %rax, %r14
testl %ebp, %ebp
je 0x7f1c1
movq 0x18(%r12), %rdi
andl $0x0, (%rsp)
pushq $0x3
popq %rcx
movq %r13, %r15
leaq 0x30(%rsp), %r13
movl $0x100, %edx            # imm = 0x100
movl $0x100, %r9d            # imm = 0x100
movq %r15, %rsi
movq %r13, %r8
callq 0xe7963
addq $0x300, %r15            # imm = 0x300
movq 0x18(%r12), %rdi
andl $0x0, (%rsp)
pushq $0x8
popq %rdx
movq %r15, %rsi
movq %rbx, %rcx
movq %r13, %r8
movq %r14, %r9
callq 0xe7cbc
pushq $0x1
popq %rdx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0xe70b7
movq %r14, %rdi
callq 0xe7084
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
testq %rbx, %rbx
movq %r15, %rax
movl $0x0, %r15d
cmovgq %rbx, %r15
testq %rax, %rax
cmovleq %rbp, %rax
movq %rax, 0x20(%rsp)
leaq (%rbx,%rbx,2), %rax
movq %rax, 0x18(%rsp)
cmpq 0x20(%rsp), %rbp
je 0x7f197
movq %r13, 0x28(%rsp)
movq %r13, %rbx
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x7f227
movq 0x18(%r12), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe45a4
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl %eax, %ecx
callq 0xe7287
incq %r13
addq $0x3, %rbx
jmp 0x7f1fa
incq %rbp
movq 0x28(%rsp), %r13
addq 0x18(%rsp), %r13
jmp 0x7f1e8
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0xa8(%rsi), %rax
testq %rax, %rax
je 0x7f2d7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rax), %rsi
cmpq (%rax), %r12
jae 0x7f2ad
movq 0x8(%rsi,%r15), %rax
testq %rax, %rax
je 0x7f289
movq %r14, %rdi
movq %rax, %rsi
callq 0xe4b94
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rsi
andq $0x0, 0x8(%rsi,%r15)
movq 0x10(%rsi,%r15), %rdi
callq 0xe5591
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rcx
andq $0x0, 0x10(%rcx,%r15)
incq %r12
addq $0x28, %r15
jmp 0x7f25a
movq %r14, %rdi
callq 0xded32
movq 0xa8(%rbx), %rsi
movq %r14, %rdi
callq 0xded32
andq $0x0, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7f53c
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe4071
movq %rax, %r12
addq %rax, %r12
addq $-0x4, %r15
cmpq %r15, %r12
jle 0x7f541
xorl %r15d, %r15d
jmp 0x7f58e
movq %r14, %rdi
callq 0xeac74
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 0xe4ced
movq %r15, %rdi
callq 0xeb7e4
leaq 0x9f93c(%rip), %rsi     # 0x11eeba
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq %r15, %rdi
callq 0xeaf3c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9f453(%rip), %rax     # 0x11e9fe
movq %rax, (%rsi)
leaq 0x9f3fb(%rip), %rax     # 0x11e9b0
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x7f5db
movq %rax, 0x18(%rsi)
leaq 0x40(%rip), %rax        # 0x7f60b
movq %rax, 0x20(%rsi)
leaq 0x197(%rip), %rax       # 0x7f76d
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x80948
movq %rax, %r14
andl $0x0, 0xc(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x80950
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x819a6
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
movq %rsp, %r15
pushq $0x16
popq %rcx
movq %r15, %rsi
xorl %edx, %edx
callq 0xe3cb7
movzbl 0x14(%r15), %ebp
cmpl $0x3, %ebp
ja 0x7f65a
leaq 0x2(%rsp), %r15
movq %r15, %rdi
callq 0x82431
testl %eax, %eax
je 0x7f65a
movq %r15, %rdi
callq 0x82e26
testl %eax, %eax
je 0x7f66c
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %eax
leaq 0x9f22b(%rip), %rcx     # 0x11e8a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl (%rsp), %eax
cmpl $0x16, %eax
jb 0x7f65a
movzbl 0x15(%rsp), %ecx
addl $0x18, %ecx
jmp 0x7f6c4
movq %rsp, %rdi
callq 0xe3f9f
cmpq $0x19, %rax
jle 0x7f65a
jmp 0x7f6cb
movb (%rsp), %al
addb $-0x4, %al
testb $-0x5, %al
jne 0x7f65a
cmpb $0x0, 0x1(%rsp)
je 0x7f6cb
jmp 0x7f65a
movzbl (%rsp), %eax
cmpl $0x19, %eax
jb 0x7f65a
movzbl 0x15(%rsp), %ecx
addl $0x1b, %ecx
addl $0x2, %eax
cmpl %eax, %ecx
ja 0x7f65a
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 %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x81a78
cmpb $0x0, (%r12)
je 0x7f65a
leaq 0xb8515(%rip), %rsi     # 0x137c32
movq %r14, %rdi
callq 0xdfcd5
pushq $0x64
popq %rbx
testl %eax, %eax
jne 0x7f65a
leaq 0x9f2c7(%rip), %rsi     # 0x11e9fe
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
jne 0x7f65a
cmpb $0x7a, 0x4(%rsp)
jne 0x7f765
leaq 0x9fb5b(%rip), %rsi     # 0x11f2b0
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
jne 0x7f65a
pushq $0x50
popq %rbx
jmp 0x7f65a
// File: /workspace/github_c_makefile_star2_O2/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 0x9f242(%rip), %rax     # 0x11e9c4
movq %rax, (%rsi)
leaq 0x9f23c(%rip), %rax     # 0x11e9c8
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x7f7ab
movq %rax, 0x18(%rsi)
leaq 0x56(%rip), %rax        # 0x7f7f8
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x80948
movq %rax, %r14
movl $0x1, 0xc(%rax)
leaq 0x9fb26(%rip), %rax     # 0x11f2ee
movq %rax, 0x10(%r14)
leaq 0x9f1f5(%rip), %rsi     # 0x11e9c8
movq %rbx, %rdi
callq 0xe07f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80950
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x819a6
// File: /workspace/github_c_makefile_star2_O2/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 0x9f185(%rip), %rax     # 0x11e9d4
movq %rax, (%rsi)
leaq 0x9f17f(%rip), %rax     # 0x11e9d8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x7f874
movq %rax, 0x18(%rsi)
leaq 0x4b(%rip), %rax        # 0x7f8ba
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x80948
movq %rax, %r14
movl $0x2, 0xc(%rax)
leaq 0x9fa61(%rip), %rsi     # 0x11f2f2
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xe07f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80950
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x819a6
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rdx
pushq $0x5
popq %rcx
movq %r14, %rsi
callq 0xe3cb7
xorl %eax, %eax
cmpb $0x2d, (%r14)
jne 0x7f91b
cmpb $0x54, 0x4(%rsp)
jne 0x7f91b
cmpb $0x4b, 0x5(%rsp)
jne 0x7f91b
movb 0x6(%rsp), %cl
andb $-0x2, %cl
cmpb $0x30, %cl
jne 0x7f91b
cmpb $0x2d, 0x7(%rsp)
jne 0x7f91b
leaq 0x9f0cc(%rip), %rsi     # 0x11e9d4
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0x4b
popq %rcx
pushq $0x64
popq %rax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f0ba(%rip), %rax     # 0x11e9e4
movq %rax, (%rsi)
leaq 0x9f0b7(%rip), %rax     # 0x11e9eb
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x7f94f
movq %rax, 0x18(%rsi)
leaq 0x4b(%rip), %rax        # 0x7f995
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x80948
movq %rax, %r14
movl $0x3, 0xc(%rax)
leaq 0x9f98a(%rip), %rsi     # 0x11f2f6
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xe07f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80950
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x819a6
// File: /workspace/github_c_makefile_star2_O2/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 0x9f012(%rip), %rax     # 0x11e9fa
movq %rax, (%rsi)
leaq 0x9f010(%rip), %rax     # 0x11ea02
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x7fa0d
movq %rax, 0x18(%rsi)
leaq 0x378(%rip), %rax       # 0x7fd80
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9ec6d(%rip), %rax     # 0x11ea22
movq %rax, (%rsi)
leaq 0x9ec67(%rip), %rax     # 0x11ea26
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x7fdda
movq %rax, 0x18(%rsi)
leaq 0x4a7(%rip), %rax       # 0x8027c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f132(%rip), %rdx     # 0x11f3bf
pushq $0x2
popq %rsi
pushq $0x5
popq %rcx
callq 0xe4d48
xorl %ebp, %ebp
testl %eax, %eax
jne 0x802d8
movq 0x18(%rbx), %rdi
pushq $0x14
popq %rsi
callq 0xe3eb4
cmpb $0x20, %al
jne 0x802d8
movq 0x18(%rbx), %rdi
pushq $0x15
popq %rsi
callq 0xe3eb4
testb %al, %al
jne 0x802d8
leaq 0x9e75d(%rip), %rsi     # 0x11ea22
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0x46
popq %rax
pushq $0x64
popq %rbp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9e753(%rip), %rax     # 0x11ea3b
movq %rax, (%rsi)
leaq 0x9e74f(%rip), %rax     # 0x11ea41
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x8030d
movq %rax, 0x18(%rsi)
leaq 0x3a7(%rip), %rax       # 0x806af
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0xe3fa3
movq %rax, %r14
addq $-0x413, %rax           # imm = 0xFBED
cmpq $-0x400, %rax           # imm = 0xFC00
jb 0x807b5
movq 0x18(%rbx), %rdi
leaq 0x8(%r14), %rax
cmpq %rax, 0x18(%rdi)
jl 0x807b5
pushq $0x2
popq %rsi
callq 0xe3fa3
cmpq $0x1, %rax
jg 0x807b5
movq 0x18(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0xe3eb4
testb %al, %al
jne 0x807b5
movq 0x18(%rbx), %rdi
leaq 0x4(%r14), %rsi
callq 0xe3fa3
testq %rax, %rax
jne 0x807b5
leaq 0x2(%r14), %rax
movq %rax, (%rsp)
movq 0x18(%rbx), %r13
pushq $0x12
popq %rbp
xorl %r12d, %r12d
cmpq %rbp, %r14
je 0x80763
leaq 0x14(%r12), %rsi
movq %r13, %rdi
callq 0xe3eb4
addb $-0x20, %al
incq %r12
incq %rbp
xorl %r15d, %r15d
cmpb $0x5f, %al
jb 0x80740
jmp 0x807b5
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
callq 0xe3fa3
movq %rax, %r15
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xe0ae9
movq %rax, %r12
movq 0x18(%rbx), %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0xe0f33
movq %r12, %rdi
callq 0xe0e95
xorl %ecx, %ecx
cmpl %r15d, %eax
pushq $0x5b
popq %r15
cmovnel %ecx, %r15d
testq %r12, %r12
je 0x807b5
movq %r12, %rdi
callq 0xe0e8d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/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 0x9e28b(%rip), %rax     # 0x11ea59
movq %rax, (%rsi)
leaq 0x9e28f(%rip), %rax     # 0x11ea67
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x807f3
movq %rax, 0x18(%rsi)
leaq 0x130(%rip), %rax       # 0x8091e
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rsi
callq 0xdecaf
movq %rax, %r15
movq %rax, %r14
leaq 0x4(%rax), %rsi
movq %rbx, %rdi
callq 0x82f21
testl %eax, %eax
je 0x808e6
cmpl $0x0, 0x4(%r14)
leaq 0x9ec77(%rip), %rax     # 0x11f4a0
leaq 0x9ec6b(%rip), %rdx     # 0x11f49b
cmoveq %rax, %rdx
leaq 0x9ec3f(%rip), %rsi     # 0x11f47a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe0824
addq $0x8, %r15
cmpl $0x0, 0x4(%r14)
movl $0x252, %esi            # imm = 0x252
je 0x80862
movq %rbx, %rdi
movq %r15, %rdx
callq 0x82fba
jmp 0x8088e
movl $0x4ec, %esi            # imm = 0x4EC
movq %rbx, %rdi
movq %r15, %rdx
callq 0x82fba
testl %eax, %eax
jne 0x8088e
movl $0x4ef, %esi            # imm = 0x4EF
movq %rbx, %rdi
movq %r15, %rdx
callq 0x82fba
testl %eax, %eax
je 0x80914
movq (%r15), %rdx
testq %rdx, %rdx
je 0x808e6
cmpb $0x0, (%r14)
jne 0x808ec
leaq 0x9ec03(%rip), %rsi     # 0x11f4a6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
movq 0x18(%rdi), %rdx
subq %rsi, %rdx
cmpl $0x0, 0x4(%r14)
leaq 0xb736a(%rip), %rax     # 0x137c32
leaq 0x9e9e1(%rip), %rcx     # 0x11f2b0
cmoveq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe4e0b
cmpb $0x0, (%r14)
jne 0x808ec
jmp 0x80904
movw $0x101, (%r14)          # imm = 0x101
cmpb $0x0, 0x1(%r14)
je 0x80904
leaq 0x9ebc2(%rip), %rsi     # 0x11f4bc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xded32
movl $0x50a, %esi            # imm = 0x50A
jmp 0x80855
// File: /workspace/github_c_makefile_star2_O2/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 0x819d9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rdi
callq 0xe0e8d
movq 0x30(%rbx), %rdi
callq 0xe0e8d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/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 0x81a33
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rsi), %rdi
callq 0xeaf3c
movq 0x70(%rbx), %rdi
callq 0xeaf3c
movq 0x78(%rbx), %rdi
callq 0xeaf3c
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xded32
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lha.c
// Function: lha_calc_checksum
static u32 lha_calc_checksum(dbuf *f, i64 pos, i64 len, struct de_crcobj *crco_cksum)
{
	u32 v;

	de_crcobj_reset(crco_cksum);
	de_crcobj_addslice(crco_cksum, f, pos, len);
	v = de_crcobj_getval(crco_cksum);
	return v & 0xff;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xe0e44
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xe0f33
movq %rbx, %rdi
callq 0xe0e95
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lha.c
// Function: get_cmpr_meth_info
static void get_cmpr_meth_info(const u8 idbuf[5], enum lha_basefmt_enum basefmt,
	struct cmpr_meth_info *cmi)
{
	size_t k;
	const struct cmpr_meth_array_item *cmai = NULL;

	// The first 4 bytes are unique for all known methods.
	cmi->uniq_id = (u32)de_getu32be_direct(idbuf);

	de_memcpy(cmi->id_raw, idbuf, 5);

	// All "possible" methods only use printable characters.
	de_memcpy(cmi->id_printable_sz, idbuf, 5);
	cmi->id_printable_sz[5] = '\0';

	for(k=0; k<DE_ARRAYCOUNT(cmpr_meth_arr); k++) {
		if(cmpr_meth_arr[k].basefmt != basefmt) continue;
		if(cmpr_meth_arr[k].uniq_id == cmi->uniq_id) {
			cmai = &cmpr_meth_arr[k];
			break;
		}
	}

	if(cmai) {
		cmi->is_recognized = 1;
		cmi->decompressor = cmai->decompressor;
	}
	else if(basefmt==BASEFMT_LHA) {
		for(k=0; k<DE_ARRAYCOUNT(other_known_cmpr_methods); k++) {
			if(other_known_cmpr_methods[k] == cmi->uniq_id) {
				cmi->is_recognized = 1;
				break;
			}
		}
	}

	if(cmai && cmai->descr) {
		de_strlcpy(cmi->descr, cmai->descr, sizeof(cmi->descr));
	}
	else if(cmi->is_recognized) {
		de_strlcpy(cmi->descr, "recognized, but no info avail.", sizeof(cmi->descr));
	}
	else {
		de_strlcpy(cmi->descr, "?", sizeof(cmi->descr));
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xe404a
movl %eax, 0x4(%rbx)
movl (%r14), %ecx
movl %ecx, 0x10(%rbx)
movb 0x4(%r14), %cl
movb %cl, 0x14(%rbx)
movl (%r14), %ecx
movl %ecx, 0x15(%rbx)
movb 0x4(%r14), %cl
movb %cl, 0x19(%rbx)
movb $0x0, 0x1a(%rbx)
pushq $0x18
popq %rcx
leaq 0x10512c(%rip), %rdx    # 0x186be0
cmpq $0x2d8, %rcx            # imm = 0x2D8
je 0x81acf
cmpl %ebp, -0x18(%rcx,%rdx)
jne 0x81ac9
cmpl %eax, -0x10(%rcx,%rdx)
je 0x81afa
addq $0x20, %rcx
jmp 0x81ab4
testl %ebp, %ebp
jne 0x81b0f
xorl %ecx, %ecx
leaq 0x9ce64(%rip), %rdx     # 0x11e940
cmpq $0x4c, %rcx
je 0x81b0f
leaq 0x4(%rcx), %rsi
cmpl %eax, (%rcx,%rdx)
movq %rsi, %rcx
jne 0x81adc
movb $0x1, (%rbx)
leaq 0x9d1ea(%rip), %rsi     # 0x11ece2
jmp 0x81b24
movb $0x1, (%rbx)
movq -0x8(%rcx,%rdx), %rsi
movq (%rcx,%rdx), %rax
movq %rax, 0x8(%rbx)
testq %rsi, %rsi
jne 0x81b24
cmpb $0x0, (%rbx)
leaq 0x9d3c8(%rip), %rax     # 0x11eee1
leaq 0x9d1c2(%rip), %rsi     # 0x11ece2
cmoveq %rax, %rsi
addq $0x1b, %rbx
pushq $0x50
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xde492
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lha.c
// Function: read_unix_timestamp
static void read_unix_timestamp(deark *c, lctx *d, struct member_data *md,
	i64 pos, int tsidx, const char *name)
{
	i64 t;
	char timestamp_buf[64];
	struct de_timestamp tmp_timestamp;

	t = de_geti32le(pos);
	de_unix_time_to_timestamp(t, &tmp_timestamp, 0x1);
	de_timestamp_to_string(&tmp_timestamp, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %d (%s)", name, (int)t, timestamp_buf);
	apply_timestamp(c, d, md, tsidx, &tmp_timestamp, 50);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
callq 0xe40f2
movq %rax, %r12
leaq 0x10(%rsp), %r13
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0xe002e
leaq 0x20(%rsp), %rbx
pushq $0x40
popq %rdx
movq %r13, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xe0644
leaq 0x9d2bc(%rip), %rsi     # 0x11ee5d
movq %r15, %rdi
movq %r14, %rdx
movl %r12d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xde896
testl %ebp, %ebp
js 0x81bf1
cmpb $0x0, 0x10(%rsp)
je 0x81bf1
movl %ebp, %eax
imulq $0x18, %rax, %rax
movq 0x8(%rsp), %rcx
cmpl $0x32, 0x90(%rcx,%rax)
jg 0x81bf1
movq 0x8(%rsp), %rcx
addq %rcx, %rax
addq $0x80, %rax
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rax)
movl $0x32, 0x10(%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lha.c
// Function: read_filename_hlev0
static void read_filename_hlev0(deark *c, lctx *d, struct member_data *md,
	i64 pos, i64 len)
{
	struct de_strarray *sa = NULL;

	if(md->filename) {
		ucstring_empty(md->filename);
	}
	else {
		md->filename = ucstring_create(c);
	}

	sa = de_strarray_create(c, MAX_SUBDIR_LEVEL+2);
	read_path_to_strarray(c, d, md, c->infile, pos, len, sa, 0);

	de_strarray_make_path(sa, md->filename, DE_MPFLAG_NOTRAILINGSLASH);
	de_dbg(c, "filename (parsed): \"%s\"", ucstring_getpsz_d(md->filename));

	de_strarray_destroy(sa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %rdi
testq %rdi, %rdi
je 0x81c29
callq 0xeac85
jmp 0x81c35
movq %rbx, %rdi
callq 0xeac74
movq %rax, 0x70(%r14)
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xeb95d
movq %rax, %r12
movq 0x18(%rbx), %rdx
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rcx
movq %r15, %r8
movq %rax, %r9
callq 0x8286b
movq 0x70(%r14), %rsi
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0xeba55
movq 0x70(%r14), %rdi
callq 0xeb877
leaq 0x9d245(%rip), %rsi     # 0x11eec3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %r12, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xeb97e
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lha.c
// Function: read_filename_hlev1_or_exthdr
static void read_filename_hlev1_or_exthdr(deark *c, lctx *d, struct member_data *md,
	i64 pos, i64 len)
{
	i64 i;

	if(md->filename) {
		ucstring_empty(md->filename);
	}
	else {
		md->filename = ucstring_create(c);
	}

	// Some files seem to assume NUL termination is allowed.
	dbuf_read_to_ucstring(c->infile, pos, len,
		md->filename, DE_CONVFLAG_STOP_AT_NUL, md->encoding);
	de_dbg(c, "filename: \"%s\"", ucstring_getpsz_d(md->filename));

	// I don't think slashes are allowed
	for(i=0; i<md->filename->len; i++) {
		if(md->filename->str[i]=='/') {
			md->filename->str[i]='_';
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rsi), %rdi
testq %rdi, %rdi
je 0x81cc8
callq 0xeac85
movq 0x70(%rbx), %rcx
jmp 0x81cd7
movq %r14, %rdi
callq 0xeac74
movq %rax, %rcx
movq %rax, 0x70(%rbx)
movq 0x18(%r14), %rdi
movl 0x4(%rbx), %r9d
pushq $0x1
popq %r8
movq %r12, %rsi
movq %r15, %rdx
callq 0xe4c9a
movq 0x70(%rbx), %rdi
callq 0xeb877
leaq 0xacd60(%rip), %rsi     # 0x12ea5e
xorl %r15d, %r15d
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x70(%rbx), %rax
movq 0x10(%rax), %rcx
cmpq %rcx, %r15
jge 0x81d33
movq 0x8(%rax), %rdx
cmpl $0x2f, (%rdx,%r15,4)
jne 0x81d2e
movl $0x5f, (%rdx,%r15,4)
incq %r15
jmp 0x81d16
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/lha.c
// Function: get_os_name
static const char *get_os_name(u8 id)
{
	const char *name = NULL;
	switch(id) {
	case ' ': name="unspecified"; break;
	case '2': name="OS/2"; break;
	case '3': name="OS/386?"; break;
	case '9': name="OS-9"; break;
	case 'A': name="Amiga"; break;
	case 'C': name="CP/M"; break;
	case 'F': name="FLEX"; break;
	case 'H': name="Human68K"; break;
	case 'J': name="JVM"; break;
	case 'K': name="OS-9/68K"; break;
	case 'M': name="DOS"; break;
	case 'R': name="RUNser"; break;
	case 'T': name="TownsOS"; break;
	case 'U': name="Unix"; break;
	case 'W': name="Windows NT"; break;
	case 'a': name="Atari ST?"; break;
	case 'm': name="Macintosh"; break;
	case 'w': name="Windows"; break;
	}
	return name?name:"?";
}

// Assembly:
leaq 0x9d19b(%rip), %rax     # 0x11eee1
leal -0x41(%rdi), %ecx
cmpl $0x16, %ecx
ja 0x81d66
leaq 0x9cb7b(%rip), %rdx     # 0x11e8d0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x8965a(%rip), %rax     # 0x10b3bf
retq
cmpl $0x77, %edi
je 0x81e05
cmpl $0x32, %edi
je 0x81e15
cmpl $0x33, %edi
je 0x81e0d
cmpl $0x39, %edi
je 0x81ded
cmpl $0x61, %edi
je 0x81dfd
cmpl $0x6d, %edi
je 0x81df5
cmpl $0x20, %edi
jne 0x81e0c
leaq 0x99019(%rip), %rax     # 0x11adb5
retq
leaq 0x9d166(%rip), %rax     # 0x11ef0a
retq
leaq 0x9d157(%rip), %rax     # 0x11ef03
retq
leaq 0x9d15e(%rip), %rax     # 0x11ef12
retq
leaq 0x9d13a(%rip), %rax     # 0x11eef6
retq
leaq 0x9d129(%rip), %rax     # 0x11eeed
retq
leaq 0x9d11c(%rip), %rax     # 0x11eee8
retq
leaq 0x9198d(%rip), %rax     # 0x113761
retq
leaq 0x9d11e(%rip), %rax     # 0x11eefa
retq
leaq 0xb4d2f(%rip), %rax     # 0x136b13
retq
leaq 0xb47cf(%rip), %rax     # 0x1365bb
retq
leaq 0x9d0ef(%rip), %rax     # 0x11eee3
retq
leaq 0xb4b9a(%rip), %rax     # 0x136996
retq
leaq 0x9d119(%rip), %rax     # 0x11ef1d
retq
leaq 0xbce33(%rip), %rax     # 0x13ec3f
retq
leaq 0x9d0c7(%rip), %rax     # 0x11eedb
retq
leaq 0x895af(%rip), %rax     # 0x10b3cb
retq