LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/fat.c
// Function: do_extract_file
static void do_extract_file(deark *c, lctx *d, struct member_data *md)
{
	dbuf *outf = NULL;
	de_finfo *fi = NULL;
	de_ucstring *fullfn = NULL;

	if(!md->is_subdir) {
		if(md->filesize > d->num_data_region_clusters * d->bytes_per_cluster) {
			de_err(c, "%s: Bad file size", ucstring_getpsz_d(md->short_fn));
			goto done;
		}
	}

	fi = de_finfo_create(c);
	fullfn = ucstring_create(c);
	de_strarray_make_path(d->curpath, fullfn, DE_MPFLAG_NOTRAILINGSLASH);
	de_finfo_set_name_from_ucstring(c, fi, fullfn, DE_SNFLAG_FULLPATH);
	fi->original_filename_flag = 1;
	if(md->is_subdir) {
		fi->is_directory = 1;
	}
	else if(md->is_volume_label) {
		fi->is_volume_label = 1;
	}
	if(md->mod_time.is_valid) {
		fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = md->mod_time;
	}

	outf = dbuf_create_output_file(c, NULL, fi, 0);

	if(!extract_file_lowlevel(c, d, md, outf)) {
		de_err(c, "%s: File extraction failed", ucstring_getpsz_d(md->short_fn));
		goto done;
	}

done:
	dbuf_close(outf);
	ucstring_destroy(fullfn);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
cmpb $0x0, 0xb(%rdx)
jne 0x5d7b3
movq 0x28(%r13), %rax
imulq 0x48(%r13), %rax
cmpq %rax, 0x28(%r12)
jle 0x5d7b3
leaq 0xc4fff(%rip), %r13     # 0x1227a5
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
jmp 0x5d854
movq %rbx, %rdi
callq 0xea9a9
movq %rax, %r14
movq %rbx, %rdi
callq 0xf6870
movq %rax, %r15
movq 0x80(%r13), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0xf776e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0xea9e4
movb $0x1, 0x8(%r14)
cmpb $0x0, 0xb(%r12)
je 0x5d804
movb $0x1, 0x9(%r14)
jmp 0x5d811
cmpb $0x0, 0xc(%r12)
je 0x5d811
movb $0x1, 0xa(%r14)
cmpb $0x0, 0x48(%r12)
je 0x5d826
leaq 0x48(%r12), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %rbp
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x5d897
testl %eax, %eax
jne 0x5d86e
leaq 0xc4f63(%rip), %r13     # 0x1227b7
movq 0x38(%r12), %rdi
callq 0xf7557
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9df7
movq %rbp, %rdi
callq 0xf0b13
movq %r15, %rdi
callq 0xf6bb0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xea9b3
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/fat.c
// Function: extract_file_lowlevel
static int extract_file_lowlevel(deark *c, lctx *d, struct member_data *md, dbuf *outf)
{
	int retval = 0;
	i64 cur_cluster;
	i64 nbytes_remaining;

	cur_cluster = md->first_cluster;
	if(md->is_subdir) {
		nbytes_remaining = 0;
	}
	else {
		nbytes_remaining = md->filesize;
	}

	while(1) {
		i64 dpos;
		i64 nbytes_to_copy;

		if(nbytes_remaining <= 0) break;
		if(!is_good_clusternum(d, cur_cluster)) break;
		if(d->cluster_used_flags[cur_cluster]) break;
		d->cluster_used_flags[cur_cluster] = 1;
		if(c->debug_level>=3) de_dbg3(c, "cluster: %d", (int)cur_cluster);
		dpos = clusternum_to_offset(c, d, cur_cluster);
		nbytes_to_copy = de_min_int(d->bytes_per_cluster, nbytes_remaining);
		dbuf_copy(c->infile, dpos, nbytes_to_copy, outf);
		nbytes_remaining -= nbytes_to_copy;
		cur_cluster = (i64)d->fat_nextcluster[cur_cluster];
	}

	if(nbytes_remaining>0) {
		goto done;
	}

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xb(%rdx)
je 0x5d8b7
xorl %r12d, %r12d
jmp 0x5d8bb
movq 0x28(%rdx), %r12
movq 0x30(%rdx), %r13
xorl %eax, %eax
testq %r12, %r12
jle 0x5d8e2
cmpq $0x2, %r13
jl 0x5d8e2
cmpq %r13, 0x78(%r14)
jle 0x5d8e0
movq 0x98(%r14), %rax
cmpb $0x0, (%rax,%r13)
je 0x5d8e8
xorl %eax, %eax
testb %al, %al
jne 0x5d8bf
jmp 0x5d947
movb $0x1, (%rax,%r13)
cmpl $0x3, (%r15)
jl 0x5d907
movq %r15, %rdi
leaq 0xc4a0d(%rip), %rsi     # 0x12230a
movl %r13d, %edx
xorl %eax, %eax
callq 0xe9461
leaq -0x2(%r13), %rbp
movq 0x28(%r14), %rdi
imulq %rdi, %rbp
addq 0x40(%r14), %rbp
movq %r12, %rsi
callq 0xea792
movq %rax, %rbx
movq 0x18(%r15), %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq (%rsp), %rcx
callq 0xefabc
subq %rbx, %r12
movq 0x90(%r14), %rax
movl (%rax,%r13,4), %r13d
movb $0x1, %al
jmp 0x5d8e2
xorl %eax, %eax
testq %r12, %r12
setle %al
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/fat.c
// Function: loaddskf_finish_checksum
static void loaddskf_finish_checksum(deark *c, struct skf_ctx *d)
{
	d->checksum_calc = de_crcobj_getval(d->crco);
	de_dbg(c, "checksum (calculated): 0x%08x", (UI)d->checksum_calc);
	if(d->checksum_calc != d->checksum_reported) {
		de_warn(c, "Checksum mismatch (reported 0x%08x, calculated 0x%08x). "
			"Something may have gone wrong.", (UI)d->checksum_reported,
			(UI)d->checksum_calc);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rdi
callq 0xebe2a
movl %eax, 0x10(%r14)
leaq 0xc50af(%rip), %rsi     # 0x122a2b
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movl 0xc(%r14), %edx
movl 0x10(%r14), %ecx
cmpl %edx, %ecx
jne 0x5d99c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc50a6(%rip), %rsi     # 0x122a49
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9b27
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/fat.c
// Function: loaddskf_pad_ima_file
static void loaddskf_pad_ima_file(deark *c, struct skf_ctx *d, dbuf *outf)
{
	i64 num_padding_bytes;
	u8 padding_value;

	dbuf_flush(outf);
	if(d->padded_size<=0) goto done;
	num_padding_bytes = d->padded_size - outf->len;
	if(num_padding_bytes<=0) goto done;
	de_dbg(c, "[adding padding]");

	// TODO: Does it matter what we pad with? Possibilities include 0x00, 0xe5, 0xf6.
	padding_value = 0x00;
	dbuf_write_run(outf, padding_value, num_padding_bytes);
done:
	;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0xf0ea4
movq 0x28(%r14), %r14
testq %r14, %r14
jle 0x5d9fc
subq 0x18(%rbx), %r14
jle 0x5d9fc
leaq 0xc503a(%rip), %rsi     # 0x122a1a
movq %r15, %rdi
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf14bd
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/flac.c
// Function: de_module_flac
void de_module_flac(deark *c, struct deark_module_info *mi)
{
	mi->id = "flac";
	mi->desc = "FLAC";
	mi->run_fn = de_run_flac;
	mi->identify_fn = de_identify_flac;
}

// Assembly:
leaq 0xc50f5(%rip), %rax     # 0x122b00
movq %rax, (%rsi)
leaq 0xcef97(%rip), %rax     # 0x12c9ac
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x5da30
movq %rax, 0x18(%rsi)
leaq 0x230(%rip), %rax       # 0x5dc5b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/flac.c
// Function: de_run_flac
static void de_run_flac(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	struct de_id3info id3i;

	d = de_malloc(c, sizeof(lctx));
	fmtutil_handle_id3(c, c->infile, &id3i, 0);
	run_flac_internal(c, d, id3i.main_start, id3i.main_end-id3i.main_start);
	de_free(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x4, %esi
callq 0xe969b
movq %rax, 0x18(%rsp)
movq 0x18(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xf95fe
movq 0x8(%r14), %rdx
movq 0x10(%r14), %r15
leaq 0x8(%rsp), %r14
movq %rdx, (%r14)
leaq 0xec4a3(%rip), %rsi     # 0x149f20
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
addq $0x4, (%r14)
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0xe958c
movq 0x8(%rsp), %rdx
movl $0x4, %eax
cmpq %r15, %rdx
jge 0x5dc10
movq %rbx, %rdi
leaq 0xc5050(%rip), %rsi     # 0x122b05
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xef14d
movl %eax, %r14d
shrb $0x7, %al
movzbl %al, %r12d
movq %rbx, %rdi
leaq 0xc5030(%rip), %rsi     # 0x122b1b
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
andb $0x7f, %r14b
movzbl %r14b, %ebp
leaq 0xce365(%rip), %rcx     # 0x12be69
cmpb $0x6, %r14b
ja 0x5db18
leaq 0xc50ef(%rip), %rax     # 0x122c00
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
movq %rbx, %rdi
leaq 0xc5005(%rip), %rsi     # 0x122b27
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xef6f2
movq %rax, %r13
addq $0x3, 0x8(%rsp)
movq %rbx, %rdi
leaq 0xc4fe5(%rip), %rsi     # 0x122b3b
movl %r13d, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x8(%rsp), %r14
cmpb $0x6, %bpl
je 0x5dbac
cmpl $0x4, %ebp
jne 0x5dbfa
movq %rbx, %rdi
leaq 0xc5028(%rip), %rsi     # 0x122ba6
movq %r14, %rdx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%rbx), %rcx
movq %rbx, %rdi
leaq 0xc501f(%rip), %rsi     # 0x122bc2
leaq 0xc5cc5(%rip), %rdx     # 0x12386f
jmp 0x5dbe2
movq %rbx, %rdi
leaq 0xc5010(%rip), %rsi     # 0x122bc6
movq %r14, %rdx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%rbx), %rcx
movq %rbx, %rdi
leaq 0xb4beb(%rip), %rsi     # 0x1127c6
leaq 0xcdb7a(%rip), %rdx     # 0x12b75c
movq %r14, %r8
movq %r13, %r9
callq 0xea66a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
addq %r13, 0x8(%rsp)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
leal (%r12,%r12,2), %eax
testl %eax, %eax
je 0x5da98
cmpl $0x4, %eax
je 0x5dc33
movq 0x8(%rsp), %rdx
leaq 0xc4f20(%rip), %rsi     # 0x122b49
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movl 0x14(%rsp), %esi
movq %rbx, %rdi
callq 0xe9595
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0xe9752
addq $0x38, %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/flac.c
// Function: de_identify_flac
static int de_identify_flac(deark *c)
{
	i64 pos = 0;

	if(!c->detection_data->id3.detection_attempted) {
		de_err(c, "flac detection requires id3 module");
		return 0;
	}

	if(c->detection_data->id3.has_id3v2) {
		pos = (i64)c->detection_data->id3.bytes_at_start;
	}

	if(!dbuf_memcmp(c->infile, pos, "fLaC", 4))
		return 100;

	return 0;
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rax
cmpb $0x0, 0x14(%rax)
je 0x5dc73
xorl %ebx, %ebx
cmpb $0x0, 0x15(%rax)
je 0x5dc85
movl 0x18(%rax), %esi
jmp 0x5dc87
leaq 0xc4f5b(%rip), %rsi     # 0x122bd5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xe9df7
jmp 0x5dca6
xorl %esi, %esi
movq 0x18(%rdi), %rdi
leaq 0xc4f66(%rip), %rdx     # 0x122bf8
movl $0x4, %ecx
callq 0xf025e
testl %eax, %eax
movl $0x64, %eax
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/dlmaker.c
// Function: de_module_dlmaker
void de_module_dlmaker(deark *c, struct deark_module_info *mi)
{
	mi->id = "dlmaker";
	mi->desc = "DL animation (DL MAKER)";
	mi->run_fn = de_run_dlmaker;
	mi->identify_fn = de_identify_dlmaker;
	mi->help_fn = de_help_dlmaker;
}

// Assembly:
leaq 0xc4f69(%rip), %rax     # 0x122c1c
movq %rax, (%rsi)
leaq 0xc4f67(%rip), %rax     # 0x122c24
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x5dce3
movq %rax, 0x18(%rsi)
leaq 0x846(%rip), %rax       # 0x5e519
movq %rax, 0x20(%rsi)
leaq 0x981(%rip), %rax       # 0x5e65f
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/dlmaker.c
// Function: de_identify_dlmaker
static int de_identify_dlmaker(deark *c)
{
	u8 v;
	i64 nscrn;
	i64 hsize;
	i64 ctlsize;
	i64 expected_filesize;

	if(!de_input_file_has_ext(c, "dl")) return 0;
	v = de_getbyte(0);
	if(v==1) {
		nscrn = (i64)de_getbyte(21);
		ctlsize = de_getu16le(22); // num frames * 1 byte
		hsize = 792;
	}
	else if(v==2) {
		if(de_getbyte(1)>2) return 0;
		nscrn = (i64)de_getbyte(42);
		ctlsize = de_getu32le(43) * 2;
		hsize = 815;
	}
	else if(v==3) {
		nscrn = (i64)de_getbyte(132);
		ctlsize = de_getu16le(134) * 2;
		hsize = 906;
	}
	else {
		return 0;
	}

	if(nscrn==0 || ctlsize==0) return 0;
	if(v==3) {
		// This is just a minimum file size. v3 is hard to identify.
		expected_filesize = hsize + nscrn*5 + ctlsize;
		if(c->infile->len < expected_filesize) return 0;
		return 10;
	}
	expected_filesize = hsize + V12_SCREEN_SIZE_IN_BYTES*nscrn + ctlsize;
	if(c->infile->len == expected_filesize) return 90;
	if(c->infile->len < expected_filesize) return 0;
	// Allow for some padding or other unknown data at EOF.
	if(c->infile->len > expected_filesize+511) return 0;
	return 10;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xc4856(%rip), %rsi     # 0x122d80
callq 0xea936
testl %eax, %eax
je 0x5e57e
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef0d5
movl %eax, %ebp
cmpb $0x3, %al
je 0x5e5c4
movzbl %bpl, %eax
cmpl $0x2, %eax
je 0x5e585
cmpl $0x1, %eax
jne 0x5e652
movq 0x18(%r14), %rdi
movl $0x15, %esi
callq 0xef0d5
movl %eax, %r15d
movq 0x18(%r14), %rdi
movl $0x16, %esi
callq 0xef1ca
movl $0x318, %ecx            # imm = 0x318
jmp 0x5e5eb
xorl %ebx, %ebx
jmp 0x5e652
movq 0x18(%r14), %rdi
movl $0x1, %esi
callq 0xef0d5
cmpb $0x2, %al
ja 0x5e652
movq 0x18(%r14), %rdi
movl $0x2a, %esi
callq 0xef0d5
movl %eax, %r15d
movq 0x18(%r14), %rdi
movl $0x2b, %esi
callq 0xef37e
addq %rax, %rax
movl $0x32f, %ecx            # imm = 0x32F
jmp 0x5e5eb
movq 0x18(%r14), %rdi
movl $0x84, %esi
callq 0xef0d5
movl %eax, %r15d
movq 0x18(%r14), %rdi
movl $0x86, %esi
callq 0xef1ca
addq %rax, %rax
movl $0x38a, %ecx            # imm = 0x38A
testb %r15b, %r15b
je 0x5e652
testq %rax, %rax
je 0x5e652
movzbl %r15b, %esi
movq 0x18(%r14), %rdx
movq 0x18(%rdx), %rdx
cmpb $0x3, %bpl
jne 0x5e620
leaq (%rsi,%rsi,4), %rsi
addq %rax, %rcx
addq %rsi, %rcx
xorl %eax, %eax
cmpq %rcx, %rdx
movl $0xa, %ebx
cmovll %eax, %ebx
jmp 0x5e652
imulq $0xfa00, %rsi, %rsi     # imm = 0xFA00
addq %rax, %rcx
addq %rsi, %rcx
movl $0x5a, %ebx
cmpq %rcx, %rdx
je 0x5e652
movl $0x0, %ebx
jl 0x5e652
addq $0x1ff, %rcx            # imm = 0x1FF
xorl %eax, %eax
cmpq %rcx, %rdx
movl $0xa, %ebx
cmovgl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/dlmaker.c
// Function: read_name
static void read_name(deark *c, lctx *d, i64 pos, de_ucstring *s, size_t nsize)
{
	size_t i;
	u8 buf[40];

	if(nsize>40) return;
	de_read(buf, pos, nsize);
	for(i=0; i<nsize; i++) {
		if(buf[i]) buf[i] ^= 0xff;
	}
	ucstring_append_bytes(s, buf, nsize, DE_CONVFLAG_STOP_AT_NUL, d->input_encoding);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq 0x18(%rdi), %rdi
movq %rsp, %rsi
movq %r8, %rcx
callq 0xeeee8
testq %rbx, %rbx
je 0x5e6a9
xorl %eax, %eax
movb (%rsp,%rax), %cl
testb %cl, %cl
je 0x5e6a1
notb %cl
movb %cl, (%rsp,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x5e695
movl (%r15), %r8d
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xf7131
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/crush.c
// Function: de_module_crush
void de_module_crush(deark *c, struct deark_module_info *mi)
{
	mi->id = "crush";
	mi->desc = "CRUSH archive";
	mi->run_fn = de_run_crush;
	mi->identify_fn = de_identify_crush;
}

// Assembly:
leaq 0xc4735(%rip), %rax     # 0x122e08
movq %rax, (%rsi)
leaq 0xc4731(%rip), %rax     # 0x122e0e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x5e6f8
movq %rax, 0x18(%rsi)
leaq 0x786(%rip), %rax       # 0x5ee79
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/crush.c
// Function: de_identify_crush
static int de_identify_crush(deark *c)
{
	u8 buf[14];

	de_read(buf, 0, 14);
	if(!de_memcmp(buf, "CRUSH v", 7) &&
		buf[10]==0x0a && buf[11]==0x1a && buf[12]==0x00)
	{
		return 100;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
leaq 0xa(%rsp), %rbx
movl $0xe, %ecx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xeeee8
movl $0x53555243, %ecx       # imm = 0x53555243
xorl (%rbx), %ecx
movl $0x76204853, %edx       # imm = 0x76204853
xorl 0x3(%rbx), %edx
movb 0xa(%rbx), %al
movb 0xb(%rbx), %sil
xorb $0xa, %al
xorb $0x1a, %sil
orb 0xc(%rbx), %sil
orb %al, %sil
movl $0x64, %eax
cmovnel %r14d, %eax
orl %ecx, %edx
cmovnel %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/cdiimage.c
// Function: de_module_cdi_imag
void de_module_cdi_imag(deark *c, struct deark_module_info *mi)
{
	mi->id = "cdi_imag";
	mi->desc = "CD-I IFF IMAG";
	mi->run_fn = de_run_cdi_imag;
	mi->identify_fn = de_identify_cdi_imag;
}

// Assembly:
leaq 0xc4049(%rip), %rax     # 0x122f48
movq %rax, (%rsi)
leaq 0xc4048(%rip), %rax     # 0x122f51
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x5ef24
movq %rax, 0x18(%rsi)
leaq 0x66(%rip), %rax        # 0x5ef85
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/cdiimage.c
// Function: de_run_cdi_imag
static void de_run_cdi_imag(deark *c, de_module_params *mparams)
{
	struct cdi_imag_ctx *d = NULL;
	struct de_iffctx *ictx = NULL;

	d = de_malloc(c, sizeof(struct cdi_imag_ctx));
	ictx = fmtutil_create_iff_decoder(c);
	ictx->userdata = (void*)d;
	ictx->has_standard_iff_chunks = 1;
	ictx->handle_chunk_fn = my_cdi_imag_chunk_handler;
	ictx->f = c->infile;
	fmtutil_read_iff_format(ictx, 0, c->infile->len);
	fmtutil_destroy_iff_decoder(ictx);
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x430, %esi            # imm = 0x430
callq 0xe969b
movq %rax, %r14
movq %rbx, %rdi
callq 0x107b04
movq %rax, %r15
movq %r14, 0x10(%rax)
movb $0x1, 0x5d(%rax)
leaq 0x7d(%rip), %rax        # 0x5efd0
movq %rax, 0x20(%r15)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r15)
movq 0x18(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x107b28
movq %r15, %rdi
callq 0x107b17
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe9752
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/cdiimage.c
// Function: yuv_to_rgb
static void yuv_to_rgb(UI y, UI u, UI v, de_color *rgbclr)
{
	double r1, g1, b1;

	b1 = (double)y + ((double)u - 128.0) * 1.733;
	r1 = (double)y + ((double)v - 128.0) * 1.371;
	g1 = ((double)y - 0.299*r1 - 0.114*b1)/0.587;
	*rgbclr = DE_MAKE_RGB(dbl_to_u8(r1), dbl_to_u8(g1), dbl_to_u8(b1));
}

// Assembly:
cvtsi2sd %edi, %xmm1
cvtsi2sd %esi, %xmm0
movsd 0xc37d1(%rip), %xmm3    # 0x122f18
addsd %xmm3, %xmm0
mulsd 0xc37cd(%rip), %xmm0    # 0x122f20
addsd %xmm1, %xmm0
cvtsi2sd %edx, %xmm2
addsd %xmm3, %xmm2
mulsd 0xc37c1(%rip), %xmm2    # 0x122f28
addsd %xmm1, %xmm2
movsd 0xc37bd(%rip), %xmm3    # 0x122f30
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
movsd 0xc37b5(%rip), %xmm1    # 0x122f38
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
divsd 0xc37ad(%rip), %xmm1    # 0x122f40
movl $0xff000000, %eax       # imm = 0xFF000000
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
jae 0x5f7c5
movl $0xffff0000, %eax       # imm = 0xFFFF0000
ucomisd 0xb7f29(%rip), %xmm2    # 0x1176d8
jae 0x5f7c5
addsd 0xb7f17(%rip), %xmm2    # 0x1176d0
cvttsd2si %xmm2, %eax
shll $0x10, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
xorl %edx, %edx
ucomisd %xmm1, %xmm3
movl $0x0, %esi
jae 0x5f7f4
movl $0xff00, %esi           # imm = 0xFF00
ucomisd 0xb7ef9(%rip), %xmm1    # 0x1176d8
jae 0x5f7f4
addsd 0xb7ee7(%rip), %xmm1    # 0x1176d0
cvttsd2si %xmm1, %esi
movzbl %sil, %esi
shll $0x8, %esi
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x5f81c
movl $0xff, %edx
ucomisd 0xb7ecd(%rip), %xmm0    # 0x1176d8
jae 0x5f81c
addsd 0xb7ebb(%rip), %xmm0    # 0x1176d0
cvttsd2si %xmm0, %edx
movzbl %dl, %edx
orl %esi, %eax
orl %edx, %eax
movl %eax, (%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/clp.c
// Function: de_module_clp
void de_module_clp(deark *c, struct deark_module_info *mi)
{
	mi->id = "clp";
	mi->desc = "Windows Clipboard";
	mi->run_fn = de_run_clp;
	mi->identify_fn = de_identify_clp;
	mi->help_fn = de_help_clp;
}

// Assembly:
leaq 0xc38e1(%rip), %rax     # 0x12310c
movq %rax, (%rsi)
leaq 0xc38db(%rip), %rax     # 0x123110
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x5f85b
movq %rax, 0x18(%rsi)
leaq 0x2e2(%rip), %rax       # 0x5fb2d
movq %rax, 0x20(%rsi)
leaq 0x321(%rip), %rax       # 0x5fb77
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/clp.c
// Function: de_identify_clp
static int de_identify_clp(deark *c)
{
	int has_ext;
	UI sig;

	// TODO: Improve this
	sig = (UI)de_getu16le(0);
	if(sig<0xc350 || sig>0xc352) return 0;
	has_ext = de_input_file_has_ext(c, "clp");
	if(has_ext) return 80;
	return 15;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef1ca
addl $0xffff3cad, %eax       # imm = 0xFFFF3CAD
cmpl $-0x3, %eax
jb 0x5fb6c
leaq 0xc35b9(%rip), %rsi     # 0x12310c
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0xf, %eax
movl $0x50, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/comicchat.c
// Function: de_module_comicchat
void de_module_comicchat(deark *c, struct deark_module_info *mi)
{
	mi->id = "comicchat";
	mi->desc = "Microsoft Comic Chat AVB or BGB";
	mi->run_fn = de_run_comicchat;
	mi->identify_fn = de_identify_comicchat;
	mi->help_fn = de_help_comicchat;
}

// Assembly:
leaq 0xc3101(%rip), %rax     # 0x123350
movq %rax, (%rsi)
leaq 0xc3101(%rip), %rax     # 0x12335a
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x6027f
movq %rax, 0x18(%rsi)
leaq 0x5be(%rip), %rax       # 0x6082d
movq %rax, 0x20(%rsi)
leaq 0x6af(%rip), %rax       # 0x60929
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/comicchat.c
// Function: de_identify_comicchat
static int de_identify_comicchat(deark *c)
{
	u8 has_ext, has_hdr, has_endtag;
	UI n0, n2, n4;

	n0 = (UI)de_getu16be(0);
	if(n0!=0x8100 && n0!=0x8181) return 0;
	n2 = (UI)de_getu16le(2);
	n4 = (UI)de_getu16le(4);

	has_hdr = 0;
	if(n0==0x8100) {
		if(n4==1 && (n2==1 || n2==2)) has_hdr = 1;
	}
	else { // 0x8181
		if(n4==2 && (n2>=1 && n2<=3)) has_hdr = 1;
	}
	if(!has_hdr) return 0;

	has_endtag = (de_getu16le(c->infile->len - 2) == 0x0007);
	has_ext = (de_input_file_has_ext(c, "avb") ||
		de_input_file_has_ext(c, "bgb"));
	if(has_endtag && has_ext) return 100;
	if(has_endtag || has_ext) return 55;
	return 35;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef169
movq %rax, %r15
cmpl $0x8181, %r15d          # imm = 0x8181
je 0x6085f
cmpl $0x8100, %r15d          # imm = 0x8100
jne 0x6091a
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef1ca
movq %rax, %r12
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef1ca
cmpl $0x8100, %r15d          # imm = 0x8100
jne 0x6089d
cmpl $0x1, %eax
sete %al
decl %r12d
cmpl $0x2, %r12d
setb %cl
testb %cl, %al
jne 0x608b2
jmp 0x6091a
cmpl $0x2, %eax
setne %al
addl $-0x4, %r12d
cmpl $-0x3, %r12d
setb %cl
orb %al, %cl
jne 0x6091a
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rsi
addq $-0x2, %rsi
callq 0xef1ca
movq %rax, %r15
leaq 0xc2d12(%rip), %rsi     # 0x1235df
movq %rbx, %rdi
callq 0xea936
movb $0x1, %cl
testl %eax, %eax
jne 0x608ef
leaq 0xc2d01(%rip), %rsi     # 0x1235e3
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
setne %cl
cmpq $0x7, %r15
sete %al
movl $0x64, %r14d
testb %cl, %al
jne 0x6091a
testb $0x1, %cl
movl $0x37, %eax
movl $0x23, %r14d
cmovnel %eax, %r14d
cmpq $0x7, %r15
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/comicchat.c
// Function: handle_chunk_string
static void handle_chunk_string(deark *c, lctx *d, i64 pos, i64 len,
	de_ucstring *s, const char *name)
{
	ucstring_empty(s);
	dbuf_read_to_ucstring_n(c->infile, pos, len, 512, s,
		DE_CONVFLAG_STOP_AT_NUL, d->input_encoding);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz_d(s));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %r8, %rdi
callq 0xf6883
movq 0x18(%rbp), %rdi
movl (%r13), %eax
movl %eax, (%rsp)
movl $0x200, %ecx            # imm = 0x200
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r8
movl $0x1, %r9d
callq 0xf0203
movq %r14, %rdi
callq 0xf7557
leaq 0xcb49d(%rip), %rsi     # 0x12be42
movq %rbp, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %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/comicchat.c
// Function: handle_chunk_multiimageptr
static void handle_chunk_multiimageptr(deark *c, lctx *d, struct chunk_ctx *cctx,
	i64 offset, i64 item_size, i64 item_count)
{
	i64 pos;
	i64 i;

	de_dbg(c, "item count: %"I64_FMT, item_count);
	pos = cctx->ck_pos + offset;

	for(i=0; i<item_count; i++) {
		i64 n, m1, m2;

		n = de_getu32le(pos);
		m1 = de_getu32le(pos+4);
		m2 = de_getu32le(pos+8);
		if(!found_image(c, d, cctx, n, m1, m2)) goto done;
		pos += item_size;
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
leaq 0xc2be4(%rip), %rsi     # 0x1235cf
movq %r8, %rdx
xorl %eax, %eax
callq 0xe9226
testq %rbx, %rbx
jle 0x60a55
movq 0x8(%r15), %rbp
addq $0xc, %rbp
leaq -0x8(%rbp), %rsi
movq 0x18(%r13), %rdi
callq 0xef37e
movq %rax, %r14
movq 0x18(%r13), %rdi
leaq -0x4(%rbp), %rsi
callq 0xef37e
movq %rax, %r12
movq 0x18(%r13), %rdi
movq %rbp, %rsi
callq 0xef37e
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %rax, %r9
callq 0x60a64
testl %eax, %eax
je 0x60a55
addq 0x8(%rsp), %rbp
decq %rbx
jne 0x60a02
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/comicchat.c
// Function: emit_images_highlevel_separate
static void emit_images_highlevel_separate(deark *c, lctx *d,
	struct image_highlevel_ctx *ih)
{
	size_t k;

	if(ih->llimg[0].img) {
		if(ih->is_icon) {
			de_finfo_set_name_from_sz(c, ih->llimg[0].fi,
				"icon", 0, DE_ENCODING_LATIN1);
		}
		de_bitmap_write_to_file_finfo(ih->llimg[0].img, ih->llimg[0].fi,
			ih->llimg[0].createflags);
	}
	for(k=1; k<=2; k++) {
		if(ih->llimg[k].img) {
			de_finfo_set_name_from_sz(c, ih->llimg[k].fi,
				(k==1?"sm_mask":"lg_mask"), 0, DE_ENCODING_LATIN1);
			de_bitmap_write_to_file_finfo(ih->llimg[k].img, ih->llimg[k].fi,
				(ih->llimg[k].createflags | DE_CREATEFLAG_IS_AUX));
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x6131a
cmpb $0x0, 0x1(%rbx)
je 0x6130a
movq 0x10(%rbx), %rsi
leaq 0xc3ab0(%rip), %rdx     # 0x124daa
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x5, %r8d
callq 0xeac7c
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x18(%rbx), %edx
callq 0xf2917
xorl %r15d, %r15d
leaq 0xc229b(%rip), %r12     # 0x1235bf
leaq 0xc229c(%rip), %r13     # 0x1235c7
cmpq $0x0, 0x20(%rbx,%r15)
je 0x61369
movq 0x28(%rbx,%r15), %rsi
testq %r15, %r15
movq %r13, %rdx
cmoveq %r12, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x5, %r8d
callq 0xeac7c
movq 0x20(%rbx,%r15), %rdi
movq 0x28(%rbx,%r15), %rsi
movl 0x30(%rbx,%r15), %edx
orl $0x1, %edx
callq 0xf2917
addq $0x18, %r15
cmpq $0x30, %r15
jne 0x6132b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/comicchat.c
// Function: extract_whole_bmp
static void extract_whole_bmp(deark *c, lctx *d, dbuf *inf, i64 pos1,
	struct image_highlevel_ctx *ih)
{
	i64 bmplen;
	dbuf *outf = NULL;
	const char *ext;

	bmplen = dbuf_getu32le(inf, pos1+2);
	if(pos1+bmplen > inf->len) goto done;
	if(bmplen < 54) goto done;

	if(ih->is_icon) {
		ext = "icon.bmp";
	}
	else {
		ext = "bmp";
	}
	outf = dbuf_create_output_file(c, ext, NULL, 0);
	dbuf_copy(inf, pos1, bmplen, outf);

done:
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x2(%rdx), %rsi
movq %r14, %rdi
callq 0xef37e
xorl %r13d, %r13d
cmpq $0x36, %rax
jl 0x613eb
movq %rax, %r15
addq %rbx, %rax
cmpq 0x18(%r14), %rax
jg 0x613eb
cmpb $0x0, 0x1(%rbp)
leaq 0xbfc92(%rip), %rax     # 0x121052
leaq 0xc21a0(%rip), %rsi     # 0x123567
cmoveq %rax, %rsi
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xefabc
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf0b13
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/comicchat.c
// Function: reconstruct_bmp_and_cvt_to_img
static void reconstruct_bmp_and_cvt_to_img(deark *c, lctx *d,
	struct image_extract_ctx *ic, struct image_highlevel_ctx *ih, int itype,
	u8 direct_to_bmp)
{
	dbuf *tmpbmp = NULL;

	tmpbmp = dbuf_create_membuf(c, 0, 0);
	fmtutil_generate_bmpfileheader(c, tmpbmp, &ic->bi, 0);
	dbuf_copy(c->infile, ic->ihpos, ic->bi.infohdrsize, tmpbmp);
	write_palette(c, d, tmpbmp, ic->pal, ic->bi.pal_entries);
	dbuf_copy(ic->unc_pixels, 0, ic->unc_pixels->len, tmpbmp);
	dbuf_flush(tmpbmp);
	if(direct_to_bmp) {
		extract_whole_bmp(c, d, tmpbmp, 0, ih);
	}
	else {
		read_bmp_to_img(c, d, tmpbmp, 0, ih, itype);
	}
	dbuf_close(tmpbmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r12d
movl %ecx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0xf0faf
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xf7d41
movq 0x18(%r15), %rdi
movq 0x18(%r13), %rdx
movq 0xa0(%r13), %rsi
movq %r14, %rcx
callq 0xefabc
movq 0x50(%r13), %rbp
testq %rbp, %rbp
jle 0x616c0
xorl %ebx, %ebx
movzbl 0xb8(%r13,%rbx,4), %esi
movq %r14, %rdi
callq 0xf11be
movzbl 0xb9(%r13,%rbx,4), %esi
movq %r14, %rdi
callq 0xf11be
movzbl 0xba(%r13,%rbx,4), %esi
movq %r14, %rdi
callq 0xf11be
movq %r14, %rdi
xorl %esi, %esi
callq 0xf11be
incq %rbx
cmpq %rbx, %rbp
jne 0x6167b
movq 0xa8(%r13), %rdi
movq 0x18(%rdi), %rdx
xorl %esi, %esi
movq %r14, %rcx
callq 0xefabc
movq %r14, %rdi
callq 0xf0ea4
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
testb %r12b, %r12b
je 0x616f6
movq 0x10(%rsp), %rcx
callq 0x6137d
jmp 0x61705
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0x61401
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf0b13
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_module_txt2com
void de_module_txt2com(deark *c, struct deark_module_info *mi)
{
	mi->id = "txt2com";
	mi->desc = "TXT2COM (K. P. Graham)";
	mi->run_fn = de_run_txt2com;
	mi->identify_fn = de_identify_txt2com;
	mi->help_fn = de_help_txt2com;
}

// Assembly:
leaq 0xc1f41(%rip), %rax     # 0x123664
movq %rax, (%rsi)
leaq 0xc1f3f(%rip), %rax     # 0x12366c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x61753
movq %rax, 0x18(%rsi)
leaq 0x194(%rip), %rax       # 0x618d7
movq %rax, 0x20(%rsi)
leaq 0x2a0(%rip), %rax       # 0x619ee
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_run_txt2com
static void de_run_txt2com(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = create_lctx(c);
	exectext_set_common_enc_opts(c, d, DE_ENCODING_CP437);
	d->chartypes[10] = ETCT_CONTROL;
	d->chartypes[13] = ETCT_CONTROL;
	de_declare_fmt(c, "TXT2COM");

	txt2com_search1(c, d);
	if(!d->found_text) {
		txt2com_search2(c, d);
	}
	if(!d->found_text) {
		d->need_errmsg = 1;
		goto done;
	}
	if(d->errflag) goto done;

	exectext_extract_default(c, d);

done:
	if(d) {
		if(d->need_errmsg) {
			de_err(c, "Not a TXT2COM file, or unsupported version");
		}
		destroy_lctx(c, d);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x138, %esi            # imm = 0x138
callq 0xe969b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x634f2
movb $0x1, %al
movb %al, 0x42(%r14)
movb %al, 0x45(%r14)
leaq 0xc203e(%rip), %rsi     # 0x1237ce
movq %rbx, %rdi
callq 0xeb6d6
movl $0xbb8, %esi            # imm = 0xBB8
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x2bc, %edx            # imm = 0x2BC
movl $0xbb8, %ecx            # imm = 0xBB8
movq %rax, %rsi
callq 0xeeee8
leaq 0xc2056(%rip), %rdx     # 0x12381b
leaq 0x8(%rsp), %r9
movl $0xbb8, %esi            # imm = 0xBB8
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xec044
testl %eax, %eax
je 0x61800
movb $0x1, 0x14(%r14)
movl $0x2c2, %edx            # imm = 0x2C2
addq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63689
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe9752
cmpb $0x0, 0x14(%r14)
jne 0x61885
movl $0xfa0, %esi            # imm = 0xFA0
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x1d4c, %edx           # imm = 0x1D4C
movl $0xfa0, %ecx            # imm = 0xFA0
movq %rax, %rsi
callq 0xeeee8
leaq 0xc2017(%rip), %rdx     # 0x123856
leaq 0x8(%rsp), %r9
movl $0xfa0, %esi            # imm = 0xFA0
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xec044
testl %eax, %eax
je 0x6187a
movb $0x1, 0x14(%r14)
movl $0x1d55, %edx           # imm = 0x1D55
addq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63689
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe9752
cmpb $0x0, 0x14(%r14)
je 0x618a0
cmpb $0x0, 0x12(%r14)
jne 0x618a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63581
jmp 0x618a5
movb $0x1, 0x13(%r14)
testq %r14, %r14
je 0x618cd
cmpb $0x0, 0x13(%r14)
je 0x618c2
leaq 0xc1f1e(%rip), %rsi     # 0x1237d6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9752
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_identify_txt2com
static int de_identify_txt2com(deark *c)
{
	u8 b1;
	u8 flag = 0;
	u8 buf[28];
	const char *ids[3] = {"TXT2COM C", "TXT2RES C", "TXT2PAS C"};

	if(c->infile->len>65280) return 0;
	b1 = de_getbyte(0);
	if(b1!=0x8d && b1!=0xe8 && b1!=0xe9) return 0;
	de_read(buf, 0, sizeof(buf));
	if(b1==0x8d) {
		if(!de_memcmp(&buf[14], ids[0], 9)) flag = 1;
	}
	else if(b1==0xe8) {
		if(!de_memcmp(&buf[5], ids[0], 9)) flag = 1;
	}
	else if(b1==0xe9) {
		if(!de_memcmp(&buf[3], ids[0], 9)) flag = 1;
		else if(!de_memcmp(&buf[3], ids[1], 9)) flag = 1;
		else if(!de_memcmp(&buf[3], ids[2], 9)) flag = 1;
	}
	return flag ? 92 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0xff00, 0x18(%rdi)     # imm = 0xFF00
jg 0x619e1
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef0d5
movl %eax, %ebp
movzbl %al, %r15d
leal -0xe8(%r15), %eax
cmpl $0x2, %eax
jb 0x61920
cmpl $0x8d, %r15d
jne 0x619e1
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
movq %rsp, %rsi
movl $0x1c, %ecx
xorl %edx, %edx
callq 0xeeee8
cmpb $-0x17, %bpl
je 0x6197d
cmpl $0xe8, %r15d
je 0x61967
cmpl $0x8d, %r15d
jne 0x619e1
movabsq $0x204d4f4332545854, %rax # imm = 0x204D4F4332545854
xorq 0xe(%rsp), %rax
movzbl 0x16(%rsp), %ecx
jmp 0x619d0
movabsq $0x204d4f4332545854, %rax # imm = 0x204D4F4332545854
xorq 0x5(%rsp), %rax
movzbl 0xd(%rsp), %ecx
jmp 0x619d0
movabsq $0x204d4f4332545854, %rax # imm = 0x204D4F4332545854
xorq 0x3(%rsp), %rax
movzbl 0xb(%rsp), %ecx
xorq $0x43, %rcx
movl $0x5c, %ebx
orq %rax, %rcx
je 0x619e1
movabsq $0x2053455232545854, %rax # imm = 0x2053455232545854
xorq 0x3(%rsp), %rax
movzbl 0xb(%rsp), %ecx
xorq $0x43, %rcx
orq %rax, %rcx
je 0x619e1
movabsq $0x2053415032545854, %rax # imm = 0x2053415032545854
xorq 0x3(%rsp), %rax
movzbl 0xb(%rsp), %ecx
xorq $0x43, %rcx
xorl %edx, %edx
orq %rax, %rcx
movl $0x5c, %ebx
cmovnel %edx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_module_show_gmr
void de_module_show_gmr(deark *c, struct deark_module_info *mi)
{
	mi->id = "show_gmr";
	mi->desc = "SHOW (G. M. Raymond)";
	mi->run_fn = de_run_show_gmr;
	mi->identify_fn = de_identify_show_gmr;
	mi->help_fn = de_help_show_gmr;
}

// Assembly:
leaq 0xc1c6a(%rip), %rax     # 0x123683
movq %rax, (%rsi)
leaq 0xc1c69(%rip), %rax     # 0x12368c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x61a49
movq %rax, 0x18(%rsi)
leaq 0x16c(%rip), %rax       # 0x61ba5
movq %rax, 0x20(%rsi)
leaq 0x1c9(%rip), %rax       # 0x61c0d
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_run_show_gmr
static void de_run_show_gmr(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = create_lctx(c);
	exectext_set_common_enc_opts(c, d, DE_ENCODING_CP437);
	de_declare_fmt(c, "SHOW (executable text)");
	d->chartypes[10] = ETCT_CONTROL;
	d->chartypes[13] = ETCT_CONTROL;

	showgmr_search(c, d);
	if(!d->found_text) {
		d->need_errmsg = 1;
		goto done;
	}
	de_dbg(c, "tpos: %"I64_FMT, d->tpos);

	d->tlen = c->infile->len - d->tpos;
	if(de_getbyte(c->infile->len-1) == 0x1a) {
		d->tlen--;
	}

	exectext_extract_default(c, d);

done:
	if(d) {
		if(d->need_errmsg) {
			de_err(c, "Not a SHOW file, or unsupported version");
		}
		destroy_lctx(c, d);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x138, %esi            # imm = 0x138
callq 0xe969b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x634f2
leaq 0xc1e7e(%rip), %rsi     # 0x1238fa
movq %rbx, %rdi
callq 0xeb6d6
movb $0x1, %al
movb %al, 0x42(%r14)
movb %al, 0x45(%r14)
movl $0x4b0, %esi            # imm = 0x4B0
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x708, %edx            # imm = 0x708
movl $0x4b0, %ecx            # imm = 0x4B0
movq %rax, %rsi
callq 0xeeee8
leaq 0xc2175(%rip), %rdx     # 0x123c30
leaq 0x8(%rsp), %r9
movl $0x4b0, %esi            # imm = 0x4B0
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xec044
testl %eax, %eax
jne 0x61b04
leaq 0xc1e56(%rip), %rdx     # 0x123939
leaq 0x8(%rsp), %r9
movl $0x4b0, %esi            # imm = 0x4B0
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xec044
testl %eax, %eax
je 0x61b17
movb $0x1, 0x14(%r14)
movl $0x718, %eax            # imm = 0x718
addq 0x8(%rsp), %rax
movq %rax, 0x28(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe9752
cmpb $0x0, 0x14(%r14)
je 0x61b6e
movq 0x28(%r14), %rdx
leaq 0xc1f2c(%rip), %rsi     # 0x123a60
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rsi
movq %rsi, %rax
subq 0x28(%r14), %rax
movq %rax, 0x30(%r14)
decq %rsi
callq 0xef0d5
cmpb $0x1a, %al
jne 0x61b61
decq 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63581
jmp 0x61b73
movb $0x1, 0x13(%r14)
testq %r14, %r14
je 0x61b9b
cmpb $0x0, 0x13(%r14)
je 0x61b90
leaq 0xc1d8b(%rip), %rsi     # 0x123911
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9752
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_identify_show_gmr
static int de_identify_show_gmr(deark *c)
{
	if(c->infile->len>65280) return 0;
	if(de_getbyte(0) != 0xe9) return 0;
	// Testing the last byte of the file may screen out corrupt files, but
	// more importantly screens out the SHOW.COM utility itself, which
	// annoyingly has the same the start-of-file signature as the files it
	// generates.
	if(de_getbyte(c->infile->len-1) != 0x1a) return 0;
	// Byte at offset 3 is 0x30 in pristine files, but it's used to save the
	// color scheme (it's a self-modifying COM file).
	if(dbuf_memcmp(c->infile, 4,
		(const u8*)"\x00\x1f\xa0\x00\x00\x53\x48\x4f\x57", 9))
	{
		return 0;
	}
	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0xff00, 0x18(%rdi)     # imm = 0xFF00
jg 0x61c03
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef0d5
cmpb $-0x17, %al
jne 0x61c03
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rsi
decq %rsi
callq 0xef0d5
cmpb $0x1a, %al
jne 0x61c03
movq 0x18(%r14), %rdi
leaq 0xc2059(%rip), %rdx     # 0x123c41
movl $0x4, %esi
movl $0x9, %ecx
callq 0xf025e
xorl %ecx, %ecx
testl %eax, %eax
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/exectext.c
// Function: de_module_asc2com
void de_module_asc2com(deark *c, struct deark_module_info *mi)
{
	mi->id = "asc2com";
	mi->desc = "Asc2Com executable text";
	mi->run_fn = de_run_asc2com;
	mi->identify_fn = de_identify_asc2com;
	mi->help_fn = de_help_asc2com;
}

// Assembly:
leaq 0xc1a69(%rip), %rax     # 0x1236a1
movq %rax, (%rsi)
leaq 0xc1a67(%rip), %rax     # 0x1236a9
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x61c68
movq %rax, 0x18(%rsi)
leaq 0x3e3(%rip), %rax       # 0x6203b
movq %rax, 0x20(%rsi)
leaq 0x416(%rip), %rax       # 0x62079
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_identify_asc2com
static int de_identify_asc2com(deark *c)
{
	struct asc2com_detection_data idd;

	if(c->infile->len>65280) return 0;
	de_zeromem(&idd, sizeof(struct asc2com_detection_data));
	asc2com_identify(c, &idd, 1);
	if(idd.found) return 72;
	return 0;
}

// Assembly:
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq $0xff00, 0x18(%rcx)     # imm = 0xFF00
jg 0x62078
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rsi
movl $0x1, %edx
callq 0x63a2c
xorl %ecx, %ecx
cmpb $0x0, (%rbx)
movl $0x48, %eax
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_module_doc2com
void de_module_doc2com(deark *c, struct deark_module_info *mi)
{
	mi->id = "doc2com";
	mi->desc = "DOC2COM executable text (G. DePyper)";
	mi->run_fn = de_run_doc2com;
	mi->identify_fn = de_identify_doc2com;
	mi->help_fn = de_help_doc2com;
}

// Assembly:
leaq 0xc161d(%rip), %rax     # 0x1236c1
movq %rax, (%rsi)
leaq 0xc161b(%rip), %rax     # 0x1236c9
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x620d4
movq %rax, 0x18(%rsi)
leaq 0x423(%rip), %rax       # 0x624e7
movq %rax, 0x20(%rsi)
leaq 0x478(%rip), %rax       # 0x62547
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_identify_doc2com
static int de_identify_doc2com(deark *c)
{
	struct doc2com_detection_data idd;
	u8 b;

	if(c->infile->len>65280) return 0;
	b = de_getbyte(0);
	if(b!=0xbe && b!=0xfc) return 0;

	de_zeromem(&idd, sizeof(struct doc2com_detection_data));
	doc2com_detect(c, &idd, 1);
	if(idd.found) return 73;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
cmpq $0xff00, 0x18(%rdi)     # imm = 0xFF00
jg 0x6253c
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef0d5
cmpb $-0x4, %al
je 0x62517
movzbl %al, %eax
cmpl $0xbe, %eax
jne 0x6253c
movq %rsp, %r14
movq $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63d49
xorl %eax, %eax
cmpb $0x0, (%r14)
movl $0x49, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_module_doc2com_dkn
void de_module_doc2com_dkn(deark *c, struct deark_module_info *mi)
{
	mi->id = "doc2com_dkn";
	mi->desc = "DOC2COM executable text (D. Nelson)";
	mi->run_fn = de_run_doc2com_dkn;
	mi->identify_fn = de_identify_doc2com_dkn;
	mi->help_fn = de_help_doc2com_dkn;
}

// Assembly:
leaq 0xc117c(%rip), %rax     # 0x1236ee
movq %rax, (%rsi)
leaq 0xc117e(%rip), %rax     # 0x1236fa
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x625a2
movq %rax, 0x18(%rsi)
leaq 0x190(%rip), %rax       # 0x62722
movq %rax, 0x20(%rsi)
leaq 0x1ef(%rip), %rax       # 0x6278c
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: de_run_doc2com_dkn
static void de_run_doc2com_dkn(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos_of_tpos = 0;
	i64 pos_of_tlen = 0;
	UI n;
	UI b1, b2;

	d = create_lctx(c);
	exectext_set_common_enc_opts(c, d, DE_ENCODING_CP437);
	d->chartypes[7] = ETCT_CONTROL;
	d->chartypes[8] = ETCT_CONTROL;
	d->chartypes[9] = ETCT_CONTROL;
	d->chartypes[10] = ETCT_CONTROL;
	d->chartypes[13] = ETCT_CONTROL;
	d->chartypes[27] = ETCT_CONTROL;

	n = (UI)de_getu16le(1);
	if(n==0x0093) {
		d->fmtcode = 1;
		pos_of_tpos = 171;
		pos_of_tlen = 178;
	}
	else if(n==0x0107) {
		d->fmtcode = 2;
		pos_of_tpos = 293;
		pos_of_tlen = 300;
	}

	if(d->fmtcode==0) goto done;
	if(de_getbyte(pos_of_tpos-1)!=0xbf) goto done;
	de_dbg(c, "fmt code: %u", d->fmtcode);
	d->tpos = de_getu16le(pos_of_tpos);
	d->tpos -= 0x100;
	if(d->fmtcode==2) d->tpos--;
	de_dbg(c, "tpos: %"I64_FMT, d->tpos);

	b1 = de_getbyte(pos_of_tlen);
	b2 = de_getbyte(pos_of_tlen+2);
	d->tlen = ((UI)b1<<8) | b2;
	de_dbg(c, "tlen: %"I64_FMT, d->tlen);

	exectext_extract_default(c, d);

done:
	if(d) {
		if(d->need_errmsg) {
			de_err(c, "Not a DOC2COM file, or unsupported version");
		}
		destroy_lctx(c, d);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x138, %esi            # imm = 0x138
callq 0xe969b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x634f2
movb $0x1, %al
movb %al, 0x45(%r14)
movb %al, 0x53(%r14)
movl $0x1010101, 0x3f(%r14)  # imm = 0x1010101
movq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0xef1ca
cmpl $0x93, %eax
je 0x6260e
cmpl $0x107, %eax            # imm = 0x107
jne 0x62625
movl $0x125, %r12d           # imm = 0x125
movl $0x12c, %r15d           # imm = 0x12C
movl $0x2, %eax
jmp 0x6261f
movl $0xab, %r12d
movl $0xb2, %r15d
movl $0x1, %eax
movl %eax, 0xc(%r14)
jmp 0x6262b
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl $0x0, 0xc(%r14)
je 0x626e9
movq 0x18(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0xef0d5
cmpb $-0x41, %al
jne 0x626e9
movl 0xc(%r14), %edx
leaq 0xc13bd(%rip), %rsi     # 0x123a14
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef1ca
leaq -0x100(%rax), %rcx
movq %rcx, 0x28(%r14)
cmpl $0x2, 0xc(%r14)
jne 0x62689
addq $-0x101, %rax           # imm = 0xFEFF
movq %rax, 0x28(%r14)
movq 0x28(%r14), %rdx
leaq 0xc13cc(%rip), %rsi     # 0x123a60
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef0d5
movl %eax, %ebp
movq 0x18(%rbx), %rdi
addq $0x2, %r15
movq %r15, %rsi
callq 0xef0d5
movzbl %al, %eax
movzbl %bpl, %edx
shll $0x8, %edx
orq %rax, %rdx
movq %rdx, 0x30(%r14)
leaq 0xc1178(%rip), %rsi     # 0x12384c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63581
testq %r14, %r14
je 0x62719
cmpb $0x0, 0x13(%r14)
je 0x62706
leaq 0xc1325(%rip), %rsi     # 0x123a21
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe9752
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq