LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: ucstring_getpsz_internal
static const char *ucstring_getpsz_internal(de_ucstring *s,
	int has_max, i64 max_bytes)
{
	i64 allocsize;

	if(!s) {
		if(has_max && max_bytes<6) return "";
		return "(null)";
	}

	if(has_max) {
		allocsize = max_bytes + 1;
	}
	else {
		// TODO: Calculating the proper allocsize could be difficult,
		// depending on how DE_CONVFLAG_MAKE_PRINTABLE is implemented.
		allocsize = s->len * 4 + 1 + 100;
	}

	if(s->tmp_string)
		de_free(s->c, s->tmp_string);
	s->tmp_string = de_malloc(s->c, allocsize);

	ucstring_to_sz(s, s->tmp_string, (size_t)allocsize, DE_CONVFLAG_MAKE_PRINTABLE, DE_ENCODING_UTF8);

	return s->tmp_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x172577
cmpl $0x0, -0x14(%rbp)
je 0x172567
cmpq $0x6, -0x20(%rbp)
jge 0x172567
leaq 0x5e672(%rip), %rax     # 0x1d0bd0
movq %rax, -0x8(%rbp)
jmp 0x172607
leaq 0x6353c(%rip), %rax     # 0x1d5aaa
movq %rax, -0x8(%rbp)
jmp 0x172607
cmpl $0x0, -0x14(%rbp)
je 0x17258b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1725a3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
addq $0x1, %rax
addq $0x64, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1725c2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x15b820
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
movl $0x2, %r8d
movl %r8d, %ecx
callq 0x172200
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: de_strarray_create
struct de_strarray *de_strarray_create(deark *c, size_t max_elems)
{
	struct de_strarray *sa;
	sa = de_malloc(c, sizeof(struct de_strarray));
	sa->c = c;
	sa->max_elems = max_elems;
	return sa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: de_strarray_destroy
void de_strarray_destroy(struct de_strarray *sa)
{
	deark *c;

	if(!sa) return;
	c = sa->c;
	while(sa->count>0) {
		de_strarray_pop(sa);
	}
	de_free(c, sa->ss);
	de_free(c, sa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x172805
jmp 0x172844
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x172826
movq -0x8(%rbp), %rdi
callq 0x172850
jmp 0x172810
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x15b820
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: de_strarray_pop
int de_strarray_pop(struct de_strarray *sa)
{
	if(sa->count<1) return 0;
	ucstring_destroy(sa->ss[sa->count-1]);
	sa->ss[sa->count-1] = NULL;
	sa->count--;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jae 0x172870
movl $0x0, -0x4(%rbp)
jmp 0x1728c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: de_strarray_push
int de_strarray_push(struct de_strarray *sa, de_ucstring *s)
{
	deark *c = sa->c;
	size_t newidx = sa->count;

	if(sa->count >= sa->max_elems) return 0;
	if(newidx >= sa->num_alloc) {
		size_t old_num_alloc = sa->num_alloc;
		sa->num_alloc *= 2;
		if(sa->num_alloc<8) sa->num_alloc=8;
		sa->ss = de_reallocarray(c, sa->ss, old_num_alloc, sizeof(de_ucstring*),
			sa->num_alloc);
	}
	sa->ss[newidx] = ucstring_clone(s);
	sa->count++;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x172915
movl $0x0, -0x4(%rbp)
jmp 0x1729b5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x172982
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
shlq %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x8, 0x18(%rax)
jae 0x172955
movq -0x10(%rbp), %rax
movq $0x8, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
movl $0x8, %ecx
callq 0x15c4d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x171700
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: de_strarray_make_path
void de_strarray_make_path(struct de_strarray *sa, de_ucstring *path, unsigned int flags)
{
	size_t i;

	for(i=0; i<sa->count; i++) {
		i64 oldlen = path->len;

		if(ucstring_isnonempty(sa->ss[i])) {
			ucstring_append_ucstring(path, sa->ss[i]);
		}
		else {
			ucstring_append_char(path, '_');
		}

		mp_squash_slashes(path, oldlen);
		if((i+1 < sa->count) || !(flags & DE_MPFLAG_NOTRAILINGSLASH)) {
			ucstring_append_char(path, '/');
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x172a87
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1717f0
cmpl $0x0, %eax
je 0x172a2e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x171460
jmp 0x172a3c
movq -0x10(%rbp), %rdi
movl $0x5f, %esi
callq 0x1714c0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172a90
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x172a66
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x172a74
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x1714c0
jmp 0x172a76
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1729db
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: mp_squash_slashes
static void mp_squash_slashes(de_ucstring *s, i64 pos1)
{
	i64 i;

	for(i=pos1; i<s->len; i++) {
		if(s->str[i]=='/') {
			s->str[i] = '_';
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x172ae7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpl $0x2f, (%rax,%rcx,4)
jne 0x172ad7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl $0x5f, (%rax,%rcx,4)
jmp 0x172ad9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x172aa4
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-ucstring.c
// Function: decode_utf8_sequence
static de_rune decode_utf8_sequence(const u8 *b, UI seqlen)
{
	UI ch;

	if(seqlen==2) { // 2-byte
		ch = b[0] & 0x1f;
		ch = (ch<<6) | (b[1] & 0x3f);
		if(ch<0x80) ch = 0xfffd;
	}
	else if(seqlen==3) { // 3-byte
		ch = b[0] & 0x0f;
		ch = (ch<<6) | (b[1] & 0x3f);
		ch = (ch<<6) | (b[2] & 0x3f);
		if(ch<0x800) ch = 0xfffd;
	}
	else if(seqlen==4) {
		ch = b[0] & 0x07;
		ch = (ch<<6) | (b[1] & 0x3f);
		ch = (ch<<6) | (b[2] & 0x3f);
		ch = (ch<<6) | (b[3] & 0x3f);
		if(ch<0x10000 || ch>0x10ffff) ch = 0xfffd;
	}
	else {
		ch = b[0] & 0x7f;
	}
	return (de_rune)ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x172b39
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x1f, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x80, -0x10(%rbp)
jae 0x172b34
movl $0xfffd, -0x10(%rbp)    # imm = 0xFFFD
jmp 0x172c0b
cmpl $0x3, -0xc(%rbp)
jne 0x172b8a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x800, -0x10(%rbp)     # imm = 0x800
jae 0x172b88
movl $0xfffd, -0x10(%rbp)    # imm = 0xFFFD
jmp 0x172c09
cmpl $0x4, -0xc(%rbp)
jne 0x172bfa
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jb 0x172bf1
cmpl $0x10ffff, -0x10(%rbp)  # imm = 0x10FFFF
jbe 0x172bf8
movl $0xfffd, -0x10(%rbp)    # imm = 0xFFFD
jmp 0x172c07
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
jmp 0x172c09
jmp 0x172c0b
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_get_bmp_compression_name
void fmtutil_get_bmp_compression_name(u32 code, char *s, size_t s_len,
	int is_os2v2)
{
	const char *name1 = "?";
	switch(code) {
	case 0: name1 = "BI_RGB, uncompressed"; break;
	case 1: name1 = "BI_RLE8"; break;
	case 2: name1 = "BI_RLE4"; break;
	case 3:
		if(is_os2v2)
			name1 = "Huffman 1D";
		else
			name1 = "BI_BITFIELDS, uncompressed";
		break;
	case 4:
		if(is_os2v2)
			name1 = "RLE24";
		else
			name1 = "BI_JPEG";
		break;
	case 5: name1 = "BI_PNG"; break;
	}
	de_strlcpy(s, name1, s_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x44f70(%rip), %rax     # 0x1b7c2d
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x172d58
movq -0x30(%rbp), %rax
leaq 0x62e43(%rip), %rcx     # 0x1d5b20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x63143(%rip), %rax     # 0x1d5e30
movq %rax, -0x28(%rbp)
jmp 0x172d58
leaq 0x6314b(%rip), %rax     # 0x1d5e45
movq %rax, -0x28(%rbp)
jmp 0x172d58
leaq 0x63146(%rip), %rax     # 0x1d5e4d
movq %rax, -0x28(%rbp)
jmp 0x172d58
cmpl $0x0, -0x1c(%rbp)
je 0x172d20
leaq 0x6313b(%rip), %rax     # 0x1d5e55
movq %rax, -0x28(%rbp)
jmp 0x172d2b
leaq 0x63139(%rip), %rax     # 0x1d5e60
movq %rax, -0x28(%rbp)
jmp 0x172d58
cmpl $0x0, -0x1c(%rbp)
je 0x172d40
leaq 0x3529a(%rip), %rax     # 0x1a7fd4
movq %rax, -0x28(%rbp)
jmp 0x172d4b
leaq 0x63134(%rip), %rax     # 0x1d5e7b
movq %rax, -0x28(%rbp)
jmp 0x172d58
leaq 0x6312f(%rip), %rax     # 0x1d5e83
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15aa30
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_generate_bmpfileheader
void fmtutil_generate_bmpfileheader(deark *c, dbuf *outf, const struct de_bmpinfo *bi,
	i64 file_size_override)
{
	i64 file_size_to_write;

	dbuf_write(outf, (const u8*)"BM", 2);

	if(file_size_override)
		file_size_to_write = file_size_override;
	else
		file_size_to_write = 14 + bi->total_size;
	dbuf_writeu32le(outf, file_size_to_write);

	dbuf_write_zeroes(outf, 4);
	dbuf_writeu32le(outf, 14 + bi->size_of_headers_and_pal);
}

// 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 -0x10(%rbp), %rdi
leaq 0x347e7(%rip), %rsi     # 0x1a7cea
movl $0x2, %edx
callq 0x166170
cmpq $0x0, -0x20(%rbp)
je 0x17351e
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x173531
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
addq $0xe, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x168c30
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x1685f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rsi
addq $0xe, %rsi
callq 0x168c30
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_handle_exif2
void fmtutil_handle_exif2(deark *c, i64 pos, i64 len,
	u32 *returned_flags, u32 *orientation, u32 *exifversion)
{
	int user_opt;
	de_module_params *mparams = NULL;

	if(returned_flags) {
		*returned_flags = 0;
	}

	user_opt = de_get_ext_option_bool(c, "extractexif", -1);
	if(user_opt==1 || (c->extract_level>=2 && user_opt!=0)) {
		// Writing raw Exif data isn't very useful, but do so if requested.
		dbuf_create_file_from_slice(c->infile, pos, len, "exif.tif", NULL, DE_CREATEFLAG_IS_AUX);

		// Caller will have to reprocess the Exif file to extract anything from it.
		return;
	}

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.codes = "E";

	de_run_module_by_id_on_slice(c, "tiff", mparams, c->infile, pos, len);
	if(returned_flags) {
		// FIXME: It's an unfortunate bug that returned_flags does not work if
		// extract_level>=2, but for now there's no reasonable way to fix it.
		// We have to process -- not extract -- the Exif chunk if we want to
		// know what's in it.
		*returned_flags = mparams->out_params.flags;
		if((mparams->out_params.flags & 0x20) && orientation) {
			*orientation = mparams->out_params.uint1;
		}

		if((mparams->out_params.flags & 0x40) && exifversion) {
			*exifversion = mparams->out_params.uint2;
		}
	}

	de_free(c, mparams);
}

// 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, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1735a9
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x62952(%rip), %rsi     # 0x1d5f06
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15cbc0
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
je 0x1735da
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jl 0x173606
cmpl $0x0, -0x34(%rbp)
je 0x173606
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x62921(%rip), %rcx     # 0x1d5f12
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %r9d
callq 0x166be0
jmp 0x1736b3
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
leaq 0x4196f(%rip), %rcx     # 0x1b4f92
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
leaq 0x628fb(%rip), %rsi     # 0x1d5f40
callq 0x15c9f0
cmpq $0x0, -0x20(%rbp)
je 0x1736a6
movq -0x40(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x173681
cmpq $0x0, -0x28(%rbp)
je 0x173681
movq -0x40(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1736a4
cmpq $0x0, -0x30(%rbp)
je 0x1736a4
movq -0x40(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1736a6
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x15b820
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_handle_iptc
void fmtutil_handle_iptc(deark *c, dbuf *f, i64 pos, i64 len,
	unsigned int flags)
{
	int should_decode;
	int should_extract;
	int user_opt;
	int extract_fmt = 1; // 0=raw, 1=TIFF-wrapped

	if(len<1) return;

	user_opt = de_get_ext_option_bool(c, "extractiptc", -1);

	if(user_opt==1 || (c->extract_level>=2 && user_opt!=0)) {
		should_decode = 0;
		should_extract = 1;
		if(flags&0x2) {
			// Avoid "extracting" in a way that would just recreate the exact same file.
			extract_fmt = 0;
		}
	}
	else {
		should_decode = 1;
		should_extract = 0;
	}

	if(should_decode) {
		de_run_module_by_id_on_slice(c, "iptc", NULL, f, pos, len);
	}

	if(should_extract && extract_fmt==0) {
		dbuf_create_file_from_slice(f, pos, len, "iptc", NULL, DE_CREATEFLAG_IS_AUX);
	}
	else if(should_extract && extract_fmt==1) {
		wrap_in_tiff(c, f, pos, len, "Deark extracted IPTC", 33723, "iptctiff",
			DE_CREATEFLAG_IS_AUX);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x1, -0x34(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x17372f
jmp 0x17382a
movq -0x8(%rbp), %rdi
leaq 0x627e1(%rip), %rsi     # 0x1d5f1b
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15cbc0
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
je 0x173760
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jl 0x173782
cmpl $0x0, -0x30(%rbp)
je 0x173782
movl $0x0, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x24(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x173780
movl $0x0, -0x34(%rbp)
jmp 0x173790
movl $0x1, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x1737b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x62775(%rip), %rsi     # 0x1d5f22
xorl %eax, %eax
movl %eax, %edx
callq 0x15c9f0
cmpl $0x0, -0x2c(%rbp)
je 0x1737e7
cmpl $0x0, -0x34(%rbp)
jne 0x1737e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x6274d(%rip), %rcx     # 0x1d5f22
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %r9d
callq 0x166be0
jmp 0x17382a
cmpl $0x0, -0x2c(%rbp)
je 0x173828
cmpl $0x1, -0x34(%rbp)
jne 0x173828
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x6271d(%rip), %r8      # 0x1d5f27
movl $0x83bb, %r9d           # imm = 0x83BB
leaq 0x62725(%rip), %rax     # 0x1d5f3c
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x173830
jmp 0x17382a
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_handle_plist
void fmtutil_handle_plist(deark *c, dbuf *f, i64 pos, i64 len,
	de_finfo *fi, unsigned int flags)
{
	if(de_get_ext_option_bool(c, "extractplist", 0)) {
		dbuf_create_file_from_slice(f, pos, len,
			fi?NULL:"plist", fi, DE_CREATEFLAG_IS_AUX);
		return;
	}

	de_run_module_by_id_on_slice(c, "plist", NULL, f, pos, len);
}

// 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)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x62328(%rip), %rsi     # 0x1d5f63
xorl %edx, %edx
callq 0x15cbc0
cmpl $0x0, %eax
je 0x173c79
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq 0x2ee7a(%rip), %rcx     # 0x1a2ad8
xorl %eax, %eax
cmpq $0x0, %r8
cmovneq %rax, %rcx
movq -0x28(%rbp), %r8
movl $0x1, %r9d
callq 0x166be0
jmp 0x173c99
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x2ee48(%rip), %rsi     # 0x1a2ad8
xorl %eax, %eax
movl %eax, %edx
callq 0x15c9f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_detect_SAUCE
int fmtutil_detect_SAUCE(deark *c, dbuf *f, struct de_SAUCE_detection_data *sdd,
	unsigned int flags)
{
	de_zeromem(sdd, sizeof(struct de_SAUCE_detection_data));
	if(f->len<128) return 0;
	if(dbuf_memcmp(f, f->len-128, "SAUCE00", 7)) return 0;
	if(flags & 0x1) {
		de_dbg(c, "SAUCE metadata, signature at %"I64_FMT, f->len-128);
	}
	sdd->has_SAUCE = 1;
	sdd->data_type = dbuf_getbyte(f, f->len-128+94);
	sdd->file_type = dbuf_getbyte(f, f->len-128+95);
	return (int)sdd->has_SAUCE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x19140
movq -0x18(%rbp), %rax
cmpq $0x80, 0x18(%rax)
jge 0x173ce1
movl $0x0, -0x4(%rbp)
jmp 0x173d9d
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
subq $0x80, %rsi
leaq 0x5abfa(%rip), %rdx     # 0x1ce8f5
movl $0x7, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x173d16
movl $0x0, -0x4(%rbp)
jmp 0x173d9d
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x173d42
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
subq $0x80, %rdx
leaq 0x62235(%rip), %rsi     # 0x1d5f70
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
subq $0x80, %rsi
addq $0x5e, %rsi
callq 0x165060
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
subq $0x80, %rsi
addq $0x5f, %rsi
callq 0x165060
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_free_SAUCE
void fmtutil_free_SAUCE(deark *c, struct de_SAUCE_info *si)
{
	if(!si) return;
	ucstring_destroy(si->title);
	ucstring_destroy(si->artist);
	ucstring_destroy(si->organization);
	ucstring_destroy(si->comment);
	de_free(c, si);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x173e59
jmp 0x173e9a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_guid_to_uuid
void fmtutil_guid_to_uuid(u8 *id)
{
	u8 tmp[16];
	de_memcpy(tmp, id, 16);
	id[0] = tmp[3]; id[1] = tmp[2]; id[2] = tmp[1]; id[3] = tmp[0];
	id[4] = tmp[5]; id[5] = tmp[4];
	id[6] = tmp[7]; id[7] = tmp[6];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movb -0x1d(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movb -0x1e(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x1f(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0x20(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movb -0x1b(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movb -0x1c(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movb -0x1a(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_read_boxes_format
void fmtutil_read_boxes_format(deark *c, struct de_boxesctx *bctx)
{
	struct boxes_parser_data *pctx = NULL;

	if(!bctx->f || !bctx->handle_box_fn) return; // Internal error
	if(bctx->curbox) return; // Internal error

	pctx = de_malloc(c, sizeof(struct boxes_parser_data));
	bctx->private_data = (void*)pctx;
	do_box_sequence(c, bctx, 0, bctx->f->len, -1, 0);
	bctx->private_data = NULL;
	de_free(c, pctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17432e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x174330
jmp 0x17439b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x17433d
jmp 0x17439b
movq -0x8(%rbp), %rdi
movl $0x82, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
movq $-0x1, %r8
xorl %r9d, %r9d
callq 0x1743b0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: do_box_sequence
static void do_box_sequence(deark *c, struct de_boxesctx *bctx,
	i64 pos1, i64 len, i64 max_nboxes, int level)
{
	i64 pos;
	i64 box_len;
	i64 endpos;
	int ret;
	i64 box_count = 0;

	if(level >= 32) { // An arbitrary recursion limit.
		return;
	}

	pos = pos1;
	endpos = pos1 + len;

	while(pos < endpos) {
		if(max_nboxes>=0 && box_count>=max_nboxes) break;
		ret = do_box(c, bctx, pos, endpos-pos, level, &box_len);
		if(!ret) break;
		box_count++;
		pos += box_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x58(%rbp)
cmpl $0x20, -0x2c(%rbp)
jl 0x1743e0
jmp 0x174457
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jge 0x174457
cmpq $0x0, -0x28(%rbp)
jl 0x174411
movq -0x58(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0x174411
jmp 0x174457
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rcx
subq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x40(%rbp), %r9
callq 0x176d90
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x17443d
jmp 0x174457
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1743f4
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_atari_decode_image
int fmtutil_atari_decode_image(deark *c, struct atari_img_decode_data *adata)
{
	switch(adata->bpp) {
	case 16:
		return decode_atari_image_16(c, adata);
	case 8: case 4: case 2: case 1:
		return decode_atari_image_paletted(c, adata);
	}

	de_err(c, "Unsupported bits/pixel (%d)", (int)adata->bpp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
decq %rax
subq $0x2, %rax
jb 0x17496c
jmp 0x174936
movq -0x20(%rbp), %rax
subq $0x4, %rax
je 0x17496c
jmp 0x174942
movq -0x20(%rbp), %rax
subq $0x8, %rax
je 0x17496c
jmp 0x17494e
movq -0x20(%rbp), %rax
subq $0x10, %rax
jne 0x17497e
jmp 0x17495a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1749b0
movl %eax, -0x4(%rbp)
jmp 0x1749a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x174a70
movl %eax, -0x4(%rbp)
jmp 0x1749a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0x570c2(%rip), %rsi     # 0x1cba54
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: decode_atari_image_16
static int decode_atari_image_16(deark *c, struct atari_img_decode_data *adata)
{
	i64 i, j;
	i64 rowspan;
	u32 v;

	rowspan = adata->w * 2;

	for(j=0; j<adata->h; j++) {
		for(i=0; i<adata->w; i++) {
			v = (u32)dbuf_getu16be(adata->unc_pixels, j*rowspan + 2*i);
			v = de_rgb565_to_888(v);
			de_bitmap_setpixel_rgb(adata->img, i, j,v);
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x174a62
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x174a4f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
imulq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
shlq %rax
addq %rax, %rsi
callq 0x1651d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x1618a0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x16b310
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1749ed
jmp 0x174a51
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1749d7
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_atari_set_standard_density
void fmtutil_atari_set_standard_density(deark *c, struct atari_img_decode_data *adata,
	de_finfo *fi)
{
	switch(adata->bpp) {
	case 4:
		fi->density.code = DE_DENSITY_UNK_UNITS;
		fi->density.xdens = 240.0;
		fi->density.ydens = 200.0;
		break;
	case 2:
		fi->density.code = DE_DENSITY_UNK_UNITS;
		fi->density.xdens = 480.0;
		fi->density.ydens = 200.0;
		break;
	case 1:
		fi->density.code = DE_DENSITY_UNK_UNITS;
		fi->density.xdens = 480.0;
		fi->density.ydens = 400.0;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
subq $0x1, %rax
je 0x174e9d
jmp 0x174e17
movq -0x20(%rbp), %rax
subq $0x2, %rax
je 0x174e68
jmp 0x174e23
movq -0x20(%rbp), %rax
subq $0x4, %rax
jne 0x174ed0
jmp 0x174e33
movq -0x18(%rbp), %rax
movl $0x1, 0x78(%rax)
movq -0x18(%rbp), %rax
movsd 0x2a4ae(%rip), %xmm0    # 0x19f2f8
movsd %xmm0, 0x80(%rax)
movq -0x18(%rbp), %rax
movsd 0x2a4ba(%rip), %xmm0    # 0x19f318
movsd %xmm0, 0x88(%rax)
jmp 0x174ed0
movq -0x18(%rbp), %rax
movl $0x1, 0x78(%rax)
movq -0x18(%rbp), %rax
movsd 0x31459(%rip), %xmm0    # 0x1a62d8
movsd %xmm0, 0x80(%rax)
movq -0x18(%rbp), %rax
movsd 0x2a485(%rip), %xmm0    # 0x19f318
movsd %xmm0, 0x88(%rax)
jmp 0x174ed0
movq -0x18(%rbp), %rax
movl $0x1, 0x78(%rax)
movq -0x18(%rbp), %rax
movsd 0x31424(%rip), %xmm0    # 0x1a62d8
movsd %xmm0, 0x80(%rax)
movq -0x18(%rbp), %rax
movsd 0x4c600(%rip), %xmm0    # 0x1c14c8
movsd %xmm0, 0x88(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_get_windows_charset_name
const char *fmtutil_get_windows_charset_name(u8 cs)
{
	struct csname_struct { u8 id; const char *name; };
	static const struct csname_struct csname_arr[] = {
		{0x00, "ANSI"},
		{0x01, "default"},
		{0x02, "symbol"},
		{0x4d, "Mac"},
		{0x80, "Shift-JIS"},
		{0x81, "Hangul"},
		{0x82, "Johab"},
		{0x86, "GB2312"},
		{0x88, "BIG5"},
		{0xa1, "Greek"},
		{0xa2, "Turkish"},
		{0xa3, "Vietnamese"},
		{0xb1, "Hebrew"},
		{0xb2, "Arabic"},
		{0xba, "Baltic"},
		{0xcc, "Russian"},
		{0xde, "Thai"},
		{0xee, "Eastern Europe"},
		{0xff, "OEM"}
	};
	size_t i;

	for(i=0; i<DE_ARRAYCOUNT(csname_arr); i++) {
		if(cs==csname_arr[i].id) return csname_arr[i].name;
	}
	return "?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x13, -0x18(%rbp)
jae 0x174fb2
movzbl -0x9(%rbp), %eax
movq -0x18(%rbp), %rdx
leaq 0xafc88(%rip), %rcx     # 0x224c00
shlq $0x4, %rdx
addq %rdx, %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x174fa2
movq -0x18(%rbp), %rcx
leaq 0xafc6f(%rip), %rax     # 0x224c00
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x174fbd
jmp 0x174fa4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x174f62
leaq 0x42c74(%rip), %rax     # 0x1b7c2d
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/fmtutil.c
// Function: fmtutil_get_windows_cb_data_type_name
const char *fmtutil_get_windows_cb_data_type_name(unsigned int ty)
{
	const char *name = "?";

	switch(ty) {
	case 1: name="CF_TEXT"; break;
	case 2: name="CF_BITMAP"; break;
	case 3: name="CF_METAFILEPICT"; break;
	case 6: name="CF_TIFF"; break;
	case 7: name="CF_OEMTEXT"; break;
	case 8: name="CF_DIB"; break;
	case 11: name="CF_RIFF"; break;
	case 12: name="CF_WAVE"; break;
	case 13: name="CF_UNICODETEXT"; break;
	case 14: name="CF_ENHMETAFILE"; break;
	case 17: name="CF_DIBV5"; break;
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x42c4f(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x10, %eax
ja 0x17509a
movq -0x18(%rbp), %rax
leaq 0x60b37(%rip), %rcx     # 0x1d5b38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x611b8(%rip), %rax     # 0x1d61c9
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x611b0(%rip), %rax     # 0x1d61d1
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x611ad(%rip), %rax     # 0x1d61db
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x611b0(%rip), %rax     # 0x1d61eb
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x611ab(%rip), %rax     # 0x1d61f3
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x611a9(%rip), %rax     # 0x1d61fe
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x611a3(%rip), %rax     # 0x1d6205
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x6119e(%rip), %rax     # 0x1d620d
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x61199(%rip), %rax     # 0x1d6215
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x6119b(%rip), %rax     # 0x1d6224
movq %rax, -0x10(%rbp)
jmp 0x17509a
leaq 0x6119d(%rip), %rax     # 0x1d6233
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: is_sane_zip_eocd
static int is_sane_zip_eocd(dbuf *f, i64 pos)
{
	i64 this_disk_num;
	i64 disk_num_with_central_dir_start;
	i64 central_dir_num_entries;
	i64 central_dir_byte_size;
	i64 central_dir_offset;

	// Validating Zip64 would take more work.
	if(dbuf_getu32be(f, pos-20) == CODE_PK67) return 1;

	this_disk_num = dbuf_getu16le(f, pos+4);
	disk_num_with_central_dir_start = dbuf_getu16le(f, pos+6);

	if(this_disk_num > 100) return 0;
	if(disk_num_with_central_dir_start > this_disk_num) return 0;
	if(disk_num_with_central_dir_start < this_disk_num-1) return 0;

	central_dir_num_entries = dbuf_getu16le(f, pos+10);
	central_dir_byte_size = dbuf_getu32le(f, pos+12);

	if(central_dir_byte_size < 46*central_dir_num_entries) return 0;

	if(this_disk_num==disk_num_with_central_dir_start) {
		if(central_dir_byte_size > f->len) return 0;
		central_dir_offset = dbuf_getu32le(f, pos+16);
		if(central_dir_offset > f->len) return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x14, %rsi
callq 0x165470
cmpq $0x504b0607, %rax       # imm = 0x504B0607
jne 0x1752c5
movl $0x1, -0x4(%rbp)
jmp 0x1753cc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
cmpq $0x64, -0x20(%rbp)
jle 0x175302
movl $0x0, -0x4(%rbp)
jmp 0x1753cc
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x175318
movl $0x0, -0x4(%rbp)
jmp 0x1753cc
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x175335
movl $0x0, -0x4(%rbp)
jmp 0x1753cc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xa, %rsi
callq 0x165280
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
callq 0x165540
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
imulq $0x2e, -0x30(%rbp), %rcx
cmpq %rcx, %rax
jge 0x175376
movl $0x0, -0x4(%rbp)
jmp 0x1753cc
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1753c5
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0x175397
movl $0x0, -0x4(%rbp)
jmp 0x1753cc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x165540
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0x1753c3
movl $0x0, -0x4(%rbp)
jmp 0x1753cc
jmp 0x1753c5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_riscos_read_load_exec
void fmtutil_riscos_read_load_exec(deark *c, dbuf *f, struct de_riscos_file_attrs *rfa, i64 pos1)
{
	i64 pos = pos1;

	rfa->load_addr = (u32)dbuf_getu32le_p(f, &pos);
	rfa->exec_addr = (u32)dbuf_getu32le_p(f, &pos);
	de_dbg(c, "load/exec addrs: 0x%08x, 0x%08x", (unsigned int)rfa->load_addr,
		(unsigned int)rfa->exec_addr);
	de_dbg_indent(c, 1);
	if((rfa->load_addr&0xfff00000U)==0xfff00000U) {
		rfa->file_type = (unsigned int)((rfa->load_addr&0xfff00)>>8);
		rfa->file_type_known = 1;
		de_dbg(c, "file type: %03X", rfa->file_type);

		de_riscos_loadexec_to_timestamp(rfa->load_addr, rfa->exec_addr, &rfa->mod_time);
		dbg_timestamp(c, &rfa->mod_time, "timestamp");
	}
	de_dbg_indent(c, -1);
}

// 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 -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x60c1e(%rip), %rsi     # 0x1d6263
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xfff00000, %eax       # imm = 0xFFF00000
cmpl $0xfff00000, %eax       # imm = 0xFFF00000
jne 0x1756d7
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xfff00, %ecx          # imm = 0xFFF00
shrl $0x8, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x60be6(%rip), %rsi     # 0x1d6283
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
addq $0x20, %rdx
callq 0x15dc20
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
leaq 0x5a344(%rip), %rdx     # 0x1cfa16
callq 0x1756f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_riscos_read_attribs_field
void fmtutil_riscos_read_attribs_field(deark *c, dbuf *f, struct de_riscos_file_attrs *rfa,
	i64 pos, unsigned int flags)
{
	rfa->attribs = (u32)dbuf_getu32le(f, pos);
	de_dbg(c, "attribs: 0x%08x", (unsigned int)rfa->attribs);
	de_dbg_indent(c, 1);
	rfa->crc_from_attribs = rfa->attribs>>16;
	if(flags & DE_RISCOS_FLAG_HAS_CRC) {
		de_dbg(c, "crc (reported): 0x%04x", (unsigned int)rfa->crc_from_attribs);
	}
	if(flags & DE_RISCOS_FLAG_HAS_LZWMAXBITS) {
		rfa->lzwmaxbits = (unsigned int)((rfa->attribs&0xff00)>>8);
		de_dbg(c, "lzw maxbits: %u", rfa->lzwmaxbits);
	}
	de_dbg_indent(c, -1);
}

// 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)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x165540
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x5b865(%rip), %rsi     # 0x1d0fe9
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
shrl $0x10, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1757ce
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x5b185(%rip), %rsi     # 0x1d094c
movb $0x0, %al
callq 0x15b0d0
movl -0x24(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x175809
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shrl $0x8, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x60a91(%rip), %rsi     # 0x1d6293
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_riscos_append_type_to_filename
void fmtutil_riscos_append_type_to_filename(deark *c, de_finfo *fi, de_ucstring *fn,
	struct de_riscos_file_attrs *rfa, int is_dir, int enabled_by_default)
{
	if(is_dir || !rfa->file_type_known) return;
	if(ucstring_isempty(fn)) return;

	// 0xff = Haven't looked for this opt
	// 0xfe = We looked, it's not there
	// 0 = Requested to be off
	// 1 = Requested to be on
	if(c->append_riscos_type==0xff) {
		c->append_riscos_type = (u8)de_get_ext_option_bool(c, "riscos:appendtype", 0xfe);
	}
	if(c->append_riscos_type==0) return;
	if(c->append_riscos_type==0xfe) {
		if(!enabled_by_default) return;
		if(!c->filenames_from_file) return;

		// By default, with ZIP output, we'll use extended fields instead of
		// mangling the filename.
		if(c->output_style==DE_OUTPUTSTYLE_ARCHIVE && c->archive_fmt==DE_ARCHIVEFMT_ZIP)
			return;
	}

	ucstring_printf(fn, DE_ENCODING_LATIN1, ",%03X", rfa->file_type);
	fi->riscos_appended_type = 1;
}

// 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)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x17584f
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x175854
jmp 0x175916
movq -0x18(%rbp), %rdi
callq 0x1717b0
cmpl $0x0, %eax
je 0x175867
jmp 0x175916
movq -0x8(%rbp), %rax
movzbl 0xd4(%rax), %eax
cmpl $0xff, %eax
jne 0x17589a
movq -0x8(%rbp), %rdi
leaq 0x60a1f(%rip), %rsi     # 0x1d62a3
movl $0xfe, %edx
callq 0x15cbc0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd4(%rax)
movq -0x8(%rbp), %rax
movzbl 0xd4(%rax), %eax
cmpl $0x0, %eax
jne 0x1758ac
jmp 0x175916
movq -0x8(%rbp), %rax
movzbl 0xd4(%rax), %eax
cmpl $0xfe, %eax
jne 0x1758f0
cmpl $0x0, -0x28(%rbp)
jne 0x1758c6
jmp 0x175916
movq -0x8(%rbp), %rax
cmpb $0x0, 0xd0(%rax)
jne 0x1758d5
jmp 0x175916
movq -0x8(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
jne 0x1758ee
movq -0x8(%rbp), %rax
cmpl $0x1, 0x80(%rax)
jne 0x1758ee
jmp 0x175916
jmp 0x1758f0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movl $0x5, %esi
leaq 0x609ae(%rip), %rdx     # 0x1d62b5
movb $0x0, %al
callq 0x171660
movq -0x10(%rbp), %rax
movb $0x1, 0x11(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_macbitmap_read_baseaddr
void fmtutil_macbitmap_read_baseaddr(deark *c, dbuf *f, struct fmtutil_macbitmap_info *bi, i64 pos)
{
	i64 n;
	de_dbg(c, "baseAddr part of PixMap, at %d", (int)pos);
	de_dbg_indent(c, 1);
	n = dbuf_getu32be(f, pos);
	de_dbg(c, "baseAddr: 0x%08x", (unsigned int)n);
	de_dbg_indent(c, -1);
}

// 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 -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x60972(%rip), %rsi     # 0x1d62bb
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x165470
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
leaq 0x6095a(%rip), %rsi     # 0x1d62da
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_macbitmap_read_rowbytes_and_bounds
void fmtutil_macbitmap_read_rowbytes_and_bounds(deark *c, dbuf *f,
	struct fmtutil_macbitmap_info *bi, i64 pos)
{
	struct pict_rect tmprect;
	i64 rowbytes_code;

	de_dbg(c, "rowBytes/bounds part of bitmap/PixMap header, at %d", (int)pos);
	de_dbg_indent(c, 1);
	rowbytes_code = dbuf_getu16be(f, pos);
	bi->rowbytes = rowbytes_code & 0x7fff;
	bi->pixmap_flag = (rowbytes_code & 0x8000)?1:0;
	de_dbg(c, "rowBytes: %d", (int)bi->rowbytes);
	de_dbg(c, "pixmap flag: %d", bi->pixmap_flag);

	pict_read_rect(f, pos+2, &tmprect, "rect");
	bi->npwidth = tmprect.r - tmprect.l;
	bi->pdwidth = bi->npwidth; // default
	bi->height = tmprect.b - tmprect.t;

	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x60922(%rip), %rsi     # 0x1d62eb
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1651d0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
andq $0x7fff, %rcx           # imm = 0x7FFF
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rdx
andq $0x8000, %rdx           # imm = 0x8000
xorl %ecx, %ecx
movl $0x1, %eax
cmpq $0x0, %rdx
cmovnel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0x4af2c(%rip), %rsi     # 0x1c0961
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %edx
leaq 0x608d1(%rip), %rsi     # 0x1d631f
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x2, %rsi
leaq -0x40(%rbp), %rdx
leaq 0x3ebe2(%rip), %rcx     # 0x1b464e
callq 0x175ac0
movq -0x28(%rbp), %rcx
subq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
subq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)