LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movl (%rsi), %eax
cmpl $0xb, %eax
je 0xd1c7c
cmpl $0xc, %eax
jne 0xd1d5c
pushq $0xc
jmp 0xd1c7e
pushq $0x5
popq %rbp
leaq 0x6(%rbp), %rax
cmpq %r15, %rax
jg 0xd1d5c
cmpb $0x20, (%r12,%rbp)
jne 0xd1d5c
cmpb $0x20, 0x4(%r12,%rbp)
jne 0xd1d5c
leaq 0x1(%rbp), %rax
movq %r15, %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
pushq $0x20
popq %rdx
cmovbq %rcx, %rdx
leaq (%r12,%rbp), %rsi
incq %rsi
movq %rsp, %r13
movq %r13, %rdi
callq 0xde492
pushq $0x8
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0xfc8f5
movq %rax, %r13
leaq 0x63fc0(%rip), %rsi     # 0x135ca1
movq %r14, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xde896
andl $0x49, %r13d
cmpq $0x1, %r13
pushq $0x2
popq %rax
sbbl $0x0, %eax
orl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0xeac74
movq %rax, %r13
leaq (%r12,%rbp), %rsi
addq $0x5, %rsi
addq $0x5, %rbp
subq %rbp, %r15
pushq $0x1
popq %r8
movq %rax, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xeb4a9
movq %r13, %rdi
callq 0xeb877
leaq 0x5cd25(%rip), %rsi     # 0x12ea5e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xdfd55
movb $0x1, 0x8(%rbx)
jmp 0xd1d5f
xorl %r13d, %r13d
movq %r13, %rdi
callq 0xeaf3c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xc(%rdi)
jne 0xd1d89
leal -0x30(%rsi), %eax
cmpb $0x9, %al
ja 0xd1da3
addb $-0x2e, %sil
jmp 0xd1dbb
leal -0x20(%rsi), %edi
xorl %ecx, %ecx
movl $0x0, %eax
cmpb $0x40, %dil
ja 0xd1dc0
andb $0x3f, %sil
xorb $0x20, %sil
jmp 0xd1dbb
leal -0x41(%rsi), %eax
cmpb $0x19, %al
ja 0xd1db0
addb $-0x35, %sil
jmp 0xd1dbb
leal -0x61(%rsi), %eax
cmpb $0x19, %al
ja 0xd1dc3
addb $-0x3b, %sil
pushq $0x1
popq %rax
movl %esi, %ecx
movb %cl, (%rdx)
retq
pushq $0x1
popq %rax
cmpb $0x2b, %sil
je 0xd1dd9
movzbl %sil, %ecx
cmpl $0x2d, %ecx
jne 0xd1ddd
movb $0x1, %cl
jmp 0xd1dc0
xorl %ecx, %ecx
jmp 0xd1dc0
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0xd1dc0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x5(%rsp), %r14
pushq $0xb
popq %r15
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xe3cb7
leaq 0x63f2f(%rip), %rsi     # 0x135d3f
movq %r14, %rdi
movq %r15, %rdx
callq 0x18230
testl %eax, %eax
je 0xd1e5b
movq 0x18(%rbx), %rdi
leaq 0x63f21(%rip), %rdx     # 0x135d4b
xorl %r14d, %r14d
pushq $0x7
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
je 0xd1e5f
movq 0x18(%rbx), %rdi
leaq 0x63f0d(%rip), %rdx     # 0x135d53
pushq $0x2
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
pushq $0x17
popq %rax
cmovnel %r14d, %eax
jmp 0xd1e62
pushq $0x15
jmp 0xd1e61
pushq $0x16
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd1f4d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x4(%rdi), %ebx
pushq $0x5
popq %rcx
pushq $0x54
popq %rdx
cmpq $0x9, %rcx
je 0xd1eac
leaq -0x4(%rcx), %rdi
movl %edx, %esi
cmpq %rax, %rdi
jae 0xd1ea2
movzbl (%r15,%rcx), %esi
imull $0x55, %ebx, %ebx
addl %esi, %ebx
incq %rcx
jmp 0xd1e8c
cmpl $0x1, %eax
je 0xd1ed8
movl %ebx, %eax
shrl $0x18, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0xe5bc5
movq 0x18(%r15), %rax
incq %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x28(%r15)
je 0xd1ed8
cmpq 0x20(%r15), %rax
jge 0xd1f44
cmpl $0x3, (%r15)
jb 0xd1f44
movl %ebx, %eax
shrl $0x10, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0xe5bc5
movq 0x18(%r15), %rax
incq %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x28(%r15)
je 0xd1f06
cmpq 0x20(%r15), %rax
jge 0xd1f44
cmpl $0x4, (%r15)
jb 0xd1f44
movzbl %bh, %esi
movq %r14, %rdi
callq 0xe5bc5
movq 0x18(%r15), %rax
incq %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x28(%r15)
je 0xd1f2f
cmpq 0x20(%r15), %rax
jge 0xd1f44
cmpl $0x5, (%r15)
jb 0xd1f44
movzbl %bl, %esi
movq %r14, %rdi
callq 0xe5bc5
incq 0x18(%r15)
andl $0x0, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leal -0x21(%rdx), %eax
cmpb $0x54, %al
ja 0xd1f70
movzbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd1fe0
cmpb $0x79, %dl
je 0xd1f96
movzbl %dl, %eax
cmpl $0x7a, %eax
jne 0xd1fda
pushq $0x5
popq %r15
subq $0x1, %r15
jb 0xd1fda
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd1fe0
jmp 0xd1f81
cmpl $0x16, 0x10(%r14)
jne 0xd1fda
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd1fe0
pushq $0x1b
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd1fe0
pushq $0x35
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd1fe0
pushq $0x43
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd1fe0
pushq $0x2b
popq %rdx
jmp 0xd1f63
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/xfer.c
// Function: do_ascii85_data_char_processed
static void do_ascii85_data_char_processed(deark *c, lctx *d, dbuf *f, i64 linenum,
	 u8 x)
{
	// Write to the output file immediately before we empty cbuf, instead of
	// immediately after we fill it.
	// This is necessary because (in old btoa format at least) we don't yet
	// know the file size.
	// Until we know that, we don't know how many bytes need to be written for
	// the very last group.
	if(d->cbuf_count>=5) {
		do_ascii85_flush(c, d, f);
	}

	if(d->cbuf_count<(UI)sizeof(d->cbuf)) {
		d->cbuf[d->cbuf_count] = x;
		d->cbuf_count++;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
jb 0xd1ffe
movq %rbx, %rdi
callq 0xd1e6c
movl (%rbx), %eax
cmpl $0x4, %eax
ja 0xd2009
movl %eax, %ecx
movb %bpl, 0x4(%rbx,%rcx)
incl %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x69a80(%rip), %rax     # 0x13ba97
movq %rax, (%rsi)
leaq 0x63f3c(%rip), %rax     # 0x135f5d
movq %rax, 0x8(%rsi)
leaq 0x1f(%rip), %rax        # 0xd204b
movq %rax, 0x18(%rsi)
leaq 0x106d(%rip), %rax      # 0xd30a4
movq %rax, 0x20(%rsi)
leaq 0x1146(%rip), %rax      # 0xd3188
movq %rax, 0x28(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x689e2(%rip), %rsi     # 0x13ba97
callq 0xdfcd5
movl %eax, %ebx
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xe404f
movq %rax, %r15
cmpl $0x504b3030, %r15d      # imm = 0x504B3030
je 0xd30df
movl %r15d, %ebp
cmpl $0x504b0304, %r15d      # imm = 0x504B0304
jne 0xd30e5
testl %ebx, %ebx
pushq $0x5a
jmp 0xd3111
movq 0x18(%r14), %rsi
pushq $0x1
popq %rdx
movq %rsp, %rcx
movq %r14, %rdi
callq 0xed59e
movq 0x28(%r14), %rcx
testl %eax, %eax
je 0xd3123
movw $0x101, 0x6(%rcx)       # imm = 0x101
movq (%rsp), %rax
movq %rax, 0x8(%rcx)
testl %ebx, %ebx
pushq $0x13
popq %rcx
pushq $0x64
popq %rax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
cmpl $0x12, (%rcx)
jg 0xd3118
testl %ebx, %ebx
je 0xd315c
movb $0x1, 0x6(%rcx)
movq 0x18(%r14), %rsi
movq %rsp, %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xed59e
testl %eax, %eax
je 0xd3173
movq 0x28(%r14), %rax
movb $0x1, 0x7(%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
pushq $0x13
popq %rax
jmp 0xd3118
shrq $0x10, %r15
cmpw $0x5a4d, %r15w          # imm = 0x5A4D
je 0xd312e
movzwl %r15w, %eax
cmpl $0x4d5a, %eax           # imm = 0x4D5A
je 0xd312e
xorl %ecx, %ecx
cmpl $0x504b0708, %ebp       # imm = 0x504B0708
pushq $0xa
popq %rax
cmovnel %ecx, %eax
testl %ebx, %ebx
cmovel %ebx, %eax
jmp 0xd3118
// File: /workspace/github_c_makefile_star2_O2/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 0x643c5(%rip), %rsi     # 0x137558
xorl %eax, %eax
callq 0xdf42e
leaq 0x643ee(%rip), %rsi     # 0x13758f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
leaq 0x6440f(%rip), %rsi     # 0x1375c1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
leaq 0x6444a(%rip), %rsi     # 0x13760d
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0xdf42e
// File: /workspace/github_c_makefile_star2_O2/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 0xe3fc4
movq %rax, (%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, 0x8(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, 0x18(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe40bf
movq %rax, 0x20(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe40bf
movq %rax, 0x28(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3fc4
movq %rax, 0x30(%rbx)
addq $-0x14, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xe404f
cmpl $0x504b0607, %eax       # imm = 0x504B0607
jne 0xd3728
movb $0x1, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x62821(%rip), %rsi     # 0x135f69
xorl %eax, %eax
callq 0xde896
movq 0x10(%r14), %rdx
leaq 0x62825(%rip), %rsi     # 0x135f7f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x18(%r14), %rdx
leaq 0x6283d(%rip), %rsi     # 0x135fac
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x20(%r14), %rdx
leaq 0x62845(%rip), %rsi     # 0x135fc9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x8(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x62842(%rip), %rsi     # 0x135fdf
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/zip.c
// Function: zc_relpos_to_abspos
static void zc_relpos_to_abspos(struct zipcombine_ctx *d, struct zc_advpos *advpos)
{
	if(advpos->rel_seg_id<0 || advpos->rel_seg_id>=d->num_segments) {
		d->errflag = 1;
		advpos->abs_pos = d->f->len;
		return;
	}
	advpos->abs_pos = d->segments[advpos->rel_seg_id].starting_offset + advpos->rel_pos;
	if(advpos->rel_seg_id==0) {
		advpos->abs_pos -= d->seg0_prefix_len;
	}
}

// Assembly:
movslq (%rsi), %rax
testq %rax, %rax
js 0xd37db
cmpl 0x4(%rdi), %eax
jge 0xd37db
movq 0x88(%rdi), %rdx
movq %rax, %r8
shlq $0x4, %r8
movq 0x8(%rsi), %rcx
addq 0x8(%rdx,%r8), %rcx
movq %rcx, 0x10(%rsi)
testl %eax, %eax
je 0xd37eb
retq
movb $0x1, (%rdi)
movq 0x78(%rdi), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsi)
retq
subq 0x80(%rdi), %rcx
movq %rcx, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/zip.c
// Function: wcd_callback_for_cdpadding
static void wcd_callback_for_cdpadding(deark *c, struct zip_wcd_ctx *wcdctx)
{
	if(c->debug_level<2) return;
	de_dbg2(c, "peek at cdir entry #%u: segment %d, pos %"I64_FMT", len %"I64_FMT,
		(UI)wcdctx->num_entries_completed,
		wcdctx->userdata_seg_id, wcdctx->entry_pos, wcdctx->entry_size);
}

// Assembly:
cmpl $0x2, (%rdi)
jge 0xd381f
retq
movl 0x10(%rsi), %ecx
movl 0x40(%rsi), %edx
movq 0x50(%rsi), %r8
movq 0x58(%rsi), %r9
leaq 0x6280b(%rip), %rsi     # 0x13603f
xorl %eax, %eax
jmp 0xde9f1
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/zip.c
// Function: wcd_callback_for_fixcdir
static void wcd_callback_for_fixcdir(deark *c, struct zip_wcd_ctx *wcdctx)
{
	struct zipcombine_ctx *d = (struct zipcombine_ctx*)wcdctx->userdata;
	struct zc_advpos ldir_pos;
	u32 sig;

	de_dbg(c, "adjusting cdir entry #%u: pos %"I64_FMT", len %"I64_FMT,
		(UI)wcdctx->num_entries_completed,
		wcdctx->entry_pos, wcdctx->entry_size);

	de_zeromem(&ldir_pos, sizeof(struct zc_advpos));
	ldir_pos.rel_seg_id = (int)dbuf_getu16le(d->f, wcdctx->entry_pos+34);
	ldir_pos.rel_pos = dbuf_getu32le(d->f, wcdctx->entry_pos+42);

	zc_relpos_to_abspos(d, &ldir_pos);

	zc_format_advpos(d, &ldir_pos);
	de_dbg_indent(c, 1);
	de_dbg(c, "ldir pos: %s", d->tmpsz);
	de_dbg_indent(c, -1);

	// If this is the right place, there should be a signature there.
	sig = (u32)dbuf_getu32be(d->f, ldir_pos.abs_pos);
	if(sig != CODE_PK34) {
		wcdctx->errflag = 1;
		wcdctx->need_errmsg = 1;
		goto done;
	}

	// segment number -> 0
	zc_writeu16le_at(d, wcdctx->entry_pos+34, 0);
	// old offset -> new offset
	zc_writeu32le_at(d, wcdctx->entry_pos+42, ldir_pos.abs_pos);

done:
	;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movl 0x40(%rsi), %edx
movq 0x50(%rsi), %rcx
movq 0x58(%rsi), %r8
leaq 0x626ce(%rip), %rsi     # 0x13610c
xorl %eax, %eax
callq 0xde896
xorps %xmm0, %xmm0
movq %rsp, %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
movq 0x78(%r14), %rdi
movq 0x50(%rbx), %rsi
addq $0x22, %rsi
callq 0xe3fa3
movl %eax, (%r12)
movq 0x78(%r14), %rdi
movq 0x50(%rbx), %rsi
addq $0x2a, %rsi
callq 0xe409f
movq %rax, 0x8(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd37ae
movq %r14, %rdi
movq %r12, %rsi
callq 0xd37f7
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xdeba7
leaq 0x90(%r14), %rdx
leaq 0x62687(%rip), %rsi     # 0x136137
movq %r15, %rdi
xorl %eax, %eax
callq 0xde896
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0xdeba7
movq 0x78(%r14), %rdi
movq 0x10(%r12), %r15
movq %r15, %rsi
callq 0xe404f
cmpl $0x504b0304, %eax       # imm = 0x504B0304
jne 0xd3b0d
movq 0x50(%rbx), %rsi
addq $0x22, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xd39a1
movq 0x50(%rbx), %rsi
addq $0x2a, %rsi
movq %r14, %rdi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd39dc
movw $0x101, 0x39(%rbx)      # imm = 0x101
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r15
movq 0x50(%rsi), %r12
leaq 0x62680(%rip), %rsi     # 0x136255
movq %r12, %rdx
xorl %eax, %eax
callq 0xde9f1
leaq 0x22(%r12), %rsi
movq %r15, %rdi
callq 0xe3fa3
movq %rax, %rbp
movq %r12, 0x8(%rsp)
leaq 0x2a(%r12), %rsi
movq %r15, %rdi
callq 0xe409f
movq %rax, %r12
movq %r14, 0x10(%rsp)
addq 0x70(%r14), %r12
movq %r13, %r14
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0xdeba7
leaq 0x6264c(%rip), %rsi     # 0x13626e
movq %r13, %rdi
movq %r12, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xde9f1
pushq $-0x1
popq %rsi
movq %r13, %rdi
callq 0xdeba7
movq %r15, %rdi
movq %r12, %rsi
callq 0xe404f
cmpl $0x504b0304, %eax       # imm = 0x504B0304
jne 0xd3ca0
movq 0x10(%rsp), %rax
cmpq 0x10(%rax), %rbp
movq %rax, %rbp
je 0xd3c94
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0xe409f
movq %rax, %r13
leaq 0xe(%r12), %rsi
movq %r15, %rdi
callq 0xe409f
cmpl %eax, %r13d
jne 0xd3cb5
leaq 0x62607(%rip), %rsi     # 0x136291
movq %r14, %rdi
xorl %eax, %eax
callq 0xde896
cmpq 0x68(%rbp), %r12
jge 0xd3ca6
movq %r12, 0x68(%rbp)
jmp 0xd3ca6
movw $0x101, 0x39(%rbx)      # imm = 0x101
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movw $0x101, 0x39(%rbx)      # imm = 0x101
movb $0x1, 0x2(%rbp)
jmp 0xd3ca6
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x22
popq %rdx
movq %rbx, %rsi
callq 0xe45f4
movq 0x88(%r13), %rdi
pushq $0x2
popq %rsi
callq 0xe5d20
leaq 0x24(%rbx), %rsi
movq 0x18(%r14), %rdi
movq 0x88(%r13), %rcx
pushq $0x6
popq %rdx
callq 0xe45f4
movq 0x18(%r15), %rdi
leaq 0x2a(%rbx), %rsi
callq 0xe409f
addq 0x70(%r13), %rax
movq 0x88(%r13), %rdi
addq 0x78(%r13), %rax
movq %rax, %rsi
callq 0xe5f7f
addq $0x2e, %rbx
leaq -0x2e(%r12), %rdx
movq 0x18(%r14), %rdi
movq 0x88(%r13), %rcx
movq %rbx, %rsi
callq 0xe45f4
addq %r12, 0x80(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xdecaf
movq %rax, %r14
movq %rbx, %rdi
callq 0xeac74
movq %rax, 0x1b8(%r14)
movq %rbx, %rdi
callq 0xeac74
movq %rax, 0x140(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd4ec6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x140(%rsi), %rdi
callq 0xeaf3c
movq 0x1b8(%rbx), %rdi
callq 0xeaf3c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/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, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movl $0x302, %ebp            # imm = 0x302
testl %r8d, %r8d
jne 0xd4f28
movzbl 0x4(%rsi), %ebp
orl $0x300, %ebp            # imm = 0x300
cmpl $0x2, 0x90(%rbx)
jl 0xd4f74
movq 0x40(%rsp), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe4e62
movq %rax, %r15
movq 0x18(%rbx), %rdi
pushq $0x6
popq %r9
movq %r12, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rax, %r8
callq 0xe66ec
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe5591
movq %rbx, %rdi
callq 0xeac74
movq %rax, %r13
movq 0x18(%rbx), %rdi
movl %ebp, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r14, %rdx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xe4ced
movq %r13, %rdi
callq 0xeb877
leaq 0x49f0f(%rip), %rsi     # 0x11eeba
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %r12
andq $0x0, (%r12)
movq %rdi, %r13
movl 0x4(%rdx), %eax
movl %eax, (%r12)
leaq 0x61661(%rip), %rsi     # 0x1366a5
xorl %edx, %edx
callq 0xdfae5
movb %al, 0x4(%r12)
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0xf473a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd508c
movl $0x4, (%rsp)
movq %rsp, %r8
movq %rcx, %rsi
movq %rax, %rdx
movq %r9, %rcx
callq 0xf4633
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd50dc
cmpb $0x0, 0xac(%rdi)
je 0xd50dc
leaq 0x61638(%rip), %rsi     # 0x136707
pushq $0x40
popq %rdx
movq %rbx, %rdi
callq 0xde492
jmp 0xd50f0
leaq 0x474be(%rip), %rdx     # 0x11c5a1
pushq $0x40
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde40c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd5839
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x8(%rdx), %rsi
leaq 0x68(%rsp), %rdx
pushq $0x4
popq %rcx
xorl %r8d, %r8d
callq 0xe657c
leaq 0x78(%rsp), %r15
leaq 0x39e89(%rip), %rsi     # 0x10f632
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xde896
cmpl $0x5a504954, -0xc(%r15) # imm = 0x5A504954
jne 0xd582c
cmpq $0xc, 0x10(%r14)
jl 0xd582c
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x4, %rsi
leaq 0x38(%rsp), %rdx
pushq $0x4
popq %rbp
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xe657c
leaq 0x48(%rsp), %rdx
leaq 0x320bf(%rip), %rsi     # 0x1078b0
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xe657c
leaq 0x18(%rsp), %rdx
leaq 0x517f1(%rip), %rsi     # 0x127013
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd5e0d
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 0x610d4(%rip), %rdx     # 0x136ef6
pushq $0x4
popq %rcx
movq %r15, %rsi
callq 0xe4d48
testl %eax, %eax
je 0xd5e4d
leaq 0x610c3(%rip), %rsi     # 0x136efb
movq %r14, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xde896
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 0xed922
addq $0xc, %r15
cmpb $0x0, 0x20(%r12)
je 0xd5ea0
movq 0x20(%rbx), %rax
cmpl $0x46, 0x58(%rax)
jg 0xd5ea0
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 0xeda08
cmpl $0x0, 0x30(%rbx)
jne 0xd5e01
movq 0x20(%rbx), %rax
cmpb $0x0, 0xc0(%rax)
jne 0xd5e01
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 0xd5e01
// File: /workspace/github_c_makefile_star2_O2/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 0xd6177
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
leaq 0x58a1e(%rip), %rcx     # 0x12eadf
movq %rsp, %r15
movq %r15, %rdx
callq 0xd667f
cmpb $0x0, (%r15)
je 0xd60f1
movq 0x20(%r14), %rax
cmpl $0x2d, 0x88(%rax)
jg 0xd60f1
movups (%rsp), %xmm0
movups %xmm0, 0x78(%rax)
movl $0x2d, 0x88(%rax)
movq 0x8(%r14), %rsi
addq $0x4, %rsi
leaq 0x58836(%rip), %rcx     # 0x12e936
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xd667f
cmpb $0x0, (%r15)
je 0xd612d
movq 0x20(%r14), %rax
cmpl $0x2d, 0x58(%rax)
jg 0xd612d
movups (%rsp), %xmm0
movups %xmm0, 0x48(%rax)
movl $0x2d, 0x58(%rax)
cmpl $0x0, 0x30(%r14)
jne 0xd616e
cmpq $0xc, 0x10(%r14)
jl 0xd616e
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x8, %rsi
callq 0xe3fa3
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0xa, %rsi
callq 0xe3fa3
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd66ee
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd61c6
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x8(%rdx), %rsi
callq 0xe3eb4
movzbl %al, %ebp
leaq 0x538da(%rip), %rsi     # 0x129a84
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xde896
cmpb $0x1, %bpl
jne 0xd61c9
cmpq $0x6, 0x10(%rbx)
jge 0xd61df
xorl %r15d, %r15d
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rsi
incq %rsi
callq 0xe409f
movq %rax, %r13
leaq 0x60d27(%rip), %rsi     # 0x136f20
movq %r14, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
callq 0xeac74
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq $-0x5, %rdx
movq 0x18(%r14), %rdi
addq $0x5, %rsi
pushq $0x2
popq %r9
movq %rax, %rcx
xorl %r8d, %r8d
callq 0xe4c9a
movq %r15, %rdi
callq 0xeb877
leaq 0x60cf9(%rip), %rsi     # 0x136f3c
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0xb8(%r12), %rdi
callq 0xe0e44
movq 0xb8(%r12), %rdi
movq 0x18(%r14), %rsi
movq 0x28(%rbx), %rax
movq 0x38(%rax), %rdx
movq 0x40(%rax), %rcx
callq 0xe0f33
movq 0xb8(%r12), %rdi
callq 0xe0e95
movl %eax, %ebp
leaq 0x60cbf(%rip), %rsi     # 0x136f4f
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xde896
cmpl %r13d, %ebp
jne 0xd61c9
movq 0x28(%rbx), %rax
movq 0x48(%rax), %rdi
callq 0xeac85
movq 0x28(%rbx), %rax
movq 0x48(%rax), %rdi
movq %r15, %rsi
callq 0xead71
jmp 0xd61c9
// File: /workspace/github_c_makefile_star2_O2/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 0xd62dc
movq %rdx, %r14
cmpq $0x4, 0x10(%rdx)
jge 0xd62e2
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0xe3fa3
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x2, %rsi
callq 0xe3fa3
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xd66ee
// File: /workspace/github_c_makefile_star2_O2/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 0xd63fa
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %rsi
callq 0xe3f2a
movzbl %al, %ebp
leaq 0x5119f(%rip), %rsi     # 0x1274f1
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xde896
cmpb $0x1, %bpl
jne 0xd63fa
addq %r14, %r13
cmpq %r13, (%rsp)
jge 0xd63fa
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xe3f2a
movzbl %al, %r15d
movq (%r14), %rsi
leaq (%rsi,%r15), %rax
cmpq %r13, %rax
jg 0xd63fa
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rcx
movl %r15d, %edx
xorl %r8d, %r8d
callq 0xe424b
addq (%rsp), %r15
movq %r15, (%rsp)
cmpq %r13, %r15
jge 0xd63fa
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0xe3f2a
movzbl %al, %r15d
movq (%r12), %rsi
leaq (%rsi,%r15), %rax
cmpq %r13, %rax
jg 0xd63fa
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rcx
movl %r15d, %edx
xorl %r8d, %r8d
callq 0xe424b
addq %r15, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd66ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/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 0xee7ee
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 0xd6523
popq %rax
popq %rcx
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jne 0xd650e
movl 0xf8(%rsp), %eax
testb $0x1, %al
je 0xd650a
movq 0x100(%rsp), %r14
movl 0xe0(%rsp), %r15d
movq 0xb8(%r13), %rdi
callq 0xe0e44
movq 0xb8(%r13), %rdi
movq 0x18(%rbp), %rcx
xorl %r12d, %r12d
movq %rbp, %rsi
xorl %edx, %edx
callq 0xe0f33
movq 0xb8(%r13), %rdi
callq 0xe0e95
movl %eax, %ebp
leaq 0x607fb(%rip), %rsi     # 0x136cf1
movq %rbx, %rdi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0xde896
cmpl %r15d, %ebp
jne 0xd650e
pushq $0x1
popq %r12
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_O2/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
movl %r9d, 0x8(%rsp)
movl %edx, 0xc(%rsp)
testq %rax, %rax
je 0xd657a
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xd657a
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %r8
movq %rbx, %r9
callq *%rax
movq (%r15), %rdi
callq 0xe58e8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6078c(%rip), %rsi     # 0x136d0d
movq %r14, %rdi
movl %r9d, %edx
xorl %eax, %eax
callq 0xdf5b8
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xee91c
// File: /workspace/github_c_makefile_star2_O2/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 0xe418b
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe0051
movq %rsp, %r12
pushq $0x40
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0xe07a8
leaq 0x658c5(%rip), %rsi     # 0x13beb2
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xde896
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
subq %rdx, %rdi
movq %rcx, %rsi
callq 0xe0102
movb $0x1, 0x1(%r15)
movq %rsp, %rbp
pushq $0x40
popq %rcx
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
xorl %r8d, %r8d
callq 0xe07a8
negq %r14
leaq 0x6088a(%rip), %rsi     # 0x136ee4
movq %r13, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movq %r14, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0xde896
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq