LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: asc2com_extract_compressed
static void asc2com_extract_compressed(deark *c, lctx *d)
{
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	struct de_lzw_params delzwp;
	dbuf *tmpf = NULL;
	dbuf *outf = NULL;

	tmpf = dbuf_create_membuf(c, 0, 0);

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = d->tpos;
	dcmpri.len = d->tlen;
	dcmpro.f = tmpf;
	dcmpro.len_known = 0;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_ASC2COM;
	fmtutil_decompress_lzw(c, &dcmpri, &dcmpro, &dres, &delzwp);
	dbuf_flush(tmpf);

	if(tmpf->len>0) {
		outf = dbuf_create_output_file(c, "txt", NULL, 0);
		dbuf_enable_wbuffer(outf);
		d->inf = tmpf;
		asc2com_filter_and_write(c, d, 0, tmpf->len, outf);
	}

	if(dres.errcode) {
		de_err(c, "%s", de_dfilter_get_errmsg(c, &dres));
		goto done;
	}

done:
	dbuf_close(tmpf);
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0xc8(%rbp)
movq $0x0, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x168020
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0xa8(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0xbc(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x19140
movl $0xc, -0xbc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0xa8(%rbp), %rcx
leaq -0xbc(%rbp), %r8
callq 0x1843b0
movq -0xc8(%rbp), %rdi
callq 0x167c30
movq -0xc8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jle 0x8ed9b
movq -0x8(%rbp), %rdi
leaq 0x126ea6(%rip), %rsi    # 0x1b5bf1
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x167b90
movq -0xc8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0xd0(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x8ee80
cmpl $0x0, -0xa8(%rbp)
je 0x8edd9
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x177360
movq -0xd8(%rbp), %rdi
movq %rax, %rdx
leaq 0x111d5f(%rip), %rsi    # 0x1a0b2f
movb $0x0, %al
callq 0x15bfb0
jmp 0x8eddb
jmp 0x8eddb
movq -0xc8(%rbp), %rdi
callq 0x1676a0
movq -0xd0(%rbp), %rdi
callq 0x1676a0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: asc2com_extract_uncompressed
static void asc2com_extract_uncompressed(deark *c, lctx *d)
{
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "txt", NULL, 0);
	dbuf_enable_wbuffer(outf);
	asc2com_filter_and_write(c, d, d->tpos, d->tpos+d->tlen, outf);
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x126dce(%rip), %rsi    # 0x1b5bf1
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq -0x18(%rbp), %r8
callq 0x8ee80
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x16, %ecx
callq 0x164d10
movzbl -0x30(%rbp), %eax
cmpl $0xbe, %eax
jne 0x8f106
movzbl -0x21(%rbp), %eax
cmpl $0x72, %eax
jne 0x8f106
leaq -0x30(%rbp), %rdi
addq $0x3, %rdi
leaq 0x120800(%rip), %rsi    # 0x1af8e0
movl $0xa, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x8f101
movq -0x10(%rbp), %rax
movl $0xa, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x8f1a1
movzbl -0x30(%rbp), %eax
cmpl $0xfc, %eax
jne 0x8f157
movzbl -0x2f(%rbp), %eax
cmpl $0xbe, %eax
jne 0x8f157
movzbl -0x20(%rbp), %eax
cmpl $0x72, %eax
jne 0x8f157
leaq -0x30(%rbp), %rdi
addq $0x4, %rdi
leaq 0x1207b7(%rip), %rsi    # 0x1af8eb
movl $0xa, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x8f155
movq -0x10(%rbp), %rax
movl $0x14, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x8f19f
movzbl -0x30(%rbp), %eax
cmpl $0xfc, %eax
jne 0x8f19d
movzbl -0x2b(%rbp), %eax
cmpl $0x49, %eax
jne 0x8f19d
leaq -0x30(%rbp), %rdi
addq $0xa, %rdi
leaq 0x1203e3(%rip), %rsi    # 0x1af55d
movl $0xc, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x8f19b
movq -0x10(%rbp), %rax
movl $0x1e, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x8f19d
jmp 0x8f19f
jmp 0x8f1a1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: doc2com_find_special_codes
static void doc2com_find_special_codes(deark *c, lctx *d)
{
	i64 foundpos;
	int ret;
	i64 count;
	i64 i;
	i64 pos;
	de_ucstring *tmpstr = NULL;

	ret = dbuf_search(c->infile, (const u8*)"\x74\xda\xeb\xf3", 4,
		633, 5, &foundpos);
	if(!ret) goto done;
	pos = foundpos+4;
	de_dbg(c, "pos of special chars: %"I64_FMT, pos);

	count = (i64)de_getbyte_p(&pos);
	de_dbg(c, "num special chars: %"I64_FMT, count);
	if(count<1 || count>16) goto done;
	tmpstr = ucstring_create(c);
	for(i=0; i<count; i++) {
		i64 b;
		b = de_getbyte_p(&pos);
		d->chartypes[(UI)b] = ETCT_DOC2COMSPECIAL;
		ucstring_printf(tmpstr, DE_ENCODING_LATIN1, " %02x", (UI)b);
	}

done:
	if(ucstring_isnonempty(tmpstr)) {
		de_dbg(c, "special chars:%s", ucstring_getpsz(tmpstr));
	}
	ucstring_destroy(tmpstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x120165(%rip), %rsi    # 0x1af59c
movl $0x4, %edx
movl $0x279, %ecx            # imm = 0x279
movl $0x5, %r8d
leaq -0x18(%rbp), %r9
callq 0x169370
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8f45e
jmp 0x8f531
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x120128(%rip), %rsi    # 0x1af5a1
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x120114(%rip), %rsi    # 0x1af5bb
movb $0x0, %al
callq 0x15b0d0
cmpq $0x1, -0x28(%rbp)
jl 0x8f4bc
cmpq $0x10, -0x28(%rbp)
jle 0x8f4be
jmp 0x8f531
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x8f52f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movl %ecx, %ecx
movb $0x65, 0x38(%rax,%rcx)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movl %eax, %ecx
movl $0x5, %esi
leaq 0x11ff9b(%rip), %rdx    # 0x1af4b5
movb $0x0, %al
callq 0x171660
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8f4d3
jmp 0x8f531
movq -0x40(%rbp), %rdi
callq 0x1717f0
cmpl $0x0, %eax
je 0x8f565
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x172500
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x11ff5d(%rip), %rsi    # 0x1af4bb
movb $0x0, %al
callq 0x15b0d0
movq -0x40(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: readmake_find_text
static void readmake_find_text(deark *c, struct readmake_ctx *rmctx, lctx *d)
{
	i64 pos;
	i64 n;

	pos = rmctx->ei->end_of_dos_code;
	n = de_getu32le(pos);
	pos += n;

	n = de_getu32le(pos);
	if(n==4) {
		// Later files have an extra field (expected value 4) or segment
		// (expected length 4). The segment after that is expected to
		// be larger. We use that to tell the difference.
		pos += 4;
		n = de_getu32le(pos);
	}
	else if(n<14) {
		d->need_errmsg = 1;
		goto done;
	}

	pos += n;
	d->tpos = pos;
	de_dbg(c, "tpos: %"I64_FMT, d->tpos);

	// TODO?: There might be a better way to figure out the length, but for
	// pristine files we can use the end of file.
	d->tlen = c->infile->len - d->tpos;

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165540
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165540
movq %rax, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jne 0x8f9a4
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165540
movq %rax, -0x28(%rbp)
jmp 0x8f9b7
cmpq $0xe, -0x28(%rbp)
jge 0x8f9b5
movq -0x18(%rbp), %rax
movb $0x1, 0x13(%rax)
jmp 0x8fa05
jmp 0x8f9b7
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x11fb8f(%rip), %rsi    # 0x1af571
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
subq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: texe_find_text
static void texe_find_text(deark *c, struct texe_ctx *tctx, lctx *d)
{
	i64 endpos;
	u8 buf[2];

	d->tpos = tctx->ei->end_of_dos_code;
	de_dbg(c, "tpos: %"I64_FMT, d->tpos);

	de_read(buf, d->tpos, 2);
	if(buf[1]==0x0a && buf[0]!=0x0d) {
		tctx->use_cr_hack = 1;
	}

	endpos = c->infile->len;
	// Files normally end with an extraneous space, which we'll strip off.
	if(de_getbyte(endpos-1) == 0x20) {
		endpos--;
	}
	d->tlen = endpos - d->tpos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x11fb26(%rip), %rsi    # 0x1af571
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x22(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
movl $0x2, %ecx
callq 0x164d10
movzbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x8fa8a
movzbl -0x22(%rbp), %eax
cmpl $0xd, %eax
je 0x8fa8a
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0x20, %eax
jne 0x8fac3
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: readamatic_find_text
static void readamatic_find_text(deark *c, struct readamatic_ctx *tctx, lctx *d)
{
	i64 foundpos;
	i64 pos;
	int ret;

	// 10 byte header
	pos = tctx->ei->end_of_dos_code + 10;

	// Then a variable-length title we need to skip over.
	ret = dbuf_search_byte(c->infile, 0x0a, pos, 256, &foundpos);
	if(!ret) {
		d->errflag = 1;
		d->need_errmsg = 1;
		goto done;
	}

	d->tpos = foundpos+1;
	d->tlen = c->infile->len - d->tpos;

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
addq $0xa, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rdx
movl $0xa, %esi
movl $0x100, %ecx            # imm = 0x100
leaq -0x20(%rbp), %r8
callq 0x1667a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x8fb42
movq -0x18(%rbp), %rax
movb $0x1, 0x12(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x13(%rax)
jmp 0x8fb6e
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
subq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/exectext.c
// Function: ascom_decrypt
static void ascom_decrypt(deark *c, lctx *d, dbuf *tmpdbuf)
{
	i64 i;

	for(i=0; i<d->tlen; i++) {
		u8 b;

		b = de_getbyte(d->tpos + i);
		b = b ^ 0x01;
		dbuf_writebyte(tmpdbuf, b);
	}
	dbuf_flush(tmpdbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jge 0x8fbeb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
addq -0x20(%rbp), %rsi
callq 0x165060
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movzbl -0x21(%rbp), %esi
callq 0x168380
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8fb9c
movq -0x18(%rbp), %rdi
callq 0x167c30
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11fcf7(%rip), %rcx    # 0x1af90e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11fcf5(%rip), %rcx    # 0x1af91a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x8fc50
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2ed(%rip), %rcx       # 0x8ff30
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x61, 0x18(%rax)
jge 0x8ff54
movl $0x0, -0x4(%rbp)
jmp 0x8ffad
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x11faae(%rip), %rdx    # 0x1afa15
movl $0x8, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x8ff7f
movl $0x0, -0x4(%rbp)
jmp 0x8ffad
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4b, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x5, %eax
jle 0x8ffa6
movl $0x0, -0x4(%rbp)
jmp 0x8ffad
movl $0x64, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11f969(%rip), %rcx    # 0x1af940
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11f963(%rip), %rcx    # 0x1af948
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x90010
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x24d(%rip), %rcx       # 0x90250
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/gws.c
// Function: get_base_filename
static void get_base_filename(de_ucstring *s1, de_ucstring *s2)
{
	i64 i;
	i64 len;

	ucstring_empty(s2);
	len = s1->len;
	for(i=0; i<len; i++) {
		de_rune ch;

		ch = s1->str[i];
		if(ch=='\\' || ch=='/') {
			ucstring_empty(s2);
		}
		else {
			ucstring_append_char(s2, ch);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x171210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x90c7c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x5c, -0x24(%rbp)
je 0x90c55
cmpl $0x2f, -0x24(%rbp)
jne 0x90c60
movq -0x10(%rbp), %rdi
callq 0x171210
jmp 0x90c6c
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1714c0
jmp 0x90c6e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x90c2d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/gws.c
// Function: gwsthn_makepal_orig
static void gwsthn_makepal_orig(deark *c, struct gws_thn_ctx *d)
{
	// Original palette
	// Based on Graphic Workshop v1.1a for Windows
	static const u8 rbvals[6] = {0x00,0x57,0x83,0xab,0xd7,0xff};
	static const u8 gvals[7] = {0x00,0x2b,0x57,0x83,0xab,0xd7,0xff};
	static const de_color gwspal_last5[5] = {
		0xff3f3f3fU,0xff6b6b6bU,0xff979797U,0xffc3c3c3U,0xffffffffU
	};
	UI k;

	for(k=0; k<=250; k++) {
		d->pal[k] = DE_MAKE_RGB(
			rbvals[k%6],
			gvals[(k%42)/6],
			rbvals[k/42]);
	}
	for(k=251; k<=255; k++) {
		d->pal[k] = gwspal_last5[k-251];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xfa, -0x14(%rbp)
ja 0x90d42
movl -0x14(%rbp), %eax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl %eax, %ecx
leaq 0x11ee59(%rip), %rax    # 0x1afb20
movzbl (%rax,%rcx), %eax
shll $0x10, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl $0x2a, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl $0x6, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x11ee29(%rip), %rcx    # 0x1afb26
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl $0x2a, %ecx
xorl %edx, %edx
divl %ecx
movl -0x18(%rbp), %edx
movl %eax, %eax
movl %eax, %ecx
leaq 0x11edfd(%rip), %rax    # 0x1afb20
movzbl (%rax,%rcx), %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x90ca3
movl $0xfb, -0x14(%rbp)
cmpl $0xff, -0x14(%rbp)
ja 0x90d7e
movl -0x14(%rbp), %eax
subl $0xfb, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x11edcb(%rip), %rax    # 0x1afb30
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x90d49
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/gws.c
// Function: gwsthn_makepal_new
static void gwsthn_makepal_new(deark *c, struct gws_thn_ctx *d)
{
	// New palette (really RGB332), introduced by v1.1c
	// Based on Graphic Workshop v1.1u for Windows
	UI k;

	for(k=0; k<256; k++) {
		u8 r, g, b;
		r = de_sample_nbit_to_8bit(3, k>>5);
		g = de_sample_nbit_to_8bit(3, (k>>2)&0x07);
		b = de_sample_nbit_to_8bit(2, k&0x03);
		d->pal[k] = DE_MAKE_RGB(r, g, b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jae 0x90e0e
movl -0x14(%rbp), %esi
shrl $0x5, %esi
movl $0x3, %edi
callq 0x161680
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %esi
shrl $0x2, %esi
andl $0x7, %esi
movl $0x3, %edi
callq 0x161680
movb %al, -0x16(%rbp)
movl -0x14(%rbp), %esi
andl $0x3, %esi
movl $0x2, %edi
callq 0x161680
movb %al, -0x17(%rbp)
movzbl -0x15(%rbp), %edx
shll $0x10, %edx
orl $0xff000000, %edx       # imm = 0xFF000000
movzbl -0x16(%rbp), %eax
shll $0x8, %eax
orl %eax, %edx
movzbl -0x17(%rbp), %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x90d97
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/gws.c
// Function: do_gwsexe_image
static void do_gwsexe_image(deark *c, struct gws_exepic_ctx *d)
{
	dbuf *unc_pixels = NULL;

	de_dbg(c, "image at %"I64_FMT, d->imgpos);
	de_dbg_indent(c, 1);
	if(d->cmpr_meth==2) {
		unc_pixels = dbuf_create_membuf(c, d->unc_image_size, 0x1);
		dbuf_enable_wbuffer(unc_pixels);
		gwsexe_decompress(c, d, unc_pixels);
		gwsexe_decode_decompressed_image(c, d, unc_pixels, 0);
	}
	else {
		gwsexe_decode_decompressed_image(c, d, c->infile, d->imgpos);
	}

	dbuf_close(unc_pixels);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x1294e3(%rip), %rsi    # 0x1ba32e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x10(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x90eb5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0x1, %edx
callq 0x168020
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x90ef0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x90fd0
jmp 0x90ed2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x90fd0
movq -0x18(%rbp), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/gws.c
// Function: gwsexe_decompress
static void gwsexe_decompress(deark *c, struct gws_exepic_ctx *d, dbuf *unc_pixels)
{
	i64 ipos = d->imgpos;
	i64 nbytes_decompressed = 0;

	while(1) {
		u8 b0;
		u8 val;
		i64 count;

		if(ipos >= c->infile->len) goto done;
		if(nbytes_decompressed >= d->unc_image_size) goto done;

		b0 = de_getbyte_p(&ipos);
		if(b0 < 0xc0) {
			count = 1;
			val = b0;
		}
		else {
			// TODO: Figure out what opcode 0xc0 means. I've never seen it used.
			count = (i64)(b0-0xc0);
			val = de_getbyte_p(&ipos);
		}

		dbuf_write_run(unc_pixels, val, count);
		nbytes_decompressed += count;
	}
done:
	dbuf_flush(unc_pixels);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x90f2f
jmp 0x90fb5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jl 0x90f3f
jmp 0x90fb5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xc0, %eax
jge 0x90f6e
movq $0x1, -0x38(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x2a(%rbp)
jmp 0x90f91
movzbl -0x29(%rbp), %eax
subl $0xc0, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movb %al, -0x2a(%rbp)
movq -0x18(%rbp), %rdi
movb -0x2a(%rbp), %al
movq -0x38(%rbp), %rdx
movzbl %al, %esi
callq 0x168800
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x90f18
movq -0x18(%rbp), %rdi
callq 0x167c30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movl $0x3, %ecx
callq 0x16b750
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jle 0x91068
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
imulq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %r8
movq -0x10(%rbp), %r9
addq $0xd8, %r9
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x16c690
jmp 0x9109d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %r8
addq $0xd8, %r8
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x16c520
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x16afd0
movq -0x28(%rbp), %rdi
callq 0x16af60
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11e9f5(%rip), %rcx    # 0x1afb5c
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11e9ec(%rip), %rcx    # 0x1afb61
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x911a0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11e9a5(%rip), %rcx    # 0x1afb6c
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11e99c(%rip), %rcx    # 0x1afb71
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x91200
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x9123a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12ffc2(%rip), %rsi    # 0x1c1207
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x912ff
cmpl $0x0, -0x14(%rbp)
jle 0x912af
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x912af
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0x112a28(%rip), %rsi    # 0x1a3cd0
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15f890
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x912c8
jmp 0x91301
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x166070
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x15f970
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9125b
jmp 0x91301
movq -0x20(%rbp), %rdi
callq 0x1676a0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11e85c(%rip), %rcx    # 0x1afb83
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11e854(%rip), %rcx    # 0x1afb89
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x91360
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x18d(%rip), %rcx       # 0x914e0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11eb09(%rip), %rsi    # 0x1afe84
callq 0x15cb30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x913a2
movq -0x8(%rbp), %rdi
leaq 0x11eaf9(%rip), %rsi    # 0x1afe8f
movb $0x0, %al
callq 0x15bfb0
jmp 0x914d8
movq -0x18(%rbp), %rdi
callq 0x15ccc0
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
jge 0x913cd
movq -0x8(%rbp), %rdi
leaq 0x11eaf1(%rip), %rsi    # 0x1afeb2
movb $0x0, %al
callq 0x15bfb0
jmp 0x914d8
movq -0x8(%rbp), %rdi
leaq 0x11eaed(%rip), %rsi    # 0x1afec5
callq 0x15cb30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x91418
movq -0x18(%rbp), %rdi
callq 0x15ccc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x91416
movq -0x8(%rbp), %rdi
leaq 0x11eac8(%rip), %rsi    # 0x1afed2
movb $0x0, %al
callq 0x15bfb0
jmp 0x914d8
jmp 0x91420
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
cqto
idivq -0x38(%rbp)
movq %rax, -0x40(%rbp)
cmpq $0x100, -0x40(%rbp)     # imm = 0x100
jle 0x91470
movq -0x8(%rbp), %rax
cmpb $0x0, 0xa0(%rax)
jne 0x91470
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x11ea83(%rip), %rsi    # 0x1afeea
movb $0x0, %al
callq 0x15bfb0
jmp 0x914d8
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x914d6
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rsi
subq -0x20(%rbp), %rsi
callq 0x15ccf0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x94260
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x91480
jmp 0x914d8
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11e679(%rip), %rcx    # 0x1afbb0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11e66f(%rip), %rcx    # 0x1afbb4
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x91570
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1fd(%rip), %rcx       # 0x91760
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x119ed7(%rip), %rcx    # 0x1ab67e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11e41e(%rip), %rcx    # 0x1afbd3
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x11e41a(%rip), %rcx    # 0x1afbde
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0xd(%rip), %rcx         # 0x917e0
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x94380
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x15e4a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x9183e
cmpl $0x0, -0x18(%rbp)
je 0x91835
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x9183c
movl $0x2, -0x14(%rbp)
jmp 0x9183e
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x9184d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12437e(%rip), %rsi    # 0x1b5bf1
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x167b90
movq -0x8(%rbp), %rax
cmpb $0x0, 0xcc(%rax)
je 0x918a6
movq -0x38(%rbp), %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0x160cc0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
orl $0x300, %ecx            # imm = 0x300
movq -0x38(%rbp), %r8
xorl %r9d, %r9d
callq 0x169da0
movq -0x38(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1242b6(%rip), %rsi    # 0x1b5bf1
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x167b90
leaq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl $0xd, %esi
callq 0x160150
movq -0x8(%rbp), %rax
cmpb $0x0, 0xcc(%rax)
je 0x91980
movq -0x38(%rbp), %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0x160cc0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq 0x2ab1(%rip), %rcx      # 0x94450
leaq -0x38(%rbp), %r8
callq 0x166260
movq -0x38(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1314a4(%rip), %rcx    # 0x1c2e7b
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11e223(%rip), %rcx    # 0x1afc08
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0x11e21a(%rip), %rcx    # 0x1afc0e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2d(%rip), %rcx        # 0x91a30
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x29e(%rip), %rcx       # 0x91cb0
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11df2e(%rip), %rcx    # 0x1afc25
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11df29(%rip), %rcx    # 0x1afc2e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x91d30
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x5, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_datetime
static void de_run_datetime(deark *c, de_module_params *mparams)
{
	struct de_timestamp timestamp;
	i64 dtime, ddate;
	i64 t;

	dtime = de_getu16le(0);
	ddate = de_getu16le(2);
	de_dos_datetime_to_timestamp(&timestamp, ddate, dtime);
	datetime_msg(c, &timestamp, "DOS time,date");

	ddate = de_getu16le(0);
	dtime = de_getu16le(2);
	de_dos_datetime_to_timestamp(&timestamp, ddate, dtime);
	datetime_msg(c, &timestamp, "DOS date,time");

	t = de_geti32le(0);
	de_unix_time_to_timestamp(t, &timestamp, 0x1);
	datetime_msg(c, &timestamp, "Unix-LE");

	t = de_geti32be(0);
	de_unix_time_to_timestamp(t, &timestamp, 0x1);
	datetime_msg(c, &timestamp, "Unix-BE");

	t = de_getu32be(0);
	de_mac_time_to_timestamp(t, &timestamp);
	datetime_msg(c, &timestamp, "Mac/HFS-BE");

	t = de_geti64le(0);
	de_FILETIME_to_timestamp(t, &timestamp, 0x1);
	datetime_msg(c, &timestamp, "Windows FILETIME");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x165280
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x15d750
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x11e35b(%rip), %rdx    # 0x1b00e6
callq 0x945a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165280
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x15d750
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x11e319(%rip), %rdx    # 0x1b00f4
callq 0x945a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165600
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x11e2ec(%rip), %rdx    # 0x1b0102
callq 0x945a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1655d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x11e2b9(%rip), %rdx    # 0x1b010a
callq 0x945a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165470
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x15d720
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x11e28b(%rip), %rdx    # 0x1b0112
callq 0x945a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1657e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x15d580
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x11e25b(%rip), %rdx    # 0x1b011d
callq 0x945a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x126ab4(%rip), %rcx    # 0x1b899b
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11dd55(%rip), %rcx    # 0x1afc4a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x91f20
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11dcd4(%rip), %rcx    # 0x1afc5b
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11dccf(%rip), %rcx    # 0x1afc64
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x91fc0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_run_deflate
static void de_run_deflate(deark *c, de_module_params *mparams)
{
	UI flags = 0;

	if(de_get_ext_option_bool(c, "deflate:deflate64", 0)) {
		flags |= DE_DEFLATEFLAG_DEFLATE64;
	}

	run_deflate_internal(c, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11deac(%rip), %rsi    # 0x1b017e
xorl %edx, %edx
callq 0x15cbc0
cmpl $0x0, %eax
je 0x922e7
movl -0x14(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x94690
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/misc.c
// Function: de_module_zlib
void de_module_zlib(deark *c, struct deark_module_info *mi)
{
	mi->id = "zlib";
	mi->desc = "Raw zlib compressed data";
	mi->run_fn = de_run_zlib;
	mi->identify_fn = de_identify_zlib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x130b83(%rip), %rcx    # 0x1c2e9a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11d983(%rip), %rcx    # 0x1afca8
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x92350
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x3d(%rip), %rcx        # 0x92380
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)