LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xc2279(%rip), %rax     # 0x123844
movq %rax, (%rsi)
leaq 0xc2277(%rip), %rax     # 0x12384c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x615fb
movq %rax, 0x18(%rsi)
leaq 0x18f(%rip), %rax       # 0x6177a
movq %rax, 0x20(%rsi)
leaq 0x29b(%rip), %rax       # 0x61891
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63336
movb $0x1, %al
movb %al, 0x42(%r14)
movb %al, 0x45(%r14)
leaq 0xc2376(%rip), %rsi     # 0x1239ae
movq %rbx, %rdi
callq 0xeb125
movl $0xbb8, %esi            # imm = 0xBB8
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x2bc, %edx            # imm = 0x2BC
movl $0xbb8, %ecx            # imm = 0xBB8
movq %rax, %rsi
callq 0xee8d4
leaq 0xc238e(%rip), %rdx     # 0x1239fb
leaq 0x8(%rsp), %r9
movl $0xbb8, %esi            # imm = 0xBB8
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xeba66
testl %eax, %eax
je 0x616a8
movb $0x1, 0x14(%r14)
movl $0x2c2, %edx            # imm = 0x2C2
addq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x634c1
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
cmpb $0x0, 0x14(%r14)
jne 0x61734
movl $0xfa0, %esi            # imm = 0xFA0
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x1d4c, %edx           # imm = 0x1D4C
movl $0xfa0, %ecx            # imm = 0xFA0
movq %rax, %rsi
callq 0xee8d4
leaq 0xc234f(%rip), %rdx     # 0x123a36
leaq 0x8(%rsp), %r9
movl $0xfa0, %esi            # imm = 0xFA0
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xeba66
testl %eax, %eax
je 0x61722
movb $0x1, 0x14(%r14)
movl $0x1d55, %edx           # imm = 0x1D55
addq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x634c1
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
cmpb $0x0, 0x14(%r14)
je 0x61748
cmpb $0x0, 0x12(%r14)
jne 0x6174d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x633b6
jmp 0x6174d
movb $0x1, 0x13(%r14)
cmpb $0x0, 0x13(%r14)
je 0x61765
leaq 0xc225b(%rip), %rsi     # 0x1239b6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x61884
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
movl %eax, %ebp
movzbl %al, %r15d
leal -0xe8(%r15), %eax
cmpl $0x2, %eax
jb 0x617c3
cmpl $0x8d, %r15d
jne 0x61884
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
movq %rsp, %rsi
movl $0x1c, %ecx
xorl %edx, %edx
callq 0xee8d4
cmpb $-0x17, %bpl
je 0x61820
cmpl $0xe8, %r15d
je 0x6180a
cmpl $0x8d, %r15d
jne 0x61884
movabsq $0x204d4f4332545854, %rax # imm = 0x204D4F4332545854
xorq 0xe(%rsp), %rax
movzbl 0x16(%rsp), %ecx
jmp 0x61873
movabsq $0x204d4f4332545854, %rax # imm = 0x204D4F4332545854
xorq 0x5(%rsp), %rax
movzbl 0xd(%rsp), %ecx
jmp 0x61873
movabsq $0x204d4f4332545854, %rax # imm = 0x204D4F4332545854
xorq 0x3(%rsp), %rax
movzbl 0xb(%rsp), %ecx
xorq $0x43, %rcx
movl $0x5c, %ebx
orq %rax, %rcx
je 0x61884
movabsq $0x2053455232545854, %rax # imm = 0x2053455232545854
xorq 0x3(%rsp), %rax
movzbl 0xb(%rsp), %ecx
xorq $0x43, %rcx
orq %rax, %rcx
je 0x61884
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_O3/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 0xc1fa7(%rip), %rax     # 0x123863
movq %rax, (%rsi)
leaq 0xc1fa6(%rip), %rax     # 0x12386c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x618ec
movq %rax, 0x18(%rsi)
leaq 0x167(%rip), %rax       # 0x61a43
movq %rax, 0x20(%rsi)
leaq 0x1c4(%rip), %rax       # 0x61aab
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63336
leaq 0xc21bb(%rip), %rsi     # 0x123ada
movq %rbx, %rdi
callq 0xeb125
movb $0x1, %al
movb %al, 0x42(%r14)
movb %al, 0x45(%r14)
movl $0x4b0, %esi            # imm = 0x4B0
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x708, %edx            # imm = 0x708
movl $0x4b0, %ecx            # imm = 0x4B0
movq %rax, %rsi
callq 0xee8d4
leaq 0xc24b2(%rip), %rdx     # 0x123e10
leaq 0x8(%rsp), %r9
movl $0x4b0, %esi            # imm = 0x4B0
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xeba66
testl %eax, %eax
jne 0x619a7
leaq 0xc2193(%rip), %rdx     # 0x123b19
leaq 0x8(%rsp), %r9
movl $0x4b0, %esi            # imm = 0x4B0
movl $0x10, %ecx
movq %r15, %rdi
movl $0x3f, %r8d
callq 0xeba66
testl %eax, %eax
je 0x619ba
movb $0x1, 0x14(%r14)
movl $0x718, %eax            # imm = 0x718
addq 0x8(%rsp), %rax
movq %rax, 0x28(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
cmpb $0x0, 0x14(%r14)
je 0x61a18
movq 0x28(%r14), %rdx
leaq 0xc2269(%rip), %rsi     # 0x123c40
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rsi
movq %rsi, %rax
subq 0x28(%r14), %rax
movq %rax, 0x30(%r14)
decq %rsi
callq 0xeead3
cmpb $0x1a, %al
jne 0x61a04
decq 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x633b6
cmpb $0x0, 0x13(%r14)
jne 0x61a1d
jmp 0x61a2e
movb $0x1, 0x13(%r14)
leaq 0xc20cd(%rip), %rsi     # 0x123af1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x61aa1
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $-0x17, %al
jne 0x61aa1
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rsi
decq %rsi
callq 0xeead3
cmpb $0x1a, %al
jne 0x61aa1
movq 0x18(%r14), %rdi
leaq 0xc239b(%rip), %rdx     # 0x123e21
movl $0x4, %esi
movl $0x9, %ecx
callq 0xefc85
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_O3/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 0xc1dab(%rip), %rax     # 0x123881
movq %rax, (%rsi)
leaq 0xc1da9(%rip), %rax     # 0x123889
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x61b06
movq %rax, 0x18(%rsi)
leaq 0x3c5(%rip), %rax       # 0x61ebb
movq %rax, 0x20(%rsi)
leaq 0x3f8(%rip), %rax       # 0x61ef9
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x61ef8
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rsi
movl $0x1, %edx
callq 0x63864
xorl %ecx, %ecx
cmpb $0x0, (%rbx)
movl $0x48, %eax
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc197d(%rip), %rax     # 0x1238a1
movq %rax, (%rsi)
leaq 0xc197b(%rip), %rax     # 0x1238a9
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x61f54
movq %rax, 0x18(%rsi)
leaq 0x425(%rip), %rax       # 0x62369
movq %rax, 0x20(%rsi)
leaq 0x47b(%rip), %rax       # 0x623ca
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x623bf
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeead3
cmpb $-0x4, %al
je 0x62399
movzbl %al, %eax
cmpl $0xbe, %eax
jne 0x623bf
movq %rsp, %r14
movq $0x0, (%r14)
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x63b71
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_O3/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 0xc14d9(%rip), %rax     # 0x1238ce
movq %rax, (%rsi)
leaq 0xc14db(%rip), %rax     # 0x1238da
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x62425
movq %rax, 0x18(%rsi)
leaq 0x181(%rip), %rax       # 0x62596
movq %rax, 0x20(%rsi)
leaq 0x1e0(%rip), %rax       # 0x62600
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63336
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 0xeebc8
cmpl $0x93, %eax
je 0x62491
cmpl $0x107, %eax            # imm = 0x107
jne 0x624a8
movl $0x125, %r12d           # imm = 0x125
movl $0x12c, %r15d           # imm = 0x12C
movl $0x2, %eax
jmp 0x624a2
movl $0xab, %r12d
movl $0xb2, %r15d
movl $0x1, %eax
movl %eax, 0xc(%r14)
jmp 0x624b9
cmpl $0x0, 0xc(%r14)
je 0x6256b
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0xeead3
cmpb $-0x41, %al
jne 0x6256b
movl 0xc(%r14), %edx
leaq 0xc171a(%rip), %rsi     # 0x123bf4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebc8
leaq -0x100(%rax), %rdx
movq %rdx, 0x28(%r14)
cmpl $0x2, 0xc(%r14)
jne 0x6250f
addq $-0x101, %rax           # imm = 0xFEFF
movq %rax, 0x28(%r14)
movq %rax, %rdx
leaq 0xc172a(%rip), %rsi     # 0x123c40
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeead3
movl %eax, %ebp
movq 0x18(%rbx), %rdi
addq $0x2, %r15
movq %r15, %rsi
callq 0xeead3
movzbl %al, %eax
movzbl %bpl, %edx
shll $0x8, %edx
orq %rax, %rdx
movq %rdx, 0x30(%r14)
leaq 0xc14d6(%rip), %rsi     # 0x123a2c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movq %r14, %rsi
callq 0x633b6
cmpb $0x0, 0x13(%r14)
je 0x62583
leaq 0xc1688(%rip), %rsi     # 0x123c01
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_identify_doc2com_dkn
static int de_identify_doc2com_dkn(deark *c)
{
	UI n;
	i64 pos;

	if(c->infile->len>65280) return 0;
	n = (UI)de_getu32be(0);
	if(n==0xe9930000U) {
		pos = 27;
	}
	else if(n==0xe9070100U) {
		pos = 19;
	}
	else {
		return 0;
	}

	if(dbuf_memcmp(c->infile, pos, (const void*)"Press  Home  P", 14)) {
		return 0;
	}
	return 79;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
cmpq $0xff00, 0x18(%rdi)     # imm = 0xFF00
jg 0x625f5
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeed0d
cmpl $0xe9930000, %eax       # imm = 0xE9930000
je 0x625cd
cmpl $0xe9070100, %eax       # imm = 0xE9070100
jne 0x625f5
movl $0x13, %esi
jmp 0x625d2
movl $0x1b, %esi
movq 0x18(%rbx), %rdi
leaq 0xc16c4(%rip), %rdx     # 0x123ca1
movl $0xe, %ecx
callq 0xefc85
xorl %ecx, %ecx
testl %eax, %eax
movl $0x4f, %r14d
cmovnel %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_module_gtxt
void de_module_gtxt(deark *c, struct deark_module_info *mi)
{
	mi->id = "gtxt";
	mi->desc = "GTXT (E. Gans)";
	mi->run_fn = de_run_gtxt;
	mi->identify_fn = de_identify_gtxt;
	mi->help_fn = de_help_gtxt;
}

// Assembly:
leaq 0xc12d3(%rip), %rax     # 0x1238fe
movq %rax, (%rsi)
leaq 0xc12ce(%rip), %rax     # 0x123903
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x6265b
movq %rax, 0x18(%rsi)
leaq 0x2be(%rip), %rax       # 0x62909
movq %rax, 0x20(%rsi)
leaq 0x325(%rip), %rax       # 0x6297b
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_identify_gtxt
static int de_identify_gtxt(deark *c)
{
	if(c->infile->len>65280) return 0;
	if(de_getbyte(0) != 0xbb) return 0;

	if(dbuf_memcmp(c->infile, 1, (const void*)"\xbc\x01\xb4\x02\xb1\x00\x8a", 7)) {
		return 0;
	}
	if(dbuf_memcmp(c->infile, 95, (const void*)"\x73\x01\xc3\x2c\x40\xc3\xcd\x20", 8)) {
		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 0x62971
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $-0x45, %al
jne 0x62971
movq 0x18(%r14), %rdi
leaq 0xc168e(%rip), %rdx     # 0x123fc6
movl $0x1, %esi
movl $0x7, %ecx
callq 0xefc85
testl %eax, %eax
jne 0x62971
movq 0x18(%r14), %rdi
leaq 0xc1382(%rip), %rdx     # 0x123cd8
movl $0x5f, %esi
movl $0x8, %ecx
callq 0xefc85
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_O3/jsummers[P]deark/modules/exectext.c
// Function: de_module_readmake
void de_module_readmake(deark *c, struct deark_module_info *mi)
{
	mi->id = "readmake";
	mi->desc = "READMAKE executable text";
	mi->run_fn = de_run_readmake;
	mi->help_fn = de_help_readmake;
}

// Assembly:
leaq 0xc0f6c(%rip), %rax     # 0x123912
movq %rax, (%rsi)
leaq 0xc0f6b(%rip), %rax     # 0x12391b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x629cb
movq %rax, 0x18(%rsi)
leaq 0x17e(%rip), %rax       # 0x62b44
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_run_readmake
static void de_run_readmake(deark *c, de_module_params *mparams)
{
	struct readmake_ctx *rmctx = NULL;
	lctx *d = NULL;

	d = create_lctx(c);

	rmctx = de_malloc(c, sizeof(struct readmake_ctx));
	rmctx->msgpfx = "[READMAKE] ";
	rmctx->ei = de_malloc(c, sizeof(struct fmtutil_exe_info));

	exectext_set_common_enc_opts(c, d, DE_ENCODING_CP437);

	d->allow_tlen_0 = 1;
	d->chartypes[8] = ETCT_CONTROL;
	d->chartypes[9] = ETCT_CONTROL;
	d->chartypes[10] = ETCT_CONTROL;
	d->chartypes[13] = ETCT_CONTROL;

	fmtutil_collect_exe_info(c, c->infile, rmctx->ei);

	rmctx->edd.restrict_to_fmt = DE_SPECIALEXEFMT_READMAKE;
	fmtutil_detect_specialexe(c, rmctx->ei, &rmctx->edd);
	if(rmctx->edd.detected_fmt!=DE_SPECIALEXEFMT_READMAKE) {
		d->need_errmsg = 1;
		goto done;
	}

	readmake_find_text(c, rmctx, d);
	if(d->tpos==0 || d->errflag) goto done;

	exectext_extract_default(c, d);

done:
	if(d) {
		if(d->need_errmsg && rmctx) {
			de_err(c, "%sBad or unsupported READMAKE file", rmctx->msgpfx);
		}
		de_free(c, d);
		d = NULL;
	}
	if(rmctx) {
		de_free(c, rmctx->ei);
		de_free(c, rmctx);
		rmctx = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x138, %esi            # imm = 0x138
callq 0xe8b2b
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movl $0x88, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
leaq 0xc12de(%rip), %rax     # 0x123ce1
movq %rax, (%r15)
movl $0xf0, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63336
movb $0x1, %al
movb %al, 0x16(%r14)
movw $0x101, 0x40(%r14)      # imm = 0x101
movb %al, 0x42(%r14)
movb %al, 0x45(%r14)
movq 0x18(%rbx), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x104f96
leaq 0x10(%r15), %rdx
movb $-0x36, 0x10(%r15)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x105864
cmpb $-0x36, 0x11(%r15)
jne 0x62aa1
movq 0x8(%r15), %rax
movq 0x48(%rax), %r13
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0xeed61
movq %rax, %r12
addq %r13, %r12
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeed61
cmpq $0x4, %rax
jne 0x62aa8
addq $0x4, %r12
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeed61
jmp 0x62ab9
movb $0x1, 0x13(%r14)
jmp 0x62afe
cmpq $0xd, %rax
jg 0x62ab9
movb $0x1, 0x13(%r14)
movq 0x28(%r14), %rax
jmp 0x62ae7
addq %rax, %r12
movq %r12, 0x28(%r14)
leaq 0xc1179(%rip), %rsi     # 0x123c40
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
movq 0x28(%r14), %rax
subq %rax, %rcx
movq %rcx, 0x30(%r14)
testq %rax, %rax
je 0x62afe
cmpb $0x0, 0x12(%r14)
jne 0x62afe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x633b6
cmpb $0x0, 0x13(%r14)
je 0x62b19
movq (%r15), %rdx
leaq 0xc11de(%rip), %rsi     # 0x123ced
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xe8be2
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_module_texe
void de_module_texe(deark *c, struct deark_module_info *mi)
{
	mi->id = "texe";
	mi->desc = "TEXE executable text";
	mi->run_fn = de_run_texe;
	mi->help_fn = de_help_texe;
}

// Assembly:
leaq 0xc0dc5(%rip), %rax     # 0x123934
movq %rax, (%rsi)
leaq 0xc0dc0(%rip), %rax     # 0x123939
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62b94
movq %rax, 0x18(%rsi)
leaq 0x1e5(%rip), %rax       # 0x62d74
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_module_readamatic
void de_module_readamatic(deark *c, struct deark_module_info *mi)
{
	mi->id = "readamatic";
	mi->desc = "Read-A-Matic executable text";
	mi->run_fn = de_run_readamatic;
	mi->help_fn = de_help_readamatic;
}

// Assembly:
leaq 0xc0baf(%rip), %rax     # 0x12394e
movq %rax, (%rsi)
leaq 0xc0bb0(%rip), %rax     # 0x123959
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62dc4
movq %rax, 0x18(%rsi)
leaq 0x163(%rip), %rax       # 0x62f22
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_run_readamatic
static void de_run_readamatic(deark *c, de_module_params *mparams)
{
	struct readamatic_ctx *tctx = NULL;
	lctx *d = NULL;
	dbuf *tmpdbuf = NULL;

	d = create_lctx(c);

	tctx = de_malloc(c, sizeof(struct readamatic_ctx));
	tctx->msgpfx = "[Read-A-Matic] ";
	tctx->ei = de_malloc(c, sizeof(struct fmtutil_exe_info));

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

	fmtutil_collect_exe_info(c, c->infile, tctx->ei);

	tctx->edd.restrict_to_fmt = DE_SPECIALEXEFMT_READAMATIC;
	fmtutil_detect_specialexe(c, tctx->ei, &tctx->edd);
	if(tctx->edd.detected_fmt!=DE_SPECIALEXEFMT_READAMATIC) {
		d->need_errmsg = 1;
		goto done;
	}

	if(tctx->ei->overlay_len<2 || tctx->ei->overlay_len > 640*1024) {
		d->need_errmsg = 1;
		goto done;
	}

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

	exectext_extract_default(c, d);

done:
	if(d) {
		if(d->need_errmsg && tctx) {
			de_err(c, "%sBad or unsupported Read-A-Matic file", tctx->msgpfx);
		}
		de_free(c, d);
		d = NULL;
	}
	if(tctx) {
		de_free(c, tctx->ei);
		de_free(c, tctx);
		tctx = NULL;
	}
	dbuf_close(tmpdbuf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x138, %esi            # imm = 0x138
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r15)
movl $0x88, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r14
leaq 0xc0f3b(%rip), %rax     # 0x123d37
movq %rax, (%r14)
movl $0xf0, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63336
movb $0x1, %al
movb %al, 0x42(%r15)
movb %al, 0x45(%r15)
movq 0x18(%rbx), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x104f96
leaq 0x10(%r14), %rdx
movb $-0x34, 0x10(%r14)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x105864
cmpb $-0x34, 0x11(%r14)
jne 0x62e69
movq 0x8(%r14), %rax
movq $-0xa0001, %rcx         # imm = 0xFFF5FFFF
addq 0x50(%rax), %rcx
cmpq $-0xa0000, %rcx         # imm = 0xFFF60000
ja 0x62ebc
movb $0x1, 0x13(%r15)
cmpb $0x0, 0x13(%r15)
je 0x62e89
movq (%r14), %rdx
leaq 0xc0ec8(%rip), %rsi     # 0x123d47
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xe8be2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
xorl %edi, %edi
callq 0xf052b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x48(%rax), %rdx
addq $0xa, %rdx
movq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %r8
movl $0x100, %ecx            # imm = 0x100
movl $0xa, %esi
callq 0xefa77
testl %eax, %eax
je 0x62f16
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x28(%r15)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x30(%r15)
cmpb $0x0, 0x12(%r15)
jne 0x62e6e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x633b6
jmp 0x62e6e
movw $0x101, 0x12(%r15)      # imm = 0x101
jmp 0x62e6e
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_module_ascom
void de_module_ascom(deark *c, struct deark_module_info *mi)
{
	mi->id = "ascom";
	mi->desc = "ASCOM";
	mi->run_fn = de_run_ascom;
	mi->identify_fn = de_identify_ascom;
	mi->help_fn = de_help_ascom;
}

// Assembly:
leaq 0xc0a29(%rip), %rax     # 0x123976
movq %rax, (%rsi)
leaq 0xc0a25(%rip), %rax     # 0x12397c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x62f7d
movq %rax, 0x18(%rsi)
leaq 0x1a2(%rip), %rax       # 0x6310f
movq %rax, 0x20(%rsi)
leaq 0x1eb(%rip), %rax       # 0x63163
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: de_identify_ascom
static int de_identify_ascom(deark *c)
{
	if(c->infile->len>65280) return 0;
	if(de_getbyte(0) != 0xe9) return 0;
	if(dbuf_memcmp(c->infile, 1,
		(const u8*)"\x00\x00\xe8\x00\x00\x8b\xfc\x36\x8b\x2d\x83\xc4\x02\x81\xed", 15))
	{
		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 0x63159
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
cmpb $-0x17, %al
jne 0x63159
movq 0x18(%r14), %rdi
leaq 0xc0e90(%rip), %rdx     # 0x123fce
movl $0x1, %esi
movl $0xf, %ecx
callq 0xefc85
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_O3/jsummers[P]deark/modules/exectext.c
// Function: de_module_textlife
void de_module_textlife(deark *c, struct deark_module_info *mi)
{
	mi->id = "textlife";
	mi->desc = "TextLife or Breeze executable text";
	mi->run_fn = de_run_textlife;
	mi->help_fn = de_help_textlife;
}

// Assembly:
leaq 0xc07f4(%rip), %rax     # 0x123982
movq %rax, (%rsi)
leaq 0xc07f3(%rip), %rax     # 0x12398b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x631b3
movq %rax, 0x18(%rsi)
leaq 0x164(%rip), %rax       # 0x63312
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: exectext_set_common_enc_opts
static void exectext_set_common_enc_opts(deark *c, lctx *d, de_encoding dflt_enc)
{
	d->input_encoding = de_get_input_encoding(c, NULL, dflt_enc);
	d->opt_fmtconv = (u8)de_get_ext_option_bool(c, "text:fmtconv", 1);
	d->opt_encconv = (u8)de_get_ext_option_bool(c, "text:encconv", 1);
	if(d->input_encoding==DE_ENCODING_ASCII) {
		d->opt_encconv = 0;
	}
	if(d->opt_fmtconv) {
		if(d->opt_encconv) {
			d->proctype = ET_PROCTYPE_FMTCONV_AND_ENCCONV;
		}
		else {
			d->proctype = ET_PROCTYPE_FMTCONV_ONLY;
		}
	}
	else {
		d->proctype = ET_PROCTYPE_RAW;
	}

	if(!d->supports_fmtconv) {
		if(d->proctype==ET_PROCTYPE_FMTCONV_ONLY) {
			d->proctype = ET_PROCTYPE_RAW;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %esi, %esi
movl $0xd, %edx
callq 0xeb220
movl %eax, 0x8(%rbx)
leaq 0xc0687(%rip), %rsi     # 0x1239e1
movq %r14, %rdi
movl $0x1, %edx
callq 0xe9bd0
movb %al, 0x10(%rbx)
leaq 0xc067d(%rip), %rsi     # 0x1239ee
movq %r14, %rdi
movl $0x1, %edx
callq 0xe9bd0
cmpl $0x1, 0x8(%rbx)
cmovel %r15d, %eax
movb %al, 0x11(%rbx)
cmpb $0x0, 0x10(%rbx)
je 0x633a9
testb %al, %al
je 0x6339c
movl $0x3, 0x18(%rbx)
jmp 0x633b0
movl $0x2, 0x18(%rbx)
cmpb $0x0, 0x17(%rbx)
jne 0x633b0
movl $0x1, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: exectext_extract_default
static void exectext_extract_default(deark *c, lctx *d)
{
	dbuf *outf = NULL;
	static struct ecnv_ctx *ecnv = NULL;

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

	outf = dbuf_create_output_file(c, "txt", NULL, 0);
	if(d->proctype!=ET_PROCTYPE_RAW) {
		dbuf_enable_wbuffer(outf);

		if(d->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
			ecnv = ecnv_create(c, d->proctype, DE_EXTENC_MAKE(d->input_encoding,
				DE_ENCSUBTYPE_PRINTABLE), outf);
			if(c->write_bom) {
				dbuf_write_uchar_as_utf8(outf, 0xfeff);
			}
		}
		if(!ecnv) {
			ecnv = ecnv_create(c, d->proctype, DE_ENCODING_UNKNOWN, outf);
		}

		exectext_convert_and_write_slice(c, d, d->tpos, d->tlen, ecnv);
	}
	else {
		dbuf_copy(d->inf, d->tpos, d->tlen, outf);
	}

done:
	if(ecnv) {
		ecnv_hard_flush(c, ecnv);
		ecnv_destroy(c, ecnv);
	}
	dbuf_close(outf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x12(%rsi)
jne 0x633d6
movq %rsi, %r15
movq %rbx, %rdi
callq 0x63572
cmpb $0x0, 0x12(%r15)
je 0x63406
xorl %r14d, %r14d
movq 0x12bda0(%rip), %rdi    # 0x18f180
testq %rdi, %rdi
je 0x633f9
callq 0x63739
movq 0x12bd8f(%rip), %rsi    # 0x18f180
movq %rbx, %rdi
callq 0x63764
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf052b
leaq 0xc6ea3(%rip), %rsi     # 0x12a2b0
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r14
cmpl $0x1, 0x18(%r15)
jne 0x63439
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rcx
callq 0xef481
jmp 0x633d9
movq %r14, %rdi
callq 0xf0855
cmpl $0x3, 0x18(%r15)
jne 0x63480
movzbl 0x8(%r15), %edx
orl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x635ac
movq %rax, 0x12bd16(%rip)    # 0x18f180
cmpb $0x0, 0xcc(%rbx)
je 0x634bc
movq %r14, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec1c4
movq 0x12bcf9(%rip), %rcx    # 0x18f180
testq %rcx, %rcx
jne 0x634a7
movl 0x18(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x635ac
movq %rax, %rcx
movq %rax, 0x12bcd9(%rip)    # 0x18f180
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
movq %r15, %rdi
callq 0x63603
jmp 0x633d9
movq %rax, %rcx
jmp 0x63487
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: txt2com_read_textpos
static void txt2com_read_textpos(deark *c, lctx *d, i64 pos1)
{
	i64 pos = pos1;
	i64 pos_of_tlen;

	de_dbg(c, "pos of tlen pointer: %"I64_FMT, pos1);

	pos_of_tlen = de_getu16le_p(&pos) - 256;
	de_dbg(c, "pos of tlen: %"I64_FMT, pos_of_tlen);

	pos += 2;

	d->tpos = de_getu16le_p(&pos) - 256;
	de_dbg(c, "tpos: %"I64_FMT, d->tpos);

	d->tlen = de_getu16le(pos_of_tlen);
	de_dbg(c, "tlen: %"I64_FMT, d->tlen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
leaq 0xc0529(%rip), %rsi     # 0x123a0c
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeebeb
movq $-0x100, %r13
leaq (%rax,%r13), %r12
leaq 0xc051d(%rip), %rsi     # 0x123a25
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe8617
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xeebeb
addq %rax, %r13
movq %r13, 0x28(%r14)
leaq 0xc070d(%rip), %rsi     # 0x123c40
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebc8
movq %rax, 0x30(%r14)
leaq 0xc04d5(%rip), %rsi     # 0x123a2c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: exectext_check_tpos
static void exectext_check_tpos(deark *c, lctx *d)
{
	if(d->tpos<0 || (d->tpos==0 && d->inf==c->infile) ||
		d->tlen<0 || (d->tlen==0 && !d->allow_tlen_0) ||
		(d->tpos+d->tlen > d->inf->len))
	{
		d->errflag = 1;
		d->need_errmsg = 1;
	}
}

// Assembly:
movq 0x28(%rsi), %rax
testq %rax, %rax
js 0x635a5
jne 0x63587
movq 0x20(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
je 0x635a5
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
js 0x635a5
jne 0x63598
cmpb $0x0, 0x16(%rsi)
je 0x635a5
addq %rax, %rcx
movq 0x20(%rsi), %rax
cmpq 0x18(%rax), %rcx
jle 0x635ab
movw $0x101, 0x12(%rsi)      # imm = 0x101
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: ecnv_create
static struct ecnv_ctx *ecnv_create(deark *c, enum et_proctype proctype,
	int ext_enc, dbuf *outf)
{
	struct ecnv_ctx *ecnv;

	ecnv = (struct ecnv_ctx*)de_malloc(c, sizeof(struct ecnv_ctx));
	ecnv->c = c;
	ecnv->tmpstr = ucstring_create(c);
	ecnv->outf = outf;
	ecnv->proctype = proctype;
	ecnv->ext_enc = ext_enc;
	de_encconv_init(&ecnv->es, ext_enc);
	return ecnv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x40, %esi
callq 0xe8b2b
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0xf6410
movq %rax, (%r12)
movq %rbx, 0x8(%r12)
movl %r14d, 0x18(%r12)
movl %ebp, 0x1c(%r12)
leaq 0x20(%r12), %rdi
movl %ebp, %esi
callq 0xebbf7
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: exectext_convert_and_write_slice
static void exectext_convert_and_write_slice(deark *c, lctx *d,
	i64 pos1, i64 len, struct ecnv_ctx *ecnv)
{
	i64 pos = pos1;
	i64 endpos = pos1 + len;

	while(pos < endpos) {
		u8 x;
		u8 tmpbyte;
		u8 next_byte_is_same;
		int k;

		x = dbuf_getbyte_p(d->inf, &pos);
		switch(d->chartypes[x]) {

		case ETCT_CONTROL:
			if(ecnv->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
				ecnv_add_rune(ecnv, (de_rune)x);
			}
			else {
				ecnv_add_byte(ecnv, x);
			}
			break;
		case ETCT_SPECIAL:
			if(ecnv->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
				ecnv_add_rune(ecnv, 0xfffd);
			}
			break;
		case ETCT_8SPACES:
			for(k=0; k<8; k++) {
				ecnv_add_byte(ecnv, 0x20);
			}
			break;
		case ETCT_CRLF:
			if(d->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
				ecnv_add_rune(ecnv, 0x0d);
				ecnv_add_rune(ecnv, 0x0a);
			}
			else {
				ecnv_add_byte(ecnv, 0x0d);
				ecnv_add_byte(ecnv, 0x0a);
			}
			break;
		case ETCT_DOC2COMSPECIAL:
			next_byte_is_same = 0;
			// Escaping is done by doubling the special character.
			// Peek ahead at the next byte:
			if(pos < endpos-1) {
				tmpbyte = dbuf_getbyte(d->inf, pos);
				if(tmpbyte==x) {
					next_byte_is_same = 1;
				}
			}
			if(next_byte_is_same) {
				ecnv_add_byte(ecnv, x);
				pos++; // Skip the extra byte we read
			}
			else {
				if(ecnv->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
					ecnv_add_rune(ecnv, 0xfffd);
				}
			}
			break;
		default:
			ecnv_add_byte(ecnv, x);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
jle 0x6372a
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
addq %rsi, %r14
leaq -0x1(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xeeb4b
movl %eax, %ebp
movzbl %al, %r13d
movzbl 0x38(%r15,%r13), %eax
cmpl $0x63, %eax
jle 0x63684
cmpl $0x66, %eax
je 0x63690
cmpl $0x65, %eax
je 0x636ae
cmpl $0x64, %eax
jne 0x636fd
movl $0x8, %ebp
movq %rbx, %rdi
movl $0x20, %esi
callq 0x637dc
decl %ebp
jne 0x6366e
jmp 0x6371f
cmpl $0x1, %eax
je 0x636ea
cmpl $0x2, %eax
je 0x636da
jmp 0x636fd
cmpl $0x3, 0x18(%r15)
jne 0x63705
movq %rbx, %rdi
movl $0xd, %esi
callq 0x6378e
movq %rbx, %rdi
movl $0xa, %esi
jmp 0x636f6
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
jge 0x636da
movq 0x20(%r15), %rdi
callq 0xeead3
cmpb %bpl, %al
jne 0x636da
movq %rbx, %rdi
movl %r13d, %esi
callq 0x637dc
incq 0x8(%rsp)
jmp 0x6371f
cmpl $0x3, 0x18(%rbx)
jne 0x6371f
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
jmp 0x636f6
cmpl $0x3, 0x18(%rbx)
jne 0x636fd
movq %rbx, %rdi
movl %r13d, %esi
callq 0x6378e
jmp 0x6371f
movq %rbx, %rdi
movl %r13d, %esi
jmp 0x6371a
movq %rbx, %rdi
movl $0xd, %esi
callq 0x637dc
movq %rbx, %rdi
movl $0xa, %esi
callq 0x637dc
cmpq %r14, 0x8(%rsp)
jl 0x63639
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: ecnv_add_rune
static void ecnv_add_rune(struct ecnv_ctx *ecnv, de_rune n)
{
	if(ecnv->proctype!=ET_PROCTYPE_FMTCONV_AND_ENCCONV) return;
	ecnv_barrier(ecnv);
	ucstring_append_char(ecnv->tmpstr, n);
	ecnv_flush_if_needed(ecnv);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, 0x18(%rdi)
jne 0x637d5
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x20(%rbx), %r8
leaq 0xe1906(%rip), %rsi     # 0x1450b0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf67b3
movq (%rbx), %rdi
movl %ebp, %esi
callq 0xf6542
movq (%rbx), %rax
cmpq $0x3e9, 0x10(%rax)      # imm = 0x3E9
jl 0x637d5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x63837
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: ecnv_add_byte
static void ecnv_add_byte(struct ecnv_ctx *ecnv, u8 b)
{
	if(ecnv->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
		ucstring_append_bytes_ex(ecnv->tmpstr, &b, 1, DE_CONVFLAG_PARTIAL_DATA, &ecnv->es);
		ecnv_flush_if_needed(ecnv);
	}
	else {
		dbuf_writebyte(ecnv->outf, b);
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb %sil, 0xf(%rsp)
cmpl $0x3, 0x18(%rdi)
jne 0x63825
movq (%rbx), %rdi
leaq 0x20(%rbx), %r8
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl $0x40, %ecx
callq 0xf67b3
movq (%rbx), %rax
cmpq $0x3e9, 0x10(%rax)      # imm = 0x3E9
jl 0x6381f
movq %rbx, %rdi
callq 0x63837
addq $0x10, %rsp
popq %rbx
retq
movq 0x8(%rbx), %rdi
movzbl %sil, %esi
addq $0x10, %rsp
popq %rbx
jmp 0xf0bd6
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: asc2com_identify
static void asc2com_identify(deark *c, struct asc2com_detection_data *idd, UI idmode)
{
	u8 buf[3];
	size_t k;
	const struct asc2com_idinfo *found_item = NULL;

	dbuf_read(c->infile, buf, 0, 3);
	if(buf[0]!=0xe8 && buf[0]!=0xe9 && buf[0]!=0xbb && buf[0]!=0xeb) return;

	for(k=0; k<DE_ARRAYCOUNT(asc2com_idinfo_arr); k++) {
		const struct asc2com_idinfo *t;
		u8 sig_type;

		t = &asc2com_idinfo_arr[k];

		if(buf[0]==t->sig1[0] && buf[1]==t->sig1[1] &&
			(t->sig1[0]==0xeb || (buf[2]==t->sig1[2])))
		{

			sig_type = t->flags & 0x03;
			if(sig_type==1) {
				if(!dbuf_memcmp(c->infile, (i64)t->sig2pos,
					(const void*)"\x49\xe3\x0e\x33\xd2\x8a\x14\xfe\xc2\x03\xf2\x49", 12))
				{
					if(t->flags & 0x40) {
						i64 tmptxtpos;

						tmptxtpos = de_getu16le((i64)t->sig2pos-2) - 0x100;
						if(tmptxtpos == t->txtpos) {
							found_item = t;
						}
					}
					else {
						found_item = t;
					}
				}
			}
			else if(sig_type==2) {
				if(!dbuf_memcmp(c->infile, (i64)t->sig2pos,
					(const void*)"ASC2COM", 7))
				{
					found_item = t;
				}
			}
		}

		if(found_item) {
			break;
		}
	}
	if(!found_item) return;
	idd->found = 1;
	if(idmode) return;

	idd->tpos = (i64)found_item->txtpos;
	idd->fmtcode = found_item->fmtcode;
	if(found_item->flags & 0x80) {
		idd->is_compressed = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x5(%rsp), %r15
movl $0x3, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
movzbl (%r15), %eax
addl $0xffffff45, %eax       # imm = 0xFFFFFF45
cmpl $0x30, %eax
ja 0x63984
movabsq $0x1600000000001, %rcx  # imm = 0x1600000000001
btq %rax, %rcx
jae 0x63984
movl $0x8, %ebx
leaq 0xc0568(%rip), %rbp     # 0x123e30
leaq 0xc0299(%rip), %r12     # 0x123b68
movb 0x5(%rsp), %al
cmpb -0x8(%rbx,%rbp), %al
jne 0x63973
movb 0x6(%rsp), %cl
cmpb -0x7(%rbx,%rbp), %cl
jne 0x63973
cmpb $-0x15, %al
je 0x638f9
movb 0x7(%rsp), %al
cmpb -0x6(%rbx,%rbp), %al
jne 0x63973
movzbl -0x5(%rbx,%rbp), %r15d
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x2, %eax
je 0x63955
cmpl $0x1, %eax
jne 0x63973
movq 0x18(%r14), %rdi
movzwl -0x4(%rbx,%rbp), %r13d
movl $0xc, %ecx
movq %r13, %rsi
movq %r12, %rdx
callq 0xefc85
testl %eax, %eax
jne 0x63973
testb $0x40, %r15b
je 0x63993
movq 0x18(%r14), %rdi
addq $-0x2, %r13
movq %r13, %rsi
callq 0xeebc8
addq $-0x100, %rax
movzwl -0x2(%rbx,%rbp), %ecx
cmpq %rcx, %rax
jne 0x63973
jmp 0x63993
movq 0x18(%r14), %rdi
movzwl -0x4(%rbx,%rbp), %esi
movl $0x7, %ecx
leaq 0xc020b(%rip), %rdx     # 0x123b75
callq 0xefc85
testl %eax, %eax
je 0x63993
addq $0xc, %rbx
cmpq $0x188, %rbx            # imm = 0x188
jne 0x638cf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
cmpl $0x0, 0x14(%rsp)
jne 0x63984
movzwl -0x2(%rbx,%rbp), %eax
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
movl (%rbx,%rbp), %eax
movl %eax, 0x4(%rcx)
testb %r15b, %r15b
jns 0x63984
movq 0x8(%rsp), %rax
movb $0x1, 0x1(%rax)
jmp 0x63984
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/exectext.c
// Function: doc2com_detect
static void doc2com_detect(deark *c, struct doc2com_detection_data *idd, UI idmode)
{
	u8 buf[22];

	dbuf_read(c->infile, buf, 0, sizeof(buf));

	if(buf[0]==0xbe && buf[15]==0x72) {
		if(!de_memcmp(&buf[3], (const void*)"\xb9\x18\x00\xe8\xb2\x01\xe2\xfb\x3b\x36", 10)) {
			idd->fmtcode = 10; // old unversioned releases
			idd->found = 1;
		}
	}
	else if(buf[0]==0xfc && buf[1]==0xbe && buf[16]==0x72) {
		if(!de_memcmp(&buf[4], (const void*)"\xb9\x18\x00\xe8\x2f\x02\xe2\xfb\x3b\x36", 10)) {
			idd->fmtcode = 20; // v1.2
			idd->found = 1;
		}
	}
	else if(buf[0]==0xfc && buf[5]==0x49) {
		// Expecting all v1.3+ files to start with:
		//  fc ?? ?? ?? ?? 49 8b 36 ?? ?? 8b fe ac 32 04 aa e2 fa ac 34 ff aa ...
		// First 3 bytes:
		//  fc 8b 0e if encrypted
		//  fc eb 13 if not encrypted
		if(!de_memcmp(&buf[10],
			(const void*)"\x8b\xfe\xac\x32\x04\xaa\xe2\xfa\xac\x34\xff\xaa", 12))
		{
			idd->fmtcode = 30; // v1.3+
			idd->found = 1;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movl $0x16, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movb (%r14), %al
cmpb $-0x42, %al
jne 0x63bc2
cmpb $0x72, 0xf(%rsp)
jne 0x63bc2
movabsq $-0x41dfe4d17ffe747, %rax # imm = 0xFBE201B2E80018B9
xorq 0x3(%rsp), %rax
movzwl 0xb(%rsp), %ecx
xorq $0x363b, %rcx           # imm = 0x363B
orq %rax, %rcx
jne 0x63c31
movl $0xa, %eax
jmp 0x63c2b
cmpb $-0x4, %al
jne 0x63bfb
cmpb $-0x42, 0x1(%rsp)
jne 0x63bfb
cmpb $0x72, 0x10(%rsp)
jne 0x63bfb
movabsq $-0x41dfdd017ffe747, %rax # imm = 0xFBE2022FE80018B9
xorq 0x4(%rsp), %rax
movzwl 0xc(%rsp), %ecx
xorq $0x363b, %rcx           # imm = 0x363B
orq %rax, %rcx
jne 0x63c31
movl $0x14, %eax
jmp 0x63c2b
cmpb $-0x4, %al
jne 0x63c31
cmpb $0x49, 0x5(%rsp)
jne 0x63c31
movabsq $-0x51d55fbcd530175, %rax # imm = 0xFAE2AA0432ACFE8B
xorq 0xa(%rsp), %rax
movl 0x12(%rsp), %ecx
movl $0xaaff34ac, %edx       # imm = 0xAAFF34AC
xorq %rcx, %rdx
orq %rax, %rdx
jne 0x63c31
movl $0x1e, %eax
movl %eax, 0x4(%rbx)
movb $0x1, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gws.c
// Function: de_module_imggal_alch
void de_module_imggal_alch(deark *c, struct deark_module_info *mi)
{
	mi->id = "imggal_alch";
	mi->desc = "Image Gallery GAL (Alchemy Mindworks)";
	mi->run_fn = de_run_imggal_alch;
	mi->identify_fn = de_identify_imggal_alch;
}

// Assembly:
leaq 0xc03dd(%rip), %rax     # 0x124020
movq %rax, (%rsi)
leaq 0xc03df(%rip), %rax     # 0x12402c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x63c68
movq %rax, 0x18(%rsi)
leaq 0x5c3(%rip), %rax       # 0x64226
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gws.c
// Function: de_identify_imggal_alch
static int de_identify_imggal_alch(deark *c)
{
	u8 b;

	if(c->infile->len<IMGGAL_HDRSIZE) return 0;
	if(dbuf_memcmp(c->infile, 0, "ALCHGLRY", 8)) return 0;
	b = de_getbyte(75);
	if(b>0x05) return 0;
	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
cmpq $0x61, 0x18(%rdi)
jl 0x64271
leaq 0xbfee5(%rip), %rdx     # 0x124127
xorl %r14d, %r14d
movl $0x8, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x64271
movq 0x18(%rbx), %rdi
movl $0x4b, %esi
callq 0xeead3
xorl %ecx, %ecx
cmpb $0x6, %al
movl $0x64, %r14d
cmovael %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gws.c
// Function: de_module_gws_thn
void de_module_gws_thn(deark *c, struct deark_module_info *mi)
{
	mi->id = "gws_thn";
	mi->desc = "Graphic Workshop thumbnail .THN";
	mi->run_fn = de_run_gws_thn;
	mi->identify_fn = de_identify_gws_thn;
}

// Assembly:
leaq 0xbfdcf(%rip), %rax     # 0x124052
movq %rax, (%rsi)
leaq 0xbfdcd(%rip), %rax     # 0x12405a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x642a8
movq %rax, 0x18(%rsi)
leaq 0x2b1(%rip), %rax       # 0x64554
movq %rax, 0x20(%rsi)
retq