LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_strlcpy
void de_strlcpy(char *dst, const char *src, size_t dstlen)
{
	size_t n;
	n = de_strlen(src);
	if(n>dstlen-1) n=dstlen-1;
	de_memcpy(dst, src, n);
	dst[n]='\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x190e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x15aa6e
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x191e0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_strcasecmp_internal
static int de_strcasecmp_internal(const char *a, const char *b,
	int has_n, size_t n)
{
	size_t k = 0;

	while(1) {
		unsigned char a1, b1;

		if(has_n && (k>=n)) break;
		a1 = (unsigned char)a[k];
		b1 = (unsigned char)b[k];
		if(a1==0 && b1==0) break;
		if(a1>='A' && a1<='Z') a1 += 32;
		if(b1>='A' && b1<='Z') b1 += 32;
		if(a1<b1) return -1;
		if(a1>b1) return 1;
		k++;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x15ab00
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x15ab00
jmp 0x15aba3
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x0, %eax
jne 0x15ab30
movzbl -0x32(%rbp), %eax
cmpl $0x0, %eax
jne 0x15ab30
jmp 0x15aba3
movzbl -0x31(%rbp), %eax
cmpl $0x41, %eax
jl 0x15ab4c
movzbl -0x31(%rbp), %eax
cmpl $0x5a, %eax
jg 0x15ab4c
movzbl -0x31(%rbp), %eax
addl $0x20, %eax
movb %al, -0x31(%rbp)
movzbl -0x32(%rbp), %eax
cmpl $0x41, %eax
jl 0x15ab68
movzbl -0x32(%rbp), %eax
cmpl $0x5a, %eax
jg 0x15ab68
movzbl -0x32(%rbp), %eax
addl $0x20, %eax
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
jge 0x15ab7d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15abaa
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
jle 0x15ab92
movl $0x1, -0x4(%rbp)
jmp 0x15abaa
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15aaeb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_puts
void de_puts(deark *c, unsigned int flags, const char *s)
{
	size_t k;

	if(!c || !c->msgfn) {
		fputs(s, stderr);
		return;
	}

	// Scan the printable string for "magic" byte sequences that represent
	// text color changes, etc. It's admittedly a little ugly that we have to
	// do this.
	//
	// We could invent and use any byte sequences we want for this, as long as
	// they will not otherwise occur in "printable" output.
	// I.e., if it's valid UTF-8, it must contain a character we classify as
	// "nonprintable". We could even use actual ANSI escape sequences, since
	// Esc is a nonprintable character (but that would have little benefit,
	// and feel kinda wrong, since this part of the code isn't supposed to
	// know about ANSI escape sequences).
	// Short sequences are preferable, because they're simpler to detect, and
	// because these bytes count against some of our size limits.
	// Valid UTF-8 is probably best, because someday we might want this scheme
	// to be compatible with something else (such as ucstrings).
	// So, we're simply using:
	//   U+0001 : DE_CODEPOINT_HL
	//   U+0002 : DE_CODEPOINT_UNHL
	//   U+0003 : DE_CODEPOINT_RGBSAMPLE (followed by 6 bytes for the RGB color)

	for(k=0; s[k]; k++) {
		if(s[k]=='\x01' || s[k]=='\x02' || s[k]=='\x03') {
			de_puts_advanced(c, flags, s);
			return;
		}
	}

	c->msgfn(c, flags, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15ac48
movq -0x8(%rbp), %rax
cmpq $0x0, 0x108(%rax)
jne 0x15ac60
movq -0x18(%rbp), %rdi
movq 0xca3a5(%rip), %rax     # 0x224ff8
movq (%rax), %rsi
callq 0x19130
jmp 0x15ace3
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x15accb
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x15aca9
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2, %eax
je 0x15aca9
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jne 0x15acbb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x15acf0
jmp 0x15ace3
jmp 0x15acbd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15ac68
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbg
void de_dbg(deark *c, const char *fmt, ...)
{
	va_list ap;

	if(c && c->debug_level<1) return;
	va_start(ap, fmt);
	de_vdbg_internal(c, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x15b108
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15b13e
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jge 0x15b13e
jmp 0x15b177
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15b180
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_vdbg_internal
static void de_vdbg_internal(deark *c, const char *fmt, va_list ap)
{
	char bars_and_spaces[128];
	size_t bpos;
	int nspaces;
	int nbars;
	const char *dprefix = "DEBUG: ";

	if(c) {
		if(c->dprefix) dprefix = c->dprefix;

		nbars = c->module_nesting_level - 1;
		if(nbars>10) nbars=10;

		nspaces = c->dbg_indent_amount;
		if(nspaces>50) nspaces=50;
	}
	else {
		nbars = 0;
		nspaces = 0;
	}

	bpos = 0;
	while(nbars>0) {
		// One or more vertical lines, to indicate module nesting
		bars_and_spaces[bpos++] = '\xe2'; // U+2502 Box drawings light vertical
		bars_and_spaces[bpos++] = '\x94';
		bars_and_spaces[bpos++] = '\x82';
		nbars--;
	}
	while(nspaces>0) {
		bars_and_spaces[bpos++] = ' ';
		nspaces--;
	}
	bars_and_spaces[bpos] = '\0';

	de_printf(c, DE_MSGTYPE_DEBUG, "%s%s", dprefix, bars_and_spaces);
	de_vprintf(c, DE_MSGTYPE_DEBUG, fmt, ap);
	de_puts(c, DE_MSGTYPE_DEBUG, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x76e93(%rip), %rax     # 0x1d2031
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15b214
movq -0x8(%rbp), %rax
cmpq $0x0, 0x120(%rax)
je 0x15b1cc
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0xb0(%rbp)
cmpl $0xa, -0xb0(%rbp)
jle 0x15b1ef
movl $0xa, -0xb0(%rbp)
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0xac(%rbp)
cmpl $0x32, -0xac(%rbp)
jle 0x15b212
movl $0x32, -0xac(%rbp)
jmp 0x15b228
movl $0x0, -0xb0(%rbp)
movl $0x0, -0xac(%rbp)
movq $0x0, -0xa8(%rbp)
cmpl $0x0, -0xb0(%rbp)
jle 0x15b2a4
movq -0xa8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xa8(%rbp)
movb $-0x1e, -0xa0(%rbp,%rax)
movq -0xa8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xa8(%rbp)
movb $-0x6c, -0xa0(%rbp,%rax)
movq -0xa8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xa8(%rbp)
movb $-0x7e, -0xa0(%rbp,%rax)
movl -0xb0(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0x15b233
jmp 0x15b2a6
cmpl $0x0, -0xac(%rbp)
jle 0x15b2dd
movq -0xa8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xa8(%rbp)
movb $0x20, -0xa0(%rbp,%rax)
movl -0xac(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x15b2a6
movq -0xa8(%rbp), %rax
movb $0x0, -0xa0(%rbp,%rax)
movq -0x8(%rbp), %rdi
movq -0xb8(%rbp), %rcx
leaq -0xa0(%rbp), %r8
movl $0x3, %esi
leaq 0x76d4b(%rip), %rdx     # 0x1d2055
movb $0x0, %al
callq 0x15afe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x3, %esi
callq 0x15b080
movq -0x8(%rbp), %rdi
movl $0x3, %esi
leaq 0x40e4c(%rip), %rdx     # 0x19c183
callq 0x15ac20
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbg2
void de_dbg2(deark *c, const char *fmt, ...)
{
	va_list ap;

	if(c && c->debug_level<2) return;
	va_start(ap, fmt);
	de_vdbg_internal(c, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x15b388
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15b3be
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jge 0x15b3be
jmp 0x15b3f7
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15b180
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbg3
void de_dbg3(deark *c, const char *fmt, ...)
{
	va_list ap;

	if(c && c->debug_level<3) return;
	va_start(ap, fmt);
	de_vdbg_internal(c, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x15b438
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15b46e
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jge 0x15b46e
jmp 0x15b4a7
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15b180
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbgx
void de_dbgx(deark *c, int lv, const char *fmt, ...)
{
	va_list ap;

	if(c && c->debug_level<lv) return;
	va_start(ap, fmt);
	de_vdbg_internal(c, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x15b4e8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15b51c
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x15b51c
jmp 0x15b555
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15b180
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_render_hexbytes_from_mem
char *de_render_hexbytes_from_mem(const u8 *inbytes, i64 ilen,
	char *outbuf, size_t outbuf_len)
{
	i64 inpos;
	size_t outpos = 0;

	if(ilen<1) goto done;
	if(ilen > (i64)(outbuf_len/3)) {
		ilen = (i64)(outbuf_len/3);
	}

	for(inpos = 0; inpos<ilen; inpos++) {
		if(inpos>0) outbuf[outpos++] = ' ';
		outbuf[outpos++] = de_get_hexchar((int)(inbytes[inpos]/16));
		outbuf[outpos++] = de_get_hexchar((int)(inbytes[inpos]%16));
	}

done:
	outbuf[outpos] = '\0';
	return outbuf;
}

// 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, -0x30(%rbp)
cmpq $0x1, -0x10(%rbp)
jge 0x15b5ec
jmp 0x15b6cd
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jle 0x15b620
movq -0x20(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x15b6cb
cmpq $0x0, -0x28(%rbp)
jle 0x15b654
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x20, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %edi
callq 0x160080
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0x160080
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15b628
jmp 0x15b6cd
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_render_hexbytes_from_dbuf
char *de_render_hexbytes_from_dbuf(dbuf *inf, i64 pos, i64 ilen,
	char *outbuf, size_t outbuf_len)
{
	u8 *inbuf = 0;

	if(ilen>1024) ilen = 1024;
	inbuf = de_malloc(inf->c, ilen);

	dbuf_read(inf, inbuf, pos, ilen);
	(void)de_render_hexbytes_from_mem(inbuf, ilen, outbuf, outbuf_len);
	de_free(inf->c, inbuf);
	return outbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x400, -0x18(%rbp)     # imm = 0x400
jle 0x15b726
movq $0x400, -0x18(%rbp)     # imm = 0x400
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b780
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x164d10
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x15b5c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x15b820
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_malloc
void *de_malloc(deark *c, i64 n)
{
	void *m;

	if(n==0) n=1;
	if(n<0 || n>DE_MAX_MALLOC) {
		de_err(c,"Out of memory (%"I64_FMT" bytes requested)", n);
		de_fatalerror(c);
		// NOTREACHED
		n = 1;
	}

	while(1) {
		m = calloc((size_t)n, 1);
		if(m) return m;

		de_err(c, "Memory allocation failed (%"I64_FMT" bytes)", n);
		de_fatalerror(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15b79f
movq $0x1, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x15b7b0
cmpq $0x1dcd6500, -0x10(%rbp) # imm = 0x1DCD6500
jle 0x15b7d7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x766f7(%rip), %rsi     # 0x1d1eb6
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rdi
callq 0x15c250
movq $0x1, -0x10(%rbp)
jmp 0x15b7d9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x19190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15b7fc
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x766cf(%rip), %rsi     # 0x1d1eda
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rdi
callq 0x15c250
jmp 0x15b7d9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbg_hexdump
void de_dbg_hexdump(deark *c, dbuf *f, i64 pos1,
	i64 nbytes_avail, i64 max_nbytes_to_dump,
	const char *prefix1, unsigned int flags)
{
	struct hexdump_ctx hctx;

	hctx.flags = flags;
	hctx.prefix = (prefix1) ? prefix1 : "data";
	hctx.printlinefn = hexdump_printline_dbg;

	de_hexdump_internal(c, &hctx, f, pos1, nbytes_avail, max_nbytes_to_dump);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x148(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x15b883
movq -0x30(%rbp), %rax
movq %rax, -0x160(%rbp)
jmp 0x15b893
leaq 0x6a2ef(%rip), %rax     # 0x1c5b79
movq %rax, -0x160(%rbp)
jmp 0x15b893
movq -0x160(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq 0x38(%rip), %rax        # 0x15b8e0
movq %rax, -0x140(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x158(%rbp), %rsi
callq 0x15b910
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_hexdump2
void de_hexdump2(deark *c, dbuf *f, i64 pos1, i64 nbytes_avail,
	i64 max_nbytes_to_dump, unsigned int flags)
{
	struct hexdump_ctx hctx;

	hctx.flags = flags | 0x2;
	hctx.prefix = NULL;
	hctx.printlinefn = hexdump_printline_ext;
	de_hexdump_internal(c, &hctx, f, pos1, nbytes_avail, max_nbytes_to_dump);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x148(%rbp)
movq $0x0, -0x158(%rbp)
leaq 0x3f(%rip), %rax        # 0x15bb60
movq %rax, -0x140(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x158(%rbp), %rsi
callq 0x15b910
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_warn
void de_warn(deark *c, const char *fmt, ...)
{
	va_list ap;

	if(!c->show_warnings) return;
	va_start(ap, fmt);
	de_vwarn(c, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x15bc48
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
jne 0x15bc7b
jmp 0x15bcb4
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15c050
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_colorsample_code
char *de_get_colorsample_code(deark *c, de_color clr, char *csamp,
	size_t csamplen)
{
	unsigned int r, g, b;

	if(csamplen<8) {
		csamp[0]='\0';
		return csamp;
	}

	r = (unsigned int)DE_COLOR_R(clr);
	g = (unsigned int)DE_COLOR_G(clr);
	b = (unsigned int)DE_COLOR_B(clr);

	// Only the low 4 bits are significant. We add 16 so that the bits can't
	// all be 0; since we can't have NUL bytes in this NUL-terminated string.
	// Also, it's nice if the values are all <= 127, to make them UTF-8
	// compatible.
	csamp[0] = '\x03'; // refer to DE_CODEPOINT_RGBSAMPLE
	csamp[1] = 16 + (r>>4)%16;
	csamp[2] = 16 + r%16;
	csamp[3] = 16 + (g>>4)%16;
	csamp[4] = 16 + g%16;
	csamp[5] = 16 + (b>>4)%16;
	csamp[6] = 16 + b%16;
	csamp[7] = '\0';
	return csamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x15bcee
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15bdaa
movl -0x14(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movb $0x3, (%rax)
movl -0x2c(%rbp), %eax
shrl $0x4, %eax
andl $0xf, %eax
addl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x2c(%rbp), %eax
andl $0xf, %eax
addl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x30(%rbp), %eax
shrl $0x4, %eax
andl $0xf, %eax
addl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x30(%rbp), %eax
andl $0xf, %eax
addl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0x34(%rbp), %eax
shrl $0x4, %eax
andl $0xf, %eax
addl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x5(%rax)
movl -0x34(%rbp), %eax
andl $0xf, %eax
addl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x7(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbg_pal_entry2
void de_dbg_pal_entry2(deark *c, i64 idx, de_color clr,
	const char *txt_before, const char *txt_in, const char *txt_after)
{
	int r,g,b,a;
	char astr[32];
	char csamp[16];

	if(c->debug_level<2) return;
	if(!txt_before) txt_before="";
	if(!txt_in) txt_in="";
	if(!txt_after) txt_after="";
	r = (int)DE_COLOR_R(clr);
	g = (int)DE_COLOR_G(clr);
	b = (int)DE_COLOR_B(clr);
	a = (int)DE_COLOR_A(clr);
	if(a!=0xff) {
		de_snprintf(astr, sizeof(astr), ",A=%d", a);
	}
	else {
		astr[0] = '\0';
	}

	de_get_colorsample_code(c, clr, csamp, sizeof(csamp));
	de_dbg2(c, "pal[%3d] = %s(%3d,%3d,%3d%s%s)%s%s", (int)idx, txt_before,
		r, g, b, astr, txt_in, csamp, txt_after);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jge 0x15bde3
jmp 0x15bee8
cmpq $0x0, -0x30(%rbp)
jne 0x15bdf5
leaq 0x74ddf(%rip), %rax     # 0x1d0bd0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x15be07
leaq 0x74dcd(%rip), %rax     # 0x1d0bd0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x15be19
leaq 0x74dbb(%rip), %rax     # 0x1d0bd0
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x48(%rbp)
movl -0x24(%rbp), %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
movl -0x24(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movzbl %al, %eax
movl %eax, -0x50(%rbp)
cmpl $0xff, -0x50(%rbp)
je 0x15be7f
leaq -0x70(%rbp), %rdi
movl -0x50(%rbp), %ecx
movl $0x20, %esi
leaq 0x75fd9(%rip), %rdx     # 0x1d1e4f
movb $0x0, %al
callq 0x15a980
jmp 0x15be83
movb $0x0, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x80(%rbp), %rdx
movl $0x10, %ecx
callq 0x15bcc0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
movq -0x30(%rbp), %rcx
movl -0x44(%rbp), %r8d
movl -0x48(%rbp), %r9d
movl -0x4c(%rbp), %r14d
leaq -0x70(%rbp), %rbx
movq -0x38(%rbp), %r11
leaq -0x80(%rbp), %r10
movq -0x40(%rbp), %rax
leaq 0x75f8c(%rip), %rsi     # 0x1d1e55
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x15b350
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_verr
void de_verr(deark *c, const char *fmt, va_list ap)
{
	if(c) {
		c->error_count++;
	}

	de_puts(c, DE_MSGTYPE_ERROR, "Error: ");
	de_vprintf(c, DE_MSGTYPE_ERROR, fmt, ap);
	de_puts(c, DE_MSGTYPE_ERROR, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15bf68
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x75f00(%rip), %rdx     # 0x1d1e78
callq 0x15ac20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x2, %esi
callq 0x15b080
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x401e0(%rip), %rdx     # 0x19c183
callq 0x15ac20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_vwarn
void de_vwarn(deark *c, const char *fmt, va_list ap)
{
	if(!c->show_warnings) return;
	de_puts(c, DE_MSGTYPE_WARNING, "Warning: ");
	de_vprintf(c, DE_MSGTYPE_WARNING, fmt, ap);
	de_puts(c, DE_MSGTYPE_WARNING, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
jne 0x15c073
jmp 0x15c0b3
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x75dfd(%rip), %rdx     # 0x1d1e80
callq 0x15ac20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x15b080
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x400d5(%rip), %rdx     # 0x19c183
callq 0x15ac20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_info
void de_info(deark *c, const char *fmt, ...)
{
	va_list ap;

	if(!c->show_infomessages) return;
	va_start(ap, fmt);
	de_vprintf(c, DE_MSGTYPE_MESSAGE, fmt, ap);
	va_end(ap);
	de_puts(c, DE_MSGTYPE_MESSAGE, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x15c0f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
jne 0x15c12b
jmp 0x15c178
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %esi, %esi
callq 0x15b080
leaq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0x40010(%rip), %rdx     # 0x19c183
callq 0x15ac20
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_internal_err_fatal
void de_internal_err_fatal(deark *c, const char *fmt, ...)
{
	va_list ap;

	de_puts(c, DE_MSGTYPE_ERROR, "Internal error: ");
	va_start(ap, fmt);
	de_vprintf(c, DE_MSGTYPE_ERROR, fmt, ap);
	va_end(ap);
	de_puts(c, DE_MSGTYPE_ERROR, "\n");
	de_fatalerror(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x15c2d8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x75b83(%rip), %rdx     # 0x1d1e8a
movl $0x2, %esi
movl %esi, -0xe4(%rbp)
callq 0x15ac20
movl -0xe4(%rbp), %esi
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x15b080
movl -0xe4(%rbp), %esi
movq -0x8(%rbp), %rdi
leaq 0x3fe23(%rip), %rdx     # 0x19c183
callq 0x15ac20
movq -0x8(%rbp), %rdi
callq 0x15c250
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_mallocarray
void *de_mallocarray(deark *c, i64 nmemb, size_t membsize)
{
	if(nmemb>DE_MAX_MALLOC || nmemb<0 || membsize>DE_MAX_MALLOC) {
		de_err(c, "Out of memory");
		de_fatalerror(c);
		// NOTREACHED
		return de_malloc(c, 1);
	}

	return de_malloc(c, nmemb*(i64)membsize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x1dcd6500, -0x18(%rbp) # imm = 0x1DCD6500
jg 0x15c47f
cmpq $0x0, -0x18(%rbp)
jl 0x15c47f
cmpq $0x1dcd6500, -0x20(%rbp) # imm = 0x1DCD6500
jbe 0x15c4ae
movq -0x10(%rbp), %rdi
leaq 0x75a1e(%rip), %rsi     # 0x1d1ea8
movb $0x0, %al
callq 0x15bfb0
movq -0x10(%rbp), %rdi
callq 0x15c250
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x15b780
movq %rax, -0x8(%rbp)
jmp 0x15c4c4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq -0x20(%rbp), %rsi
callq 0x15b780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_reallocarray
void *de_reallocarray(deark *c, void *m, i64 oldnmemb, size_t membsize,
	i64 newnmemb)
{
	if(newnmemb>DE_MAX_MALLOC || newnmemb<0 || oldnmemb<0 || membsize>DE_MAX_MALLOC) {
		de_err(c, "Out of memory");
		de_fatalerror(c);
		// NOTREACHED
		return de_malloc(c, 1);
	}

	return de_realloc(c, m,
		oldnmemb*(i64)membsize,
		newnmemb*(i64)membsize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x1dcd6500, -0x30(%rbp) # imm = 0x1DCD6500
jg 0x15c50e
cmpq $0x0, -0x30(%rbp)
jl 0x15c50e
cmpq $0x0, -0x20(%rbp)
jl 0x15c50e
cmpq $0x1dcd6500, -0x28(%rbp) # imm = 0x1DCD6500
jbe 0x15c53d
movq -0x10(%rbp), %rdi
leaq 0x7598f(%rip), %rsi     # 0x1d1ea8
movb $0x0, %al
callq 0x15bfb0
movq -0x10(%rbp), %rdi
callq 0x15c250
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x15b780
movq %rax, -0x8(%rbp)
jmp 0x15c560
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
imulq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
imulq -0x28(%rbp), %rcx
callq 0x15c570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_realloc
void *de_realloc(deark *c, void *oldmem, i64 oldsize, i64 newsize)
{
	void *newmem;

	if(!oldmem) {
		return de_malloc(c, newsize);
	}

	newmem = realloc(oldmem, (size_t)newsize);
	if(!newmem) {
		de_err(c, "Memory reallocation failed (%"I64_FMT" bytes)", newsize);
		free(oldmem);
		de_fatalerror(c);
		// NOTREACHED
		return de_malloc(c, newsize);
	}

	if(oldsize<newsize) {
		// zero out any newly-allocated bytes
		de_zeromem(&((u8*)newmem)[oldsize], (size_t)(newsize-oldsize));
	}

	return newmem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15c5a2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b780
movq %rax, -0x8(%rbp)
jmp 0x15c61e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x19240
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x15c5f5
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x75936(%rip), %rsi     # 0x1d1eff
movb $0x0, %al
callq 0x15bfb0
movq -0x18(%rbp), %rdi
callq 0x19030
movq -0x10(%rbp), %rdi
callq 0x15c250
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b780
movq %rax, -0x8(%rbp)
jmp 0x15c61e
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x15c616
movq -0x30(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
subq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x19140
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_strdup
char *de_strdup(deark *c, const char *s)
{
	size_t len0;
	char *s2;

	len0 = de_strlen(s) + 1;
	s2 = de_malloc(c, len0);
	de_memcpy(s2, s, len0);
	return s2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x190e0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x191e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_module_idx_by_id
int de_get_module_idx_by_id(deark *c, const char *module_id)
{
	int i;
	int k;

	if(!module_id) return -1;

	for(i=0; i<c->num_modules; i++) {
		if(!de_strcmp(c->module_info[i].id, module_id)) {
			return i;
		}
		for(k=0; k<DE_MAX_MODULE_ALIASES; k++) {
			if(!c->module_info[i].id_alias[k]) break;
			if(!de_strcmp(c->module_info[i].id_alias[k], module_id)) {
				return i;
			}
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15c6a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15c779
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1a8(%rcx), %eax
jge 0x15c772
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x191a0
cmpl $0x0, %eax
jne 0x15c6ef
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15c779
movl $0x0, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x15c762
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, 0x38(%rax,%rcx,8)
jne 0x15c720
jmp 0x15c762
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movq 0x38(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x191a0
cmpl $0x0, %eax
jne 0x15c755
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15c779
jmp 0x15c757
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15c6f6
jmp 0x15c764
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15c6aa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_run_module_by_id
int de_run_module_by_id(deark *c, const char *id, de_module_params *mparams)
{
	struct deark_module_info *module_to_use;

	module_to_use = de_get_module_by_id(c, id);
	if(!module_to_use) {
		de_err(c, "Unknown or unsupported format \"%s\"", id);
		return 0;
	}

	return de_run_module(c, module_to_use, mparams, DE_MODDISP_INTERNAL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15c790
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x15c9cb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x755d1(%rip), %rsi     # 0x1d1f8c
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x4(%rbp)
jmp 0x15c9e4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x3, %ecx
callq 0x15c7f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_run_module_by_id_on_slice
int de_run_module_by_id_on_slice(deark *c, const char *id, de_module_params *mparams,
	dbuf *f, i64 pos, i64 len)
{
	dbuf *old_ifile;
	int ret;

	old_ifile = c->infile;

	if(pos==0 && len==f->len) {
		// Optimization: We don't need a subfile in this case
		c->infile = f;
		ret = de_run_module_by_id(c, id, mparams);
	}
	else {
		c->infile = dbuf_open_input_subfile(f, pos, len);
		ret = de_run_module_by_id(c, id, mparams);
		dbuf_close(c->infile);
	}

	c->infile = old_ifile;
	return ret;
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x15ca53
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x15ca53
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15c980
movl %eax, -0x3c(%rbp)
jmp 0x15ca90
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1691b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15c980
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1676a0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_run_module_by_id_on_slice2
int de_run_module_by_id_on_slice2(deark *c, const char *id, const char *codes,
	dbuf *f, i64 pos, i64 len)
{
	de_module_params *mparams = NULL;
	int ret;

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.codes = codes;
	ret = de_run_module_by_id_on_slice(c, id, mparams, f, pos, len);
	de_free(c, mparams);
	return ret;
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x15c9f0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x15b820
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_ext_option
const char *de_get_ext_option(deark *c, const char *name)
{
	int i;

	for(i=0; i<c->num_ext_options; i++) {
		if(!de_strcmp(c->ext_option[i].name, name)) {
			return c->ext_option[i].val;
		}
	}
	return NULL; // Option name not found.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1b8(%rcx), %eax
jge 0x15cba8
movq -0x10(%rbp), %rax
addq $0x1c0, %rax            # imm = 0x1C0
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x191a0
cmpl $0x0, %eax
jne 0x15cb9b
movq -0x10(%rbp), %rax
addq $0x1c0, %rax            # imm = 0x1C0
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15cbb0
jmp 0x15cb9d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15cb47
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_ext_option_bool
int de_get_ext_option_bool(deark *c, const char *name, int defaultval)
{
	const char *val;

	val = de_get_ext_option(c, name);
	if(!val) return defaultval;
	if(val[0]=='\0' || val[0]=='1' || val[0]=='y' || val[0]=='Y' ||
		val[0]=='t' || val[0]=='T')
	{
		return 1;
	}
	if(val[0]=='0' || val[0]=='n' || val[0]=='N' || val[0]=='f' ||
		val[0]=='F')
	{
		return 0;
	}
	return defaultval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15cb30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x15cbf6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15cc92
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x15cc3e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
je 0x15cc3e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x79, %eax
je 0x15cc3e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x59, %eax
je 0x15cc3e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
je 0x15cc3e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
jne 0x15cc47
movl $0x1, -0x4(%rbp)
jmp 0x15cc92
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x15cc83
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
je 0x15cc83
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
je 0x15cc83
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
je 0x15cc83
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
jne 0x15cc8c
movl $0x0, -0x4(%rbp)
jmp 0x15cc92
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_constrain_int
int de_constrain_int(i64 *pn, i64 lv, i64 hv)
{
	if(*pn < lv) {
		*pn = lv;
		return 0;
	}
	if(*pn > hv) {
		*pn = hv;
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jge 0x15cdc1
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x15cde9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jle 0x15cde2
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x15cde9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_pad_to_n
i64 de_pad_to_n(i64 x, i64 n)
{
	i64 r;
	if(n<2)
		return x;
	r = x%n;
	if(r==0)
		return x;
	return x - r + n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jge 0x15cead
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15cedc
movq -0x10(%rbp), %rax
cqto
idivq -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15cecc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15cedc
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_log2_rounded_up
i64 de_log2_rounded_up(i64 n)
{
	i64 i;

	if(n<=2) return 1;
	for(i=2; i<32; i++) {
		if(n <= (((i64)1)<<i)) return i;
	}
	return 32;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
jg 0x15cf09
movq $0x1, -0x8(%rbp)
jmp 0x15cf52
movq $0x2, -0x18(%rbp)
cmpq $0x20, -0x18(%rbp)
jge 0x15cf4a
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jg 0x15cf3a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15cf52
jmp 0x15cf3c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x15cf11
movq $0x20, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_print_base2_fixed
char *de_print_base2_fixed(char *buf, size_t buf_len, u64 n, UI bitcount)
{
	UI x;
	size_t bpos = 0;

	if(buf_len<(size_t)bitcount+1) {
		goto done;
	}

	for(x=0; x<bitcount; x++) {
		buf[bpos++] = (n & (1ULL<<(bitcount-1-x))) ? '1' : '0';
	}
done:
	buf[bpos] = '\0';
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x15cf8d
jmp 0x15cfee
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x15cfec
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
subl $0x1, %eax
subl -0x20(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
andq %rax, %rdx
movl $0x30, %eax
movl $0x31, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15cf94
jmp 0x15cfee
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_sz_ext
const char *de_get_sz_ext(const char *sz)
{
	int len;
	int pos;

	if(!sz) return g_empty_string;

	len = (int)de_strlen(sz);
	if(len<2) return g_empty_string;

	// Find the position of the last ".", that's after the last "/"
	pos = len-2;

	while(pos>=0) {
		if(sz[pos]=='.') {
			return &sz[pos+1];
		}
		if(sz[pos]=='/' || sz[pos]=='\\')
			break;
		pos--;
	}
	return g_empty_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15d023
leaq 0x74d7e(%rip), %rax     # 0x1d1d98
movq %rax, -0x8(%rbp)
jmp 0x15d0b2
movq -0x10(%rbp), %rdi
callq 0x190e0
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x15d042
leaq 0x74d5c(%rip), %rax     # 0x1d1d98
movq %rax, -0x8(%rbp)
jmp 0x15d0b2
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x15d0a7
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x15d078
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x15d0b2
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x15d09a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x15d09c
jmp 0x15d0a7
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15d04b
leaq 0x74cea(%rip), %rax     # 0x1d1d98
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_input_file_ext
const char *de_get_input_file_ext(deark *c)
{
	if(c->suppress_detection_by_filename) return g_empty_string;

	if(!c->input_filename) return g_empty_string;

	// If we skipped over the first part of the file, assume we're reading
	// an embedded format that's not indicated by the file extension.
	if(c->slice_start_req) return g_empty_string;

	return de_get_sz_ext(c->input_filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7a(%rax)
je 0x15d0e3
leaq 0x74cbb(%rip), %rax     # 0x1d1d98
movq %rax, -0x8(%rbp)
jmp 0x15d124
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x15d0fb
leaq 0x74ca3(%rip), %rax     # 0x1d1d98
movq %rax, -0x8(%rbp)
jmp 0x15d124
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x15d113
leaq 0x74c8b(%rip), %rax     # 0x1d1d98
movq %rax, -0x8(%rbp)
jmp 0x15d124
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x15d000
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop