LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: zipreloc_wcd_prescan
static void zipreloc_wcd_prescan(deark *c, struct zip_wcd_ctx *wcdctx)
{
	struct zipreloc_ctx *d = (struct zipreloc_ctx*)wcdctx->userdata;
	i64 pos1 = wcdctx->entry_pos;
	dbuf *inf = wcdctx->inf;
	u32 sig;
	i64 ldir_seg_num;
	i64 ldir_offset;

	de_dbg2(c, "central dir entry at %"I64_FMT, pos1);

	ldir_seg_num = dbuf_getu16le(inf, pos1+34);
	ldir_offset = dbuf_getu32le(inf, pos1+42) + d->offset_correction;
	de_dbg_indent(c, 1);
	de_dbg2(c, "local dir offset: %"I64_FMT", segment %"I64_FMT, ldir_offset,
		ldir_seg_num);
	de_dbg_indent(c, -1);

	sig = (u32)dbuf_getu32be(inf, ldir_offset);
	if(sig != CODE_PK34) {
		wcdctx->errflag = 1;
		wcdctx->need_errmsg = 1;
		goto done;
	}

	if(ldir_seg_num != d->eocd.this_seg_num) {
		u32 crc_from_cdir;
		u32 crc_from_ldir;

		crc_from_cdir = (u32)dbuf_getu32le(inf, pos1+16);
		crc_from_ldir = (u32)dbuf_getu32le(inf, ldir_offset+14);
		if(crc_from_cdir == crc_from_ldir) {
			de_dbg(c, "[tolerating mismatched segment id]");
		}
		else {
			wcdctx->errflag = 1;
			wcdctx->need_errmsg = 1;
			d->seg_id_mismatch_flag = 1;
			goto done;
		}
	}

	if(ldir_offset < d->min_ldir_offset) {
		d->min_ldir_offset = ldir_offset;
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movq 0x8(%rsi), %r14
movq 0x18(%rsi), %r12
movq 0x50(%rsi), %r15
leaq 0x65771(%rip), %rsi     # 0x1431c5
movq %r15, %rdx
xorl %eax, %eax
callq 0xe93cf
leaq 0x22(%r15), %rsi
movq %r12, %rdi
callq 0xef1ca
movq %rax, %rbp
movq %r15, 0x8(%rsp)
leaq 0x2a(%r15), %rsi
movq %r12, %rdi
callq 0xef37e
movq %rax, %r15
movq %r14, 0x10(%rsp)
addq 0x70(%r14), %r15
movq %r13, %r14
movq %r13, %rdi
movl $0x1, %esi
callq 0xe9585
leaq 0x6573d(%rip), %rsi     # 0x1431de
movq %r13, %rdi
movq %r15, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xe93cf
movq %r13, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
movq %r12, %rdi
movq %r15, %rsi
callq 0xef32a
cmpl $0x504b0304, %eax       # imm = 0x504B0304
jne 0xddb19
movq 0x10(%rsp), %rax
cmpq 0x10(%rax), %rbp
movq %rax, %rbp
je 0xddb30
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0xef37e
movq %rax, %r13
leaq 0xe(%r15), %rsi
movq %r12, %rdi
callq 0xef37e
movq %rax, %r12
cmpl %r12d, %r13d
jne 0xddb21
leaq 0x656f4(%rip), %rsi     # 0x143201
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9226
jmp 0xddb2b
movw $0x101, 0x39(%rbx)      # imm = 0x101
jmp 0xddb3a
movw $0x101, 0x39(%rbx)      # imm = 0x101
movb $0x1, 0x2(%rbp)
cmpl %r12d, %r13d
jne 0xddb3a
cmpq 0x68(%rbp), %r15
jge 0xddb3a
movq %r15, 0x68(%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: zipreloc_wcd_convert
static void zipreloc_wcd_convert(deark *c, struct zip_wcd_ctx *wcdctx)
{
	struct zipreloc_ctx *d = (struct zipreloc_ctx*)wcdctx->userdata;
	i64 pos1 = wcdctx->entry_pos;
	i64 len = wcdctx->entry_size;
	i64 cpstart, cplen;
	i64 ldir_offset;

	// Copy the first 34 bytes of the central dir entry
	// (signature thru comment len).
	cpstart = pos1;
	cplen = 34;
	dbuf_copy(wcdctx->inf, cpstart, cplen, d->outf);

	// Segment number, that we force to 0 (offset 34 len 2)
	dbuf_write_zeroes(d->outf, 2);

	// Copy the next 6 bytes (offset 36)
	// (internal attribs, thru external attribs)
	cpstart = pos1+36;
	cplen = 6;
	dbuf_copy(wcdctx->inf, cpstart, cplen, d->outf);

	// Edit the offset-of-local-hdr field (offset 42 len 4)
	ldir_offset = de_getu32le(pos1+42) + d->offset_correction;
	dbuf_writeu32le(d->outf, ldir_offset + d->offset_diff);

	// Copy the rest of the entry (offset 46+).
	cpstart = pos1+46;
	cplen = len - 46;
	dbuf_copy(wcdctx->inf, cpstart, cplen, d->outf);
	d->central_dir_nbytes_converted += len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rsi), %rbx
movq 0x58(%rsi), %r12
movq 0x8(%rsi), %r13
movq 0x18(%rsi), %rdi
movq 0x88(%r13), %rcx
movl $0x22, %edx
movq %rbx, %rsi
callq 0xefabc
movq 0x88(%r13), %rdi
movl $0x2, %esi
callq 0xf1346
leaq 0x24(%rbx), %rsi
movq 0x18(%r14), %rdi
movq 0x88(%r13), %rcx
movl $0x6, %edx
callq 0xefabc
movq 0x18(%r15), %rdi
leaq 0x2a(%rbx), %rsi
callq 0xef37e
addq 0x70(%r13), %rax
movq 0x88(%r13), %rdi
addq 0x78(%r13), %rax
movq %rax, %rsi
callq 0xf1645
addq $0x2e, %rbx
leaq -0x2e(%r12), %rdx
movq 0x18(%r14), %rdi
movq 0x88(%r13), %rcx
movq %rbx, %rsi
callq 0xefabc
addq %r12, 0x80(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: create_member_data
static struct member_data *create_member_data(deark *c, lctx *d)
{
	struct member_data *md;

	md = de_malloc(c, sizeof(struct member_data));
	md->local_dir_entry_data.fname = ucstring_create(c);
	md->central_dir_entry_data.fname = ucstring_create(c);
	return md;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x208, %esi            # imm = 0x208
callq 0xe969b
movq %rax, %r14
movq %rbx, %rdi
callq 0xf6870
movq %rax, 0x1b8(%r14)
movq %rbx, %rdi
callq 0xf6870
movq %rax, 0x140(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: destroy_member_data
static void destroy_member_data(deark *c, struct member_data *md)
{
	if(!md) return;
	ucstring_destroy(md->central_dir_entry_data.fname);
	ucstring_destroy(md->local_dir_entry_data.fname);
	de_free(c, md);
}

// Assembly:
testq %rsi, %rsi
je 0xdefe0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x140(%rsi), %rdi
callq 0xf6bb0
movq 0x1b8(%rbx), %rdi
callq 0xf6bb0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9752
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: do_comment
static void do_comment(deark *c, lctx *d, i64 pos, i64 len, int utf8_flag,
	const char *name, const char *ext)
{
	de_ext_encoding ee;

	if(len<1) return;
	ee = utf8_flag ? DE_ENCODING_UTF8 : d->default_enc_for_comments;
	ee = DE_EXTENC_MAKE(ee, DE_ENCSUBTYPE_HYBRID);
	if(c->extract_level>=2) {
		do_comment_extract(c, d, pos, len, ee, ext);
	}
	else {
		do_comment_display(c, d, pos, len, ee, name);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movl $0x302, %ebp            # imm = 0x302
testl %r8d, %r8d
jne 0xdf00c
movzbl 0x4(%rsi), %ebp
orl $0x300, %ebp            # imm = 0x300
cmpl $0x2, 0x90(%rbx)
jl 0xdf05c
movq 0x40(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xf037a
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %rax, %r8
movl $0x6, %r9d
callq 0xf1f28
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf0b13
movq %rbx, %rdi
callq 0xf6870
movq %rax, %r13
movq 0x18(%rbx), %rdi
movl %ebp, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %r13, %rdi
callq 0xf7557
leaq 0x4cdaf(%rip), %rsi     # 0x12be42
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9226
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6bb0
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: do_decompress_implode
static void do_decompress_implode(deark *c, lctx *d, struct compression_params *cparams,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_zipimplode_params params;

	de_zeromem(&params, sizeof(struct de_zipimplode_params));
	params.bit_flags = cparams->bit_flags;
	params.mml_bug = (u8)de_get_ext_option_bool(c, "zip:implodebug", 0);
	fmtutil_decompress_zip_implode(c, dcmpri, dcmpro, dres, &params);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r13
movq $0x0, (%r13)
movl 0x4(%rdx), %eax
movl %eax, (%r13)
leaq 0x644df(%rip), %rsi     # 0x143615
xorl %edx, %edx
callq 0xea727
movb %al, 0x4(%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x100e1f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: do_decompress_deflate
static void do_decompress_deflate(deark *c, lctx *d, struct compression_params *cparams,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_deflate_params inflparams;

	de_zeromem(&inflparams, sizeof(struct de_deflate_params));
	if(cparams->cmpr_meth==9) {
		inflparams.flags |= DE_DEFLATEFLAG_DEFLATE64;
	};
	fmtutil_decompress_deflate_ex(c, dcmpri, dcmpro, dres, &inflparams);
}

// Assembly:
subq $0x18, %rsp
movq %r8, %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpl $0x9, (%rdx)
jne 0xdf17a
orb $0x4, (%rsp)
movq %rsp, %r8
movq %rcx, %rsi
movq %rax, %rdx
movq %r9, %rcx
callq 0x100d13
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: format_int_with_zip64_override
static char *format_int_with_zip64_override(lctx *d, i64 v, i64 specialval,
	char *tmpbuf, size_t tmpbuf_len)
{
	static const char *g_zip64_override_msg = "[overridden by Zip64]";

	if(d->is_zip64 && v==specialval) {
		de_strlcpy(tmpbuf, g_zip64_override_msg, tmpbuf_len);
	}
	else {
		de_snprintf(tmpbuf, tmpbuf_len, "%"I64_FMT, v);
	}
	return tmpbuf;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movq %rsi, %rcx
cmpq %rdx, %rsi
jne 0xdf1cc
cmpb $0x0, 0xac(%rdi)
je 0xdf1cc
leaq 0x644ba(%rip), %rsi     # 0x143677
movl $0x40, %edx
movq %rbx, %rdi
callq 0xe8ded
jmp 0xdf1e2
leaq 0x4a3de(%rip), %rdx     # 0x1295b1
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8d67
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: ef_zipitmac_2705
static void ef_zipitmac_2705(deark *c, lctx *d, struct extra_item_info_struct *eii)
{
	struct de_fourcc sig;
	struct de_fourcc filetype;
	struct de_fourcc creator;

	if(eii->dlen<4) goto done;
	dbuf_read_fourcc(c->infile, eii->dpos, &sig, 4, 0x0);
	de_dbg(c, "signature: '%s'", sig.id_dbgstr);
	if(sig.id!=0x5a504954U) goto done; // expecting 'ZPIT'
	if(eii->dlen<12) goto done;
	dbuf_read_fourcc(c->infile, eii->dpos+4, &filetype, 4, 0x0);
	de_dbg(c, "filetype: '%s'", filetype.id_dbgstr);
	dbuf_read_fourcc(c->infile, eii->dpos+8, &creator, 4, 0x0);
	de_dbg(c, "creator: '%s'", creator.id_dbgstr);

done:
	;
}

// Assembly:
cmpq $0x4, 0x10(%rdx)
jl 0xdf974
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x8(%rdx), %rsi
leaq 0x60(%rsp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
leaq 0x70(%rsp), %r15
leaq 0x3cd2e(%rip), %rsi     # 0x11c612
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe9226
cmpl $0x5a504954, -0xc(%r15) # imm = 0x5A504954
jne 0xdf968
cmpq $0xc, 0x10(%r14)
jl 0xdf968
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x4, %rsi
leaq 0x30(%rsp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
leaq 0x40(%rsp), %rdx
leaq 0x34f34(%rip), %rsi     # 0x114860
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x8, %rsi
movq %rsp, %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
leaq 0x10(%rsp), %rdx
leaq 0x54595(%rip), %rsi     # 0x133ef3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: ef_acorn
static void ef_acorn(deark *c, lctx *d, struct extra_item_info_struct *eii)
{
	i64 pos = eii->dpos;
	struct de_riscos_file_attrs rfa;

	if(eii->dlen<16) return;
	if(dbuf_memcmp(c->infile, eii->dpos, "ARC0", 4)) {
		de_dbg(c, "[unsupported Acorn extra-field type]");
		return;
	}
	pos += 4;

	de_zeromem(&rfa, sizeof(struct de_riscos_file_attrs));
	fmtutil_riscos_read_load_exec(c, c->infile, &rfa, pos);
	pos += 8;
	if(rfa.mod_time.is_valid) {
		apply_timestamp(c, d, eii->md, DE_TIMESTAMPIDX_MODIFY, &rfa.mod_time, 70);
	}

	fmtutil_riscos_read_attribs_field(c, c->infile, &rfa, pos, 0);

	if(!eii->is_central && !eii->md->has_riscos_data) {
		eii->md->has_riscos_data = 1;
		eii->md->rfa = rfa;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq $0x10, 0x10(%rdx)
jge 0xdff6a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %r15
movq 0x18(%rdi), %rdi
leaq 0x63ee7(%rip), %rdx     # 0x143e66
movl $0x4, %ecx
movq %r15, %rsi
callq 0xf025e
testl %eax, %eax
je 0xdffac
leaq 0x63ed4(%rip), %rsi     # 0x143e6b
movq %r14, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe9226
leaq 0x4(%r15), %rcx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq 0x18(%r14), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0xf978c
addq $0xc, %r15
cmpb $0x0, 0x20(%r12)
je 0xdffff
movq 0x20(%rbx), %rax
cmpl $0x46, 0x58(%rax)
jg 0xdffff
leaq 0x20(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x48(%rax)
movl $0x46, 0x58(%rax)
movq 0x18(%r14), %rsi
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xf9878
cmpl $0x0, 0x30(%rbx)
jne 0xdff5e
movq 0x20(%rbx), %rax
cmpb $0x0, 0xc0(%rax)
jne 0xdff5e
movb $0x1, 0xc0(%rax)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm0, 0xc8(%rax)
movups %xmm1, 0xd8(%rax)
movups %xmm2, 0xe8(%rax)
jmp 0xdff5e
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: ef_infozip1
static void ef_infozip1(deark *c, lctx *d, struct extra_item_info_struct *eii)
{
	i64 uidnum, gidnum;
	struct de_timestamp timestamp_tmp;

	if(eii->dlen<8) return;
	read_unix_timestamp(c, d, eii->dpos, &timestamp_tmp, "atime");
	apply_timestamp(c, d, eii->md, DE_TIMESTAMPIDX_ACCESS, &timestamp_tmp, 45);
	read_unix_timestamp(c, d, eii->dpos+4, &timestamp_tmp, "mtime");
	apply_timestamp(c, d, eii->md, DE_TIMESTAMPIDX_MODIFY, &timestamp_tmp, 45);
	if(!eii->is_central && eii->dlen>=12) {
		uidnum = de_getu16le(eii->dpos+8);
		gidnum = de_getu16le(eii->dpos+10);
		dbg_zip_uid_gid_num(c, uidnum, gidnum);
	}
}

// Assembly:
cmpq $0x8, 0x10(%rdx)
jl 0xe02f8
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
leaq 0x5b830(%rip), %rcx     # 0x13ba55
movq %rsp, %r15
movq %r15, %rdx
callq 0xe0858
cmpb $0x0, (%r15)
je 0xe0255
movq 0x20(%r14), %rax
cmpl $0x2d, 0x88(%rax)
jg 0xe0255
movups (%rsp), %xmm0
movups %xmm0, 0x78(%rax)
movl $0x2d, 0x88(%rax)
movq 0x8(%r14), %rsi
addq $0x4, %rsi
leaq 0x5b648(%rip), %rcx     # 0x13b8ac
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe0858
cmpb $0x0, (%r15)
je 0xe0291
movq 0x20(%r14), %rax
cmpl $0x2d, 0x58(%rax)
jg 0xe0291
movups (%rsp), %xmm0
movups %xmm0, 0x48(%rax)
movl $0x2d, 0x58(%rax)
cmpl $0x0, 0x30(%r14)
jne 0xe02ef
cmpq $0xc, 0x10(%r14)
jl 0xe02ef
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x8, %rsi
callq 0xef1ca
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0xa, %rsi
callq 0xef1ca
movq %rax, %r14
leaq 0x4bbf7(%rip), %rsi     # 0x12bec5
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
leaq 0x4bbeb(%rip), %rsi     # 0x12becd
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe9226
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: ef_unicodepath
static void ef_unicodepath(deark *c, lctx *d, struct extra_item_info_struct *eii)
{
	u8 ver;
	de_ucstring *fn = NULL;
	i64 fnlen;
	u32 crc_reported, crc_calculated;

	if(eii->dlen<1) goto done;
	ver = de_getbyte(eii->dpos);
	de_dbg(c, "version: %u", (UI)ver);
	if(ver!=1) goto done;
	if(eii->dlen<6) goto done;
	crc_reported = (u32)de_getu32le(eii->dpos+1);
	de_dbg(c, "name-crc (reported): 0x%08x", (UI)crc_reported);
	fn = ucstring_create(c);
	fnlen = eii->dlen - 5;
	dbuf_read_to_ucstring(c->infile, eii->dpos+5, fnlen, fn, 0, DE_ENCODING_UTF8);
	de_dbg(c, "unicode name: \"%s\"", ucstring_getpsz_d(fn));

	// Need to go back and calculate a CRC of the main filename. This is
	// protection against the case where a ZIP editor may have changed the
	// original filename, but retained a now-orphaned Unicode Path field.
	de_crcobj_reset(d->crco);
	de_crcobj_addslice(d->crco, c->infile, eii->dd->main_fname_pos, eii->dd->main_fname_len);
	crc_calculated = de_crcobj_getval(d->crco);
	de_dbg(c, "name-crc (calculated): 0x%08x", (UI)crc_calculated);

	if(crc_calculated == crc_reported) {
		ucstring_empty(eii->dd->fname);
		ucstring_append_ucstring(eii->dd->fname, fn);
	}

done:
	ucstring_destroy(fn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdx)
jle 0xe0347
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x8(%rdx), %rsi
callq 0xef0d5
movzbl %al, %ebp
leaq 0x5668f(%rip), %rsi     # 0x1369ba
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
cmpb $0x1, %bpl
jne 0xe034a
cmpq $0x6, 0x10(%rbx)
jge 0xe0360
xorl %r15d, %r15d
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6bb0
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rsi
incq %rsi
callq 0xef37e
movq %rax, %r13
leaq 0x63b16(%rip), %rsi     # 0x143e90
movq %r14, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
callq 0xf6870
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq $-0x5, %rdx
movq 0x18(%r14), %rdi
addq $0x5, %rsi
movq %rax, %rcx
xorl %r8d, %r8d
movl $0x2, %r9d
callq 0xf01b0
movq %r15, %rdi
callq 0xf7557
leaq 0x63ae6(%rip), %rsi     # 0x143eac
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
movq 0xb8(%r12), %rdi
callq 0xebdc3
movq 0xb8(%r12), %rdi
movq 0x18(%r14), %rsi
movq 0x28(%rbx), %rax
movq 0x38(%rax), %rdx
movq 0x40(%rax), %rcx
callq 0xebf09
movq 0xb8(%r12), %rdi
callq 0xebe2a
movl %eax, %ebp
leaq 0x63aac(%rip), %rsi     # 0x143ebf
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
cmpl %r13d, %ebp
jne 0xe034a
movq 0x28(%rbx), %rax
movq 0x48(%rax), %rdi
callq 0xf6883
movq 0x28(%rbx), %rax
movq 0x48(%rax), %rdi
movq %r15, %rsi
callq 0xf6969
jmp 0xe034a
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: ef_infozip2
static void ef_infozip2(deark *c, lctx *d, struct extra_item_info_struct *eii)
{
	i64 uidnum, gidnum;

	if(eii->is_central) return;
	if(eii->dlen<4) return;
	uidnum = de_getu16le(eii->dpos);
	gidnum = de_getu16le(eii->dpos+2);
	dbg_zip_uid_gid_num(c, uidnum, gidnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x30(%rdx)
jne 0xe045f
movq %rdx, %r14
cmpq $0x4, 0x10(%rdx)
jge 0xe0465
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0xef1ca
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x2, %rsi
callq 0xef1ca
movq %rax, %r14
leaq 0x4ba32(%rip), %rsi     # 0x12bec5
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
leaq 0x4ba26(%rip), %rsi     # 0x12becd
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe9226
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: ef_infozip3
static void ef_infozip3(deark *c, lctx *d, struct extra_item_info_struct *eii)
{
	i64 pos = eii->dpos;
	i64 uidnum, gidnum;
	u8 ver;
	i64 endpos;
	i64 sz;

	endpos = pos+eii->dlen;

	if(pos+1>endpos) return;
	ver = de_getbyte_p(&pos);
	de_dbg(c, "version: %d", (int)ver);
	if(ver!=1) return;

	if(pos+1>endpos) return;
	sz = (i64)de_getbyte_p(&pos);
	if(pos+sz>endpos) return;
	uidnum = dbuf_getint_ext(c->infile, pos, (UI)sz, 1, 0);
	pos += sz;

	if(pos+1>endpos) return;
	sz = (i64)de_getbyte_p(&pos);
	if(pos+sz>endpos) return;
	gidnum = dbuf_getint_ext(c->infile, pos, (UI)sz, 1, 0);
	pos += sz;

	dbg_zip_uid_gid_num(c, uidnum, gidnum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %r14
movq %r14, (%rsp)
movq 0x10(%rdx), %r13
testq %r13, %r13
jle 0xe05bf
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %rsi
callq 0xef14d
movzbl %al, %ebp
leaq 0x53edf(%rip), %rsi     # 0x1343d1
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
cmpb $0x1, %bpl
jne 0xe05bf
addq %r14, %r13
cmpq %r13, (%rsp)
jge 0xe05bf
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xef14d
movzbl %al, %r15d
movq (%r14), %rsi
leaq (%rsi,%r15), %rax
cmpq %r13, %rax
jg 0xe05bf
movq 0x18(%rbx), %rdi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xef6f2
addq (%rsp), %r15
movq %r15, (%rsp)
cmpq %r13, %r15
jge 0xe05bf
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0xef14d
movzbl %al, %r15d
movq (%r12), %rsi
leaq (%rsi,%r15), %rax
cmpq %r13, %rax
jg 0xe05bf
movq 0x18(%rbx), %rdi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xef6f2
movq %rax, %r12
addq %r15, (%rsp)
leaq 0x4b927(%rip), %rsi     # 0x12bec5
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe9226
leaq 0x4b91b(%rip), %rsi     # 0x12becd
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: do_decompress_attrib_data
static int do_decompress_attrib_data(deark *c, lctx *d,
	i64 dpos, i64 dlen, dbuf *outf, i64 uncmprsize, u32 crc_reported,
	int cmpr_meth, const struct cmpr_meth_info *cmi, UI flags, const char *name)
{
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	u32 crc_calculated;
	int retval = 0;

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = dpos;
	dcmpri.len = dlen;
	dcmpro.f = outf;
	dcmpro.expected_len = uncmprsize;
	dcmpro.len_known = 1;

	do_decompress_lowlevel(c, d, &dcmpri, &dcmpro, &dres, cmpr_meth, cmi, 0);
	if(dres.errcode) {
		goto done; // Could report the error, but this isn't critical data
	}

	if(flags & 0x1) {
		de_crcobj_reset(d->crco);
		de_crcobj_addslice(d->crco, outf, 0, outf->len);
		crc_calculated = de_crcobj_getval(d->crco);
		de_dbg(c, "%s crc (calculated): 0x%08x", name, (UI)crc_calculated);
		if(crc_calculated != crc_reported) goto done;
	}

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %r14
leaq 0x48(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0xfa6e0
movq 0x18(%rbx), %rax
movq %rax, (%r15)
movq %rbp, 0x8(%r15)
movq (%rsp), %rbp
movq %r12, 0x10(%r15)
movq %rbp, (%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14)
movb $0x1, 0x8(%r14)
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
leaq 0x48(%rsp), %r14
movq %r14, %r8
movl 0xe8(%rsp), %r9d
pushq $0x0
pushq 0xf8(%rsp)
callq 0xe06ec
addq $0x10, %rsp
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jne 0xe06d7
movl 0xf8(%rsp), %eax
testb $0x1, %al
je 0xe06d1
movq 0x100(%rsp), %r14
movl 0xe0(%rsp), %r15d
movq 0xb8(%r13), %rdi
callq 0xebdc3
movq 0xb8(%r13), %rdi
movq 0x18(%rbp), %rcx
xorl %r12d, %r12d
movq %rbp, %rsi
xorl %edx, %edx
callq 0xebf09
movq 0xb8(%r13), %rdi
callq 0xebe2a
movl %eax, %ebp
leaq 0x635a4(%rip), %rsi     # 0x143c61
movq %rbx, %rdi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe9226
cmpl %r15d, %ebp
jne 0xe06d7
movl $0x1, %r12d
movl %r12d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: do_decompress_lowlevel
static void do_decompress_lowlevel(deark *c, lctx *d, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres,
	int cmpr_meth, const struct cmpr_meth_info *cmi, UI bit_flags)
{
	struct compression_params cparams;

	de_zeromem(&cparams, sizeof(struct compression_params));
	cparams.cmpr_meth = cmpr_meth;
	cparams.bit_flags = bit_flags;

	if(cmi && cmi->decompressor) {
		cmi->decompressor(c, d, &cparams, dcmpri, dcmpro, dres);
		dbuf_flush(dcmpro->f);
	}
	else {
		de_internal_err_nonfatal(c, "Unsupported compression method (%d)", cmpr_meth);
		de_dfilter_set_generic_error(c, dres, NULL);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %rcx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movl 0x38(%rsp), %edx
movq $0x0, 0x8(%rsp)
movl %r9d, 0x8(%rsp)
movl %edx, 0xc(%rsp)
testq %rax, %rax
je 0xe074c
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xe074c
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %r8
movq %rbx, %r9
callq *%rax
movq (%r15), %rdi
callq 0xf0ea4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6352a(%rip), %rsi     # 0x143c7d
movq %r14, %rdi
movl %r9d, %edx
xorl %eax, %eax
callq 0xea1a2
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfa815
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: read_FILETIME
static void read_FILETIME(deark *c, lctx *d, i64 pos,
	struct de_timestamp *timestamp, const char *name)
{
	i64 t_FILETIME;
	char timestamp_buf[64];

	t_FILETIME = de_geti64le(pos);
	de_FILETIME_to_timestamp(t_FILETIME, timestamp, 0x1);
	de_dbg_timestamp_to_string(c, timestamp, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %s", name, timestamp_buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
callq 0xef536
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xead1a
movq %rsp, %r12
movl $0x40, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0xeb687
leaq 0x68627(%rip), %rsi     # 0x148dea
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xe9226
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: handle_mac_time
static void handle_mac_time(deark *c, lctx *d,
	i64 mt_raw, i64 mt_offset,
	struct de_timestamp *ts, const char *name)
{
	char timestamp_buf[64];
	de_mac_time_to_timestamp(mt_raw - mt_offset, ts);
	ts->tzcode = DE_TZCODE_UTC;
	de_dbg_timestamp_to_string(c, ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %"I64_FMT" %+"I64_FMT" (%s)", name,
		mt_raw, -mt_offset, timestamp_buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %rsi, %rdi
subq %rdx, %rdi
movq %rcx, %rsi
callq 0xeae04
movb $0x1, 0x1(%r12)
movq %rsp, %rbp
movl $0x40, %ecx
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %r8d, %r8d
callq 0xeb687
negq %r14
leaq 0x63621(%rip), %rsi     # 0x143e54
movq %r13, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0xe9226
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: read_unix_timestamp
static void read_unix_timestamp(deark *c, lctx *d, i64 pos,
	struct de_timestamp *timestamp, const char *name)
{
	i64 t;
	char timestamp_buf[64];

	t = de_geti32le(pos);
	de_unix_time_to_timestamp(t, timestamp, 0x1);
	de_dbg_timestamp_to_string(c, timestamp, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %"I64_FMT" (%s)", name, t, timestamp_buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
callq 0xef417
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xeace2
movq %rsp, %r13
movl $0x40, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
callq 0xeb687
leaq 0x362d7(%rip), %rsi     # 0x116b81
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0xe9226
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zip.c
// Function: main_walk_cdir_cb
static void main_walk_cdir_cb(deark *c, struct zip_wcd_ctx *wcdctx)
{
	lctx *d = (lctx*)wcdctx->userdata;
	struct member_data *md = NULL;
	i64 entry_size = 0;
	int ret = 0;

	md = create_member_data(c, d);
	md->central_dir_entry_data.have_read_sig_and_hdrsize = 1;
	md->central_dir_entry_data.fn_len = wcdctx->fn_len;
	md->central_dir_entry_data.extra_len = wcdctx->extra_len;
	md->central_dir_entry_data.comment_len = wcdctx->comment_len;

	ret = do_member_from_central_dir_entry(c, d, md, wcdctx->num_entries_completed,
		wcdctx->entry_pos, &entry_size);

	// TODO: Decide exactly what to do if something fails.
	if(!ret) {
		wcdctx->errflag = 1;
	}

	destroy_member_data(c, md);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
leaq 0x10(%rsp), %rax
movq %r13, (%rax)
callq 0xddda9
movq %rax, %r15
movb $0x1, 0x148(%rax)
movq 0x60(%r14), %rax
movq %rax, 0x150(%r15)
movq 0x68(%r14), %rax
movq %rax, 0x158(%r15)
movq 0x70(%r14), %rax
movq %rax, 0x160(%r15)
movl 0x40(%r14), %ebp
movq 0x50(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xe958c
leaq 0x10(%rsp), %rax
movq %r13, (%rax)
leaq 0x63b6b(%rip), %rsi     # 0x1444b2
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq %rbx, %rdi
movq %r12, %r13
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movq 0x18(%rsp), %r8
leaq 0x10(%rsp), %r9
callq 0xddde6
testl %eax, %eax
je 0xe09c3
movl %eax, %ebp
movq 0x18(%r15), %r8
leaq 0x20(%rsp), %r9
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xddde6
testl %eax, %eax
je 0xe09b1
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xde96b
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0xe9595
testl %ebp, %ebp
jne 0xe09d4
jmp 0xe09cf
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0xe9595
movb $0x1, 0x39(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdefa7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: de_module_zoo
void de_module_zoo(deark *c, struct deark_module_info *mi)
{
	mi->id = "zoo";
	mi->desc = "Zoo compressed archive format";
	mi->run_fn = de_run_zoo;
	mi->identify_fn = de_identify_zoo;
	mi->help_fn = de_help_zoo;
}

// Assembly:
leaq 0x63c11(%rip), %rax     # 0x144608
movq %rax, (%rsi)
leaq 0x63c0b(%rip), %rax     # 0x14460c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xe0a27
movq %rax, 0x18(%rsi)
leaq 0xf00(%rip), %rax       # 0xe1917
movq %rax, 0x20(%rsi)
leaq 0xf1e(%rip), %rax       # 0xe1940
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: de_module_zoo_filter
void de_module_zoo_filter(deark *c, struct deark_module_info *mi)
{
	mi->id = "zoo_filter";
	mi->desc = "Zoo filter format";
	mi->run_fn = de_run_zoo_filter;
	mi->identify_fn = de_identify_zoo_filter;
}

// Assembly:
leaq 0x62cd5(%rip), %rax     # 0x14462a
movq %rax, (%rsi)
leaq 0x62cd6(%rip), %rax     # 0x144635
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xe197a
movq %rax, 0x18(%rsi)
leaq 0x22b(%rip), %rax       # 0xe1ba0
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: de_identify_zoo_filter
static int de_identify_zoo_filter(deark *c)
{
	u8 b[2];

	if(c->infile->len<6) return 0;
	if(de_getu16le(0) != 0x5a32) return 0;

	// LZH ends with 16 0 bits, followed by 0 to 7 bits of padding that we
	// will hope are 0. So it must end with two 0x00 bytes.
	// LZD ends with the EOF code: 257. By my calculation, one of the 1 bits
	// from that code must occur in the second-to-last byte. And the last byte
	// can have at most one '1' bit.
	de_read(b, c->infile->len-4, 2);
	if(b[0]==0) {
		if(b[1]==0) return 45; // Possible LZH
	}
	else {
		if(b[1]<=0x02 || b[1]==0x04 || b[1]==0x08 || b[1]==0x10 ||
			b[1]==0x20 || b[1]==0x40 || b[1]==0x80)
		{
			return 45; // Possible LZD
		}
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0x6, 0x18(%rdi)
jl 0xe1c24
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef1ca
cmpq $0x5a32, %rax           # imm = 0x5A32
jne 0xe1c24
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rdx
addq $-0x4, %rdx
leaq 0x6(%rsp), %rbx
movl $0x2, %ecx
movq %rbx, %rsi
callq 0xeeee8
cmpb $0x0, (%rbx)
movzbl 0x1(%rbx), %eax
je 0xe1c17
movl $0x2d, %ebx
leal -0x4(%rax), %ecx
cmpl $0x3c, %ecx
ja 0xe1c09
movabsq $0x1000000010001011, %rdx # imm = 0x1000000010001011
btq %rcx, %rdx
jb 0xe1c24
cmpl $0x3, %eax
jb 0xe1c24
cmpl $0x80, %eax
je 0xe1c24
jmp 0xe1c1b
testl %eax, %eax
je 0xe1c1f
xorl %ebx, %ebx
jmp 0xe1c24
movl $0x2d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: de_module_zoo_z
void de_module_zoo_z(deark *c, struct deark_module_info *mi)
{
	mi->id = "zoo_z";
	mi->desc = "Zoo Z format";
	mi->run_fn = de_run_zoo_z;
	mi->identify_fn = de_identify_zoo_z;
}

// Assembly:
leaq 0x62a12(%rip), %rax     # 0x144647
movq %rax, (%rsi)
leaq 0x62a0e(%rip), %rax     # 0x14464d
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xe1c5a
movq %rax, 0x18(%rsi)
leaq 0x286(%rip), %rax       # 0xe1edb
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: do_comment
static void do_comment(deark *c, lctx *d, i64 pos, i64 len, const char *name,
	int is_main, int extract_to_file)
{
	on_offset_found(c, d, pos, len);
	if(len<1) return;
	if(pos<0 || pos+len>c->infile->len) return;
	if(extract_to_file) {
		do_extract_comment(c, d, pos, len, is_main);
	}
	else {
		do_dbg_comment(c, d, pos, len, name, is_main);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
sets %cl
orb %al, %cl
jne 0xe1f35
cmpq %r15, 0x40(%r13)
jle 0xe1f35
movq %r15, 0x40(%r13)
testq %r15, %r15
sets %al
testq %r14, %r14
setle %cl
orb %al, %cl
jne 0xe1f53
leaq (%r14,%r15), %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0xe1f62
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r9d, %r9d
je 0xe1fbc
leaq 0x3648d(%rip), %rsi     # 0x1183fb
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xf037a
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq (%r13), %rax
movzbl 0x18(%rax), %ecx
orl $0x300, %ecx            # imm = 0x300
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %r8
movl $0x6, %r9d
callq 0xf1f28
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf0b13
cmpl $0x0, (%rbx)
jle 0xe1f53
movq %rbx, %rdi
callq 0xf6870
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq (%r13), %rax
movzbl 0x18(%rax), %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r15, %rsi
movq %r14, %rdx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %rbp, %rdi
callq 0xf7557
leaq 0x49e3d(%rip), %rsi     # 0x12be42
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9226
movq %rbp, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6bb0
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: zoo_decompressor_fn
static void zoo_decompressor_fn(struct de_arch_member_data *md)
{
	struct zoo_member_data *mdz = (struct zoo_member_data*)md->userdata;

	switch(mdz->method) {
	case ZOOCMPR_STORED:
		fmtutil_decompress_uncompressed(md->c, md->dcmpri, md->dcmpro, md->dres, 0);
		break;
	case ZOOCMPR_LZD:
		decompress_lzd(md->c, md->dcmpri, md->dcmpro, md->dres);
		break;
	case ZOOCMPR_LZH:
		decompress_lzh(md->c, md->dcmpri, md->dcmpro, md->dres);
		break;
	}
}

// Assembly:
subq $0x18, %rsp
movq 0x88(%rdi), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2, %eax
je 0xe20b6
cmpl $0x1, %eax
je 0xe2073
testl %eax, %eax
jne 0xe20f3
movq (%rdi), %rax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
movq %rax, %rdi
xorl %r8d, %r8d
addq $0x18, %rsp
jmp 0xfaa08
movq (%rdi), %rax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x0, 0x10(%r8)
movl $0x4, (%r8)
movl $0xd, 0xc(%r8)
movq %rax, %rdi
callq 0x102cf0
jmp 0xe20f3
movq (%rdi), %rax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x5, (%r8)
movw $0x1, 0x4(%r8)
movb $0x0, 0x6(%r8)
movq %rax, %rdi
callq 0xff330
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: finish_modtime_decoding
static void finish_modtime_decoding(deark *c, lctx *d, struct de_arch_member_data *md)
{
	struct zoo_member_data *mdz = (struct zoo_member_data*)md->userdata;
	i64 timestamp_offset;
	char timestamp_buf[64];

	timestamp_offset = 0;
	if      ( mdz->timzon < 127 )  timestamp_offset = 15*60*((i64)mdz->timzon      );
	else if ( 127 < mdz->timzon )  timestamp_offset = 15*60*((i64)mdz->timzon - 256);

	de_dos_datetime_to_timestamp(&md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], (i64)mdz->datdos, (i64)mdz->timdos);
	de_timestamp_to_string(&md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "mod time: %s", timestamp_buf);
	if(mdz->timzon == 127) {
		md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY].tzcode = DE_TZCODE_LOCAL;
	}
	else {
		de_timestamp_cvt_to_utc(&md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], timestamp_offset);
		de_timestamp_to_string(&md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], timestamp_buf, sizeof(timestamp_buf), 0);
		de_dbg(c, "mod time (UTC): %s", timestamp_buf);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rsi), %r13
movzbl 0x37(%r13), %eax
cmpq $0x7e, %rax
ja 0xe2126
imulq $0x384, %rax, %r15      # imm = 0x384
jmp 0xe213d
testb %al, %al
js 0xe212f
xorl %r15d, %r15d
jmp 0xe213d
imulq $0x384, %rax, %r15      # imm = 0x384
addq $-0x38400, %r15         # imm = 0xFFFC7C00
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movl 0x20(%r13), %esi
movl 0x24(%r13), %edx
callq 0xeae33
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movq %rsp, %r12
movl $0x40, %edx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xeb4f8
leaq 0x3c914(%rip), %rsi     # 0x11ea87
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe9226
cmpb $0x7f, 0x37(%r13)
movq 0x50(%r14), %rdi
jne 0xe2191
movb $0x2, 0x19(%rdi)
jmp 0xe21cb
addq $0x18, %rdi
movq %r15, %rsi
callq 0xeb2ca
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movq %rsp, %r14
movl $0x40, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xeb4f8
leaq 0x62941(%rip), %rsi     # 0x144aff
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xe9226
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/zoo.c
// Function: calc_hdr_crc
static void calc_hdr_crc(deark *c, lctx *d, struct de_arch_member_data *md, i64 lvar)
{
	struct zoo_member_data *mdz = (struct zoo_member_data*)md->userdata;

	de_crcobj_reset(d->da->crco);
	de_crcobj_addslice(d->da->crco, c->infile, md->member_hdr_pos, 54);
	de_crcobj_addzeroes(d->da->crco, 2);
	de_crcobj_addslice(d->da->crco, c->infile, md->member_hdr_pos+56, lvar);
	mdz->crc_hdr_calculated = de_crcobj_getval(d->da->crco);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x88(%rdx), %r13
movq (%rsi), %rax
movq 0x30(%rax), %rdi
callq 0xebdc3
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x18(%r12), %rsi
movq 0x18(%r15), %rdx
movl $0x36, %ecx
callq 0xebf09
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movl $0x2, %esi
callq 0xebec6
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x18(%r12), %rsi
movq 0x18(%r15), %rdx
addq $0x38, %rdx
movq %r14, %rcx
callq 0xebf09
movq (%rbx), %rax
movq 0x30(%rax), %rdi
callq 0xebe2a
movl %eax, 0x30(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/rar.c
// Function: de_module_rar
void de_module_rar(deark *c, struct deark_module_info *mi)
{
	mi->id = "rar";
	mi->desc = "RAR archive";
	mi->run_fn = de_run_rar;
	mi->identify_fn = de_identify_rar;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0x62aad(%rip), %rax     # 0x144d18
movq %rax, (%rsi)
leaq 0x62aa7(%rip), %rax     # 0x144d1c
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0xe2294
movq %rax, 0x18(%rsi)
leaq 0x12e0(%rip), %rax      # 0xe356b
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/rar.c
// Function: rar_get_fmtver
static int rar_get_fmtver(dbuf *f, i64 pos)
{
	u8 buf[8];

	dbuf_read(f, buf, pos, sizeof(buf));
	if(!de_memcmp(buf, g_rar4_sig, 7)) {
		return 4; // ver 1.5x-4.xx
	}
	if(!de_memcmp(buf, g_rar5_sig, 8)) {
		return 5;
	}
	if(!de_memcmp(buf, g_rar_oldsig, 4)) {
		return 1; // ver < 1.50
	}
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movl $0x8, %ecx
movq %rbx, %rsi
callq 0xeeee8
movl $0x21726152, %eax       # imm = 0x21726152
xorl (%rbx), %eax
movl $0x71a21, %ecx          # imm = 0x71A21
xorl 0x3(%rbx), %ecx
orl %eax, %ecx
je 0xe35d0
movabsq $0x1071a21726152, %rax  # imm = 0x1071A21726152
cmpq %rax, 0x8(%rsp)
je 0xe35d7
xorl %eax, %eax
cmpl $0x5e7e4552, 0x8(%rsp)  # imm = 0x5E7E4552
sete %al
jmp 0xe35dc
movl $0x4, %eax
jmp 0xe35dc
movl $0x5, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/rar.c
// Function: rar_handle_noncmpr_comment
static void rar_handle_noncmpr_comment(deark *c, de_arch_lctx *d, i64 pos, i64 len,
	de_encoding enc, int is_file_comment)
{
	de_ucstring *comment = NULL;
	const char *ext;

	if(len<1) goto done;

	ext = is_file_comment?"fcomment.txt":"comment.txt";

	if(c->extract_level>=2) {
		dbuf_create_file_from_slice(c->infile, pos, len, ext,
			NULL, DE_CREATEFLAG_IS_AUX);
	}
	else {
		comment = ucstring_create(c);
		dbuf_read_to_ucstring_n(c->infile, pos, len, DE_DBG_MAX_STRLEN,
			comment, 0, DE_EXTENC_MAKE(enc, DE_ENCSUBTYPE_HYBRID));
		de_dbg(c, "%scomment: \"%s\"", (is_file_comment?"file ":""),
			ucstring_getpsz_d(comment));
	}

done:
	ucstring_destroy(comment);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0xe3637
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpl $0x2, 0x90(%rdi)
jl 0xe363b
testl %ebp, %ebp
leaq 0x34deb(%rip), %rax     # 0x1183fb
leaq 0x34de3(%rip), %rcx     # 0x1183fa
cmoveq %rax, %rcx
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
movq %r12, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xf0321
jmp 0xe36a2
xorl %ebx, %ebx
jmp 0xe36a2
movl %ecx, %r13d
movq %r14, %rdi
callq 0xf6870
movq %rax, %rbx
movq 0x18(%r14), %rdi
movzbl %r13b, %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0xf0203
testl %ebp, %ebp
leaq 0x61558(%rip), %rax     # 0x144bd0
leaq 0x61741(%rip), %r15     # 0x144dc0
cmoveq %rax, %r15
movq %rbx, %rdi
callq 0xf7557
leaq 0x6171e(%rip), %rsi     # 0x144db0
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6bb0
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/rodraw.c
// Function: de_module_rodraw
void de_module_rodraw(deark *c, struct deark_module_info *mi)
{
	mi->id = "rodraw";
	mi->desc = "RISC OS Draw, Acorn Draw";
	mi->run_fn = de_run_rodraw;
	mi->identify_fn = de_identify_rodraw;
}

// Assembly:
leaq 0x611ee(%rip), %rax     # 0x145255
movq %rax, (%rsi)
leaq 0x611eb(%rip), %rax     # 0x14525c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xe408c
movq %rax, 0x18(%rsi)
leaq 0xc5(%rip), %rax        # 0xe414c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/rodraw.c
// Function: de_run_rodraw
static void de_run_rodraw(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;

	d = de_malloc(c, sizeof(lctx));

	pos = 0;
	if(!do_header(c, d, pos)) goto done;
	pos += 40;

	if(!do_object_sequence(c, d, pos, c->infile->len-pos)) goto done;

done:
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0xc, %esi
callq 0xe969b
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x552a6(%rip), %rsi     # 0x13935e
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
addq $0x4, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef3a0
movl %eax, (%r14)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef3a0
movl %eax, 0x4(%r14)
movl (%r14), %edx
leaq 0x61177(%rip), %rsi     # 0x145275
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xe9226
addq $0x1c, (%r15)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
addq $-0x28, %rcx
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe41a3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9752
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/rodraw.c
// Function: do_object_sprite
static void do_object_sprite(deark *c, lctx *d, struct objinfo *oi)
{
	i64 dpos, dlen;
	dbuf *outf = NULL;
	de_finfo *fi = NULL;

	fi = de_finfo_create(c);

	dpos = oi->dpos;
	dlen = oi->dlen;

	if(oi->objtype==13) {
		// Skip transformation matrix
		dpos += 24;
		dlen -= 24;
	}

	if(dlen>=16) {
		// Peek at the sprite name, to use in the output filename.
		de_ucstring *s = NULL;
		s = ucstring_create(c);
		dbuf_read_to_ucstring(c->infile, dpos+4, 12, s,
			DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_RISCOS);
		de_finfo_set_name_from_ucstring(c, fi, s, 0);
		ucstring_destroy(s);
	}

	// An .acorn extension may be needed to open these files with XnView.
	outf = dbuf_create_output_file(c, "acorn", fi, 0x0);

	// Manufacture a sprite file, by adding a 12-byte header.
	dbuf_writeu32le(outf, 1); // number of sprites
	dbuf_writeu32le(outf, 12+4); // offset of sprite data (+4)
	dbuf_writeu32le(outf, 12+dlen+4); // file size (+4)
	dbuf_copy(c->infile, dpos, dlen, outf);

	dbuf_close(outf);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
callq 0xea9a9
movq %rax, %r14
movq 0x18(%r12), %rax
movq 0x20(%r12), %rcx
leaq -0x18(%rcx), %r15
cmpl $0xd, (%r12)
cmovneq %rcx, %r15
leaq 0x18(%rax), %r12
cmovneq %rax, %r12
cmpq $0x10, %r15
jl 0xe4449
movq %rbx, %rdi
callq 0xf6870
movq %rax, %r13
movq 0x18(%rbx), %rdi
leaq 0x4(%r12), %rsi
movl $0xc, %edx
movq %rax, %rcx
movl $0x1, %r8d
movl $0x14, %r9d
callq 0xf01b0
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xea9e4
movq %r13, %rdi
callq 0xf6bb0
leaq 0x60ee6(%rip), %rsi     # 0x145336
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, %r13
movl $0x1, %esi
movq %rax, %rdi
callq 0xf1645
movl $0x10, %esi
movq %r13, %rdi
callq 0xf1645
leaq 0x10(%r15), %rsi
movq %r13, %rdi
callq 0xf1645
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xefabc
movq %r13, %rdi
callq 0xf0b13
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xea9b3