LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x62781
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef32a
cmpl $0xe9930000, %eax       # imm = 0xE9930000
je 0x62759
cmpl $0xe9070100, %eax       # imm = 0xE9070100
jne 0x62781
movl $0x13, %esi
jmp 0x6275e
movl $0x1b, %esi
movq 0x18(%rbx), %rdi
leaq 0xc1358(%rip), %rdx     # 0x123ac1
movl $0xe, %ecx
callq 0xf025e
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_O1/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 0xc0f67(%rip), %rax     # 0x12371e
movq %rax, (%rsi)
leaq 0xc0f62(%rip), %rax     # 0x123723
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x627e7
movq %rax, 0x18(%rsi)
leaq 0x2dd(%rip), %rax       # 0x62ab4
movq %rax, 0x20(%rsi)
leaq 0x344(%rip), %rax       # 0x62b26
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x62b1c
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef0d5
cmpb $-0x45, %al
jne 0x62b1c
movq 0x18(%r14), %rdi
leaq 0xc1303(%rip), %rdx     # 0x123de6
movl $0x1, %esi
movl $0x7, %ecx
callq 0xf025e
testl %eax, %eax
jne 0x62b1c
movq 0x18(%r14), %rdi
leaq 0xc0ff7(%rip), %rdx     # 0x123af8
movl $0x5f, %esi
movl $0x8, %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_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 0xc0be1(%rip), %rax     # 0x123732
movq %rax, (%rsi)
leaq 0xc0be0(%rip), %rax     # 0x12373b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62b76
movq %rax, 0x18(%rsi)
leaq 0x17e(%rip), %rax       # 0x62cef
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe969b
movq %rax, %r15
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r15)
movl $0x88, %esi
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r14
leaq 0xc0f53(%rip), %rax     # 0x123b01
movq %rax, (%r14)
movl $0xf0, %esi
movq %rbx, %rdi
callq 0xe969b
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x634f2
movb $0x1, %al
movb %al, 0x16(%r15)
movw $0x101, 0x40(%r15)      # imm = 0x101
movb %al, 0x42(%r15)
movb %al, 0x45(%r15)
movq 0x18(%rbx), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1053ee
leaq 0x10(%r14), %rdx
movb $-0x36, 0x10(%r14)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x105ccc
cmpb $-0x36, 0x11(%r14)
jne 0x62c4c
movq 0x8(%r14), %rax
movq 0x48(%rax), %r13
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0xef37e
movq %rax, %r12
addq %r13, %r12
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef37e
cmpq $0x4, %rax
jne 0x62c53
addq $0x4, %r12
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef37e
jmp 0x62c60
movb $0x1, 0x13(%r15)
jmp 0x62ca4
cmpq $0xd, %rax
jg 0x62c60
movb $0x1, 0x13(%r15)
jmp 0x62c8b
addq %rax, %r12
movq %r12, 0x28(%r15)
leaq 0xc0df2(%rip), %rsi     # 0x123a60
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
subq 0x28(%r15), %rax
movq %rax, 0x30(%r15)
cmpq $0x0, 0x28(%r15)
je 0x62ca4
cmpb $0x0, 0x12(%r15)
jne 0x62ca4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63581
testq %r15, %r15
je 0x62ccf
cmpb $0x0, 0x13(%r15)
je 0x62cc4
movq (%r14), %rdx
leaq 0xc0e53(%rip), %rsi     # 0x123b0d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe9752
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xe9752
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe9752
// File: /workspace/github_c_makefile_star2_O1/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 0xc0a3a(%rip), %rax     # 0x123754
movq %rax, (%rsi)
leaq 0xc0a35(%rip), %rax     # 0x123759
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62d3f
movq %rax, 0x18(%rsi)
leaq 0x1ea(%rip), %rax       # 0x62f24
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc081f(%rip), %rax     # 0x12376e
movq %rax, (%rsi)
leaq 0xc0820(%rip), %rax     # 0x123779
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x62f74
movq %rax, 0x18(%rsi)
leaq 0x165(%rip), %rax       # 0x630d4
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe969b
movq %rax, %r15
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r15)
movl $0x88, %esi
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r14
leaq 0xc0bab(%rip), %rax     # 0x123b57
movq %rax, (%r14)
movl $0xf0, %esi
movq %rbx, %rdi
callq 0xe969b
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x634f2
movb $0x1, %al
movb %al, 0x42(%r15)
movb %al, 0x45(%r15)
movq 0x18(%rbx), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1053ee
leaq 0x10(%r14), %rdx
movb $-0x34, 0x10(%r14)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x105ccc
cmpb $-0x34, 0x11(%r14)
jne 0x63019
movq 0x8(%r14), %rax
movq $-0xa0001, %rcx         # imm = 0xFFF5FFFF
addq 0x50(%rax), %rcx
cmpq $-0xa0000, %rcx         # imm = 0xFFF60000
ja 0x63071
movb $0x1, 0x13(%r15)
testq %r15, %r15
je 0x63049
cmpb $0x0, 0x13(%r15)
je 0x6303e
movq (%r14), %rdx
leaq 0xc0b33(%rip), %rsi     # 0x123b67
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9df7
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe9752
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xe9752
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9752
xorl %edi, %edi
callq 0xf0b13
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 0xf0057
testl %eax, %eax
je 0x630b2
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)
jmp 0x630b9
movw $0x101, 0x12(%r15)      # imm = 0x101
cmpb $0x0, 0x12(%r15)
jne 0x6301e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63581
jmp 0x6301e
// File: /workspace/github_c_makefile_star2_O1/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 0xc0697(%rip), %rax     # 0x123796
movq %rax, (%rsi)
leaq 0xc0693(%rip), %rax     # 0x12379c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x6312f
movq %rax, 0x18(%rsi)
leaq 0x1a7(%rip), %rax       # 0x632c6
movq %rax, 0x20(%rsi)
leaq 0x1f0(%rip), %rax       # 0x6331a
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x63310
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef0d5
cmpb $-0x17, %al
jne 0x63310
movq 0x18(%r14), %rdi
leaq 0xc0af9(%rip), %rdx     # 0x123dee
movl $0x1, %esi
movl $0xf, %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_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 0xc045d(%rip), %rax     # 0x1237a2
movq %rax, (%rsi)
leaq 0xc045c(%rip), %rax     # 0x1237ab
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6336a
movq %rax, 0x18(%rsi)
leaq 0x169(%rip), %rax       # 0x634ce
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb7d1
movl %eax, 0x8(%rbx)
leaq 0xc02eb(%rip), %rsi     # 0x123801
movq %r14, %rdi
movl $0x1, %edx
callq 0xea727
movb %al, 0x10(%rbx)
leaq 0xc02e1(%rip), %rsi     # 0x12380e
movq %r14, %rdi
movl $0x1, %edx
callq 0xea727
cmpl $0x1, 0x8(%rbx)
cmovel %r15d, %eax
movb %al, 0x11(%rbx)
cmpb $0x0, 0x10(%rbx)
je 0x63558
testb %al, %al
je 0x63561
movl $0x3, 0x18(%rbx)
jmp 0x63568
movl $0x1, 0x18(%rbx)
jmp 0x63568
movl $0x2, 0x18(%rbx)
cmpb $0x0, 0x17(%rbx)
jne 0x6357b
cmpl $0x2, 0x18(%rbx)
jne 0x6357b
movl $0x1, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x635a1
movq %rsi, %r15
movq %rbx, %rdi
callq 0x6373a
cmpb $0x0, 0x12(%r15)
je 0x635d1
xorl %r14d, %r14d
movq 0x12bbd5(%rip), %rdi    # 0x18f180
testq %rdi, %rdi
je 0x635c4
callq 0x63901
movq 0x12bbc4(%rip), %rsi    # 0x18f180
movq %rbx, %rdi
callq 0x6392c
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf0b13
leaq 0xc6a68(%rip), %rsi     # 0x12a040
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r14
cmpl $0x1, 0x18(%r15)
jne 0x63604
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rcx
callq 0xefabc
jmp 0x635a4
movq %r14, %rdi
callq 0xf0e3f
cmpl $0x3, 0x18(%r15)
jne 0x6364b
movzbl 0x8(%r15), %edx
orl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x63774
movq %rax, 0x12bb4b(%rip)    # 0x18f180
cmpb $0x0, 0xcc(%rbx)
je 0x6364b
movq %r14, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec81c
cmpq $0x0, 0x12bb2d(%rip)    # 0x18f180
jne 0x6366d
movl 0x18(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x63774
movq %rax, 0x12bb13(%rip)    # 0x18f180
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
movq 0x12bb04(%rip), %rcx    # 0x18f180
movq %r15, %rdi
callq 0x637cb
jmp 0x635a4
// File: /workspace/github_c_makefile_star2_O1/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 0xc0181(%rip), %rsi     # 0x12382c
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef1ed
movq $-0x100, %r13
leaq (%rax,%r13), %r12
leaq 0xc0175(%rip), %rsi     # 0x123845
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe9226
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef1ed
addq %rax, %r13
movq %r13, 0x28(%r14)
leaq 0xc0365(%rip), %rsi     # 0x123a60
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef1ca
movq %rax, 0x30(%r14)
leaq 0xc012d(%rip), %rsi     # 0x12384c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6376d
jne 0x6374f
movq 0x20(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
je 0x6376d
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
js 0x6376d
jne 0x63760
cmpb $0x0, 0x16(%rsi)
je 0x6376d
addq %rax, %rcx
movq 0x20(%rsi), %rax
cmpq 0x18(%rax), %rcx
jle 0x63773
movw $0x101, 0x12(%rsi)      # imm = 0x101
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe969b
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0xf6870
movq %rax, (%r12)
movq %rbx, 0x8(%r12)
movl %r14d, 0x18(%r12)
movl %ebp, 0x1c(%r12)
leaq 0x20(%r12), %rdi
movl %ebp, %esi
callq 0xec207
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x638f2
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 0xef14d
movl %eax, %ebp
movzbl %al, %r13d
movzbl 0x38(%r15,%r13), %eax
cmpl $0x63, %eax
jle 0x6384c
cmpl $0x66, %eax
je 0x63858
cmpl $0x65, %eax
je 0x63876
cmpl $0x64, %eax
jne 0x638c5
movl $0x8, %ebp
movq %rbx, %rdi
movl $0x20, %esi
callq 0x639a4
decl %ebp
jne 0x63836
jmp 0x638e7
cmpl $0x1, %eax
je 0x638b2
cmpl $0x2, %eax
je 0x638a2
jmp 0x638c5
cmpl $0x3, 0x18(%r15)
jne 0x638cd
movq %rbx, %rdi
movl $0xd, %esi
callq 0x63956
movq %rbx, %rdi
movl $0xa, %esi
jmp 0x638be
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
jge 0x638a2
movq 0x20(%r15), %rdi
callq 0xef0d5
cmpb %bpl, %al
jne 0x638a2
movq %rbx, %rdi
movl %r13d, %esi
callq 0x639a4
incq 0x8(%rsp)
jmp 0x638e7
cmpl $0x3, 0x18(%rbx)
jne 0x638e7
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
jmp 0x638be
cmpl $0x3, 0x18(%rbx)
jne 0x638c5
movq %rbx, %rdi
movl %r13d, %esi
callq 0x63956
jmp 0x638e7
movq %rbx, %rdi
movl %r13d, %esi
jmp 0x638e2
movq %rbx, %rdi
movl $0xd, %esi
callq 0x639a4
movq %rbx, %rdi
movl $0xa, %esi
callq 0x639a4
cmpq %r14, 0x8(%rsp)
jl 0x63801
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/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 0x6399d
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x20(%rbx), %r8
leaq 0xe125e(%rip), %rsi     # 0x144bd0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf6c10
movq (%rbx), %rdi
movl %ebp, %esi
callq 0xf69a2
movq (%rbx), %rax
cmpq $0x3e9, 0x10(%rax)      # imm = 0x3E9
jl 0x6399d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x639ff
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x639ed
movq (%rbx), %rdi
leaq 0x20(%rbx), %r8
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl $0x40, %ecx
callq 0xf6c10
movq (%rbx), %rax
cmpq $0x3e9, 0x10(%rax)      # imm = 0x3E9
jl 0x639e7
movq %rbx, %rdi
callq 0x639ff
addq $0x10, %rsp
popq %rbx
retq
movq 0x8(%rbx), %rdi
movzbl %sil, %esi
addq $0x10, %rsp
popq %rbx
jmp 0xf11be
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/exectext.c
// Function: asc2com_filter_and_write
static void asc2com_filter_and_write(deark *c, lctx *d,
	i64 ipos1, i64 endpos, dbuf *outf)
{
	i64 ipos;
	u8 n;
	static struct ecnv_ctx *ecnv = NULL;

	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) {
		// This object won't necessarily be used, but that's ok.
		ecnv = ecnv_create(c, d->proctype, DE_ENCODING_UNKNOWN, outf);
	}

	ipos = ipos1;
	while(ipos < endpos) {
		n = dbuf_getbyte_p(d->inf, &ipos);
		if(d->proctype==ET_PROCTYPE_FMTCONV_AND_ENCCONV) {
			exectext_convert_and_write_slice(c, d, ipos, (i64)n, ecnv);
			ecnv_add_rune(ecnv, 13);
			ecnv_add_rune(ecnv, 10);
		}
		else if(d->proctype==ET_PROCTYPE_FMTCONV_ONLY) {
			exectext_convert_and_write_slice(c, d, ipos, (i64)n, ecnv);
			ecnv_add_byte(ecnv, 13);
			ecnv_add_byte(ecnv, 10);
		}
		else { // ET_PROCTYPE_RAW
			dbuf_copy(d->inf, ipos, (i64)n, outf);
			dbuf_write(outf, (const u8*)"\x0d\x0a", 2);
		}
		ipos += (i64)n;
	}

	if(ecnv) {
		ecnv_hard_flush(c, ecnv);
		ecnv_destroy(c, ecnv);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
cmpl $0x3, 0x18(%rsi)
jne 0x63c09
movzbl 0x8(%r12), %edx
orl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x63774
movq %rax, 0x12b596(%rip)    # 0x18f188
cmpb $0x0, 0xcc(%r13)
je 0x63c09
movq %r14, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec81c
cmpq $0x0, 0x12b577(%rip)    # 0x18f188
jne 0x63c2c
movl 0x18(%r12), %esi
movq %r13, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x63774
movq %rax, 0x12b55c(%rip)    # 0x18f188
movq %r13, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
cmpq %r15, %rbx
jge 0x63d18
leaq 0x8(%rsp), %r13
leaq 0xb2d00(%rip), %rbp     # 0x11694b
movq 0x20(%r12), %rdi
movq %r13, %rsi
callq 0xef14d
movl 0x18(%r12), %ecx
movzbl %al, %ebx
cmpl $0x2, %ecx
je 0x63ca5
cmpl $0x3, %ecx
jne 0x63ce0
movq 0x8(%rsp), %rsi
movq 0x12b512(%rip), %rcx    # 0x18f188
movq %r12, %rdi
movq %rbx, %rdx
callq 0x637cb
movq 0x12b500(%rip), %rdi    # 0x18f188
movl $0xd, %esi
callq 0x63956
movq 0x12b4ef(%rip), %rdi    # 0x18f188
movl $0xa, %esi
callq 0x63956
jmp 0x63d05
movq 0x8(%rsp), %rsi
movq 0x12b4d7(%rip), %rcx    # 0x18f188
movq %r12, %rdi
movq %rbx, %rdx
callq 0x637cb
movq 0x12b4c5(%rip), %rdi    # 0x18f188
movl $0xd, %esi
callq 0x639a4
movq 0x12b4b4(%rip), %rdi    # 0x18f188
movl $0xa, %esi
callq 0x639a4
jmp 0x63d05
movq 0x20(%r12), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xefabc
movl $0x2, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0xefb82
addq 0x8(%rsp), %rbx
movq %rbx, 0x8(%rsp)
cmpq %r15, %rbx
jl 0x63c4b
movq 0x12b469(%rip), %rdi    # 0x18f188
testq %rdi, %rdi
je 0x63d3a
callq 0x63901
movq 0x12b458(%rip), %rsi    # 0x18f188
movq 0x10(%rsp), %rdi
callq 0x6392c
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/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 0x18(%rdi), %rdi
movq %rsp, %r14
movl $0x16, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xeeee8
movb (%r14), %al
cmpb $-0x42, %al
jne 0x63d9e
cmpb $0x72, 0xf(%rsp)
jne 0x63d9e
movabsq $-0x41dfe4d17ffe747, %rax # imm = 0xFBE201B2E80018B9
xorq 0x3(%rsp), %rax
movzwl 0xb(%rsp), %ecx
xorq $0x363b, %rcx           # imm = 0x363B
orq %rax, %rcx
jne 0x63e0d
movl $0xa, %eax
jmp 0x63e07
cmpb $-0x4, %al
jne 0x63dd7
cmpb $-0x42, 0x1(%rsp)
jne 0x63dd7
cmpb $0x72, 0x10(%rsp)
jne 0x63dd7
movabsq $-0x41dfdd017ffe747, %rax # imm = 0xFBE2022FE80018B9
xorq 0x4(%rsp), %rax
movzwl 0xc(%rsp), %ecx
xorq $0x363b, %rcx           # imm = 0x363B
orq %rax, %rcx
jne 0x63e0d
movl $0x14, %eax
jmp 0x63e07
cmpb $-0x4, %al
jne 0x63e0d
cmpb $0x49, 0x5(%rsp)
jne 0x63e0d
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 0x63e0d
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_O1/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 0xbffdf(%rip), %rax     # 0x123dfe
movq %rax, (%rsi)
leaq 0xbffe1(%rip), %rax     # 0x123e0a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x63e44
movq %rax, 0x18(%rsi)
leaq 0x5b3(%rip), %rax       # 0x643f2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6443d
leaq 0xbfaf7(%rip), %rdx     # 0x123f05
xorl %r14d, %r14d
movl $0x8, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x6443d
movq 0x18(%rbx), %rdi
movl $0x4b, %esi
callq 0xef0d5
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_O1/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 0xbf9e1(%rip), %rax     # 0x123e30
movq %rax, (%rsi)
leaq 0xbf9df(%rip), %rax     # 0x123e38
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x64474
movq %rax, 0x18(%rsi)
leaq 0x2b2(%rip), %rax       # 0x64721
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/gws.c
// Function: gwsexe_decode_decompressed_image
static void gwsexe_decode_decompressed_image(deark *c, struct gws_exepic_ctx *d,
	dbuf *inf, i64 inf_pos)
{
	de_bitmap *img = NULL;

	img = de_bitmap_create(c, d->w, d->h, 3);
	if(d->nplanes>1) {
		de_convert_image_paletted_planar(inf, inf_pos, d->nplanes,
			d->byprpp*d->nplanes, d->byprpp, d->pal, img, 0x2);
	}
	else {
		de_convert_image_paletted(inf, inf_pos, d->depth_adj, d->byprpp, d->pal,
			img, 0);
	}
	de_bitmap_write_to_file(img, NULL, DE_CREATEFLAG_OPT_IMAGE);
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq 0x20(%rsi), %rsi
movq 0x28(%r14), %rdx
movl $0x3, %ecx
callq 0xf2cab
movq %rax, %rbx
movq 0x30(%r14), %rdx
cmpq $0x2, %rdx
jl 0x64b1f
movq 0x40(%r14), %r8
movq %r8, %rcx
imulq %rdx, %rcx
addq $0xd8, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %r9
pushq $0x2
pushq %rbx
callq 0xf36f9
jmp 0x64b45
movq 0x18(%r14), %rdx
movq 0x40(%r14), %rcx
addq $0xd8, %r14
subq $0x8, %rsp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %r8
movq %rbx, %r9
pushq $0x0
callq 0xf35b8
addq $0x10, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xf2923
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf28d4
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_null
void de_module_null(deark *c, struct deark_module_info *mi)
{
	mi->id = "null";
	mi->desc = "Do nothing";
	mi->run_fn = de_run_null;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xbf49c(%rip), %rax     # 0x12404c
movq %rax, (%rsi)
leaq 0xbf497(%rip), %rax     # 0x124051
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x64bce
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_join
void de_module_join(deark *c, struct deark_module_info *mi)
{
	mi->id = "join";
	mi->desc = "Concatenate files";
	mi->run_fn = de_run_join;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
leaq 0xbf486(%rip), %rax     # 0x12405c
movq %rax, (%rsi)
leaq 0xbf481(%rip), %rax     # 0x124061
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x64bf4
movq %rax, 0x18(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_run_join
static void de_run_join(deark *c, de_module_params *mparams)
{
	int k;
	int num_parts = 1;
	dbuf *outf = NULL;

	if(c->mp_data) {
		num_parts += c->mp_data->count;
	}

	outf = dbuf_create_output_file(c, "bin", NULL, 0);

	for(k=0; k<num_parts; k++) {
		dbuf *inf;

		if(k>0 && c->mp_data) {
			de_dbg(c, "[mp file %d: %s]", k-1, c->mp_data->item[k-1].fn);
		}
		inf = de_mp_acquire_dbuf(c, k);
		if(!inf) {
			goto done;
		}

		dbuf_copy(inf, 0, inf->len, outf);

		de_mp_release_dbuf(c, k, &inf);
	}

done:
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x64c11
movl (%rax), %ebp
incl %ebp
jmp 0x64c16
movl $0x1, %ebp
leaq 0xd0814(%rip), %rsi     # 0x135431
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r14
testl %ebp, %ebp
jle 0x64caa
movl %ebp, %ebp
shlq $0x4, %rbp
movq %rsp, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %r12, %r12
je 0x64c6b
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x64c6b
movq 0x8(%rax), %rax
movq -0x10(%rax,%r12), %rcx
leal -0x1(%r13), %edx
movq %rbx, %rdi
leaq 0xb3217(%rip), %rsi     # 0x117e7b
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl %r13d, %esi
callq 0xec0f5
movq %rax, (%rsp)
testq %rax, %rax
je 0x64caa
movq 0x18(%rax), %rdx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xefabc
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0xec15f
incl %r13d
addq $0x10, %r12
cmpq %r12, %rbp
jne 0x64c3f
movq %r14, %rdi
callq 0xf0b13
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/misc.c
// Function: de_module_split
void de_module_split(deark *c, struct deark_module_info *mi)
{
	mi->id = "split";
	mi->desc = "Split the file into equal-sized chunks";
	mi->run_fn = de_run_split;
	mi->help_fn = de_help_split;
}

// Assembly:
leaq 0xbf3ab(%rip), %rax     # 0x124073
movq %rax, (%rsi)
leaq 0xbf3a7(%rip), %rax     # 0x124079
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x64ced
movq %rax, 0x18(%rsi)
leaq 0x190(%rip), %rax       # 0x64e78
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_run_split
static void de_run_split(deark *c, de_module_params *mparams)
{
	const char *s;
	i64 pos;
	i64 chunknum;
	i64 chunksize, chunkstride;
	i64 chunkcount;

	s = de_get_ext_option(c, "split:size");
	if(!s) {
		de_err(c, "\"-opt split:size=<n>\" is required.");
		goto done;
	}
	chunksize = de_atoi64(s);
	if(chunksize<1) {
		de_err(c, "Invalid chunk size");
		goto done;
	}

	s = de_get_ext_option(c, "split:stride");
	if(s) {
		chunkstride = de_atoi64(s);
		if(chunkstride<chunksize) {
			de_err(c, "Stride must be "DE_CHAR_GEQ" size");
			goto done;
		}
	}
	else {
		chunkstride = chunksize;
	}

	chunkcount = (c->infile->len + (chunkstride-1)) / chunkstride;

	if((chunkcount>256) && (!c->user_set_max_output_files)) {
		de_err(c, "Large number of chunks; use \"-maxfiles %"I64_FMT"\" if you "
			"really want to do this.", chunkcount);
		goto done;
	}

	pos = 0;
	for(chunknum = 0; chunknum<chunkcount; chunknum++) {
		i64 this_chunk_size;

		this_chunk_size = de_min_int(chunksize, c->infile->len-pos);
		do_split_onechunk(c, chunknum, pos, this_chunk_size);

		pos += chunkstride;
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xbf68b(%rip), %rsi     # 0x124390
callq 0xea6cb
testq %rax, %rax
je 0x64d56
movq %rax, %rdi
callq 0xea786
testq %rax, %rax
jle 0x64e37
movq %rax, %r12
leaq 0xbf6a7(%rip), %rsi     # 0x1243d1
movq %rbx, %rdi
callq 0xea6cb
movq %r12, %rcx
testq %rax, %rax
je 0x64d62
movq %rax, %rdi
callq 0xea786
movq %rax, %rcx
cmpq %r12, %rax
jge 0x64d62
leaq 0xbf68d(%rip), %rsi     # 0x1243de
jmp 0x64e3e
leaq 0xbf63e(%rip), %rsi     # 0x12439b
jmp 0x64e3e
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq %rcx, %rax
decq %rax
cqto
idivq %rcx
cmpq $0x101, %rax            # imm = 0x101
jl 0x64d8a
cmpb $0x0, 0xa0(%rbx)
je 0x64e56
testq %rax, %rax
jle 0x64e28
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rsi
addq %r15, %rsi
movq %r12, %rdi
callq 0xea792
movq %rax, %r12
movl $0x20, %esi
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
leaq 0xbf66c(%rip), %rdx     # 0x124441
movq %r14, %rcx
xorl %eax, %eax
callq 0xe8d67
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %r12
movq %rax, %rcx
callq 0xefabc
movq %rbp, %rdi
callq 0xf0b13
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
addq %rcx, %r13
incq %r14
subq %rcx, %r15
cmpq %r14, %rax
jne 0x64dab
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbf580(%rip), %rsi     # 0x1243be
movq %rbx, %rdi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9df7
leaq 0xbf599(%rip), %rsi     # 0x1243f6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9df7
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_xor
void de_module_xor(deark *c, struct deark_module_info *mi)
{
	mi->id = "xor";
	mi->desc = "Invert bits, or XOR with a key";
	mi->run_fn = de_run_xor;
	mi->help_fn = de_help_xor;
}

// Assembly:
leaq 0xbf1fd(%rip), %rax     # 0x1240a0
movq %rax, (%rsi)
leaq 0xbf1f7(%rip), %rax     # 0x1240a4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x64ec8
movq %rax, 0x18(%rsi)
leaq 0x1a7(%rip), %rax       # 0x6506a
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_plaintext
void de_module_plaintext(deark *c, struct deark_module_info *mi)
{
	mi->id = "plaintext";
	mi->desc = "Plain text";
	mi->desc2 = "Convert to UTF-8";
	mi->run_fn = de_run_plaintext;
}

// Assembly:
leaq 0xba96f(%rip), %rax     # 0x11f9ee
movq %rax, (%rsi)
leaq 0xbf03a(%rip), %rax     # 0x1240c3
movq %rax, 0x8(%rsi)
leaq 0xbf03a(%rip), %rax     # 0x1240ce
movq %rax, 0x10(%rsi)
leaq 0x5(%rip), %rax         # 0x650a4
movq %rax, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_run_plaintext
static void de_run_plaintext(deark *c, de_module_params *mparams)
{
	de_encoding input_encoding;
	de_encoding enc_from_bom;
	UI existing_bom_len = 0;
	i64 dpos, dlen;
	dbuf *outf = NULL;

	enc_from_bom = get_bom_enc(c, &existing_bom_len);
	input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_UNKNOWN);
	if(input_encoding==DE_ENCODING_UNKNOWN) {
		if(enc_from_bom!=DE_ENCODING_UNKNOWN) {
			input_encoding = enc_from_bom;
		}
		else {
			input_encoding = DE_ENCODING_UTF8;
		}
	}
	if(input_encoding!=enc_from_bom) {
		// Even if there was something that looked like a BOM, ignore it.
		existing_bom_len = 0;
	}

	dpos = (i64)existing_bom_len;
	dlen = c->infile->len - dpos;

	outf = dbuf_create_output_file(c, "txt", NULL, 0);
	dbuf_enable_wbuffer(outf);

	if(c->write_bom) {
		dbuf_write_uchar_as_utf8(outf, 0xfeff);
	}

	dbuf_copy_slice_convert_to_utf8(c->infile, dpos, dlen,
		DE_EXTENC_MAKE(input_encoding, DE_ENCSUBTYPE_HYBRID),
		outf, 0);

	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x5(%rsp), %r15
movl $0x3, %r14d
movl $0x3, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xeeee8
movb (%r15), %al
movb 0x1(%r15), %cl
cmpb $-0x11, %al
jne 0x650ed
cmpb $-0x45, %cl
jne 0x650ed
movl $0x2, %r13d
cmpb $-0x41, 0x7(%rsp)
je 0x6511e
movl %eax, %edx
xorb $-0x2, %dl
movl %ecx, %esi
notb %sil
orb %dl, %sil
jne 0x6510a
movl $0x4, %r13d
movl $0x2, %r14d
jmp 0x6511e
notb %al
xorb $-0x2, %cl
xorl %edx, %edx
orb %al, %cl
sete %dl
leal (%rdx,%rdx), %r14d
leal (%rdx,%rdx,2), %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xeb7d1
movl %eax, %ebp
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r15
leaq 0xc4f05(%rip), %rsi     # 0x12a040
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r12
movq %rax, %rdi
callq 0xf0e3f
cmpb $0x0, 0xcc(%rbx)
je 0x65168
movq %r12, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec81c
testl %r13d, %r13d
movl $0x2, %eax
cmovnel %r13d, %eax
testl %ebp, %ebp
cmovnel %ebp, %eax
xorl %ecx, %ecx
cmpl %r13d, %eax
cmovneq %rcx, %r14
subq %r14, %r15
movq 0x18(%rbx), %rdi
movzbl %al, %ecx
orl $0x300, %ecx            # imm = 0x300
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xf1f28
movq %r12, %rdi
callq 0xf0b13
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/misc.c
// Function: de_run_cp437
static void de_run_cp437(deark *c, de_module_params *mparams)
{
	struct cp437ctx_struct cp437ctx;

	cp437ctx.outf = dbuf_create_output_file(c, "txt", NULL, 0);
	dbuf_enable_wbuffer(cp437ctx.outf);
	de_encconv_init(&cp437ctx.es, DE_ENCODING_CP437_G);
	if(c->write_bom) {
		dbuf_write_uchar_as_utf8(cp437ctx.outf, 0xfeff);
	}
	dbuf_buffered_read(c->infile, 0, c->infile->len, cp437_cbfn, (void*)&cp437ctx);
	dbuf_close(cp437ctx.outf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc4e54(%rip), %rsi     # 0x12a040
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
movq %rax, %rdi
callq 0xf0e3f
movq %r14, %rdi
movl $0xd, %esi
callq 0xec207
cmpb $0x0, 0xcc(%rbx)
je 0x6522a
movq (%rsp), %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xec81c
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1e0d(%rip), %rcx      # 0x67046
movq %rsp, %rbx
xorl %esi, %esi
movq %rbx, %r8
callq 0xefc28
movq (%rbx), %rdi
callq 0xf0b13
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_crc
void de_module_crc(deark *c, struct deark_module_info *mi)
{
	mi->id = "crc";
	mi->id_alias[0] = "crc32";
	mi->desc = "Calculate various CRCs";
	mi->run_fn = de_run_crc;
	mi->help_fn = de_help_crc;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xd1fae(%rip), %rax     # 0x13720b
movq %rax, (%rsi)
leaq 0xbee91(%rip), %rax     # 0x1240f8
movq %rax, 0x38(%rsi)
leaq 0xbee8c(%rip), %rax     # 0x1240fe
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x65291
movq %rax, 0x18(%rsi)
leaq 0x14f(%rip), %rax       # 0x653d7
movq %rax, 0x28(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_run_crc
static void de_run_crc(deark *c, de_module_params *mparams)
{
	struct crcctx_struct crcctx;
	size_t n;

	de_zeromem(&crcctx, sizeof(struct crcctx_struct));
	crcctx.opt_all = (u8)de_get_ext_option_bool(c, "crc:all", 0xff);
	if(crcctx.opt_all==0xff) {
		if(c->extract_level>=2) {
			crcctx.opt_all = 1;
		}
		else {
			crcctx.opt_all = 0;
		}
	}

	for(n=0; n<CRCM_NUMCRCS; n++) {
		if((crcm_map[n].flags & 0x1)==0 && !crcctx.opt_all) continue;
		crcctx.crcos[n] = de_crcobj_create(c, crcm_map[n].crctype);
	}

	dbuf_buffered_read(c->infile, 0, c->infile->len, crc_cbfn, (void*)&crcctx);

	for(n=0; n<CRCM_NUMCRCS; n++) {
		u32 val = 0;
		u64 val64 = 0;

		if(!crcctx.crcos[n]) continue;

		if(crcm_map[n].nbits==0) {
			val64 = de_crcobj_getval64(crcctx.crcos[n]);
		}
		else {
			val = de_crcobj_getval(crcctx.crcos[n]);
		}

		if(crcm_map[n].nbits==0) {
			de_msg(c, "%-18s: 0x%"U64_FMTx, crcm_map[n].name, val64);
		}
		else if(crcm_map[n].nbits==16) {
			de_msg(c, "%-18s: 0x%04x", crcm_map[n].name, (UI)val);
		}
		else {
			de_msg(c, "%-18s: 0x%08x", crcm_map[n].name, (UI)val);
		}
	}

	for(n=0; n<CRCM_NUMCRCS; n++) {
		de_crcobj_destroy(crcctx.crcos[n]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0xbf239(%rip), %rsi     # 0x124502
movl $0xff, %edx
callq 0xea727
movb %al, (%rsp)
cmpb $-0x1, %al
jne 0x652ed
cmpl $0x2, 0x90(%rbx)
jl 0x652e9
movb $0x1, (%rsp)
jmp 0x652ed
movb $0x0, (%rsp)
xorl %r14d, %r14d
leaq 0x11c889(%rip), %r13    # 0x181b80
movb 0x4(%r13,%r14,2), %al
andb $0x1, %al
orb (%rsp), %al
je 0x65318
leaq (%r14,%r14), %rax
movl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0xeba56
movq %rax, 0x8(%rsp,%r14)
addq $0x8, %r14
cmpq $0x58, %r14
jne 0x652f7
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
leaq 0x1d8b(%rip), %rcx      # 0x670bc
movq %rsp, %r8
xorl %esi, %esi
callq 0xefc28
leaq 0xbf1c8(%rip), %r15     # 0x12450a
leaq 0xbf1dc(%rip), %r12     # 0x124525
xorl %ebp, %ebp
movq 0x8(%rsp,%rbp), %rdi
testq %rdi, %rdi
je 0x653a7
movzbl 0x5(%r13,%rbp,2), %r14d
testl %r14d, %r14d
je 0x6536b
callq 0xebe2a
movl %eax, %ecx
xorl %eax, %eax
jmp 0x65372
callq 0xebe4c
xorl %ecx, %ecx
movq 0x8(%r13,%rbp,2), %rdx
movq %rbx, %rdi
cmpl $0x10, %r14d
je 0x65394
testl %r14d, %r14d
jne 0x6539d
movq %r15, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9fc3
jmp 0x653a7
leaq 0xbf17c(%rip), %rsi     # 0x124517
jmp 0x653a0
movq %r12, %rsi
xorl %eax, %eax
callq 0xe9fc3
addq $0x8, %rbp
cmpq $0x58, %rbp
jne 0x6534b
movl $0x1, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0xebe1d
incq %rbx
cmpq $0xc, %rbx
jne 0x653b6
addq $0x68, %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/misc.c
// Function: de_module_datetime
void de_module_datetime(deark *c, struct deark_module_info *mi)
{
	mi->id = "datetime";
	mi->desc = "Interpret a date/time field";
	mi->run_fn = de_run_datetime;
	mi->flags |= DE_MODFLAG_HIDDEN | DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xbed29(%rip), %rax     # 0x124115
movq %rax, (%rsi)
leaq 0xbed28(%rip), %rax     # 0x12411e
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x6540a
movq %rax, 0x18(%rsi)
orb $0x5, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_hexdump
void de_module_hexdump(deark *c, struct deark_module_info *mi)
{
	mi->id = "hexdump";
	mi->desc = "Print a hex dump";
	mi->run_fn = de_run_hexdump;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xc75dd(%rip), %rax     # 0x12cbd7
movq %rax, (%rsi)
leaq 0xbeb36(%rip), %rax     # 0x12413a
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x65618
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc.c
// Function: de_module_bytefreq
void de_module_bytefreq(deark *c, struct deark_module_info *mi)
{
	mi->id = "bytefreq";
	mi->desc = "Print a byte frequence analysis";
	mi->run_fn = de_run_bytefreq;
	mi->flags |= DE_MODFLAG_NOEXTRACT;
}

// Assembly:
leaq 0xbeb14(%rip), %rax     # 0x12414b
movq %rax, (%rsi)
leaq 0xbeb13(%rip), %rax     # 0x124154
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0x65655
movq %rax, 0x18(%rsi)
orb $0x4, 0x30(%rsi)
retq