LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xdcb68
cmpl 0x4(%rdi), %eax
jge 0xdcb68
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 0xdcb78
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_O3/jsummers[P]deark/modules/zip.c
// Function: zc_modify_eocd
static void zc_modify_eocd(deark *c, struct zipcombine_ctx *d)
{
	de_dbg(c, "[adjusting eocd]");

	// this segment id -> 0
	zc_writeu16le_at(d, d->eocd_pos.abs_pos + 4, 0);

	// cdir segment num -> 0
	zc_writeu16le_at(d, d->eocd_pos.abs_pos + 6, 0);

	// cdir num entries this segment
	zc_writeu16le_at(d, d->eocd_pos.abs_pos + 8, d->eocd.cdir_num_entries_total);

	// cdir offset
	zc_writeu32le_at(d, d->eocd_pos.abs_pos + 16, d->cdir_pos.abs_pos);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x6699b(%rip), %rsi     # 0x143532
xorl %eax, %eax
callq 0xe8617
movq 0x58(%rbx), %r14
addq $0x4, %r14
leaq 0x6(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xf0f89
movq 0x78(%rbx), %rdi
movl $0x2, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0xf0c11
movq 0x58(%rbx), %r14
addq $0x6, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xf0f89
movq 0x78(%rbx), %rdi
movl $0x2, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0xf0c11
movq 0x20(%rbx), %rsi
movq 0x58(%rbx), %r14
addq $0x8, %r14
leaq 0xa(%rsp), %r15
movq %r15, %rdi
callq 0xf0f89
movq 0x78(%rbx), %rdi
movl $0x2, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0xf0c11
movq 0x58(%rbx), %r14
movq 0x70(%rbx), %rsi
addq $0x10, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdi
callq 0xf103f
movq 0x78(%rbx), %rdi
movl $0x4, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0xf0c11
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: zc_modify_cdir
static void zc_modify_cdir(deark *c, struct zipcombine_ctx *d)
{
	struct zip_wcd_ctx *wcdctx = NULL;

	de_dbg(c, "[adjusting cdir entries]");
	de_dbg_indent(c, 1);
	wcdctx = de_malloc(c, sizeof(struct zip_wcd_ctx));
	wcdctx->userdata = (void*)d;
	wcdctx->cbfn = wcd_callback_for_fixcdir;
	wcdctx->inf = d->f;
	wcdctx->max_entries = d->eocd.cdir_num_entries_total;
	wcdctx->inf_startpos = d->cdir_pos.abs_pos;
	wcdctx->inf_endpos = d->f->len;
	zip_wcd_run(c, wcdctx);
	d->errflag = wcdctx->errflag;
	d->need_errmsg = wcdctx->need_errmsg;
	if(d->errflag) {
		goto done;
	}

done:
	de_free(c, wcdctx);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x668d9(%rip), %rsi     # 0x143543
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movl $0x78, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq %r14, 0x8(%rax)
leaq 0x1ff(%rip), %rax       # 0xdce98
movq %rax, (%r15)
movq 0x78(%r14), %rax
movq %rax, 0x18(%r15)
movq 0x20(%r14), %rcx
movq %rcx, 0x30(%r15)
movq 0x70(%r14), %rcx
movq %rcx, 0x20(%r15)
movq 0x18(%rax), %rax
movq %rax, 0x28(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdcd15
movb 0x39(%r15), %al
movb %al, (%r14)
movb 0x3a(%r15), %al
movb %al, 0x1(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0xe8a15
// File: /workspace/github_c_makefile_star2_O3/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 0xdccf9
retq
movl 0x10(%rsi), %ecx
movl 0x40(%rsi), %edx
movq 0x50(%rsi), %r8
movq 0x58(%rsi), %r9
leaq 0x66781(%rip), %rsi     # 0x14348f
xorl %eax, %eax
jmp 0xe87e4
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rbp
movl 0x40(%rsi), %edx
movq 0x50(%rsi), %rcx
movq 0x58(%rsi), %r8
leaq 0x6669d(%rip), %rsi     # 0x14355c
xorl %eax, %eax
callq 0xe8617
movq 0x78(%rbp), %rdi
movq 0x50(%rbx), %rsi
addq $0x22, %rsi
callq 0xeebc8
movq %rax, %r12
movq 0x78(%rbp), %rdi
movq 0x50(%rbx), %rsi
addq $0x2a, %rsi
callq 0xeed61
testl %r12d, %r12d
js 0xdcf20
cmpl %r12d, 0x4(%rbp)
jle 0xdcf20
movq 0x88(%rbp), %rcx
movl %r12d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %r15
addq %rax, %r15
testl %r12d, %r12d
jne 0xdcf2c
subq 0x80(%rbp), %r15
jmp 0xdcf2c
movb $0x1, (%rbp)
movq 0x78(%rbp), %rcx
movq 0x18(%rcx), %r15
leaq 0x90(%rbp), %r13
leaq 0x665de(%rip), %rdx     # 0x143518
movl $0x50, %esi
movq %r13, %rdi
movl %r12d, %ecx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0xe8193
movq %r14, %rdi
movl $0x1, %esi
callq 0xe8a15
leaq 0x66621(%rip), %rsi     # 0x143587
movq %r14, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq 0x78(%rbp), %rdi
movq %r15, %rsi
callq 0xeed0d
cmpl $0x504b0304, %eax       # imm = 0x504B0304
jne 0xdcfec
movq 0x50(%rbx), %r14
addq $0x22, %r14
leaq 0x2(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xf0f89
movq 0x78(%rbp), %rdi
movl $0x2, %ecx
movq %r14, %rsi
movq %r12, %rdx
callq 0xf0c11
movq 0x50(%rbx), %rbx
addq $0x2a, %rbx
leaq 0x4(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xf103f
movq 0x78(%rbp), %rdi
movl $0x4, %ecx
movq %rbx, %rsi
movq %r14, %rdx
callq 0xf0c11
jmp 0xdcff2
movw $0x101, 0x39(%rbx)      # imm = 0x101
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 0x665ee(%rip), %rsi     # 0x1436a5
movq %r12, %rdx
xorl %eax, %eax
callq 0xe87e4
leaq 0x22(%r12), %rsi
movq %r15, %rdi
callq 0xeebc8
movq %rax, %rbp
movq %r12, 0x8(%rsp)
leaq 0x2a(%r12), %rsi
movq %r15, %rdi
callq 0xeed61
movq %rax, %r12
movq %r14, 0x10(%rsp)
addq 0x70(%r14), %r12
movq %r13, %r14
movq %r13, %rdi
movl $0x1, %esi
callq 0xe8a15
leaq 0x665b8(%rip), %rsi     # 0x1436be
movq %r13, %rdi
movq %r12, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xe87e4
movq %r13, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq %r15, %rdi
movq %r12, %rsi
callq 0xeed0d
cmpl $0x504b0304, %eax       # imm = 0x504B0304
jne 0xdd186
movq 0x10(%rsp), %rax
cmpq 0x10(%rax), %rbp
movq %rax, %rbp
je 0xdd17a
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0xeed61
movq %rax, %r13
leaq 0xe(%r12), %rsi
movq %r15, %rdi
callq 0xeed61
cmpl %eax, %r13d
jne 0xdd19b
leaq 0x66571(%rip), %rsi     # 0x1436e1
movq %r14, %rdi
xorl %eax, %eax
callq 0xe8617
cmpq 0x68(%rbp), %r12
jge 0xdd18c
movq %r12, 0x68(%rbp)
jmp 0xdd18c
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 0xdd18c
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: zipreloc_wcd_convert
static void zipreloc_wcd_convert(deark *c, struct zip_wcd_ctx *wcdctx)
{
	struct zipreloc_ctx *d = (struct zipreloc_ctx*)wcdctx->userdata;
	i64 pos1 = wcdctx->entry_pos;
	i64 len = wcdctx->entry_size;
	i64 cpstart, cplen;
	i64 ldir_offset;

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rsi), %rbx
movq 0x58(%rsi), %r12
movq 0x8(%rsi), %r13
movq 0x18(%rsi), %rdi
movq 0x88(%r13), %rcx
movl $0x22, %edx
movq %rbx, %rsi
callq 0xef481
movq 0x88(%r13), %rdi
movl $0x2, %esi
callq 0xf0d35
leaq 0x24(%rbx), %rsi
movq 0x18(%r14), %rdi
movq 0x88(%r13), %rcx
movl $0x6, %edx
callq 0xef481
movq 0x18(%r15), %rdi
leaq 0x2a(%rbx), %rsi
callq 0xeed61
addq 0x70(%r13), %rax
movq 0x88(%r13), %rdi
addq 0x78(%r13), %rax
movq %rax, %rsi
callq 0xf1042
addq $0x2e, %rbx
leaq -0x2e(%r12), %rdx
movq 0x18(%r14), %rdi
movq 0x88(%r13), %rcx
movq %rbx, %rsi
callq 0xef481
addq %r12, 0x80(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe8b2b
movq %rax, %r14
movq %rbx, %rdi
callq 0xf6410
movq %rax, 0x1b8(%r14)
movq %rbx, %rdi
callq 0xf6410
movq %rax, 0x140(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xde5f8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x140(%rsi), %rdi
callq 0xf6753
movq 0x1b8(%rbx), %rdi
callq 0xf6753
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8be2
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: do_comment
static void do_comment(deark *c, lctx *d, i64 pos, i64 len, int utf8_flag,
	const char *name, const char *ext)
{
	de_ext_encoding ee;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movl $0x302, %ebp            # imm = 0x302
testl %r8d, %r8d
jne 0xde624
movzbl 0x4(%rsi), %ebp
orl $0x300, %ebp            # imm = 0x300
cmpl $0x2, 0x90(%rbx)
jl 0xde674
movq 0x40(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xefda1
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %rax, %r8
movl $0x6, %r9d
callq 0xf1883
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf052b
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r13
movq 0x18(%rbx), %rdi
movl %ebp, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq %r13, %rdi
callq 0xf70f6
leaq 0x4da7f(%rip), %rsi     # 0x12c12a
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: do_decompress_implode
static void do_decompress_implode(deark *c, lctx *d, struct compression_params *cparams,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_zipimplode_params params;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r13
movq $0x0, (%r13)
movl 0x4(%rdx), %eax
movl %eax, (%r13)
leaq 0x653ae(%rip), %rsi     # 0x143af5
xorl %edx, %edx
callq 0xe9bd0
movb %al, 0x4(%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x10069b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 0xde78e
movl $0x4, (%rsp)
movq %rsp, %r8
movq %rcx, %rsi
movq %rax, %rdx
movq %r9, %rcx
callq 0x10058f
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testb %dil, %dil
sete %al
cmpq %rdx, %rsi
setne %dl
orb %al, %dl
jne 0xde7df
leaq 0x65387(%rip), %rsi     # 0x143b57
movl $0x40, %edx
movq %rbx, %rdi
callq 0xe8219
jmp 0xde7f8
movq %rsi, %rcx
leaq 0x4aff8(%rip), %rdx     # 0x1297e1
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8193
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdef6c
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x8(%rdx), %rsi
leaq 0x60(%rsp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1762
leaq 0x70(%rsp), %r15
leaq 0x3d846(%rip), %rsi     # 0x11c722
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe8617
cmpl $0x5a504954, -0xc(%r15) # imm = 0x5A504954
jne 0xdef60
cmpq $0xc, 0x10(%r14)
jl 0xdef60
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x4, %rsi
leaq 0x30(%rsp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1762
leaq 0x40(%rsp), %rdx
leaq 0x35a17(%rip), %rsi     # 0x11493b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x8, %rsi
movq %rsp, %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1762
leaq 0x10(%rsp), %rdx
leaq 0x55395(%rip), %rsi     # 0x1342eb
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdf579
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 0x64db8(%rip), %rdx     # 0x144346
movl $0x4, %ecx
movq %r15, %rsi
callq 0xefc85
testl %eax, %eax
je 0xdf5bb
leaq 0x64da5(%rip), %rsi     # 0x14434b
movq %r14, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8617
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 0xf9284
addq $0xc, %r15
cmpb $0x0, 0x20(%r12)
je 0xdf60e
movq 0x20(%rbx), %rax
cmpl $0x46, 0x58(%rax)
jg 0xdf60e
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 0xf9370
cmpl $0x0, 0x30(%rbx)
jne 0xdf56d
movq 0x20(%rbx), %rax
cmpb $0x0, 0xc0(%rax)
jne 0xdf56d
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 0xdf56d
// File: /workspace/github_c_makefile_star2_O3/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 0xdf902
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
leaq 0x5c5a0(%rip), %rcx     # 0x13bdcf
movq %rsp, %r15
movq %r15, %rdx
callq 0xdfe59
cmpb $0x0, (%r15)
je 0xdf85f
movq 0x20(%r14), %rax
cmpl $0x2d, 0x88(%rax)
jg 0xdf85f
movups (%rsp), %xmm0
movups %xmm0, 0x78(%rax)
movl $0x2d, 0x88(%rax)
movq 0x8(%r14), %rsi
addq $0x4, %rsi
leaq 0x5c3b8(%rip), %rcx     # 0x13bc26
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xdfe59
cmpb $0x0, (%r15)
je 0xdf89b
movq 0x20(%r14), %rax
cmpl $0x2d, 0x58(%rax)
jg 0xdf89b
movups (%rsp), %xmm0
movups %xmm0, 0x48(%rax)
movl $0x2d, 0x58(%rax)
cmpl $0x0, 0x30(%r14)
jne 0xdf8f9
cmpq $0xc, 0x10(%r14)
jl 0xdf8f9
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x8, %rsi
callq 0xeebc8
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0xa, %rsi
callq 0xeebc8
movq %rax, %r14
leaq 0x4c8d5(%rip), %rsi     # 0x12c1ad
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe8617
leaq 0x4c8c9(%rip), %rsi     # 0x12c1b5
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe8617
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdf951
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x8(%rdx), %rsi
callq 0xeead3
movzbl %al, %ebp
leaq 0x5744f(%rip), %rsi     # 0x136d84
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
cmpb $0x1, %bpl
jne 0xdf954
cmpq $0x6, 0x10(%rbx)
jge 0xdf96a
xorl %r15d, %r15d
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rsi
incq %rsi
callq 0xeed61
movq %rax, %r13
leaq 0x649ec(%rip), %rsi     # 0x144370
movq %r14, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xe8617
movq %r14, %rdi
callq 0xf6410
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq $-0x5, %rdx
movq 0x18(%r14), %rdi
addq $0x5, %rsi
movq %rax, %rcx
xorl %r8d, %r8d
movl $0x2, %r9d
callq 0xefbd7
movq %r15, %rdi
callq 0xf70f6
leaq 0x649bc(%rip), %rsi     # 0x14438c
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq 0xb8(%r12), %rdi
callq 0xeb7fe
movq 0xb8(%r12), %rdi
movq 0x18(%r14), %rsi
movq 0x28(%rbx), %rax
movq 0x38(%rax), %rdx
movq 0x40(%rax), %rcx
callq 0xeb944
movq 0xb8(%r12), %rdi
callq 0xeb865
movl %eax, %ebp
leaq 0x64982(%rip), %rsi     # 0x14439f
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
cmpl %r13d, %ebp
jne 0xdf954
movq 0x28(%rbx), %rax
movq 0x48(%rax), %rdi
callq 0xf6423
movq 0x28(%rbx), %rax
movq 0x48(%rax), %rdi
movq %r15, %rsi
callq 0xf6509
jmp 0xdf954
// File: /workspace/github_c_makefile_star2_O3/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 0xdfa69
movq %rdx, %r14
cmpq $0x4, 0x10(%rdx)
jge 0xdfa6f
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0xeebc8
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
addq $0x2, %rsi
callq 0xeebc8
movq %rax, %r14
leaq 0x4c710(%rip), %rsi     # 0x12c1ad
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe8617
leaq 0x4c704(%rip), %rsi     # 0x12c1b5
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe8617
// File: /workspace/github_c_makefile_star2_O3/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 0xdfbc9
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %rsi
callq 0xeeb4b
movzbl %al, %ebp
leaq 0x54ccd(%rip), %rsi     # 0x1347c9
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
cmpb $0x1, %bpl
jne 0xdfbc9
addq %r14, %r13
cmpq %r13, (%rsp)
jge 0xdfbc9
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xeeb4b
movzbl %al, %r15d
movq (%r14), %rsi
leaq (%rsi,%r15), %rax
cmpq %r13, %rax
jg 0xdfbc9
movq 0x18(%rbx), %rdi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xef0f6
addq (%rsp), %r15
movq %r15, (%rsp)
cmpq %r13, %r15
jge 0xdfbc9
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0xeeb4b
movzbl %al, %r15d
movq (%r12), %rsi
leaq (%rsi,%r15), %rax
cmpq %r13, %rax
jg 0xdfbc9
movq 0x18(%rbx), %rdi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xef0f6
movq %rax, %r12
addq %r15, (%rsp)
leaq 0x4c605(%rip), %rsi     # 0x12c1ad
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe8617
leaq 0x4c5f9(%rip), %rsi     # 0x12c1b5
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/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 0xfa1dc
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 0xdfcf6
addq $0x10, %rsp
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jne 0xdfce1
movl 0xf8(%rsp), %eax
testb $0x1, %al
je 0xdfcdb
movq 0x100(%rsp), %r14
movl 0xe0(%rsp), %r15d
movq 0xb8(%r13), %rdi
callq 0xeb7fe
movq 0xb8(%r13), %rdi
movq 0x18(%rbp), %rcx
xorl %r12d, %r12d
movq %rbp, %rsi
xorl %edx, %edx
callq 0xeb944
movq 0xb8(%r13), %rdi
callq 0xeb865
movl %eax, %ebp
leaq 0x6447a(%rip), %rsi     # 0x144141
movq %rbx, %rdi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe8617
cmpl %r15d, %ebp
jne 0xdfce1
movl $0x1, %r12d
movl %r12d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdfd4d
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xdfd4d
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %r8
movq %rbx, %r9
callq *%rax
movq (%r15), %rdi
callq 0xf08ba
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x64409(%rip), %rsi     # 0x14415d
movq %r14, %rdi
movl %r9d, %edx
xorl %eax, %eax
callq 0xe9640
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfa311
// File: /workspace/github_c_makefile_star2_O3/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 0xeef09
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xea829
movq %rsp, %r12
movl $0x40, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0xeb0d6
leaq 0x695be(%rip), %rsi     # 0x149382
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xe8617
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zip.c
// Function: handle_mac_time
static void handle_mac_time(deark *c, lctx *d,
	i64 mt_raw, i64 mt_offset,
	struct de_timestamp *ts, const char *name)
{
	char timestamp_buf[64];
	de_mac_time_to_timestamp(mt_raw - mt_offset, ts);
	ts->tzcode = DE_TZCODE_UTC;
	de_dbg_timestamp_to_string(c, ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %"I64_FMT" %+"I64_FMT" (%s)", name,
		mt_raw, -mt_offset, timestamp_buf);
}

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

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

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

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

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

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

	destroy_member_data(c, md);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %r15
callq 0xdd40c
movq %rax, %r14
movb $0x1, 0x148(%rax)
movups 0x60(%r12), %xmm0
movups %xmm0, 0x150(%rax)
movq 0x70(%r12), %rax
movq %rax, 0x160(%r14)
movl 0x40(%r12), %ebp
movq 0x50(%r12), %r13
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xe8a1c
leaq 0x64a68(%rip), %rsi     # 0x144992
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %ecx
movq %r13, %r8
callq 0xdd449
testl %eax, %eax
je 0xdff9b
movq 0x18(%r14), %r8
leaq 0x10(%rsp), %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xdd449
testl %eax, %eax
je 0xdff8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xddfb3
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xe8a25
jmp 0xdffad
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xe8a25
movb $0x1, 0x39(%r12)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xde5bf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zoo.c
// Function: de_module_zoo
void de_module_zoo(deark *c, struct deark_module_info *mi)
{
	mi->id = "zoo";
	mi->desc = "Zoo compressed archive format";
	mi->run_fn = de_run_zoo;
	mi->identify_fn = de_identify_zoo;
	mi->help_fn = de_help_zoo;
}

// Assembly:
leaq 0x64b19(%rip), %rax     # 0x144ae8
movq %rax, (%rsi)
leaq 0x64b13(%rip), %rax     # 0x144aec
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xdffff
movq %rax, 0x18(%rsi)
leaq 0xf15(%rip), %rax       # 0xe0f04
movq %rax, 0x20(%rsi)
leaq 0xf33(%rip), %rax       # 0xe0f2d
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zoo.c
// Function: de_module_zoo_filter
void de_module_zoo_filter(deark *c, struct deark_module_info *mi)
{
	mi->id = "zoo_filter";
	mi->desc = "Zoo filter format";
	mi->run_fn = de_run_zoo_filter;
	mi->identify_fn = de_identify_zoo_filter;
}

// Assembly:
leaq 0x63bc8(%rip), %rax     # 0x144b0a
movq %rax, (%rsi)
leaq 0x63bc9(%rip), %rax     # 0x144b15
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xe0f67
movq %rax, 0x18(%rsi)
leaq 0x21d(%rip), %rax       # 0xe117f
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zoo.c
// Function: de_identify_zoo_filter
static int de_identify_zoo_filter(deark *c)
{
	u8 b[2];

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
sets %cl
orb %al, %cl
jne 0xe1514
cmpq %r15, 0x40(%r13)
jle 0xe1514
movq %r15, 0x40(%r13)
testq %r15, %r15
sets %al
testq %r14, %r14
setle %cl
orb %al, %cl
jne 0xe1532
leaq (%r14,%r15), %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0xe1541
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r9d, %r9d
je 0xe159b
leaq 0x36fe6(%rip), %rsi     # 0x118533
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xefda1
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq (%r13), %rax
movzbl 0x18(%rax), %ecx
orl $0x300, %ecx            # imm = 0x300
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %r8
movl $0x6, %r9d
callq 0xf1883
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf052b
cmpl $0x0, (%rbx)
jle 0xe1532
movq %rbx, %rdi
callq 0xf6410
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq (%r13), %rax
movzbl 0x18(%rax), %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r15, %rsi
movq %r14, %rdx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq %rbp, %rdi
callq 0xf70f6
leaq 0x4ab46(%rip), %rsi     # 0x12c12a
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq %rbp, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zoo.c
// Function: zoo_decompressor_fn
static void zoo_decompressor_fn(struct de_arch_member_data *md)
{
	struct zoo_member_data *mdz = (struct zoo_member_data*)md->userdata;

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rsi), %r13
movzbl 0x37(%r13), %eax
cmpq $0x7e, %rax
ja 0xe16f7
imulq $0x384, %rax, %r15      # imm = 0x384
jmp 0xe170e
testb %al, %al
js 0xe1700
xorl %r15d, %r15d
jmp 0xe170e
imulq $0x384, %rax, %r15      # imm = 0x384
addq $-0x38400, %r15         # imm = 0xFFFC7C00
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movl 0x20(%r13), %esi
movl 0x24(%r13), %edx
callq 0xea92a
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movq %rsp, %r12
movl $0x40, %edx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xeaf46
leaq 0x3d44b(%rip), %rsi     # 0x11eb8f
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe8617
cmpb $0x7f, 0x37(%r13)
movq 0x50(%r14), %rdi
jne 0xe1762
movb $0x2, 0x19(%rdi)
jmp 0xe179c
addq $0x18, %rdi
movq %r15, %rsi
callq 0xead31
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movq %rsp, %r14
movl $0x40, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xeaf46
leaq 0x63850(%rip), %rsi     # 0x144fdf
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xe8617
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/zoo.c
// Function: calc_hdr_crc
static void calc_hdr_crc(deark *c, lctx *d, struct de_arch_member_data *md, i64 lvar)
{
	struct zoo_member_data *mdz = (struct zoo_member_data*)md->userdata;

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

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

// Assembly:
leaq 0x639bd(%rip), %rax     # 0x1451f8
movq %rax, (%rsi)
leaq 0x639b7(%rip), %rax     # 0x1451fc
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0xe1864
movq %rax, 0x18(%rsi)
leaq 0x111a(%rip), %rax      # 0xe2975
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq