LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r15
xorl %eax, %eax
cmpq 0x8(%rdi), %r15
jae 0xeba4f
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
cmpq %rdx, %r15
jb 0xeba38
movq (%rbx), %rdi
leaq (%rdx,%rdx), %r8
cmpq $0x9, %r8
pushq $0x8
popq %rcx
cmovbq %rcx, %r8
movq %r8, 0x18(%rbx)
movq 0x20(%rbx), %rsi
callq 0xdf6b6
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0xeaf0b
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq 0x10(%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x5f
popq %rbp
cmpq 0x10(%r15), %r13
jae 0xebadc
movq 0x10(%r14), %r12
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %rsi
testq %rsi, %rsi
je 0xeba96
cmpq $0x0, 0x10(%rsi)
jle 0xeba96
movq %r14, %rdi
callq 0xead71
jmp 0xebaa0
movq %r14, %rdi
movl %ebp, %esi
callq 0xeada5
movq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0xebac1
movq 0x8(%r14), %rcx
cmpl $0x2f, (%rcx,%r12,4)
jne 0xebabc
movl $0x5f, (%rcx,%r12,4)
incq %r12
jmp 0xebaa4
incq %r13
testb $0x1, %bl
je 0xebacf
cmpq 0x10(%r15), %r13
jae 0xeba6e
movq %r14, %rdi
pushq $0x2f
popq %rsi
callq 0xeada5
jmp 0xeba6e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rax
cmpl $0x5, %edi
ja 0xebb96
movl %edi, %esi
leaq 0x50fff(%rip), %rdi     # 0x13cb40
movslq (%rdi,%rsi,4), %rsi
addq %rdi, %rsi
jmpq *%rsi
leaq 0x5135f(%rip), %rsi     # 0x13ceb0
jmp 0xebb9d
testl %ecx, %ecx
leaq 0x5139f(%rip), %rcx     # 0x13cefb
leaq 0x237a5(%rip), %rsi     # 0x10f308
jmp 0xebb7e
leaq 0x51361(%rip), %rsi     # 0x13cecd
jmp 0xebb9d
testl %ecx, %ecx
leaq 0x51369(%rip), %rcx     # 0x13cee0
leaq 0x51357(%rip), %rsi     # 0x13ced5
cmoveq %rcx, %rsi
jmp 0xebb9d
leaq 0x5133a(%rip), %rsi     # 0x13cec5
jmp 0xebb9d
leaq 0x5136f(%rip), %rsi     # 0x13cf03
jmp 0xebb9d
leaq 0x33344(%rip), %rsi     # 0x11eee1
movq %rax, %rdi
jmp 0xde492
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x22fb6(%rip), %rsi     # 0x10f01e
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0xe46ba
testq %r15, %r15
jne 0xec083
movq 0x90(%r14), %r15
addq $0xe, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe5f7f
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xe5d20
movq 0x88(%r14), %rsi
addq $0xe, %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe5f7f
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
testq %rcx, %rcx
je 0xec0d8
andl $0x0, (%r12)
leaq 0x50ea7(%rip), %rsi     # 0x13cf86
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0xdfae5
cmpl $0x1, %eax
je 0xec0fd
testl %eax, %eax
je 0xec128
cmpl $0x2, 0x90(%r14)
jl 0xec128
movq 0x18(%r14), %rdi
leaq 0x50e8a(%rip), %rcx     # 0x13cf92
pushq $0x1
popq %r9
movq %rbp, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe4e0b
movq %rbx, (%rsp)
pushq $0x70
popq %rsi
movq %r14, %rdi
callq 0xdecaf
movq %rax, %rbx
leaq 0x302e3(%rip), %rax     # 0x11c424
movq %rax, (%rbx)
movq 0x18(%r14), %rcx
leaq 0x50e71(%rip), %rsi     # 0x13cfc0
movq %r14, %rdi
movq %rbx, %rdx
movq %rbp, %r8
movq %r13, %r9
callq 0xdf9b8
testq %r12, %r12
je 0xec199
movl 0x40(%rbx), %eax
movl %eax, (%r12)
testb $0x20, %al
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
jne 0xec184
movl 0x44(%rbx), %eax
movl %eax, (%r15)
movl 0x40(%rbx), %eax
cmpq $0x0, (%rsp)
je 0xec199
andl $0x40, %eax
je 0xec199
movl 0x48(%rbx), %eax
movq (%rsp), %rcx
movl %eax, (%rcx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rcx, %rcx
jle 0xec231
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x50db5(%rip), %rsi     # 0x13cf9b
pushq $-0x1
popq %rdx
callq 0xdfae5
cmpl $0x1, %eax
je 0xec202
testl %eax, %eax
je 0xec266
cmpl $0x1, 0x90(%r12)
jle 0xec266
testb $0x2, %bpl
jne 0xec23e
leaq 0x50dad(%rip), %rax     # 0x13cfbc
movq %rax, (%rsp)
leaq 0x50d8d(%rip), %r8      # 0x13cfa7
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl $0x83bb, %r9d           # imm = 0x83BB
callq 0xec28c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50d5d(%rip), %rcx     # 0x13cfa2
pushq $0x1
popq %r9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe4e0b
leaq 0x50d35(%rip), %rsi     # 0x13cfa2
movq %r12, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xdf9b8
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_handle_photoshop_rsrc2
void fmtutil_handle_photoshop_rsrc2(deark *c, dbuf *f, i64 pos, i64 len,
	unsigned int flags, struct de_module_out_params *oparams)
{
	int should_decode;
	int should_extract;
	int extract_fmt = 1; // 0=raw, 1=TIFF-wrapped

	if(flags&0x1) {
		should_decode = 0;
		should_extract = 1;
	}
	else if(de_get_ext_option_bool(c, "extract8bim", 0)) {
		should_extract = 1;
		should_decode = 0;
		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_module_params *mparams = NULL;

		mparams = de_malloc(c, sizeof(de_module_params));
		mparams->in_params.codes = "R";
		if(oparams) {
			// Since mparams->out_params is an embedded struct, not a pointer,
			// we have to copy oparam's fields to and from it.
			mparams->out_params = *oparams; // struct copy
		}
		de_run_module_by_id_on_slice(c, "psd", mparams, f, pos, len);
		if(oparams) {
			*oparams = mparams->out_params; // struct copy
		}
		de_free(c, mparams);
	}

	if(should_extract && extract_fmt==0) {
		dbuf_create_file_from_slice(f, pos, len, "8bim", NULL, DE_CREATEFLAG_IS_AUX);
	}
	else if(should_extract && extract_fmt==1) {
		wrap_in_tiff(c, f, pos, len, "Deark extracted 8BIM", 34377, "8bimtiff",
			DE_CREATEFLAG_IS_AUX);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testb $0x1, %bpl
jne 0xec4f3
movq %r9, %r13
leaq 0x3977f(%rip), %rsi     # 0x125c5a
movq %rbx, %rdi
xorl %edx, %edx
callq 0xdfae5
testl %eax, %eax
je 0xec52b
testb $0x2, %bpl
jne 0xec59c
leaq 0x50ae0(%rip), %rax     # 0x13cfda
movq %rax, (%rsp)
leaq 0x50ac0(%rip), %r8      # 0x13cfc5
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl $0x8649, %r9d           # imm = 0x8649
callq 0xec28c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x70
popq %rsi
movq %rbx, %rdi
callq 0xdecaf
movq %rax, %rbp
leaq 0x527a6(%rip), %rax     # 0x13ece6
movq %rax, (%rbp)
testq %r13, %r13
je 0xec5c6
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x60(%rbp)
movups %xmm1, 0x50(%rbp)
movups %xmm0, 0x40(%rbp)
leaq 0x395d5(%rip), %rsi     # 0x125b40
movq %rbx, %rdi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0xdf9b8
movups 0x40(%rbp), %xmm0
movups 0x50(%rbp), %xmm1
movups 0x60(%rbp), %xmm2
movups %xmm0, (%r13)
movups %xmm1, 0x10(%r13)
movups %xmm2, 0x20(%r13)
jmp 0xec5e1
leaq 0x396be(%rip), %rcx     # 0x125c61
pushq $0x1
popq %r9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe4e0b
leaq 0x39573(%rip), %rsi     # 0x125b40
movq %rbx, %rdi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0xdf9b8
movq %rbx, %rdi
movq %rbp, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x509c2(%rip), %rsi     # 0x13cfe3
xorl %edx, %edx
callq 0xdfae5
testl %eax, %eax
je 0xec65a
xorl %ecx, %ecx
testq %r12, %r12
leaq 0x1d5f4(%rip), %rax     # 0x109c2c
cmoveq %rax, %rcx
pushq $0x1
popq %r9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe4e0b
leaq 0x1d5cb(%rip), %rsi     # 0x109c2c
movq %r13, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xdf9b8
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
andw $0x0, (%rdx)
movb $0x0, 0x2(%rdx)
movq 0x18(%rsi), %rsi
xorl %r12d, %r12d
cmpq $0x80, %rsi
jl 0xec70e
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r15
addq $-0x80, %rsi
leaq 0x49286(%rip), %rdx     # 0x135939
pushq $0x7
popq %rcx
movq %r14, %rdi
callq 0xe4d48
testl %eax, %eax
jne 0xec70e
testb $0x1, %bpl
je 0xec6e1
movq 0x18(%r14), %rdx
addq $-0x80, %rdx
leaq 0x50919(%rip), %rsi     # 0x13cff0
movq %r15, %rdi
xorl %eax, %eax
callq 0xde896
movb $0x1, (%rbx)
movq 0x18(%r14), %rsi
addq $-0x22, %rsi
movq %r14, %rdi
callq 0xe3eb4
movb %al, 0x1(%rbx)
movq 0x18(%r14), %rsi
addq $-0x21, %rsi
movq %r14, %rdi
callq 0xe3eb4
movb %al, 0x2(%rbx)
movzbl (%rbx), %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0xec7af
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
callq 0xeaf3c
movq 0x10(%rbx), %rdi
callq 0xeaf3c
movq 0x18(%rbx), %rdi
callq 0xeaf3c
movq 0x60(%rbx), %rdi
callq 0xeaf3c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rsi)
je 0xeca55
movq %rsi, %r14
cmpq $0x0, 0x20(%rsi)
je 0xeca55
cmpq $0x0, 0x28(%r14)
je 0xeca5b
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl $0x82, %esi
callq 0xdecaf
movq %rax, %r15
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rax
movq 0x18(%rax), %rcx
pushq $-0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0xecaa0
andq $0x0, 0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_find_zip_eocd
int fmtutil_find_zip_eocd(deark *c, dbuf *f, UI flags, i64 *foundpos)
{
	u32 bof_sig;
	u32 sig;
	int skip_sanity_check = 0;
	u8 *buf = NULL;
	int retval = 0;
	i64 buf_offset;
	i64 buf_size;
	i64 pos;
	i64 i;

	*foundpos = 0;
	if(f->len < 22) goto done;

	bof_sig = (u32)dbuf_getu32be(f, 0);
	if(bof_sig==CODE_PK36) {
		skip_sanity_check = 1;
	}

	// End-of-central-dir record usually starts 22 bytes from EOF. Try that first.
	pos = f->len - 22;
	sig = (u32)dbuf_getu32be(f, pos);
	if(sig==CODE_PK56 && (skip_sanity_check || is_sane_zip_eocd(f, pos))) {
		*foundpos = pos;
		retval = 1;
		goto done;
	}

	if(flags & 0x1) goto done;

	// Search for the signature.
	// The end-of-central-directory record could theoretically appear anywhere
	// in the file. We'll follow Info-Zip/UnZip's lead and search the last 66000
	// bytes.
#define MAX_ZIP_EOCD_SEARCH 66000
	buf_size = f->len;
	if(buf_size > MAX_ZIP_EOCD_SEARCH) buf_size = MAX_ZIP_EOCD_SEARCH;

	buf = de_malloc(c, buf_size);
	buf_offset = f->len - buf_size;
	dbuf_read(f, buf, buf_offset, buf_size);

	for(i=buf_size-22; i>=0; i--) {
		if(buf[i]=='P' && buf[i+1]=='K' && buf[i+2]==5 && buf[i+3]==6 &&
			(skip_sanity_check || is_sane_zip_eocd(f, buf_offset+i)))
		{
			*foundpos = buf_offset + i;
			retval = 1;
			goto done;
		}
	}

done:
	de_free(c, buf);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andq $0x0, (%rcx)
cmpq $0x16, 0x18(%rsi)
jge 0xed5c1
xorl %r15d, %r15d
xorl %ebp, %ebp
jmp 0xed6be
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
callq 0xe404f
movl %eax, %ebp
movq 0x18(%r12), %r13
addq $-0x16, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xe404f
cmpl $0x504b0506, %eax       # imm = 0x504B0506
jne 0xed61d
cmpl $0x504b0306, %ebp       # imm = 0x504B0306
je 0xed60f
movq %r12, %rdi
movq %r13, %rsi
callq 0xed6d8
testl %eax, %eax
je 0xed61d
xorl %ebp, %ebp
movq %r13, (%r14)
pushq $0x1
popq %r15
jmp 0xed6b9
testb $0x1, %bl
jne 0xed6b7
movq %rbp, 0x10(%rsp)
movq 0x18(%r12), %rax
movl $0x101d0, %ebx          # imm = 0x101D0
cmpq %rbx, %rax
cmovlq %rax, %rbx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xdecaf
movq %rax, %rbp
movq 0x18(%r12), %r13
movq %r13, %rdx
subq %rbx, %rdx
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0xe3cb7
addq $-0x16, %rbx
addq $-0x16, %r13
testq %rbx, %rbx
js 0xed6b9
cmpb $0x50, (%rbp,%rbx)
jne 0xed6af
cmpb $0x4b, 0x1(%rbp,%rbx)
jne 0xed6af
cmpb $0x5, 0x2(%rbp,%rbx)
jne 0xed6af
cmpb $0x6, 0x3(%rbp,%rbx)
jne 0xed6af
cmpl $0x504b0306, 0x10(%rsp) # imm = 0x504B0306
je 0xed611
movq %r12, %rdi
movq %r13, %rsi
callq 0xed6d8
testl %eax, %eax
jne 0xed611
decq %rbx
decq %r13
jmp 0xed66d
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xded32
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $-0x14, %rsi
callq 0xe404f
pushq $0x1
popq %rbp
cmpq $0x504b0607, %rax       # imm = 0x504B0607
je 0xed789
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0xe3fa3
movq %rax, %r15
leaq 0x6(%r14), %rsi
movq %rbx, %rdi
callq 0xe3fa3
movq %rax, %r12
cmpq $0x65, %r15
setge %al
cmpq %r15, %r12
setg %cl
orb %al, %cl
leaq -0x1(%r15), %rax
cmpq %rax, %r12
setl %al
xorl %ebp, %ebp
orb %cl, %al
jne 0xed789
leaq 0xa(%r14), %rsi
movq %rbx, %rdi
callq 0xe3fa3
movq %rax, %r13
leaq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0xe409f
imulq $0x2e, %r13, %rcx
cmpq %rcx, %rax
jl 0xed789
cmpq %r12, %r15
pushq $0x1
popq %r15
jne 0xed786
cmpq 0x18(%rbx), %rax
jg 0xed789
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe409f
cmpq 0x18(%rbx), %rax
jg 0xed789
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %rcx, (%r12)
movq %rsi, %rdi
movq %r12, %rsi
callq 0xe40bf
movl %eax, 0x4(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe40bf
movl %eax, 0x8(%r14)
movl 0x4(%r14), %edx
leaq 0x4f97b(%rip), %rsi     # 0x13d2e3
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movl 0x4(%r14), %edx
cmpl $0xfff00000, %edx       # imm = 0xFFF00000
jb 0xed9f1
shrl $0x8, %edx
andl $0xfff, %edx            # imm = 0xFFF
movl %edx, 0x10(%r14)
movb $0x1, (%r14)
leaq 0x4f960(%rip), %rsi     # 0x13d303
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
addq $0x20, %r14
movq %r14, %rdx
callq 0xe03de
leaq 0x10(%rsp), %r15
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0xe0644
leaq 0x4e4d5(%rip), %rsi     # 0x13beb2
leaq 0x490af(%rip), %rdx     # 0x136a93
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0xde896
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0xe409f
movl %eax, 0xc(%r14)
leaq 0x4a65e(%rip), %rsi     # 0x138089
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movl 0xc(%r14), %edx
shrl $0x10, %edx
movl %edx, 0x18(%r14)
testb $0x1, %bpl
je 0xeda64
leaq 0x49f82(%rip), %rsi     # 0x1379dc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
testb $0x2, %bpl
je 0xeda84
movzbl 0xd(%r14), %edx
movl %edx, 0x14(%r14)
leaq 0x4f899(%rip), %rsi     # 0x13d313
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
pushq $-0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xdeba7
// File: /workspace/github_c_makefile_star2_O2/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:
testl %r8d, %r8d
je 0xeda99
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
cmpb $0x0, (%rcx)
je 0xedb39
movl %r9d, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq %rdx, %rdi
callq 0xeaf76
testl %eax, %eax
jne 0xedb39
movb 0xd4(%r12), %al
cmpb $-0x1, %al
jne 0xedaed
leaq 0x4f84b(%rip), %rsi     # 0x13d323
movq %r12, %rdi
movl $0xfe, %edx
callq 0xdfae5
movb %al, 0xd4(%r12)
testb %al, %al
je 0xedb39
movzbl %al, %eax
cmpl $0xfe, %eax
jne 0xedb1d
testl %ebp, %ebp
je 0xedb39
cmpb $0x0, 0xd0(%r12)
je 0xedb39
cmpl $0x1, 0x7c(%r12)
jne 0xedb1d
cmpl $0x1, 0x80(%r12)
je 0xedb39
movl 0x10(%r15), %ecx
leaq 0x4f80d(%rip), %rdx     # 0x13d335
pushq $0x5
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xeae8b
movb $0x1, 0x11(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4f7e4(%rip), %rsi     # 0x13d33b
movl %r14d, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq %r15, %rdi
movq %r14, %rsi
callq 0xe404f
leaq 0x4f7dc(%rip), %rsi     # 0x13d35a
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
pushq $-0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdeba7
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4f7b0(%rip), %rsi     # 0x13d36b
movl %r12d, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3f46
movl %eax, %edx
andl $0x7fff, %edx           # imm = 0x7FFF
movq %rdx, (%r14)
shrl $0xf, %eax
andl $0x1, %eax
movl %eax, 0x6c(%r14)
leaq 0x3a03a(%rip), %rsi     # 0x127c31
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movl 0x6c(%r14), %edx
leaq 0x4f793(%rip), %rsi     # 0x13d39f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
leaq 0x2(%r12), %rsi
movq %r15, %rdi
callq 0xe3fee
movq %rax, 0x10(%rsp)
leaq 0x4(%r12), %rsi
movq %r15, %rdi
callq 0xe3fee
movq %rax, %rbp
leaq 0x6(%r12), %rsi
movq %r15, %rdi
callq 0xe3fee
movq %rax, %r13
addq $0x8, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3fee
movq %rax, %r12
movq 0x8(%r15), %rdi
movl %r13d, (%rsp)
leaq 0x38a20(%rip), %rsi     # 0x126689
leaq 0x2de70(%rip), %rdx     # 0x11bae0
movl %ebp, %ecx
movq 0x10(%rsp), %r15
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0xde896
subq %rbp, %r12
movq %r12, 0x10(%r14)
movq %r12, 0x18(%r14)
subq %r15, %r13
movq %r13, 0x20(%r14)
pushq $-0x1
popq %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdeba7
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_cus_p
i64 fmtutil_hlp_get_cus_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;

	x1 = (i64)dbuf_getbyte_p(f, ppos);
	if(x1%2 == 0) {
		// If it's even, divide by two.
		return x1>>1;
	}
	// If it's odd, divide by two, and add 128 times the value of
	// the next byte.
	x2 = (i64)dbuf_getbyte_p(f, ppos);
	return (x1>>1) | (x2<<7);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe3f2a
movzbl %al, %ebx
testb $0x1, %bl
jne 0xee06a
shrl %ebx
jmp 0xee07f
movq %r15, %rdi
movq %r14, %rsi
callq 0xe3f2a
shrl %ebx
movzbl %al, %eax
shll $0x7, %eax
orl %eax, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_css_p
i64 fmtutil_hlp_get_css_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;

	x1 = (i64)dbuf_getbyte_p(f, ppos);
	if(x1%2 == 0) {
		// If it's even, divide by two, and subtract 64
		return (x1>>1) - 64;
	}
	// If it's odd, divide by two, add 128 times the value of
	// the next byte, and subtract 16384.
	x1 >>= 1;
	x2 = (i64)dbuf_getbyte_p(f, ppos);
	x1 += x2 * 128;
	x1 -= 16384;
	return x1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe3f2a
movzbl %al, %eax
movl %eax, %ebx
shrl %ebx
testb $0x1, %al
jne 0xee0a9
addq $-0x40, %rbx
jmp 0xee0c4
movq %r15, %rdi
movq %r14, %rsi
callq 0xe3f2a
movzbl %al, %eax
shll $0x7, %eax
addq %rax, %rbx
addq $-0x4000, %rbx          # imm = 0xC000
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_cul_p
i64 fmtutil_hlp_get_cul_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;
	x1 = dbuf_getu16le_p(f, ppos);
	if(x1%2 == 0) {
		// If it's even, divide by two.
		return x1>>1;
	}
	// If it's odd, divide by two, and add 32768 times the value of
	// the next two bytes.
	x2 = dbuf_getu16le_p(f, ppos);
	return (x1>>1) | (x2<<15);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe3fc4
movq %rax, %rbx
testb $0x1, %bl
jne 0xee0ea
sarq %rbx
jmp 0xee0ff
movq %r15, %rdi
movq %r14, %rsi
callq 0xe3fc4
sarq %rbx
shlq $0xf, %rax
orq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_csl_p
i64 fmtutil_hlp_get_csl_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;

	x1 = dbuf_getu16le_p(f, ppos);

	if(x1%2 == 0) {
		// If it's even, divide by two, and subtract 16384
		return (x1>>1) - 16384;
	}
	// If it's odd, divide by two, add 32768 times the value of
	// the next two bytes, and subtract 67108864.
	x1 >>= 1;
	x2 = dbuf_getu16le_p(f, ppos);
	x1 += x2*32768;
	x1 -= 67108864;
	return x1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe3fc4
movq %rax, %rbx
sarq %rbx
testb $0x1, %al
jne 0xee12b
addq $-0x4000, %rbx          # imm = 0xC000
jmp 0xee144
movq %r15, %rdi
movq %r14, %rsi
callq 0xe3fc4
shlq $0xf, %rax
addq %rax, %rbx
addq $-0x4000000, %rbx       # imm = 0xFC000000
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_scan_for_arj_data
int fmtutil_scan_for_arj_data(dbuf *f, i64 startpos, i64 max_skip,
	UI flags, i64 *pfoundpos)
{
	struct de_crcobj *crco = NULL;
	i64 curpos, endpos;
	int retval = 0;

	curpos = startpos;
	endpos = startpos + max_skip + 2; // Search space includes the 2-byte signature
	if(endpos-2 > f->len-ARJ_MIN_FILE_SIZE) endpos = (f->len-ARJ_MIN_FILE_SIZE)+2;

	while(curpos<=(endpos-2)) {
		int ret;

		ret = dbuf_search(f, (const u8*)"\x60\xea", 2, curpos, endpos-curpos,
			pfoundpos);
		if(!ret) goto done;

		if(crco) {
			de_crcobj_reset(crco);
		}
		else {
			crco = de_crcobj_create(f->c, DE_CRCOBJ_CRC32_IEEE);
		}
		if(is_arj_data_at1(f, *pfoundpos, crco)) {
			retval = 1;
			goto done;
		}
		curpos = *pfoundpos+2; // Continue the search here
	}

done:
	de_crcobj_destroy(crco);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %r14
leaq (%rdx,%rsi), %rax
addq $0x2, %rax
addq %rsi, %rdx
movq 0x18(%rdi), %r13
leaq -0x54(%r13), %rsi
addq $-0x52, %r13
cmpq %rsi, %rdx
cmovleq %rax, %r13
movq %r8, %r12
leaq -0x2(%r13), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
movq %r13, 0x8(%rsp)
cmpq 0x10(%rsp), %rcx
jg 0xee254
movq %r13, %r8
subq %rcx, %r8
movq %r14, %rdi
leaq 0x1cd26(%rip), %rsi     # 0x10aed4
pushq $0x2
popq %rdx
movq %r12, %r9
callq 0xe62f1
testl %eax, %eax
je 0xee254
testq %r15, %r15
je 0xee1d0
movq %r15, %rdi
callq 0xe0e44
jmp 0xee1df
movq 0x8(%r14), %rdi
pushq $0x10
popq %rsi
callq 0xe0ae9
movq %rax, %r15
movq (%r12), %rbp
leaq 0x2(%rbp), %rsi
movq %r14, %rdi
callq 0xe3fa3
movq %rax, %rbx
addq $-0xa29, %rax           # imm = 0xF5D7
cmpq $-0xa0b, %rax           # imm = 0xF5F5
jb 0xee247
leaq 0xa(%rbp), %rsi
movq %r14, %rdi
callq 0xe3eb4
cmpb $0x2, %al
jne 0xee247
leaq 0x4(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0xe0f33
movq %r15, %rdi
callq 0xe0e95
movl %eax, %r13d
leaq (%rbx,%rbp), %rsi
addq $0x4, %rsi
movq %r14, %rdi
callq 0xe409f
cmpl %eax, %r13d
movq 0x8(%rsp), %r13
je 0xee26f
movq (%r12), %rcx
addq $0x2, %rcx
jmp 0xee193
xorl %ebx, %ebx
movq %r15, %rdi
callq 0xe0e8d
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
movl %eax, %ebx
jmp 0xee256
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_results_clear
void de_dfilter_results_clear(deark *c, struct de_dfilter_results *dres)
{
	dres->errcode = 0;
	dres->bytes_consumed_valid = 0;
	dres->bytes_consumed = 0;
	dres->errmsg[0] = '\0';
}

// Assembly:
andl $0x0, (%rsi)
xorl %eax, %eax
movb %al, 0x4(%rsi)
andq $0x0, 0x8(%rsi)
movb %al, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_init_objects
void de_dfilter_init_objects(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	if(dcmpri)
		de_zeromem(dcmpri, sizeof(struct de_dfilter_in_params));
	if(dcmpro)
		de_zeromem(dcmpro, sizeof(struct de_dfilter_out_params));
	if(dres)
		de_dfilter_results_clear(c, dres);
}

// Assembly:
testq %rsi, %rsi
je 0xee7fd
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
testq %rdx, %rdx
je 0xee80d
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
testq %rcx, %rcx
je 0xee822
andl $0x0, (%rcx)
xorl %eax, %eax
movb %al, 0x4(%rcx)
andq $0x0, 0x8(%rcx)
movb %al, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_set_errorf
void de_dfilter_set_errorf(deark *c, struct de_dfilter_results *dres, const char *modname,
	const char *fmt, ...)
{
	va_list ap;

	if(dres->errcode != 0) return; // Only record the first error
	dres->errcode = 1;

	va_start(ap, fmt);
	if(modname) {
		char tmpbuf[80];

		de_vsnprintf(tmpbuf, sizeof(tmpbuf), fmt, ap);
		de_snprintf(dres->errmsg, sizeof(dres->errmsg), "[%s] %s", modname, tmpbuf);
	}
	else {
		de_vsnprintf(dres->errmsg, sizeof(dres->errmsg), fmt, ap);
	}
	va_end(ap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xee876
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x0, (%rsi)
jne 0xee90d
movq %rdx, %r14
movq %rsi, %rbx
movl $0x1, (%rsi)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x150(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rsp)
testq %rdx, %rdx
je 0xee8f5
leaq 0xd0(%rsp), %r15
pushq $0x50
popq %r12
movq %rsp, %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0xfc8d8
addq $0x10, %rbx
leaq 0x40f02(%rip), %rdx     # 0x12f7e2
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0xde40c
jmp 0xee90d
addq $0x10, %rbx
pushq $0x50
popq %rsi
movq %rsp, %rax
movq %rbx, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0xfc8d8
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_create
struct de_dfilter_ctx *de_dfilter_create(deark *c,
	dfilter_codec_type codec_init_fn, void *codec_private_params,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dfilter_ctx *dfctx = NULL;

	dfctx = de_malloc(c, sizeof(struct de_dfilter_ctx));
	dfctx->c = c;
	dfctx->dres = dres;
	dfctx->dcmpro = dcmpro;

	if(codec_init_fn) {
		codec_init_fn(dfctx, codec_private_params);
	}
	// TODO: How should we handle failure to initialize a codec?

	return dfctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rbp
pushq $0x50
popq %rsi
callq 0xdecaf
movq %rax, %r15
movq %rbp, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
testq %rbx, %rbx
je 0xee96d
movq %r15, %rdi
movq %r14, %rsi
callq *%rbx
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_addbuf
void de_dfilter_addbuf(struct de_dfilter_ctx *dfctx,
	const u8 *buf, i64 buf_len)
{
	if(dfctx->finished_flag) return;

	if(dfctx->codec_addbuf_fn && (buf_len>0)) {
		dfctx->codec_addbuf_fn(dfctx, buf, buf_len);

		if(dfctx->dres->errcode) {
			dfctx->finished_flag = 1;
		}
	}
}

// Assembly:
cmpb $0x0, 0x20(%rdi)
je 0xee986
retq
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
sete %cl
testq %rdx, %rdx
setle %dil
orb %cl, %dil
jne 0xee9b2
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
je 0xee9b2
movb $0x1, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_destroy
void de_dfilter_destroy(struct de_dfilter_ctx *dfctx)
{
	deark *c;

	if(!dfctx) return;
	c = dfctx->c;
	if(dfctx->codec_destroy_fn) {
		dfctx->codec_destroy_fn(dfctx);
	}

	de_free(c, dfctx);
}

// Assembly:
testq %rdi, %rdi
je 0xeea0c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0xee9fa
movq %rbx, %rdi
callq *%rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_decompress_oneshot
void de_dfilter_decompress_oneshot(deark *c,
	dfilter_codec_type codec_init_fn, void *codec_private_params,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_dfilter_ctx *dfctx = NULL;

	dfctx = de_dfilter_create(c, codec_init_fn, codec_private_params,
		dcmpro, dres);
	dfctx->input_file_offset = dcmpri->pos;
	de_dfilter_addslice(dfctx, dcmpri->f, dcmpri->pos, dcmpri->len);
	de_dfilter_finish(dfctx);
	de_dfilter_destroy(dfctx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %r8, %rcx
movq %r9, %r8
callq 0xee930
movq %rax, %rbx
movq 0x8(%r14), %rdx
movq %rdx, 0x18(%rax)
movq (%r14), %rsi
movq 0x10(%r14), %rcx
movq %rax, %rdi
callq 0xeea0d
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0xeea80
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xee9dd
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: fmtutil_decompress_uncompressed
void fmtutil_decompress_uncompressed(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres, UI flags)
{
	i64 len;
	i64 nbytes_avail;

	nbytes_avail = de_min_int(dcmpri->len, dcmpri->f->len - dcmpri->pos);

	if(dcmpro->len_known) {
		len = dcmpro->expected_len;
	}
	else {
		len = dcmpri->len;
	}

	if(len>nbytes_avail) len = nbytes_avail;
	if(len<0) len = 0;

	dbuf_copy(dcmpri->f, dcmpri->pos, len, dcmpro->f);
	dres->bytes_consumed = len;
	dres->bytes_consumed_valid = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq 0x10(%rsi), %rdi
movq 0x18(%rax), %rsi
subq 0x8(%r15), %rsi
callq 0xdfb45
cmpb $0x0, 0x8(%r14)
movq %r14, %rcx
cmoveq %r15, %rcx
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
cmovlq %rcx, %rax
xorl %r12d, %r12d
testq %rax, %rax
cmovgq %rax, %r12
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq (%r14), %rcx
movq %r12, %rdx
callq 0xe45f4
movq %r12, 0x8(%rbx)
movb $0x1, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: dfilter_packbits_codec
void dfilter_packbits_codec(struct de_dfilter_ctx *dfctx, void *codec_private_params)
{
	struct packbitsctx *rctx = NULL;
	struct de_packbits_params *pbparams = (struct de_packbits_params*)codec_private_params;

	rctx = de_malloc(dfctx->c, sizeof(struct packbitsctx));
	rctx->modname = "packbits";

	dfctx->codec_private = (void*)rctx;
	dfctx->codec_addbuf_fn = my_packbits_codec_addbuf;
	dfctx->codec_finish_fn = my_packbits_codec_finish;
	dfctx->codec_command_fn = my_packbits_codec_command;
	dfctx->codec_destroy_fn = my_packbits_codec_destroy;

	rctx->nbytes_per_unit = 1;
	if(pbparams) {
		if(pbparams->nbytes_per_unit>DE_PACKBITS_MAX_NBYTES_PER_UNIT) {
			de_dfilter_set_generic_error(dfctx->c, dfctx->dres, rctx->modname);
		}
		else if(pbparams->nbytes_per_unit>1) {
			rctx->nbytes_per_unit = pbparams->nbytes_per_unit;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x48
popq %rsi
callq 0xdecaf
leaq 0x4eb04(%rip), %rcx     # 0x13d61b
movq %rcx, 0x40(%rax)
movq %rax, 0x28(%rbx)
leaq 0x61(%rip), %rcx        # 0xeeb87
movq %rcx, 0x30(%rbx)
leaq 0x1c2(%rip), %rcx       # 0xeecf3
movq %rcx, 0x40(%rbx)
leaq 0x1d1(%rip), %rcx       # 0xeed0d
movq %rcx, 0x38(%rbx)
leaq 0x1ec(%rip), %rcx       # 0xeed33
movq %rcx, 0x48(%rbx)
movq $0x1, (%rax)
testq %r14, %r14
je 0xeeb7f
movl (%r14), %ecx
cmpq $0x9, %rcx
jb 0xeeb77
movq 0x8(%rbx), %rsi
leaq 0x4eab0(%rip), %rdx     # 0x13d61b
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xee91c
cmpl $0x2, %ecx
jb 0xeeb7f
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_packbits_codec_finish
static void my_packbits_codec_finish(struct de_dfilter_ctx *dfctx)
{
	struct packbitsctx *rctx = (struct packbitsctx*)dfctx->codec_private;

	if(!rctx) return;
	dfctx->dres->bytes_consumed = rctx->total_nbytes_processed;
	dfctx->dres->bytes_consumed_valid = 1;
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xeed0c
movq 0x18(%rax), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movb $0x1, 0x4(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_packbits_codec_destroy
static void my_packbits_codec_destroy(struct de_dfilter_ctx *dfctx)
{
	struct packbitsctx *rctx = (struct packbitsctx*)dfctx->codec_private;

	if(rctx) {
		de_free(dfctx->c, rctx);
	}
	dfctx->codec_private = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0xeed48
movq (%rbx), %rdi
callq 0xded32
andq $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: fmtutil_decompress_packbits
int fmtutil_decompress_packbits(dbuf *f, i64 pos1, i64 len,
	dbuf *unc_pixels, i64 *cmpr_bytes_consumed)
{
	struct de_dfilter_results dres;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;

	if(cmpr_bytes_consumed) *cmpr_bytes_consumed = 0;
	de_dfilter_init_objects(f->c, &dcmpri, &dcmpro, &dres);

	dcmpri.f = f;
	dcmpri.pos = pos1;
	dcmpri.len = len;
	dcmpro.f = unc_pixels;
	if(unc_pixels->has_len_limit) {
		dcmpro.len_known = 1;
		dbuf_flush(unc_pixels);
		dcmpro.expected_len = unc_pixels->len_limit - unc_pixels->len;
	}

	de_dfilter_decompress_oneshot(f->c, dfilter_packbits_codec, NULL,
		&dcmpri, &dcmpro, &dres);

	if(cmpr_bytes_consumed && dres.bytes_consumed_valid) {
		*cmpr_bytes_consumed = dres.bytes_consumed;
	}
	if(dres.errcode != 0) return 0;
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r14
testq %r8, %r8
je 0xeed88
andq $0x0, (%rbx)
andq $0x0, 0x38(%rsp)
xorps %xmm0, %xmm0
andl $0x0, 0x40(%rsp)
xorl %eax, %eax
movb %al, 0x44(%rsp)
andq $0x0, 0x48(%rsp)
movups %xmm0, 0x10(%rsp)
movb %al, 0x50(%rsp)
movq %r14, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r15, 0x8(%rsp)
cmpl $0x0, 0x30(%r15)
je 0xeede0
movb $0x1, 0x10(%rsp)
movq %r15, %rdi
callq 0xe58e8
movq 0x28(%r15), %rax
subq 0x18(%r15), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rdi
leaq -0x2f0(%rip), %rsi      # 0xeeafb
leaq 0x20(%rsp), %rcx
leaq 0x8(%rsp), %r8
leaq 0x40(%rsp), %r9
xorl %edx, %edx
callq 0xeea46
testq %rbx, %rbx
je 0xeee15
cmpb $0x0, 0x44(%rsp)
je 0xeee15
movq 0x48(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x40(%rsp)
sete %al
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: dfilter_rle90_codec
void dfilter_rle90_codec(struct de_dfilter_ctx *dfctx, void *codec_private_params)
{
	struct rle90ctx *rctx = NULL;

	rctx = de_malloc(dfctx->c, sizeof(struct rle90ctx));
	dfctx->codec_private = (void*)rctx;
	dfctx->codec_addbuf_fn = my_rle90_codec_addbuf;
	dfctx->codec_finish_fn = my_rle90_codec_finish;
	dfctx->codec_destroy_fn = my_rle90_codec_destroy;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x18
popq %rsi
callq 0xdecaf
movq %rax, 0x28(%rbx)
leaq 0x1c(%rip), %rax        # 0xeee79
movq %rax, 0x30(%rbx)
leaq 0x116(%rip), %rax       # 0xeef7e
movq %rax, 0x40(%rbx)
leaq 0x124(%rip), %rax       # 0xeef97
movq %rax, 0x48(%rbx)
popq %rbx
retq