LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: do_extract_member_file
static void do_extract_member_file(deark *c, lctx *d, struct member_data *md)
{
	struct advfudata u;

	ucstring_append_ucstring(md->advf->filename, md->full_fname);
	md->advf->original_filename_flag = 1;
	md->advf->snflags = DE_SNFLAG_FULLPATH;
	de_advfile_set_orig_filename(md->advf, md->fname->sz, md->fname->sz_strlen);

	// resource fork
	if(md->rfork.cmpr_len>0) {
		de_dbg(c, "rsrc fork data at %"I64_FMT", len=%"I64_FMT,
			md->rfork.cmpr_pos, md->rfork.cmpr_len);
		md->advf->rsrcfork.fork_len = md->rfork.unc_len;
		de_dbg_indent(c, 1);
		do_pre_decompress_fork(c, d, md, &md->rfork);
		de_dbg_indent(c, -1);
	}

	// data fork
	if(md->dfork.cmpr_len>0) {
		de_dbg(c, "data fork data at %"I64_FMT", len=%"I64_FMT,
			md->dfork.cmpr_pos, md->dfork.cmpr_len);
		md->advf->mainfork.fork_len = md->dfork.unc_len;
		de_dbg_indent(c, 1);
		do_pre_decompress_fork(c, d, md, &md->dfork);
		de_dbg_indent(c, -1);
	}

	u.d = d;
	u.md = md;
	md->advf->userdata = (void*)&u;
	md->advf->writefork_cbfn = my_advfile_cbfn;
	de_advfile_run(md->advf);

	if(md->advf->rsrcfork.fork_exists) {
		do_post_decompress_fork(c, d, md, &md->rfork);
	}
	if(md->advf->mainfork.fork_exists) {
		do_post_decompress_fork(c, d, md, &md->dfork);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
movq 0x18(%rdx), %rsi
movq 0x68(%rax), %rdi
callq 0xf6509
movq 0x8(%rbx), %rdi
movb $0x1, 0x79(%rdi)
movl $0x1, 0x70(%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xfc530
leaq 0xa0(%rbx), %r12
movq 0xc0(%rbx), %rcx
testq %rcx, %rcx
jle 0xd6f91
movq 0xb8(%rbx), %rdx
leaq 0x6b4d5(%rip), %rsi     # 0x142422
movq %r15, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x8(%rbx), %rax
movq 0xb0(%rbx), %rcx
movq %rcx, 0x40(%rax)
movq %r15, %rdi
movl $0x1, %esi
callq 0xe8a15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xd7807
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
leaq 0xe0(%rbx), %r13
movq 0x100(%rbx), %rcx
testq %rcx, %rcx
jle 0xd6ff6
movq 0xf8(%rbx), %rdx
leaq 0x6b48f(%rip), %rsi     # 0x142441
movq %r15, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x8(%rbx), %rax
movq 0xf0(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %r15, %rdi
movl $0x1, %esi
callq 0xe8a15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0xd7807
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq %rsp, %rax
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x8(%rbx), %rdi
movq %rax, 0x8(%rdi)
leaq 0x93e(%rip), %rax       # 0xd794d
movq %rax, 0x60(%rdi)
callq 0xfc5b7
movq 0x8(%rbx), %rax
cmpb $0x0, 0x38(%rax)
je 0xd7037
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xd7987
movq 0x8(%rbx), %rax
cmpb $0x0, 0x10(%rax)
je 0xd704e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0xd7987
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: decode_cmpr_meth
static void decode_cmpr_meth(deark *c, lctx *d, struct fork_data *fk,
	de_ucstring *s)
{
	const char *name = NULL;
	u8 cmpr = fk->cmpr_meth_etc;

	if(d->file_fmt==1 && cmpr<32 && (cmpr & 16)) {
		fk->is_encrypted = 1;
		cmpr -= 16;
	}

	if(d->file_fmt==2 || cmpr<16) {
		fk->is_a_file = 1;
		fk->cmpr_meth = cmpr;
	}

	if(fk->is_a_file) {
		fk->cmi = find_cmpr_meth_info(c, fk->cmpr_meth);
	}

	if(fk->cmi) {
		name = fk->cmi->name;
	}
	else if(d->file_fmt==1 && fk->cmpr_meth_etc==32) {
		name = "folder";
	}
	else if(d->file_fmt==1 && fk->cmpr_meth_etc==33) {
		name = "end of folder marker";
	}

	if(!name) name="?";
	ucstring_append_flags_item(s, name);
	if(d->file_fmt==1 && fk->is_encrypted) {
		ucstring_append_flags_item(s, "encrypted");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb 0x1(%rsi), %al
movl (%rdi), %ecx
cmpl $0x1, %ecx
setne %dl
movl %eax, %esi
andb $-0x10, %sil
cmpb $0x10, %sil
setne %sil
orb %dl, %sil
je 0xd70ac
cmpl $0x2, %ecx
sete %dl
cmpb $0x10, %al
setb %sil
orb %dl, %sil
movl %eax, %edx
cmpb $0x1, %sil
je 0xd70b4
cmpb $0x0, 0x2(%r14)
jne 0xd70bd
movq 0x30(%r14), %rdx
jmp 0xd70ec
movb $0x1, 0x4(%r14)
leal -0x10(%rax), %edx
movb $0x1, 0x2(%r14)
movb %dl, 0x3(%r14)
movb 0x3(%r14), %dil
xorl %edx, %edx
leaq 0xb6d36(%rip), %rsi     # 0x18de00
xorl %r8d, %r8d
cmpb %dil, (%r8,%rsi)
je 0xd70e2
addq $0x18, %r8
cmpq $0xf0, %r8
jne 0xd70cd
jmp 0xd70e8
addq %r8, %rsi
movq %rsi, %rdx
movq %rdx, 0x30(%r14)
testq %rdx, %rdx
je 0xd70f7
movq 0x8(%rdx), %rcx
jmp 0xd711c
cmpl $0x1, %ecx
je 0xd7100
xorl %ecx, %ecx
jmp 0xd711c
cmpb $0x20, %al
jne 0xd710d
leaq 0x42ece(%rip), %rcx     # 0x119fd9
jmp 0xd711c
xorl %ecx, %ecx
cmpb $0x21, %al
leaq 0x6b19a(%rip), %rax     # 0x1422b2
cmoveq %rax, %rcx
testq %rcx, %rcx
leaq 0x5502b(%rip), %rsi     # 0x12c151
cmovneq %rcx, %rsi
movq %rbx, %rdi
callq 0xf7105
cmpl $0x1, (%r15)
jne 0xd7153
cmpb $0x0, 0x4(%r14)
je 0xd7153
leaq 0x6b181(%rip), %rsi     # 0x1422c7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf7105
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: do_pre_decompress_fork
static void do_pre_decompress_fork(deark *c, lctx *d, struct member_data *md,
	struct fork_data *frk)
{
	struct de_advfile_forkinfo *advfki;
	int ok = 0;

	if(frk->is_rsrc_fork) {
		advfki = &md->advf->rsrcfork;
	}
	else {
		advfki = &md->advf->mainfork;
	}

	if(!frk->is_a_file) {
		goto done;
	}

	// TODO: What is the correct way to determine the nonexistence of a fork?
	if(frk->unc_len==0 && frk->cmpr_len==0) {
		goto done;
	}

	if(frk->cmpr_pos + frk->cmpr_len > c->infile->len) {
		de_err(c, "Unexpected end of file");
		goto done;
	}

	de_dbg(c, "cmpr method: %u (%s)", (unsigned int)frk->cmpr_meth,
		frk->cmi?frk->cmi->name:"?");

	if(!frk->cmi) {
		de_err(c, "Unknown compression method: %u", (unsigned int)frk->cmpr_meth);
		goto done;
	}

	if(!frk->cmi->decompressor) {
		de_err(c, "%s[%s fork]: Unsupported compression method: %u (%s)",
			ucstring_getpsz_d(md->full_fname), frk->forkname,
			(unsigned int)frk->cmpr_meth, frk->cmi->name);
		goto done;
	}

	if(frk->is_encrypted) {
		de_err(c, "Encrypted files are not supported");
		goto done;
	}

	ok = 1;

	advfki->writelistener_cb = de_writelistener_for_crc;
	if(frk->is_rsrc_fork) {
		advfki->userdata_for_writelistener = (void*)d->crco_rfork;
		de_crcobj_reset(d->crco_rfork);
	}
	else {
		advfki->userdata_for_writelistener = (void*)d->crco_dfork;
		de_crcobj_reset(d->crco_dfork);
	}

done:
	advfki->fork_exists = (ok)?1:0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rcx)
movq 0x8(%rdx), %r13
movl $0x10, %eax
movl $0x38, %ebp
cmoveq %rax, %rbp
cmpb $0x0, 0x2(%rcx)
je 0xd783d
movq %rcx, %r14
movq 0x20(%rcx), %rax
movq 0x10(%rcx), %rcx
orq %rax, %rcx
jne 0xd7845
xorl %r14d, %r14d
jmp 0xd7939
movq %rdi, %rbx
addq 0x18(%r14), %rax
movq 0x18(%rdi), %rcx
cmpq 0x18(%rcx), %rax
jle 0xd786f
leaq 0x3b4b7(%rip), %rsi     # 0x112d14
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xd7939
movq %rdx, %r12
movq %rsi, %r15
movzbl 0x3(%r14), %edx
movq 0x30(%r14), %rax
testq %rax, %rax
je 0xd7889
movq 0x8(%rax), %rcx
jmp 0xd7890
leaq 0x548c1(%rip), %rcx     # 0x12c151
leaq 0x5114d(%rip), %rsi     # 0x1289e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x30(%r14), %rax
testq %rax, %rax
je 0xd78c1
cmpq $0x0, 0x10(%rax)
je 0xd78dc
cmpb $0x0, 0x4(%r14)
je 0xd7910
leaq 0x73632(%rip), %rsi     # 0x14aef1
jmp 0xd785d
movzbl 0x3(%r14), %edx
leaq 0x6ab93(%rip), %rsi     # 0x142460
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xd7939
movq 0x18(%r12), %rdi
callq 0xf70f6
movzbl 0x3(%r14), %r8d
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdx
movq 0x8(%rdx), %r9
leaq 0x6ab81(%rip), %rsi     # 0x14247f
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9295
jmp 0xd7939
leaq 0x19b3a(%rip), %rax     # 0xf1451
movq %rax, 0x20(%r13,%rbp)
cmpb $0x0, (%r14)
je 0xd7928
movq 0x28(%r15), %rdi
jmp 0xd792c
movq 0x30(%r15), %rdi
movq %rdi, 0x18(%r13,%rbp)
callq 0xeb7fe
movb $0x1, %r14b
movb %r14b, (%r13,%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: do_post_decompress_fork
static void do_post_decompress_fork(deark *c, lctx *d, struct member_data *md,
	struct fork_data *frk)
{
	u32 crc_calc;

	if(!frk->decompress_succeeded) goto done;

	if(frk->is_rsrc_fork) {
		crc_calc = de_crcobj_getval(d->crco_rfork);
	}
	else {
		crc_calc = de_crcobj_getval(d->crco_dfork);
	}
	de_dbg(c, "%s crc (calculated): 0x%04x", frk->forkname, (unsigned int)crc_calc);
	if(crc_calc != frk->crc_reported) {
		de_err(c, "CRC check failed for file %s[%s fork]", ucstring_getpsz_d(md->full_fname),
			frk->forkname);
	}
done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x38(%rcx)
je 0xd79ce
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorl %eax, %eax
cmpb $0x0, (%rcx)
sete %al
movq 0x28(%rsi,%rax,8), %rdi
callq 0xeb865
movl %eax, %ebp
movq 0x28(%r14), %rdx
leaq 0x57f30(%rip), %rsi     # 0x12f8ec
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xe8617
cmpl 0x8(%r14), %ebp
jne 0xd79d9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r15), %rdi
callq 0xf70f6
movq 0x28(%r14), %rcx
leaq 0x6aac7(%rip), %rsi     # 0x1424b4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe9295
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/stuffit.c
// Function: do_main_decompress_fork
static void do_main_decompress_fork(deark *c, lctx *d, struct member_data *md,
	struct fork_data *frk, dbuf *outf)
{
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);
	if(!frk || !frk->cmi || !frk->cmi->decompressor) {
		goto done;
	}

	de_dbg(c, "decompressing %s fork", frk->forkname);
	de_dbg_indent(c, 1);

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = frk->cmpr_pos;
	dcmpri.len = frk->cmpr_len;
	dcmpro.f = outf;
	dcmpro.len_known = 1;
	dcmpro.expected_len = frk->unc_len;
	frk->cmi->decompressor(c, &dcmpri, &dcmpro, &dres);
	dbuf_flush(dcmpro.f);
	if(dres.errcode) {
		de_err(c, "Decompression failed for file %s[%s fork]: %s", ucstring_getpsz_d(md->full_fname),
			frk->forkname, de_dfilter_get_errmsg(c, &dres));
		goto done;
	}
	frk->decompress_succeeded = 1;

done:
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
callq 0xe8a1c
testq %r14, %r14
je 0xd7b16
movq 0x30(%r14), %rax
testq %rax, %rax
je 0xd7b16
cmpq $0x0, 0x10(%rax)
je 0xd7b16
movq 0x28(%r14), %rdx
leaq 0x3d18b(%rip), %rsi     # 0x114be2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
leaq 0x88(%rsp), %r13
leaq 0x70(%rsp), %rbp
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xfa1dc
movq 0x18(%rbx), %rax
movq %rax, (%r13)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x8(%r13)
movq %r12, (%rbp)
movb $0x1, 0x8(%rbp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbp)
movq 0x30(%r14), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
leaq 0x10(%rsp), %rcx
callq *0x10(%rax)
movq (%rbp), %rdi
callq 0xf08ba
leaq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0xd7b11
movq 0x18(%r15), %rdi
callq 0xf70f6
movq %rax, %r15
movq 0x28(%r14), %r14
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa1a4
leaq 0x3d11d(%rip), %rsi     # 0x114c19
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xe9295
jmp 0xd7b16
movb $0x1, 0x38(%r14)
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0xe8a25
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/sis.c
// Function: de_module_sis
void de_module_sis(deark *c, struct deark_module_info *mi)
{
	mi->id = "sis";
	mi->desc = "SIS (EPOC/Symbian installation archive)";
	mi->run_fn = de_run_sis;
	mi->identify_fn = de_identify_sis;
}

// Assembly:
leaq 0x4bcd5(%rip), %rax     # 0x124390
movq %rax, (%rsi)
leaq 0x6a0b2(%rip), %rax     # 0x142777
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd86e0
movq %rax, 0x18(%rsi)
leaq 0x1049(%rip), %rax      # 0xd9724
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/sis.c
// Function: de_identify_sis
static int de_identify_sis(deark *c)
{
	if(!dbuf_memcmp(c->infile, 8, "\x19\x04\x00\x10", 4)) {
		if(!dbuf_memcmp(c->infile, 4, "\x6d\x00\x00\x10", 4))
			return 100;
		if(!dbuf_memcmp(c->infile, 4, "\x12\x3a\x00\x10", 4))
			return 100;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x695b3(%rip), %rdx     # 0x142ce8
movl $0x8, %esi
movl $0x4, %ecx
callq 0xefc85
testl %eax, %eax
je 0xd9753
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rdi
leaq 0x6958f(%rip), %rdx     # 0x142ced
movl $0x4, %esi
movl $0x4, %ecx
callq 0xefc85
movl $0x64, %ebp
testl %eax, %eax
je 0xd974a
movq 0x18(%rbx), %rdi
leaq 0x69571(%rip), %rdx     # 0x142cf2
movl $0x4, %esi
movl $0x4, %ecx
callq 0xefc85
testl %eax, %eax
jne 0xd9748
jmp 0xd974a
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/sauce.c
// Function: de_module_sauce
void de_module_sauce(deark *c, struct deark_module_info *mi)
{
	mi->id = "sauce";
	mi->desc = "SAUCE metadata";
	mi->run_fn = de_run_sauce;
	mi->identify_fn = de_identify_sauce;
	mi->flags |= DE_MODFLAG_HIDDEN | DE_MODFLAG_SHAREDDETECTION;
}

// Assembly:
leaq 0x69599(%rip), %rax     # 0x142d74
movq %rax, (%rsi)
leaq 0x69595(%rip), %rax     # 0x142d7a
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0xd9804
movq %rax, 0x18(%rsi)
leaq 0x118(%rip), %rax       # 0xd9913
movq %rax, 0x20(%rsi)
orb $0x11, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/sauce.c
// Function: de_run_sauce
static void de_run_sauce(deark *c, de_module_params *mparams)
{
	if(c->module_disposition==DE_MODDISP_INTERNAL) {
		run_sauce_as_submodule(c, mparams);
	}
	else {
		run_sauce_direct(c, mparams);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x3, 0x24(%rdi)
jne 0xd9833
testq %rsi, %rsi
je 0xd98b3
movq 0x68(%rsi), %rdx
testq %rdx, %rdx
je 0xd98b3
xorl %r14d, %r14d
jmp 0xd98c1
movq 0x18(%rbx), %rsi
leaq 0xd(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
movl $0x1, %ecx
callq 0xf7f3d
cmpb $0x0, (%r14)
je 0xd98e0
movq %rbx, %rdi
callq 0xf8028
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd9938
movl %eax, %ebp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
testl %ebp, %ebp
je 0xd98ff
cmpl $0x1, 0x24(%rbx)
jne 0xd98ff
movzbl 0x38(%r14), %edx
movzbl 0x39(%r14), %ecx
leaq 0x696e5(%rip), %rsi     # 0x142f8c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xd98ff
movq %rbx, %rdi
callq 0xf8028
movq %rax, %r14
movq %rax, %rdx
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xd9938
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xf8032
cmpl $0x2, 0x24(%rbx)
jne 0xd98fc
leaq 0x69689(%rip), %rsi     # 0x142f76
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xd98ff
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf8032
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_module_base16
void de_module_base16(deark *c, struct deark_module_info *mi)
{
	mi->id = "base16";
	mi->id_alias[0] = "hex";
	mi->desc = "Base16";
	mi->run_fn = de_run_base16;
}

// Assembly:
leaq 0x68cc1(%rip), %rax     # 0x143004
movq %rax, (%rsi)
leaq 0x6b4d7(%rip), %rax     # 0x145824
movq %rax, 0x38(%rsi)
leaq 0x68cb3(%rip), %rax     # 0x14300b
movq %rax, 0x8(%rsi)
leaq 0x5(%rip), %rax         # 0xda368
movq %rax, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_run_base64
static void de_run_base64(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	dbuf *f = NULL;

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

	f = dbuf_create_output_file(c, "bin", NULL, 0);
	do_base64_internal(c, d, 0, f);

	dbuf_close(f);
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x38, %esi
callq 0xe8b2b
movq %rax, %r14
leaq 0x5b3d7(%rip), %rsi     # 0x1357bd
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xdab62
movq %r15, %rdi
callq 0xf052b
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_module_uuencode
void de_module_uuencode(deark *c, struct deark_module_info *mi)
{
	mi->id = "uuencode";
	mi->desc = "UUEncode";
	mi->run_fn = de_run_uuencode;
	mi->identify_fn = de_identify_uuencode;
}

// Assembly:
leaq 0x68bfc(%rip), %rax     # 0x143020
movq %rax, (%rsi)
leaq 0x68bfb(%rip), %rax     # 0x143029
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xda449
movq %rax, 0x18(%rsi)
leaq 0x110(%rip), %rax       # 0xda554
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_run_uuencode
static void de_run_uuencode(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	dbuf *f = NULL;
	struct uu_hdr_parser *uuhp = NULL;
	int ret;

	uuhp = de_malloc(c, sizeof(struct uu_hdr_parser));
	d = de_malloc(c, sizeof(lctx));

	d->fi = de_finfo_create(c);
	ret = uuencode_read_header(c, uuhp, d->fi, 0);
	if(!ret) goto done;

	if(uuhp->hdr_line_type==HDR_UUENCODE_BASE64) {
		de_declare_fmt(c, "Base64 with uuencode wrapper");
		d->data_fmt = FMT_BASE64;
		f = dbuf_create_output_file(c, NULL, d->fi, 0);
		do_base64_internal(c, d, uuhp->data_startpos, f);
	}
	else {
		de_declare_fmt(c, "Uuencoded");
		d->data_fmt = FMT_UUENCODE;
		f = dbuf_create_output_file(c, NULL, d->fi, 0);
		do_uudecode_internal(c, d, uuhp, f);
	}

done:
	dbuf_close(f);
	if(uuhp) {
		de_free(c, uuhp);
	}
	if(d) {
		de_finfo_destroy(c, d->fi);
		de_free(c, d);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %esi
callq 0xe8b2b
movq %rax, %r15
movl $0x38, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r14
movq %rbx, %rdi
callq 0xea504
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xdad78
testl %eax, %eax
je 0xda4d5
cmpl $0xc, (%r15)
jne 0xda4e3
leaq 0x68bfe(%rip), %rsi     # 0x14309c
movq %rbx, %rdi
callq 0xeb125
movl $0x1, 0xc(%r14)
movq 0x30(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r12
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0xdab62
jmp 0xda51f
xorl %edi, %edi
callq 0xf052b
testq %r15, %r15
jne 0xda527
jmp 0xda532
leaq 0x68bcf(%rip), %rsi     # 0x1430b9
movq %rbx, %rdi
callq 0xeb125
movl $0x2, 0xc(%r14)
movq 0x30(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r12
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0xdaf21
movq %r12, %rdi
callq 0xf052b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0xea50e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_identify_uuencode
static int de_identify_uuencode(deark *c)
{
	u8 b[17];
	i64 pos;
	int retval = 0;
	struct uu_hdr_parser *uuhp;

	pos = bom_length(c);
	de_read(b, pos, sizeof(b));

	if(!de_memcmp(b, "begin-base64 ", 13)) {
		return 100;
	}
	if(!de_memcmp(b, "begin ", 6)) {
		if(b[9]==' ' && de_is_digit_string(&b[6], 3)) {
			// This needs to be lower than XXEncode.
			return 85;
		}
	}

	if(!de_input_file_has_ext(c, "uue") &&
		!de_input_file_has_ext(c, "uu"))
	{
		return 0;
	}

	// For some extensions, do detection the slow way.
	uuhp = de_malloc(c, sizeof(struct uu_hdr_parser));
	uuencode_read_header(c, uuhp, NULL, 1);
	if(uuhp->hdr_line_type==HDR_UUENCODE_OR_XXENCODE) {
		retval = 19;
	}
	else if(uuhp->hdr_line_type==HDR_UUENCODE_BASE64) {
		retval = 19;
	}
	de_free(c, uuhp);

	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xf170a
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq (%rcx,%rcx,2), %rdx
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movl $0x11, %ecx
movq %r14, %rsi
callq 0xee8d4
movabsq $0x61622d6e69676562, %rax # imm = 0x61622D6E69676562
xorq (%r14), %rax
movabsq $0x203436657361622d, %rcx # imm = 0x203436657361622D
xorq 0x5(%r14), %rcx
orq %rax, %rcx
je 0xda656
movl $0x69676562, %eax       # imm = 0x69676562
xorl (%rsp), %eax
movzwl 0x4(%rsp), %ecx
xorl $0x206e, %ecx           # imm = 0x206E
orl %eax, %ecx
jne 0xda5ec
cmpb $0x20, 0x9(%rsp)
jne 0xda5ec
movq $-0x3, %rax
movb 0x9(%rsp,%rax), %cl
addb $-0x3a, %cl
cmpb $-0xb, %cl
jbe 0xda5ec
incq %rax
jne 0xda5d4
movl $0x55, %ebp
jmp 0xda65b
leaq 0x68b6d(%rip), %rsi     # 0x143160
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
jne 0xda612
leaq 0x68b5e(%rip), %rsi     # 0x143164
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
je 0xda668
movl $0x20, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xdad78
movl (%r14), %eax
addl $-0xb, %eax
cmpl $0x2, %eax
movl $0x13, %ebp
cmovael %r15d, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
jmp 0xda65b
movl $0x64, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xda65b
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_module_xxencode
void de_module_xxencode(deark *c, struct deark_module_info *mi)
{
	mi->id = "xxencode";
	mi->desc = "XXEncode";
	mi->run_fn = de_run_xxencode;
	mi->identify_fn = de_identify_xxencode;
}

// Assembly:
leaq 0x689bf(%rip), %rax     # 0x143032
movq %rax, (%rsi)
leaq 0x689be(%rip), %rax     # 0x14303b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xda698
movq %rax, 0x18(%rsi)
leaq 0xd7(%rip), %rax        # 0xda76a
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_run_xxencode
static void de_run_xxencode(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	dbuf *f = NULL;
	struct uu_hdr_parser *uuhp = NULL;
	int ret;

	uuhp = de_malloc(c, sizeof(struct uu_hdr_parser));
	d = de_malloc(c, sizeof(lctx));

	d->fi = de_finfo_create(c);
	ret = uuencode_read_header(c, uuhp, d->fi, 0);
	if(!ret) goto done;
	if(uuhp->hdr_line_type!=HDR_UUENCODE_OR_XXENCODE) goto done;

	de_declare_fmt(c, "XXEncoded");
	f = dbuf_create_output_file(c, NULL, d->fi, 0);
	d->data_fmt = FMT_XXENCODE;
	do_uudecode_internal(c, d, uuhp, f);

done:
	dbuf_close(f);
	if(uuhp) {
		de_free(c, uuhp);
	}
	if(d) {
		de_finfo_destroy(c, d->fi);
		de_free(c, d);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %esi
callq 0xe8b2b
movq %rax, %r15
movl $0x38, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r14
movq %rbx, %rdi
callq 0xea504
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xdad78
testl %eax, %eax
je 0xda724
cmpl $0xb, (%r15)
jne 0xda732
leaq 0x68a7a(%rip), %rsi     # 0x143167
movq %rbx, %rdi
callq 0xeb125
movq 0x30(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r12
movl $0x3, 0xc(%r14)
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0xdaf21
jmp 0xda735
xorl %edi, %edi
callq 0xf052b
testq %r15, %r15
jne 0xda73d
jmp 0xda748
xorl %r12d, %r12d
movq %r12, %rdi
callq 0xf052b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0xea50e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_identify_xxencode
static int de_identify_xxencode(deark *c)
{
	int retval = 0;
	struct uu_hdr_parser *uuhp;

	// XXEncode is hard to distinguish from UUEncode, so we rely on the
	// filename.
	if(!de_input_file_has_ext(c, "xxe") &&
		!de_input_file_has_ext(c, "xx"))
	{
		return 0;
	}

	uuhp = de_malloc(c, sizeof(struct uu_hdr_parser));
	uuencode_read_header(c, uuhp, NULL, 1);
	if(uuhp->hdr_line_type==HDR_UUENCODE_OR_XXENCODE) {
		retval = (uuhp->hdr_line_startpos<=3) ? 90 : 20;
	}
	de_free(c, uuhp);

	return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x689f8(%rip), %rsi     # 0x143171
callq 0xea491
testl %eax, %eax
jne 0xda795
leaq 0x689ec(%rip), %rsi     # 0x143175
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
je 0xda7e8
movl $0x20, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xdad78
cmpl $0xb, (%r15)
jne 0xda7d4
cmpq $0x4, 0x8(%r15)
movl $0x5a, %eax
movl $0x14, %r14d
cmovll %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %r14d, %r14d
jmp 0xda7df
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: de_module_ascii85
void de_module_ascii85(deark *c, struct deark_module_info *mi)
{
	mi->id = "ascii85";
	mi->desc = "Ascii85";
	mi->run_fn = de_run_ascii85;
	mi->identify_fn = de_identify_ascii85;
}

// Assembly:
leaq 0x68850(%rip), %rax     # 0x143044
movq %rax, (%rsi)
leaq 0x6884e(%rip), %rax     # 0x14304c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xda819
movq %rax, 0x18(%rsi)
leaq 0x32e(%rip), %rax       # 0xdab42
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: do_base64_internal
static void do_base64_internal(deark *c, lctx *d, i64 pos, dbuf *outf)
{
	u8 b;
	int found_terminator = 0;
	int bad_warned = 0;

	d->cbuf_count = 0;
	while(pos<c->infile->len) {
		b = de_getbyte(pos++);
		if(b>='A' && b<='Z') {
			d->cbuf[d->cbuf_count++] = b-65;
		}
		else if(b>='a' && b<='z') {
			d->cbuf[d->cbuf_count++] = b-71;
		}
		else if(b>='0' && b<='9') {
			d->cbuf[d->cbuf_count++] = b+4;
		}
		else if(b=='+') {
			d->cbuf[d->cbuf_count++] = 62;
		}
		else if(b=='/') {
			d->cbuf[d->cbuf_count++] = 63;
		}
		else if(b=='=') {
			found_terminator = 1;
			break;
		}
		else if(b==9 || b==10 || b==13 || b==32) {
			; // ignore whitespace
		}
		else {
			if(!bad_warned) {
				de_warn(c, "Bad Base64 character(s) found (offset %d)", (int)pos);
				bad_warned = 1;
			}
		}

		if(d->cbuf_count>=4) {
			do_base64_flush(c, d, outf, 3);
		}
	}

	if(d->cbuf_count>0) {
		if(!found_terminator || d->cbuf_count==1) {
			de_warn(c, "Unexpected end of Base64 data");
		}
		do_base64_flush(c, d, outf, 3);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x0, (%rsi)
movq 0x18(%rdi), %rdi
cmpq %rdx, 0x18(%rdi)
jle 0xdacaf
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movabsq $0x100002600, %rbp      # imm = 0x100002600
xorl %r13d, %r13d
movq %r12, %rsi
callq 0xeead3
leal -0x41(%rax), %edx
cmpb $0x19, %dl
ja 0xdabba
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movb %dl, 0x4(%r14,%rax)
jmp 0xdabde
leal -0x61(%rax), %ecx
cmpb $0x19, %cl
ja 0xdabc6
addb $-0x47, %al
jmp 0xdabd0
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xdac02
addb $0x4, %al
movl (%r14), %edx
leal 0x1(%rdx), %ecx
movl %ecx, (%r14)
movb %al, 0x4(%r14,%rdx)
cmpl $0x4, %ecx
jb 0xdabf3
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdacc2
incq %r12
movq 0x18(%r15), %rdi
cmpq 0x18(%rdi), %r12
jl 0xdab9a
jmp 0xdac6e
cmpb $0x2b, %al
je 0xdac3f
movzbl %al, %ecx
cmpl $0x2f, %ecx
je 0xdac2e
cmpl $0x3d, %ecx
je 0xdacbe
testl %r13d, %r13d
jne 0xdac29
cmpb $0x20, %al
ja 0xdac50
xorl %r13d, %r13d
btq %rcx, %rbp
jae 0xdac50
movl (%r14), %ecx
jmp 0xdabde
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movb $0x3f, 0x4(%r14,%rax)
jmp 0xdabde
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movb $0x3e, 0x4(%r14,%rax)
jmp 0xdabde
leal 0x1(%r12), %edx
movq %r15, %rdi
leaq 0x683f5(%rip), %rsi     # 0x143054
xorl %eax, %eax
callq 0xe8faa
movl $0x1, %r13d
jmp 0xdac29
movb $0x1, %al
movl (%r14), %ecx
testl %ecx, %ecx
je 0xdacaf
cmpl $0x1, %ecx
setne %cl
notb %al
testb %cl, %al
jne 0xdac94
leaq 0x683f4(%rip), %rsi     # 0x14307e
movq %r15, %rdi
xorl %eax, %eax
callq 0xe8faa
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdacc2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xdac70
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: do_base64_flush
static i64 do_base64_flush(deark *c, lctx *d, dbuf *f, i64 max_to_write)
{
	i64 bytes_written = 0;

	if(d->cbuf_count>=2 && bytes_written<max_to_write) {
		dbuf_writebyte(f, (u8)((d->cbuf[0]<<2)|(d->cbuf[1]>>4)));
		bytes_written++;
	}
	if(d->cbuf_count>=3 && bytes_written<max_to_write) {
		dbuf_writebyte(f, (u8)((d->cbuf[1]<<4)|(d->cbuf[2]>>2)));
		bytes_written++;
	}
	if(d->cbuf_count>=4 && bytes_written<max_to_write) {
		dbuf_writebyte(f, (u8)((d->cbuf[2]<<6)|d->cbuf[3]));
		bytes_written++;
	}
	d->cbuf_count=0;
	return bytes_written;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
setb %cl
testq %rdx, %rdx
setle %dl
orb %cl, %dl
jne 0xdad08
movb 0x4(%rbx), %al
movb 0x5(%rbx), %cl
shlb $0x2, %al
shrb $0x4, %cl
orb %al, %cl
movzbl %cl, %esi
movq %r14, %rdi
callq 0xf0bd6
movl (%rbx), %eax
movl $0x1, %r12d
jmp 0xdad0b
xorl %r12d, %r12d
cmpl $0x3, %eax
setb %cl
cmpq %r15, %r12
setge %dl
orb %cl, %dl
jne 0xdad39
movb 0x5(%rbx), %al
movb 0x6(%rbx), %cl
shlb $0x4, %al
shrb $0x2, %cl
orb %al, %cl
movzbl %cl, %esi
movq %r14, %rdi
callq 0xf0bd6
incq %r12
movl (%rbx), %eax
cmpl $0x4, %eax
setae %al
cmpq %r15, %r12
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xdad63
movb 0x6(%rbx), %al
shlb $0x6, %al
orb 0x7(%rbx), %al
movzbl %al, %esi
movq %r14, %rdi
callq 0xf0bd6
incq %r12
movl $0x0, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: parse_begin_line
static void parse_begin_line(deark *c,
	struct uu_hdr_parser *uuhp, de_finfo *fi, const u8 *buf, i64 buf_len)
{
	i64 beginsize;
	de_ucstring *fn = NULL;
	i64 mode;
	size_t nbytes_to_copy;
	char tmpbuf[32];

	if(!fi) goto done;

	if(uuhp->hdr_line_type==HDR_UUENCODE_OR_XXENCODE) {
		beginsize = 5; // "begin" has 5 letters
	}
	else if(uuhp->hdr_line_type==HDR_UUENCODE_BASE64) {
		beginsize = 12; // "begin-base64"
	}
	else {
		goto done;
	}

	if(buf_len<beginsize+6 || buf[beginsize]!=' ' || buf[beginsize+4]!=' ') {
		goto done;
	}

	// Make a NUL-terminated copy of the file permissions mode.
	nbytes_to_copy = (size_t)(buf_len - (beginsize+1));
	if(nbytes_to_copy>sizeof(tmpbuf)) nbytes_to_copy = sizeof(tmpbuf);
	de_strlcpy(tmpbuf, (const char*)&buf[beginsize+1], nbytes_to_copy);
	mode = de_strtoll(tmpbuf, NULL, 8);
	de_dbg(c, "mode: %03o", (unsigned int)mode);
	if((mode & 0111)!=0) {
		fi->mode_flags |= DE_MODEFLAG_EXE;
	}
	else {
		fi->mode_flags |= DE_MODEFLAG_NONEXE;
	}

	fn = ucstring_create(c);
	ucstring_append_bytes(fn, &buf[beginsize+5], buf_len-(beginsize+5), 0, DE_ENCODING_ASCII);
	de_dbg(c, "filename: \"%s\"", ucstring_getpsz_d(fn));
	de_finfo_set_name_from_ucstring(c, fi, fn, 0);
	fi->original_filename_flag = 1;

done:
	ucstring_destroy(fn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0xb, %esi
je 0xdb138
cmpl $0xc, %esi
jne 0xdb222
movl $0xc, %ebp
jmp 0xdb13d
movl $0x5, %ebp
leaq 0x6(%rbp), %rax
cmpq %r15, %rax
jg 0xdb222
cmpb $0x20, (%r12,%rbp)
jne 0xdb222
cmpb $0x20, 0x4(%r12,%rbp)
jne 0xdb222
leaq 0x1(%rbp), %rax
movq %r15, %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
movl $0x20, %edx
cmovbq %rcx, %rdx
leaq (%r12,%rbp), %rsi
incq %rsi
movq %rsp, %r13
movq %r13, %rdi
callq 0xe8219
movq %r13, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10937d
movq %rax, %r13
leaq 0x67f4e(%rip), %rsi     # 0x1430f1
movq %r14, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xe8617
andl $0x49, %r13d
cmpq $0x1, %r13
movl $0x2, %eax
sbbl $0x0, %eax
orl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0xf6410
movq %rax, %r13
leaq (%r12,%rbp), %rsi
addq $0x5, %rsi
addq $0x5, %rbp
subq %rbp, %r15
movq %rax, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xf6cdd
movq %r13, %rdi
callq 0xf70f6
leaq 0x60b4f(%rip), %rsi     # 0x13bd4e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xea53f
movb $0x1, 0x8(%rbx)
jmp 0xdb225
xorl %r13d, %r13d
movq %r13, %rdi
callq 0xf6753
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: get_uu_byte_value
static int get_uu_byte_value(deark *c, lctx *d, u8 b, u8 *val)
{
	if(d->data_fmt==FMT_XXENCODE) {
		if(b>='0' && b<='9') *val = b-46;
		else if(b>='A' && b<='Z') *val = b-53;
		else if(b>='a' && b<='z') *val = b-59;
		else if(b=='+') *val = 0;
		else if(b=='-') *val = 1;
		else {
			*val = 0;
			return 0;
		}
		return 1;
	}

	// Standard UUEncoding
	if(b>=32 && b<=96) {
		*val = (b-32)%64;
		return 1;
	}
	*val = 0;
	return 0;
}

// Assembly:
cmpl $0x3, %edi
jne 0xdb24e
leal -0x30(%rsi), %eax
cmpb $0x9, %al
ja 0xdb268
addb $-0x2e, %sil
jmp 0xdb280
leal -0x20(%rsi), %edi
xorl %ecx, %ecx
movl $0x0, %eax
cmpb $0x40, %dil
ja 0xdb287
andb $0x3f, %sil
xorb $0x20, %sil
jmp 0xdb280
leal -0x41(%rsi), %eax
cmpb $0x19, %al
ja 0xdb275
addb $-0x35, %sil
jmp 0xdb280
leal -0x61(%rsi), %eax
cmpb $0x19, %al
ja 0xdb28a
addb $-0x3b, %sil
movl $0x1, %eax
movl %esi, %ecx
movb %cl, (%rdx)
retq
movl $0x1, %eax
cmpb $0x2b, %sil
je 0xdb2a2
movzbl %sil, %ecx
cmpl $0x2d, %ecx
jne 0xdb2a6
movb $0x1, %cl
jmp 0xdb287
xorl %ecx, %ecx
jmp 0xdb287
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0xdb287
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: ascii85_detect_fmt
static int ascii85_detect_fmt(deark *c)
{
	u8 buf[11];

	de_read(buf, 0, 11);

	if(!de_memcmp(buf, "xbtoa Begin", 11)) {
		return ASCII85_FMT_BTOA_OLD;
	}
	else if(!dbuf_memcmp(c->infile, 0, "xbtoa5 ", 7)) {
		return ASCII85_FMT_BTOA_NEW;
	}
	else if(!dbuf_memcmp(c->infile, 0, "<~", 2)) {
		return ASCII85_FMT_STANDARD;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xd(%rsp), %r14
movl $0xb, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movabsq $0x654220616f746278, %rax # imm = 0x654220616F746278
xorq (%r14), %rax
movabsq $0x6e6967654220616f, %rcx # imm = 0x6E6967654220616F
xorq 0x3(%r14), %rcx
orq %rax, %rcx
je 0xdb330
movq 0x18(%rbx), %rdi
leaq 0x67ea2(%rip), %rdx     # 0x14319b
xorl %r14d, %r14d
movl $0x7, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
je 0xdb337
movq 0x18(%rbx), %rdi
leaq 0x67e8c(%rip), %rdx     # 0x1431a3
movl $0x2, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
movl $0x17, %eax
cmovnel %r14d, %eax
jmp 0xdb33c
movl $0x15, %eax
jmp 0xdb33c
movl $0x16, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: do_ascii85_flush
static void do_ascii85_flush(deark *c, lctx *d, dbuf *f)
{
	i64 i;
	u32 code;

	if(d->cbuf_count<1) return;

	code = (u32)d->cbuf[0];
	for(i=1; i<5; i++) {
		if(i<d->cbuf_count)
			code = code*85 + (u32)d->cbuf[i];
		else
			code = code*85 + 84; // (This shouldn't happen with btoa format)
	}

	// TODO: Simplify this code
	if(d->cbuf_count>=2) {
		dbuf_writebyte(f, (u8)((code>>24)&0xff));
		d->bytes_written++;
		if(d->output_filesize_known && d->bytes_written>=d->output_filesize) goto done;
	}
	if(d->cbuf_count>=3) {
		dbuf_writebyte(f, (u8)((code>>16)&0xff));
		d->bytes_written++;
		if(d->output_filesize_known && d->bytes_written>=d->output_filesize) goto done;
	}
	if(d->cbuf_count>=4) {
		dbuf_writebyte(f, (u8)((code>>8)&0xff));
		d->bytes_written++;
		if(d->output_filesize_known && d->bytes_written>=d->output_filesize) goto done;
	}
	if(d->cbuf_count>=5) {
		dbuf_writebyte(f, (u8)(code&0xff));
		d->bytes_written++;
		if(d->output_filesize_known && d->bytes_written>=d->output_filesize) goto done;
	}

done:
	d->cbuf_count = 0;
}

// Assembly:
movl (%rdi), %eax
testq %rax, %rax
je 0xdb428
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x4(%rdi), %ebx
movl $0x5, %ecx
leaq -0x4(%rcx), %rsi
movl $0x54, %edx
cmpq %rax, %rsi
jae 0xdb376
movzbl (%r15,%rcx), %edx
imull $0x55, %ebx, %ebx
addl %edx, %ebx
incq %rcx
cmpq $0x9, %rcx
jne 0xdb363
cmpl $0x1, %eax
je 0xdb3b0
movl %ebx, %eax
shrl $0x18, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0xf0bd6
movq 0x18(%r15), %rax
incq %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x28(%r15)
je 0xdb3b0
cmpq 0x20(%r15), %rax
jge 0xdb41c
cmpl $0x3, (%r15)
jb 0xdb41c
movl %ebx, %eax
shrl $0x10, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0xf0bd6
movq 0x18(%r15), %rax
incq %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x28(%r15)
je 0xdb3de
cmpq 0x20(%r15), %rax
jge 0xdb41c
cmpl $0x4, (%r15)
jb 0xdb41c
movzbl %bh, %esi
movq %r14, %rdi
callq 0xf0bd6
movq 0x18(%r15), %rax
incq %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x28(%r15)
je 0xdb407
cmpq 0x20(%r15), %rax
jge 0xdb41c
cmpl $0x5, (%r15)
jb 0xdb41c
movzbl %bl, %esi
movq %r14, %rdi
callq 0xf0bd6
incq 0x18(%r15)
movl $0x0, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/xfer.c
// Function: do_ascii85_data_char_raw
static void do_ascii85_data_char_raw(deark *c, lctx *d, dbuf *f, i64 linenum,
	 const u8 x)
{
	i64 k;

	if(x>='!' && x<='u') {
		do_ascii85_data_char_processed(c, d, f, linenum, x-33);
	}
	else if(x=='z') {
		// 'z' represents four 0x00 bytes, which encodes to five 0 values
		// (not including the +33 bias).
		for(k=0; k<5; k++)
			do_ascii85_data_char_processed(c, d, f, linenum, 0);
	}
	else if(x=='y' && d->ascii85_fmt==ASCII85_FMT_BTOA_NEW) {
		// This is what four spaces encodes to (not including the +33 bias).
		do_ascii85_data_char_processed(c, d, f, linenum, 0x0a);
		do_ascii85_data_char_processed(c, d, f, linenum, 0x1b);
		do_ascii85_data_char_processed(c, d, f, linenum, 0x35);
		do_ascii85_data_char_processed(c, d, f, linenum, 0x43);
		do_ascii85_data_char_processed(c, d, f, linenum, 0x2b);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leal -0x21(%rdx), %ebp
cmpb $0x54, %bpl
ja 0xdb46c
movl (%rbx), %eax
cmpl $0x5, %eax
jb 0xdb45c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %eax
cmpl $0x5, %eax
jae 0xdb56e
movl %eax, %ecx
movb %bpl, 0x4(%rbx,%rcx)
incl %eax
movl %eax, (%rbx)
jmp 0xdb56e
cmpb $0x79, %dl
je 0xdb4b1
movzbl %dl, %eax
cmpl $0x7a, %eax
jne 0xdb56e
movl (%rbx), %eax
movl $0x5, %r15d
cmpl $0x5, %eax
jb 0xdb49c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %eax
cmpl $0x4, %eax
ja 0xdb4a7
movl %eax, %ecx
movb $0x0, 0x4(%rbx,%rcx)
incl %eax
movl %eax, (%rbx)
decq %r15
jne 0xdb485
jmp 0xdb56e
cmpl $0x16, 0x10(%rbx)
jne 0xdb56e
movl (%rbx), %ecx
cmpl $0x5, %ecx
jb 0xdb4d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %ecx
cmpl $0x4, %ecx
ja 0xdb4e5
movl %ecx, %eax
movb $0xa, 0x4(%rbx,%rax)
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
cmpl $0x4, %ecx
jb 0xdb4f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %eax
cmpl $0x4, %eax
ja 0xdb508
movl %eax, %ecx
movb $0x1b, 0x4(%rbx,%rcx)
leal 0x1(%rax), %edx
movl %edx, (%rbx)
cmpl $0x4, %eax
jb 0xdb51a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %edx
cmpl $0x4, %edx
ja 0xdb52b
movl %edx, %eax
movb $0x35, 0x4(%rbx,%rax)
leal 0x1(%rdx), %ecx
movl %ecx, (%rbx)
cmpl $0x4, %edx
jb 0xdb53d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %ecx
cmpl $0x4, %ecx
ja 0xdb555
movl %ecx, %eax
movb $0x43, 0x4(%rbx,%rax)
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
movb $0x2b, %bpl
cmpl $0x4, %ecx
jb 0xdb45c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb344
movl (%rbx), %eax
movb $0x2b, %bpl
cmpl $0x4, %eax
jbe 0xdb45c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: de_module_zip
void de_module_zip(deark *c, struct deark_module_info *mi)
{
	mi->id = "zip";
	mi->desc = "ZIP archive";
	mi->run_fn = de_run_zip;
	mi->identify_fn = de_identify_zip;
	mi->help_fn = de_help_zip;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
leaq 0x6d9e4(%rip), %rax     # 0x148f67
movq %rax, (%rsi)
leaq 0x67e20(%rip), %rax     # 0x1433ad
movq %rax, 0x8(%rsi)
leaq 0x1f(%rip), %rax        # 0xdb5b7
movq %rax, 0x18(%rsi)
leaq 0x6b9(%rip), %rax       # 0xdbc5c
movq %rax, 0x20(%rsi)
leaq 0x7a1(%rip), %rax       # 0xdbd4f
movq %rax, 0x28(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: de_identify_zip
static int de_identify_zip(deark *c)
{
	u32 bof_sig;
	int has_zip_ext;
	int has_mz_sig = 0;
	i64 eocd_pos;

	has_zip_ext = de_input_file_has_ext(c, "zip");

	// Fast tests:

	bof_sig = (u32)de_getu32be(0);
	if(bof_sig==CODE_PK34 || bof_sig==CODE_PK00) {
		return has_zip_ext ? 100 : 90;
	}
	if((bof_sig>>16)==0x4d5a || (bof_sig>>16)==0x5a4d) {
		has_mz_sig = 1;
	}

	// First try "fast" mode. Note that we won't update c->detection_data
	// if this fails, because a later full search might succeed.
	if(fmtutil_find_zip_eocd(c, c->infile, 0x1, &eocd_pos)) {
		c->detection_data->zip_eocd_looked_for = 1;
		c->detection_data->zip_eocd_found = 1;
		c->detection_data->zip_eocd_pos = eocd_pos;
		return has_zip_ext ? 100 : 19;
	}

	// Things to consider:
	// * We want de_fmtutil_find_zip_eocd() to be called no more than once, and
	// only on files that for some reason we suspect could be ZIP files.
	// * If the user disables exe format detection (e.g. with "-onlydetect zip"),
	// we want self-extracting-ZIP .exe files to be detected as ZIP instead.
	// * And we want the above to work even if the file has a ZIP file comment,
	// making it expensive to detect as ZIP.

	// Tests below can't return a confidence higher than this.
	if(c->detection_data->best_confidence_so_far >= 19) return 0;

	// Slow tests:

	if(has_mz_sig || has_zip_ext) {
		c->detection_data->zip_eocd_looked_for = 1;
		if(fmtutil_find_zip_eocd(c, c->infile, 0, &eocd_pos)) {
			c->detection_data->zip_eocd_found = 1;
			c->detection_data->zip_eocd_pos = eocd_pos;
			return 19;
		}
	}

	if(has_zip_ext && bof_sig==CODE_PK78) {
		return 10; // First segment of a mult-segment archive
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x6d2f8(%rip), %rsi     # 0x148f67
callq 0xea491
movl %eax, %ebx
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xeed0d
movq %rax, %r15
cmpl $0x504b3030, %r15d      # imm = 0x504B3030
je 0xdbc96
cmpl $0x504b0304, %r15d      # imm = 0x504B0304
jne 0xdbc9f
testl %ebx, %ebx
movl $0x5a, %ecx
jmp 0xdbcd3
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl $0x1, %edx
callq 0xf8ed5
movq 0x28(%r14), %rcx
testl %eax, %eax
je 0xdbce5
movw $0x101, 0x6(%rcx)       # imm = 0x101
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rcx)
testl %ebx, %ebx
movl $0x13, %ecx
movl $0x64, %eax
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
cmpl $0x12, (%rcx)
jg 0xdbcdb
testl %ebx, %ebx
je 0xdbd23
movb $0x1, 0x6(%rcx)
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xf8ed5
testl %eax, %eax
je 0xdbd37
movq 0x28(%r14), %rax
movb $0x1, 0x7(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x13, %eax
jmp 0xdbcdb
movl %r15d, %eax
shrl $0x10, %eax
cmpl $0x5a4d, %eax           # imm = 0x5A4D
je 0xdbcf0
cmpl $0x4d5a, %eax           # imm = 0x4D5A
je 0xdbcf0
xorl %ecx, %ecx
cmpl $0x504b0708, %r15d      # imm = 0x504B0708
movl $0xa, %eax
cmovnel %ecx, %eax
testl %ebx, %ebx
cmovel %ebx, %eax
jmp 0xdbcdb
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: de_help_zip
static void de_help_zip(deark *c)
{
	de_msg(c, "-opt zip:scanmode : Do not use the \"central directory\"");
	de_msg(c, "-opt zip:implodebug : Behave like PKZIP 1.01/1.02");
	de_msg(c, "-opt zip:reloc[=<new_offset>] : Instead of decoding, "
		"copy/optimize the file");
	de_msg(c, "-mp -opt zip:combine : Instead of decoding, "
		"combine a multi-segment archive into one file");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x68c4e(%rip), %rsi     # 0x1449a8
xorl %eax, %eax
callq 0xe9461
leaq 0x68c77(%rip), %rsi     # 0x1449df
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
leaq 0x68c98(%rip), %rsi     # 0x144a11
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9461
leaq 0x68cd3(%rip), %rsi     # 0x144a5d
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0xe9461
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: simple_read_eocd
static void simple_read_eocd(deark *c, dbuf *f, i64 pos1,
	struct eocd_struct *eocd)
{
	i64 pos = pos1+4;

	eocd->this_seg_num = dbuf_getu16le_p(f, &pos);
	eocd->cdir_starting_seg_num = dbuf_getu16le_p(f, &pos);
	eocd->cdir_num_entries_this_seg = dbuf_getu16le_p(f, &pos);
	eocd->cdir_num_entries_total = dbuf_getu16le_p(f, &pos);
	eocd->cdir_byte_size = dbuf_getu32le_p(f, &pos);
	eocd->cdir_offset = dbuf_getu32le_p(f, &pos);
	eocd->archive_comment_len = dbuf_getu16le_p(f, &pos);

	if((UI)dbuf_getu32be(f, pos1-20) == CODE_PK67) {
		eocd->is_likely_zip64 = 1;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsi), %rax
movq %rsp, %r12
movq %rax, (%r12)
movq %r12, %rsi
callq 0xeebeb
movq %rax, (%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x8(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x18(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeed83
movq %rax, 0x20(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeed83
movq %rax, 0x28(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x30(%rbx)
addq $-0x14, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xeed0d
cmpl $0x504b0607, %eax       # imm = 0x504B0607
jne 0xdcab5
movb $0x1, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: simple_dbg_eocd
static void simple_dbg_eocd(deark *c, struct eocd_struct *eocd)
{
	de_dbg(c, "this segment num: %"I64_FMT, eocd->this_seg_num);
	de_dbg(c, "central dir num entries on this segment: %"I64_FMT,
		eocd->cdir_num_entries_this_seg);
	de_dbg(c, "central dir num entries: %"I64_FMT, eocd->cdir_num_entries_total);
	de_dbg(c, "central dir size: %"I64_FMT, eocd->cdir_byte_size);
	de_dbg(c, "central dir offset: %"I64_FMT", segment %"I64_FMT, eocd->cdir_offset,
		eocd->cdir_starting_seg_num);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdx
leaq 0x668e4(%rip), %rsi     # 0x1433b9
xorl %eax, %eax
callq 0xe8617
movq 0x10(%r14), %rdx
leaq 0x668e8(%rip), %rsi     # 0x1433cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdx
leaq 0x66900(%rip), %rsi     # 0x1433fc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x20(%r14), %rdx
leaq 0x66908(%rip), %rsi     # 0x143419
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x8(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x66905(%rip), %rsi     # 0x14342f
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8617