LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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;
		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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %r8
leaq 0x86565(%rip), %rsi     # 0x1cf066
movb $0x0, %al
callq 0x15b0d0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x19140
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x22, %rsi
callq 0x165280
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x2a, %rsi
callq 0x165540
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1484c0
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x148530
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x88, %rdx
leaq 0x86502(%rip), %rsi     # 0x1cf091
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165470
movl %eax, -0x34(%rbp)
cmpl $0x504b0304, -0x34(%rbp) # imm = 0x504B0304
je 0x148bcb
movq -0x10(%rbp), %rax
movb $0x1, 0x14(%rax)
jmp 0x148bfd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x22, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x148a20
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x2a, %rsi
movq -0x20(%rbp), %rdx
callq 0x148a70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: zipreloc_err
static void zipreloc_err(deark *c, struct zipreloc_ctx *d, const char *fmt, ...)
{
	va_list ap;

	if(d->quiet) return;
	va_start(ap, fmt);
	de_verr(c, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x148c48
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x3(%rax)
je 0x148c75
jmp 0x148cae
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15bf40
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: zipreloc_walk_central_dir
static void zipreloc_walk_central_dir(deark *c, struct zipreloc_ctx *d,
	zipreloc_wcd_callback cbfn)
{
	i64 i;
	i64 pos = d->cdir_offset_actual;
	i64 endpos = d->cdir_offset_actual + d->eocd.cdir_byte_size;

	for(i=0; i<d->eocd.cdir_num_entries_this_seg; i++) {
		u32 sig;
		i64 fn_len, extra_len, comment_len;
		i64 len;

		if(d->errflag) goto done;
		sig = (u32)de_getu32be(pos);
		if(sig!=CODE_PK12) {
			d->errflag = 1;
			d->need_errmsg = 1;
			goto done;
		}

		fn_len = de_getu16le(pos+28);
		extra_len = de_getu16le(pos+30);
		comment_len = de_getu16le(pos+32);
		len = 46 + fn_len + extra_len + comment_len;
		if(pos+len > endpos) {
			d->errflag = 1;
			d->need_errmsg = 1;
			goto done;
		}

		cbfn(c, d, pos, len);
		pos += len;
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x30(%rcx), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jge 0x148dfe
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x148d1c
jmp 0x148e00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x165470
movl %eax, -0x34(%rbp)
cmpl $0x504b0102, -0x34(%rbp) # imm = 0x504B0102
je 0x148d4d
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x148e00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x1c, %rsi
callq 0x165280
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x1e, %rsi
callq 0x165280
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
callq 0x165280
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
addq $0x2e, %rax
addq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
addq -0x58(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x148dcb
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x148e00
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movq -0x58(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x148cfc
jmp 0x148e00
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: zipreloc_wcd_cb1
static void zipreloc_wcd_cb1(deark *c, struct zipreloc_ctx *d, i64 pos1, i64 len)
{
	u32 sig;
	i64 ldir_seg_num;
	i64 ldir_offset;

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

	ldir_seg_num = de_getu16le(pos1+34);
	ldir_offset = de_getu32le(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)de_getu32be(ldir_offset);
	if(sig != CODE_PK34) {
		d->errflag = 1;
		d->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)de_getu32le(pos1+16);
		crc_from_ldir = (u32)de_getu32le(ldir_offset+14);
		if(crc_from_cdir == crc_from_ldir) {
			de_dbg(c, "[tolerating mismatched segment id]");
		}
		else {
			d->errflag = 1;
			d->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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x86378(%rip), %rsi     # 0x1cf1af
movb $0x0, %al
callq 0x15b350
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x22, %rsi
callq 0x165280
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x2a, %rsi
callq 0x165540
movq -0x10(%rbp), %rcx
addq 0x70(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x8632f(%rip), %rsi     # 0x1cf1c8
movb $0x0, %al
callq 0x15b350
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x165470
movl %eax, -0x24(%rbp)
cmpl $0x504b0304, -0x24(%rbp) # imm = 0x504B0304
je 0x148edf
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x148f70
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x148f54
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x165540
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rsi
addq $0xe, %rsi
callq 0x165540
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x148f39
movq -0x8(%rbp), %rdi
leaq 0x862bb(%rip), %rsi     # 0x1cf1eb
movb $0x0, %al
callq 0x15b0d0
jmp 0x148f52
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x2(%rax)
jmp 0x148f70
jmp 0x148f54
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x68(%rcx), %rax
jge 0x148f6e
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
jmp 0x148f70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: zipreloc_wcd_cb2
static void zipreloc_wcd_cb2(deark *c, struct zipreloc_ctx *d, i64 pos1, i64 len)
{
	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(c->infile, 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(c->infile, 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(c->infile, cpstart, cplen, d->outf);
	d->central_dir_nbytes_converted += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x22, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
callq 0x166070
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
movl $0x2, %esi
callq 0x1685f0
movq -0x18(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x28(%rbp)
movq $0x6, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
callq 0x166070
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x2a, %rsi
callq 0x165540
movq -0x10(%rbp), %rcx
addq 0x70(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
addq 0x78(%rax), %rsi
callq 0x168c30
movq -0x18(%rbp), %rax
addq $0x2e, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq $0x2e, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
callq 0x166070
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: do_local_dir_only
static int do_local_dir_only(deark *c, lctx *d, i64 pos1, i64 *pmember_size)
{
	struct member_data *md = NULL;
	i64 tmp_entry_size;
	int retval = 0;

	md = create_member_data(c, d);

	md->offset_of_local_header = pos1;

	// Read the local file header
	if(!do_file_header(c, d, md, 0, md->offset_of_local_header, &tmp_entry_size)) {
		goto done;
	}

	if(!do_process_member(c, d, md)) goto done;

	*pmember_size = md->file_data_pos + md->cmpr_size - pos1;
	retval = 1;

done:
	destroy_member_data(c, md);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1493d0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %r8
xorl %ecx, %ecx
leaq -0x30(%rbp), %r9
callq 0x149430
cmpl $0x0, %eax
jne 0x14937a
jmp 0x1493b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x149fe0
cmpl $0x0, %eax
jne 0x149392
jmp 0x1493b7
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x198(%rax), %rcx
subq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14a190
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1b8, %esi            # imm = 0x1B8
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x190(%rax)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x140(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14a1a9
jmp 0x14a1d6
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: get_platform_name
static const char *get_platform_name(UI ver_hi)
{
	static const char *pltf_names[20] = {
		"MS-DOS, etc.", "Amiga", "OpenVMS", "Unix",
		"VM/CMS", "Atari ST", "HPFS", "Macintosh",
		"Z-System", "CP/M", "NTFS or TOPS-20", "MVS or NTFS",
		"VSE or SMS/QDOS", "Acorn RISC OS", "VFAT", "MVS",
		"BeOS", "Tandem", "OS/400", "OS X" };

	if(ver_hi<20)
		return pltf_names[ver_hi];
	if(ver_hi==30) return "AtheOS/Syllable";
	return "?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jae 0x14a203
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xdb747(%rip), %rax     # 0x225940
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x14a221
cmpl $0x1e, -0xc(%rbp)
jne 0x14a216
leaq 0x85361(%rip), %rax     # 0x1cf571
movq %rax, -0x8(%rbp)
jmp 0x14a221
leaq 0x6da10(%rip), %rax     # 0x1b7c2d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: get_cmpr_meth_info
static const struct cmpr_meth_info *get_cmpr_meth_info(int cmpr_meth)
{
	size_t k;

	for(k=0; k<DE_ARRAYCOUNT(cmpr_meth_info_arr); k++) {
		if(cmpr_meth_info_arr[k].cmpr_meth == cmpr_meth) {
			return &cmpr_meth_info_arr[k];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x16, -0x18(%rbp)
jae 0x14a281
leaq 0xd9eb3(%rip), %rax     # 0x224100
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x14a271
leaq 0xd9e9d(%rip), %rax     # 0x224100
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x14a289
jmp 0x14a273
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14a23f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: apply_timestamp
static void apply_timestamp(deark *c, lctx *d, struct member_data *md, int tstype,
	const struct de_timestamp *ts, int quality)
{
	if(!ts->is_valid) return;

	// In case of a tie, we prefer the later timestamp that we encountered.
	// This makes local headers have priority over central headers, for
	// example.
	if(quality >= md->tsdata[tstype].quality) {
		md->tsdata[tstype].ts = *ts;
		md->tsdata[tstype].quality = quality;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x14a496
jmp 0x14a4ef
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
addq $0x48, %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jl 0x14a4ef
movq -0x18(%rbp), %rax
addq $0x48, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
addq $0x48, %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: describe_internal_attr
static void describe_internal_attr(deark *c, struct member_data *md,
	de_ucstring *s)
{
	UI bf = md->attr_i;

	if(bf & 0x0001) {
		ucstring_append_flags_item(s, "text file");
		bf -= 0x0001;
	}

	if(bf!=0) { // Report any unrecognized flags
		ucstring_append_flags_itemf(s, "0x%04x", bf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14a582
movq -0x18(%rbp), %rdi
leaq 0x8512c(%rip), %rsi     # 0x1cf6a0
callq 0x172680
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x14a59d
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x6734c(%rip), %rsi     # 0x1b18e2
movb $0x0, %al
callq 0x1726d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: do_read_filename
static void do_read_filename(deark *c, lctx *d,
	struct member_data *md, struct dir_entry_data *dd,
	i64 pos, i64 len, int utf8_flag)
{
	de_encoding from_encoding;

	ucstring_empty(dd->fname);
	from_encoding = utf8_flag ? DE_ENCODING_UTF8 : d->default_enc_for_filenames;
	dbuf_read_to_ucstring(c->infile, pos, len, dd->fname, 0, from_encoding);
	de_dbg(c, "filename: \"%s\"", ucstring_getpsz_d(dd->fname));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x171210
cmpl $0x0, 0x10(%rbp)
je 0x14a5f0
movl $0x2, %eax
movl %eax, -0x38(%rbp)
jmp 0x14a5f9
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rcx
movl -0x34(%rbp), %r9d
xorl %r8d, %r8d
callq 0x1669f0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x172650
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x7cf3d(%rip), %rsi     # 0x1c7583
movb $0x0, %al
callq 0x15b0d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x14a85d
jmp 0x14a8d6
cmpl $0x0, -0x24(%rbp)
je 0x14a86d
movl $0x2, %eax
movl %eax, -0x38(%rbp)
jmp 0x14a877
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0xff, %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jl 0x14a8b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq 0x10(%rbp), %r9
callq 0x14c900
jmp 0x14a8d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq -0x30(%rbp), %r9
callq 0x14c980
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x19140
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x84c23(%rip), %rsi     # 0x1cf628
xorl %edx, %edx
callq 0x15cbc0
movb %al, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x17f660
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x18(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x14aa72
movl -0x40(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x17f4b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xac(%rax), %eax
cmpl $0x0, %eax
je 0x14ab2c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x14ab2c
movq -0x20(%rbp), %rdi
movq 0xdaebf(%rip), %rsi     # 0x2259e0
movq -0x28(%rbp), %rdx
callq 0x15aa30
jmp 0x14ab46
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x6a5d0(%rip), %rdx     # 0x1b510f
movb $0x0, %al
callq 0x15a980
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: get_extra_item_type_info
static const struct extra_item_type_info_struct *get_extra_item_type_info(i64 id)
{
	static const struct extra_item_type_info_struct default_ei =
		{ 0, "?", NULL };
	size_t i;

	for(i=0; i<DE_ARRAYCOUNT(extra_item_type_info_arr); i++) {
		if(id == (i64)extra_item_type_info_arr[i].id) {
			return &extra_item_type_info_arr[i];
		}
	}
	return &default_ei;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x36, -0x18(%rbp)
jae 0x14aba7
movq -0x10(%rbp), %rax
leaq 0xd97be(%rip), %rcx     # 0x224330
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
jne 0x14ab97
leaq 0xd97a7(%rip), %rax     # 0x224330
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x14abb2
jmp 0x14ab99
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14ab60
leaq 0xd9762(%rip), %rax     # 0x224310
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x4, 0x10(%rax)
jge 0x14b317
jmp 0x14b3f4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x48(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rdx
addq $0x10, %rdx
leaq 0x5cf88(%rip), %rsi     # 0x1a82d3
movb $0x0, %al
callq 0x15b0d0
cmpl $0x5a504954, -0x44(%rbp) # imm = 0x5A504954
je 0x14b360
jmp 0x14b3f4
movq -0x18(%rbp), %rax
cmpq $0xc, 0x10(%rax)
jge 0x14b370
jmp 0x14b3f4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x4, %rsi
leaq -0x78(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x78(%rbp), %rdx
addq $0x10, %rdx
leaq 0x5535f(%rip), %rsi     # 0x1a0707
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x8, %rsi
leaq -0xa8(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
addq $0x10, %rdx
leaq 0x74945(%rip), %rsi     # 0x1bfd32
movb $0x0, %al
callq 0x15b0d0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x10, 0x10(%rax)
jge 0x14bc50
jmp 0x14bd5c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x84212(%rip), %rdx     # 0x1cfe79
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x14bc8d
movq -0x8(%rbp), %rdi
leaq 0x841fd(%rip), %rsi     # 0x1cfe7e
movb $0x0, %al
callq 0x15b0d0
jmp 0x14bd5c
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19140
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rcx
leaq -0x50(%rbp), %rdx
callq 0x1755e0
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, -0x30(%rbp)
je 0x14bcf9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
leaq -0x50(%rbp), %r8
addq $0x20, %r8
xorl %ecx, %ecx
movl $0x46, %r9d
callq 0x14a470
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rcx
leaq -0x50(%rbp), %rdx
xorl %r8d, %r8d
callq 0x175740
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x14bd5c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpb $0x0, 0xc0(%rax)
jne 0x14bd5c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movb $0x1, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc8, %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x191e0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x8, 0x10(%rax)
jge 0x14bfd4
jmp 0x14c0bd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rcx
leaq 0x7b615(%rip), %r8      # 0x1c7604
callq 0x14c830
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movl $0x2, %ecx
leaq -0x38(%rbp), %r8
movl $0x2d, %r9d
callq 0x14a470
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x4, %rdx
leaq -0x38(%rbp), %rcx
leaq 0x7b424(%rip), %r8      # 0x1c745b
callq 0x14c830
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
xorl %ecx, %ecx
leaq -0x38(%rbp), %r8
movl $0x2d, %r9d
callq 0x14a470
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x14c0bd
movq -0x18(%rbp), %rax
cmpq $0xc, 0x10(%rax)
jl 0x14c0bd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x8, %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0xa, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x14c8b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x14c2b0
jmp 0x14c304
movq -0x18(%rbp), %rax
cmpq $0x4, 0x10(%rax)
jge 0x14c2bd
jmp 0x14c304
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x2, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x14c8b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x40(%rbp), %rax
jle 0x14c353
jmp 0x14c470
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x31(%rbp), %edx
leaq 0x73e9a(%rip), %rsi     # 0x1c0210
movb $0x0, %al
callq 0x15b0d0
movzbl -0x31(%rbp), %eax
cmpl $0x1, %eax
je 0x14c38b
jmp 0x14c470
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x40(%rbp), %rax
jle 0x14c39e
jmp 0x14c470
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
addq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x14c3c9
jmp 0x14c470
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rax
movl %eax, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x165a80
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x40(%rbp), %rax
jle 0x14c408
jmp 0x14c470
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
addq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x14c430
jmp 0x14c470
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rax
movl %eax, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x165a80
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x14c8b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0xc8(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x1, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl 0x18(%rbp), %r9d
movq 0x20(%rbp), %rax
leaq -0x50(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0xc8(%rbp), %r8
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x14c620
cmpl $0x0, -0xc8(%rbp)
je 0x14c587
jmp 0x14c60d
movl 0x28(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14c603
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x15f250
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x15f500
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x15f340
movl %eax, -0xcc(%rbp)
movq -0x8(%rbp), %rdi
movq 0x30(%rbp), %rdx
movl -0xcc(%rbp), %ecx
leaq 0x83687(%rip), %rsi     # 0x1cfc74
movb $0x0, %al
callq 0x15b0d0
movl -0xcc(%rbp), %eax
cmpl 0x10(%rbp), %eax
je 0x14c601
jmp 0x14c60d
jmp 0x14c603
movl $0x1, -0xd0(%rbp)
movl -0xd0(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq -0x34(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x19140
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpq $0x0, 0x10(%rbp)
je 0x14c6a5
movq 0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14c6a5
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x34(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x167c30
jmp 0x14c6cb
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x835dd(%rip), %rsi     # 0x1cfc90
movb $0x0, %al
callq 0x15c380
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177560
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1657e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x15d580
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movl $0x40, %ecx
xorl %r8d, %r8d
callq 0x15e2d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq 0x88777(%rip), %rsi     # 0x1d4ec6
movb $0x0, %al
callq 0x15b0d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
subq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d720
movq -0x28(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movl $0x40, %ecx
xorl %r8d, %r8d
callq 0x15e2d0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
subq -0x20(%rbp), %r8
leaq -0x70(%rbp), %r9
leaq 0x83645(%rip), %rsi     # 0x1cfe67
movb $0x0, %al
callq 0x15b0d0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: read_unix_timestamp
static void read_unix_timestamp(deark *c, lctx *d, i64 pos,
	struct de_timestamp *timestamp, const char *name)
{
	i64 t;
	char timestamp_buf[64];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165600
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movl $0x40, %ecx
xorl %r8d, %r8d
callq 0x15e2d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x70(%rbp), %r8
leaq 0x561aa(%rip), %rsi     # 0x1a2a4d
movb $0x0, %al
callq 0x15b0d0
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: do_comment_extract
static void do_comment_extract(deark *c, lctx *d, i64 pos, i64 len, de_ext_encoding ee,
	const char *ext)
{
	dbuf *f = NULL;

	f = dbuf_create_output_file(c, ext, NULL, DE_CREATEFLAG_IS_AUX);
	dbuf_copy_slice_convert_to_utf8(c->infile, pos, len, ee, f, 0x2|0x4);
	dbuf_close(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x166c60
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %r8
movl $0x6, %r9d
callq 0x169da0
movq -0x38(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/zip.c
// Function: do_comment_display
static void do_comment_display(deark *c, lctx *d, i64 pos, i64 len, de_ext_encoding ee,
	const char *name)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, len, DE_DBG_MAX_STRLEN, s, 0, ee);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %r8
movl -0x24(%rbp), %eax
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x172650
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0x6b1ff(%rip), %rsi     # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)