LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xe40f2
movq %rax, %r12
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe002e
movq %rsp, %r13
pushq $0x40
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
callq 0xe07a8
leaq 0x334d4(%rip), %rsi     # 0x109ba1
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0xde896
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/zip.c
// Function: 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 0xd3d69
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 0xdebae
leaq 0x60d9c(%rip), %rsi     # 0x137542
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xdeba7
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r13, %r8
callq 0xd3da6
testl %eax, %eax
je 0xd6814
movq 0x18(%r14), %r8
leaq 0x10(%rsp), %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xd3da6
testl %eax, %eax
je 0xd6806
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd4888
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xdebb7
jmp 0xd6826
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xdebb7
movb $0x1, 0x39(%r12)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd4e8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/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 0x60e51(%rip), %rax     # 0x137698
movq %rax, (%rsi)
leaq 0x60e4b(%rip), %rax     # 0x13769c
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xd6877
movq %rax, 0x18(%rsi)
leaq 0xe9c(%rip), %rax       # 0xd7703
movq %rax, 0x20(%rsi)
leaq 0xeb4(%rip), %rax       # 0xd7726
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5ff7f(%rip), %rax     # 0x1376ba
movq %rax, (%rsi)
leaq 0x5ff80(%rip), %rax     # 0x1376c5
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd7760
movq %rax, 0x18(%rsi)
leaq 0x1db(%rip), %rax       # 0xd7936
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd79b4
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3fa3
cmpq $0x5a32, %rax           # imm = 0x5A32
jne 0xd79b4
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rdx
addq $-0x4, %rdx
leaq 0x6(%rsp), %rbx
pushq $0x2
popq %rcx
movq %rbx, %rsi
callq 0xe3cb7
cmpb $0x0, (%rbx)
movzbl 0x1(%rbx), %eax
je 0xd79a9
pushq $0x2d
popq %rbx
leal -0x4(%rax), %ecx
cmpl $0x3c, %ecx
ja 0xd799b
movabsq $0x1000000010001011, %rdx # imm = 0x1000000010001011
btq %rcx, %rdx
jb 0xd79b4
cmpl $0x3, %eax
jb 0xd79b4
cmpl $0x80, %eax
je 0xd79b4
jmp 0xd79ad
testl %eax, %eax
je 0xd79b1
xorl %ebx, %ebx
jmp 0xd79b4
pushq $0x2d
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5fd12(%rip), %rax     # 0x1376d7
movq %rax, (%rsi)
leaq 0x5fd0e(%rip), %rax     # 0x1376dd
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd79ea
movq %rax, 0x18(%rsi)
leaq 0x268(%rip), %rax       # 0xd7c4d
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd7ca3
cmpq %r15, 0x40(%r13)
jle 0xd7ca3
movq %r15, 0x40(%r13)
testq %r15, %r15
sets %al
testq %r14, %r14
setle %cl
orb %al, %cl
jne 0xd7cc1
leaq (%r14,%r15), %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0xd7cd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r9d, %r9d
je 0xd7d26
leaq 0x33767(%rip), %rsi     # 0x10b443
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe4e62
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq (%r13), %rax
movzbl 0x18(%rax), %ecx
orl $0x300, %ecx            # imm = 0x300
pushq $0x6
popq %r9
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %r8
callq 0xe66ec
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe5591
cmpl $0x0, (%rbx)
jle 0xd7cc1
movq %rbx, %rdi
callq 0xeac74
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 0xe4ced
movq %rbp, %rdi
callq 0xeb877
leaq 0x4714b(%rip), %rsi     # 0x11eeba
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq %rbp, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/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:
movq 0x88(%rdi), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2, %eax
je 0xd7df1
cmpl $0x1, %eax
je 0xd7dd1
testl %eax, %eax
jne 0xd7e11
movq (%rdi), %rax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
movq %rax, %rdi
xorl %r8d, %r8d
jmp 0xeea8f
movq (%rdi), %rax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
movq %rax, %rdi
jmp 0xd7f74
movq (%rdi), %rax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
movq %rax, %rdi
jmp 0xd7f9e
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd7e40
imulq $0x384, %rax, %r15      # imm = 0x384
jmp 0xd7e57
testb %al, %al
js 0xd7e49
xorl %r15d, %r15d
jmp 0xd7e57
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 0xe0110
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movq %rsp, %r12
pushq $0x40
popq %rdx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xe0644
leaq 0x39c34(%rip), %rsi     # 0x111abf
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xde896
cmpb $0x7f, 0x37(%r13)
movq 0x50(%r14), %rdi
jne 0xd7ea9
movb $0x2, 0x19(%rdi)
jmp 0xd7ee1
addq $0x18, %rdi
movq %r15, %rsi
callq 0xe0491
movq 0x50(%r14), %rdi
addq $0x18, %rdi
movq %rsp, %r14
pushq $0x40
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xe0644
leaq 0x5fcbb(%rip), %rsi     # 0x137b8f
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xde896
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe0e44
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x18(%r12), %rsi
movq 0x18(%r15), %rdx
pushq $0x36
popq %rcx
callq 0xe0f33
movq (%rbx), %rax
movq 0x30(%rax), %rdi
pushq $0x2
popq %rsi
callq 0xe0f29
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x18(%r12), %rsi
movq 0x18(%r15), %rdx
addq $0x38, %rdx
movq %r14, %rcx
callq 0xe0f33
movq (%rbx), %rax
movq 0x30(%rax), %rdi
callq 0xe0e95
movl %eax, 0x30(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/zoo.c
// Function: decompress_lzd
static void decompress_lzd(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_ZOOLZD;
	delzwp.max_code_size = 13;
	fmtutil_decompress_lzw(c, dcmpri, dcmpro, dres, &delzwp);
}

// Assembly:
subq $0x18, %rsp
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r8
movups %xmm0, 0x4(%r8)
movl $0x4, (%r8)
movl $0xd, 0xc(%r8)
callq 0xf644c
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5fdd9(%rip), %rax     # 0x137da8
movq %rax, (%rsi)
leaq 0x5fdd3(%rip), %rax     # 0x137dac
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0xd7ff8
movq %rax, 0x18(%rsi)
leaq 0xefc(%rip), %rax       # 0xd8eeb
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rar.c
// Function: rar_get_fmtver
static int rar_get_fmtver(dbuf *f, i64 pos)
{
	u8 buf[8];

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
leaq 0x8(%rsp), %rbx
pushq $0x8
popq %rcx
movq %rbx, %rsi
callq 0xe3cb7
leaq 0x5ede8(%rip), %rsi     # 0x137d08
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x18230
testl %eax, %eax
je 0xd8f4f
movabsq $0x1071a21726152, %rax  # imm = 0x1071A21726152
cmpq %rax, 0x8(%rsp)
je 0xd8f53
xorl %eax, %eax
cmpl $0x5e7e4552, 0x8(%rsp)  # imm = 0x5E7E4552
sete %al
jmp 0xd8f56
pushq $0x4
jmp 0xd8f55
pushq $0x5
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rar.c
// Function: rar_handle_noncmpr_comment
static void rar_handle_noncmpr_comment(deark *c, de_arch_lctx *d, i64 pos, i64 len,
	de_encoding enc, int is_file_comment)
{
	de_ucstring *comment = NULL;
	const char *ext;

	if(len<1) goto done;

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

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

done:
	ucstring_destroy(comment);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0xd8faf
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpl $0x2, 0x90(%rdi)
jl 0xd8fb3
testl %ebp, %ebp
leaq 0x324b9(%rip), %rax     # 0x10b443
leaq 0x324b1(%rip), %rcx     # 0x10b442
cmoveq %rax, %rcx
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
pushq $0x1
popq %r9
movq %r12, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xe4e0b
jmp 0xd901a
xorl %ebx, %ebx
jmp 0xd901a
movl %ecx, %r13d
movq %r14, %rdi
callq 0xeac74
movq %rax, %rbx
movq 0x18(%r14), %rdi
movzbl %r13b, %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0xe4ced
testl %ebp, %ebp
leaq 0x5ec70(%rip), %rax     # 0x137c60
leaq 0x5ee59(%rip), %r15     # 0x137e50
cmoveq %rax, %r15
movq %rbx, %rdi
callq 0xeb877
leaq 0x5ee36(%rip), %rsi     # 0x137e40
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rar.c
// Function: rar_get_vint_p
static u64 rar_get_vint_p(de_arch_lctx *d, dbuf *f, i64 *ppos)
{
	u64 val = 0;
	UI nbits_set = 0;

	// TODO: Better handling of errors & oversized ints
	while(1) {
		u8 b;

		if(nbits_set>=64) { val = 0; break; }
		b = dbuf_getbyte_p(f, ppos);
		if(nbits_set < 64) {
			val |= (((u64)(b&0x7f))<<nbits_set);
			nbits_set += 7;
		}
		if((b&0x80)==0) break;
	}
	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq $0x3f, %r12
ja 0xd9a28
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe3f2a
movl %eax, %ecx
andb $0x7f, %cl
movzbl %cl, %edx
movl %r12d, %ecx
shlq %cl, %rdx
orq %rdx, %r15
addq $0x7, %r12
testb %al, %al
js 0xd99fc
jmp 0xd9a2b
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rodraw.c
// Function: de_module_rodraw
void de_module_rodraw(deark *c, struct deark_module_info *mi)
{
	mi->id = "rodraw";
	mi->desc = "RISC OS Draw, Acorn Draw";
	mi->run_fn = de_run_rodraw;
	mi->identify_fn = de_identify_rodraw;
}

// Assembly:
leaq 0x5e8a2(%rip), %rax     # 0x1382e5
movq %rax, (%rsi)
leaq 0x5e89f(%rip), %rax     # 0x1382ec
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xd9a68
movq %rax, 0x18(%rsi)
leaq 0xb9(%rip), %rax        # 0xd9b1c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rodraw.c
// Function: de_run_rodraw
static void de_run_rodraw(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;

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

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

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

done:
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0xc
popq %rsi
callq 0xdecaf
movq %rax, %r14
leaq 0x52968(%rip), %rsi     # 0x12c3ee
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
leaq 0x8(%rsp), %r15
movq $0x4, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movl %eax, (%r14)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movl %eax, 0x4(%r14)
movl (%r14), %edx
leaq 0x5e833(%rip), %rsi     # 0x138305
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xde896
addq $0x1c, (%r15)
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
addq $-0x28, %rcx
pushq $0x28
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9b69
movq %rbx, %rdi
movq %r14, %rsi
callq 0xded32
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rodraw.c
// Function: do_object_sprite
static void do_object_sprite(deark *c, lctx *d, struct objinfo *oi)
{
	i64 dpos, dlen;
	dbuf *outf = NULL;
	de_finfo *fi = NULL;

	fi = de_finfo_create(c);

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
callq 0xdfd1a
movq %rax, %r14
movq 0x18(%r12), %rax
movq 0x20(%r12), %rcx
leaq -0x18(%rcx), %r15
cmpl $0xd, (%r12)
cmovneq %rcx, %r15
leaq 0x18(%rax), %r12
cmovneq %rax, %r12
cmpq $0x10, %r15
jl 0xd9dfa
movq %rbx, %rdi
callq 0xeac74
movq %rax, %r13
movq 0x18(%rbx), %rdi
leaq 0x4(%r12), %rsi
pushq $0xc
popq %rdx
pushq $0x1
popq %r8
pushq $0x14
popq %r9
movq %rax, %rcx
callq 0xe4c9a
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xdfd55
movq %r13, %rdi
callq 0xeaf3c
leaq 0x5e5c5(%rip), %rsi     # 0x1383c6
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r13
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xe5f7f
pushq $0x10
popq %rsi
movq %r13, %rdi
callq 0xe5f7f
leaq 0x10(%r15), %rsi
movq %r13, %rdi
callq 0xe5f7f
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xe45f4
movq %r13, %rdi
callq 0xe5591
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xdfd24
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/rm.c
// Function: de_module_rm
void de_module_rm(deark *c, struct deark_module_info *mi)
{
	mi->id = "rm";
	mi->desc = "RealMedia";
	mi->run_fn = de_run_rm;
	mi->identify_fn = de_identify_rm;
}

// Assembly:
leaq 0x33ed7(%rip), %rax     # 0x10e082
movq %rax, (%rsi)
leaq 0x5e278(%rip), %rax     # 0x13842d
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xda1d0
movq %rax, 0x18(%rsi)
leaq 0x598(%rip), %rax       # 0xda763
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/reko.c
// Function: de_module_reko
void de_module_reko(deark *c, struct deark_module_info *mi)
{
	mi->id = "reko";
	mi->desc = "REKO cardset";
	mi->run_fn = de_run_reko;
	mi->identify_fn = de_identify_reko;
	mi->help_fn = de_help_reko;
}

// Assembly:
leaq 0x5dd5c(%rip), %rax     # 0x13851b
movq %rax, (%rsi)
leaq 0x5dd57(%rip), %rax     # 0x138520
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xda7ef
movq %rax, 0x18(%rsi)
leaq 0x11e6(%rip), %rax      # 0xdb9c5
movq %rax, 0x20(%rsi)
leaq 0x11ed(%rip), %rax      # 0xdb9d7
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/reko.c
// Function: de_module_wizsolitaire
void de_module_wizsolitaire(deark *c, struct deark_module_info *mi)
{
	mi->id = "wizsolitaire";
	mi->desc = "Wiz Solitaire deck";
	mi->run_fn = de_run_wizsolitaire;
	mi->identify_fn = de_identify_wizsolitaire;
}

// Assembly:
leaq 0x5cb41(%rip), %rax     # 0x13852d
movq %rax, (%rsi)
leaq 0x5cb44(%rip), %rax     # 0x13853a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xdba11
movq %rax, 0x18(%rsi)
leaq 0x2df(%rip), %rax       # 0xdbceb
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/reko.c
// Function: reko_fmt_from_sig
static u8 reko_fmt_from_sig(deark *c)
{
	u8 buf[8];

	de_read(buf, 0, sizeof(buf));

	if(!de_memcmp(buf, (const void*)"REKO", 4)) {
		// Just to screen out text files, I think we can assume the high byte
		// of the cardsize field is 0.
		if(de_getbyte(8) == 0) {
			return RKFMT_AMIGA;
		}
	}
	if(!de_memcmp(buf, (const void*)"PCREKO", 6)) {
		if(buf[6]=='D' && buf[7]==0x20) return RKFMT_RKP8;
		if(buf[6]==0 && buf[7]==0) return RKFMT_RKP16;
	}
	if(!de_memcmp(buf, (const void*)"PCRKP\0", 6)) {
		return RKFMT_RKP24;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %r14
pushq $0x8
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xe3cb7
cmpl $0x4f4b4552, (%r14)     # imm = 0x4F4B4552
jne 0xdbd41
movq 0x18(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0xe3eb4
testb %al, %al
je 0xdbd98
leaq 0x5c851(%rip), %rsi     # 0x138599
movq %rsp, %rdi
pushq $0x6
popq %rdx
callq 0x18230
testl %eax, %eax
je 0xdbd75
leaq 0x5c7b6(%rip), %rsi     # 0x138514
movq %rsp, %rdi
pushq $0x6
popq %rdx
callq 0x18230
xorl %ecx, %ecx
testl %eax, %eax
pushq $0x6
popq %rax
cmovnel %ecx, %eax
jmp 0xdbd9a
movb 0x6(%rsp), %cl
movb 0x7(%rsp), %dl
movl %ecx, %esi
xorb $0x44, %sil
movl %edx, %edi
xorb $0x20, %dil
movb $0x4, %al
orb %sil, %dil
je 0xdbd9a
movb $0x5, %al
orb %dl, %cl
jne 0xdbd57
jmp 0xdbd9a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/reko.c
// Function: set_reko_card_filename
static void set_reko_card_filename(deark *c, i64 idx_of_first_main_card,
	i64 cardidx, de_finfo *fi)
{
	static const char *cnames = "a23456789tjqk";
	static const char *snames = "cdhs";
	char nbuf[16];

	if(cardidx>=idx_of_first_main_card && cardidx<idx_of_first_main_card+52) {
		nbuf[0] = cnames[(cardidx-idx_of_first_main_card)/4];
		nbuf[1] = snames[(cardidx-idx_of_first_main_card)%4];
		nbuf[2] = '\0';
	}
	else if(cardidx==0) {
		de_strlcpy(nbuf, "back", sizeof(nbuf));
	}
	else {
		de_strlcpy(nbuf, "other", sizeof(nbuf));
	}

	de_finfo_set_name_from_sz(c, fi, nbuf, 0, DE_ENCODING_LATIN1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %rdx, %rax
subq %rsi, %rax
setge %cl
addq $0x34, %rsi
cmpq %rdx, %rsi
setg %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0xdbdf6
pushq $0x4
popq %rcx
cqto
idivq %rcx
leaq 0x5c866(%rip), %rcx     # 0x138641
movb (%rax,%rcx), %al
movb %al, (%rsp)
leaq 0x5c867(%rip), %rax     # 0x13864f
movb (%rdx,%rax), %al
movb %al, 0x1(%rsp)
movb $0x0, 0x2(%rsp)
jmp 0xdbe16
testq %rdx, %rdx
je 0xdbe04
leaq 0x635cb(%rip), %rsi     # 0x13f3cd
jmp 0xdbe0b
leaq 0x5c849(%rip), %rsi     # 0x138654
movq %rsp, %rdi
pushq $0x10
popq %rdx
callq 0xde492
movq %rsp, %rdx
pushq $0x5
popq %r8
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xdffbd
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/sgiimage.c
// Function: de_module_sgiimage
void de_module_sgiimage(deark *c, struct deark_module_info *mi)
{
	mi->id = "sgiimage";
	mi->desc = "SGI image";
	mi->run_fn = de_run_sgiimage;
	mi->identify_fn = de_identify_sgiimage;
}

// Assembly:
leaq 0x5c974(%rip), %rax     # 0x1387af
movq %rax, (%rsi)
leaq 0x5c973(%rip), %rax     # 0x1387b8
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xdbe60
movq %rax, 0x18(%rsi)
leaq 0x6fe(%rip), %rax       # 0xdc559
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/sgiimage.c
// Function: de_identify_sgiimage
static int de_identify_sgiimage(deark *c)
{
	UI n;

	if(c->infile->len<513) return 0;

	n = (UI)de_getu16be(0); // MAGIC
	if(n!=474) return 0;

	n = (UI)de_getbyte(2); // "STORAGE"
	if(n>1) return 0;

	n = (UI)de_getbyte(3); // "BPC"
	if(n<1 || n>2) return 0;

	n = (UI)de_getu16be(4); // "DIMENSION"
	// Only 1-3 are legal, but we allow 0-4 because this field is confusing
	// and underspecified.
	if(n>4) return 0;

	n = (UI)de_getu16be(10); // "ZSIZE"
	// Allow 0 because this field may be unused for some image types.
	if(n>4) return 0;

	return 60;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0x201, 0x18(%rdi)      # imm = 0x201
jl 0xdc5ca
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3f46
cmpl $0x1da, %eax            # imm = 0x1DA
jne 0xdc5ca
movq 0x18(%r14), %rdi
pushq $0x2
popq %rsi
callq 0xe3eb4
cmpb $0x1, %al
ja 0xdc5ca
movq 0x18(%r14), %rdi
pushq $0x3
popq %rsi
callq 0xe3eb4
addb $-0x3, %al
cmpb $-0x2, %al
jb 0xdc5ca
movq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
callq 0xe3f46
cmpl $0x4, %eax
ja 0xdc5ca
movq 0x18(%r14), %rdi
pushq $0xa
popq %rsi
callq 0xe3f46
xorl %ecx, %ecx
cmpl $0x5, %eax
pushq $0x3c
popq %rbx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/sgiimage.c
// Function: sgiimage_decode_image
static void sgiimage_decode_image(deark *c, struct sgiimage_ctx *d,
	dbuf *inf, i64 pos1, de_bitmap *img, de_bitmap *imglo)
{
	i64 pos = pos1;
	i64 pn;
	i64 i, j;

	for(pn=0; pn<d->num_channels; pn++) {
		i64 samplenum;

		if(d->has_alpha && pn==(d->num_channels-1))
			samplenum = 3;
		else
			samplenum = pn;

		for(j=0; j<d->height; j++) {
			for(i=0; i<d->width; i++) {
				UI s;

				s = sgiimage_getsample_p(d, inf, &pos);

				if(imglo) {
					de_bitmap_setsample(img, i, j, samplenum, (de_colorsample)(s>>8));
					de_bitmap_setsample(imglo, i, j, samplenum, (s&0xff));
				}
				else {
					de_bitmap_setsample(img, i, j, samplenum, (de_colorsample)s);
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, (%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
leaq 0x20(%rsp), %rax
movq %rdx, (%rax)
xorl %ecx, %ecx
movq 0x30(%rbp), %rax
cmpq %rax, %rcx
jge 0xdc6cb
decq %rax
cmpq %rax, %rcx
movq %rcx, %rdx
pushq $0x3
popq %rax
cmoveq %rax, %rdx
cmpb $0x0, 0x39(%rbp)
movq %rcx, 0x10(%rsp)
cmoveq %rcx, %rdx
movq %rdx, 0x8(%rsp)
xorl %r13d, %r13d
cmpq 0x28(%rbp), %r13
jge 0xdc6be
xorl %r14d, %r14d
cmpq 0x20(%rbp), %r14
jge 0xdc6b6
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xdc6da
movl %eax, %r15d
testq %rbx, %rbx
je 0xdc699
movl %r15d, %r8d
shrl $0x8, %r8d
movl $0xff, %eax
andl %eax, %r8d
movq (%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %r12
movq %r12, %rcx
callq 0xe712a
movl $0xff, %eax
andl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %r15d, %r8d
jmp 0xdc6ac
movzbl %r15b, %r8d
movq (%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
callq 0xe712a
incq %r14
jmp 0xdc63a
incq %r13
jmp 0xdc62d
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0xdc5fb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/sgiimage.c
// Function: sgiimage_getsample_p
static UI sgiimage_getsample_p(struct sgiimage_ctx *d, dbuf *f, i64 *ppos)
{
	UI s;

	if(d->bytes_per_sample==2) {
		s = (UI)dbuf_getu16be_p(f, ppos);
	}
	else {
		s = dbuf_getbyte_p(f, ppos);
	}
	return s;
}

// Assembly:
pushq %rax
cmpl $0x2, 0x8(%rdi)
jne 0xdc6ee
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xe3f6e
jmp 0xdc6fc
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xe3f2a
movzbl %al, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/storyboard.c
// Function: de_module_storyboard
void de_module_storyboard(deark *c, struct deark_module_info *mi)
{
	mi->id = "storyboard";
	mi->desc = "Storyboard PIC/CAP";
	mi->run_fn = de_run_storyboard;
	mi->identify_fn = de_identify_storyboard;
}

// Assembly:
leaq 0x5c2d9(%rip), %rax     # 0x1389e0
movq %rax, (%rsi)
leaq 0x5c2da(%rip), %rax     # 0x1389eb
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xdc72c
movq %rax, 0x18(%rsi)
leaq 0xda5(%rip), %rax       # 0xdd4cc
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/storyboard.c
// Function: de_identify_storyboard
static int de_identify_storyboard(deark *c)
{
	u8 b[6];
	int has_ext;

	de_read(b, 0, sizeof(b));

	if(!de_memcmp(b, (const void*)"EP_CAP", 6)) {
		return 100;
	}

	if(c->infile->len<1856) return 0;
	if(b[2]!=0xc1) return 0;
	if(b[0]!=0x00 && b[0]!=0x54) return 0;

	has_ext = de_input_file_has_ext(c, "pic") ||
		de_input_file_has_ext(c, "cap");

	if(b[1]==0x84) {
		if(b[3]==0x01 || b[3]==0x03 || b[3]==0x07 || b[3]==0x08) {
			return has_ext ? 90 : 50;
		}
	}
	else if(b[1]==0x85 || b[1]==0x86) {
		return has_ext ? 51 : 11;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0x2(%rsp), %r15
pushq $0x6
popq %r12
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0xe3cb7
leaq 0x5b635(%rip), %rsi     # 0x138b2f
movq %r15, %rdi
movq %r12, %rdx
callq 0x18230
testl %eax, %eax
je 0xdd582
movq 0x18(%r14), %rax
cmpq $0x740, 0x18(%rax)      # imm = 0x740
jl 0xdd59b
cmpb $-0x3f, 0x4(%rsp)
jne 0xdd59b
movzbl 0x2(%rsp), %eax
cmpl $0x54, %eax
je 0xdd530
testl %eax, %eax
jne 0xdd59b
leaq 0x4b94e(%rip), %rsi     # 0x128e85
movq %r14, %rdi
callq 0xdfcd5
movb $0x1, %cl
testl %eax, %eax
jne 0xdd559
leaq 0x5b5ea(%rip), %rsi     # 0x138b36
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
setne %cl
movb 0x3(%rsp), %al
cmpb $-0x7c, %al
jne 0xdd587
movzbl 0x5(%rsp), %eax
cmpl $0x8, %eax
ja 0xdd59b
movl $0x18a, %edx            # imm = 0x18A
btl %eax, %edx
jae 0xdd59b
testb %cl, %cl
pushq $0x5a
popq %rax
pushq $0x32
popq %rbx
cmovnel %eax, %ebx
jmp 0xdd59b
pushq $0x64
popq %rbx
jmp 0xdd59b
addb $0x7b, %al
testb %cl, %cl
pushq $0x33
popq %rcx
pushq $0xb
popq %rdx
cmovnel %ecx, %edx
xorl %ebx, %ebx
cmpb $0x2, %al
cmovbl %edx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/xwd.c
// Function: de_module_xwd
void de_module_xwd(deark *c, struct deark_module_info *mi)
{
	mi->id = "xwd";
	mi->desc = "X-Windows screen dump";
	mi->run_fn = de_run_xwd;
	mi->identify_fn = de_identify_xwd;
}

// Assembly:
leaq 0x5b3ef(%rip), %rax     # 0x138b3a
movq %rax, (%rsi)
leaq 0x5b3e9(%rip), %rax     # 0x138b3e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xdd770
movq %rax, 0x18(%rsi)
leaq 0xb92(%rip), %rax       # 0xde2fd
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/xwd.c
// Function: de_identify_xwd
static int de_identify_xwd(deark *c)
{
	int has_ext = 0;
	i64 hdrsize;
	i64 cmapn;
	UI n;

	// TODO: Identification could be improved.

	n = (UI)de_getu32be(4); // version
	if (n!=7) return 0;

	hdrsize = (UI)de_getu32be(0);
	if(hdrsize<100 || hdrsize>500) return 0;

	n = (UI)de_getu32be(8); // pixfmt
	if(n>2) return 0;

	n = (UI)de_getu32be(12); // depth
	if(n<1 || n>32) return 0;

	cmapn = de_getu32be(76);
	if(cmapn>512) return 0;
	if(hdrsize + 12*cmapn > c->infile->len) return 0;

	has_ext = de_input_file_has_ext(c, "xwd");
	if(has_ext) return 100;
	return 75;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
pushq $0x4
popq %rsi
callq 0xe404f
xorl %ebx, %ebx
cmpl $0x7, %eax
jne 0xde39f
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe404f
movl %eax, %r15d
leaq -0x1f5(%r15), %rax
cmpq $-0x191, %rax           # imm = 0xFE6F
jb 0xde39f
movq 0x18(%r14), %rdi
pushq $0x8
popq %rsi
callq 0xe404f
cmpl $0x2, %eax
ja 0xde39f
movq 0x18(%r14), %rdi
pushq $0xc
popq %rsi
callq 0xe404f
addl $-0x21, %eax
cmpl $-0x20, %eax
jb 0xde39f
movq 0x18(%r14), %rdi
pushq $0x4c
popq %rsi
callq 0xe404f
cmpq $0x200, %rax            # imm = 0x200
jg 0xde39f
imulq $0xc, %rax, %rax
addq %r15, %rax
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rax
jg 0xde39f
leaq 0x5a7ae(%rip), %rsi     # 0x138b3a
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0x4b
popq %rax
pushq $0x64
popq %rbx
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_strcasecmp_internal
static int de_strcasecmp_internal(const char *a, const char *b,
	int has_n, size_t n)
{
	size_t k = 0;

	while(1) {
		unsigned char a1, b1;

		if(has_n && (k>=n)) break;
		a1 = (unsigned char)a[k];
		b1 = (unsigned char)b[k];
		if(a1==0 && b1==0) break;
		if(a1>='A' && a1<='Z') a1 += 32;
		if(b1>='A' && b1<='Z') b1 += 32;
		if(a1<b1) return -1;
		if(a1>b1) return 1;
		k++;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x1, %r9d
xorl %r10d, %r10d
testl %edx, %edx
sete %r11b
cmpq %rcx, %r10
setb %bl
orb %r11b, %bl
cmpb $0x1, %bl
jne 0xde54b
movb (%rdi,%r10), %bl
movb (%rsi,%r10), %r11b
movl %ebx, %ebp
orb %r11b, %bpl
je 0xde54b
leal -0x41(%rbx), %ebp
movzbl %bl, %r14d
orb $0x20, %bl
cmpb $0x1a, %bpl
movzbl %bl, %ebx
cmovael %r14d, %ebx
leal -0x41(%r11), %ebp
movzbl %r11b, %r14d
orb $0x20, %r11b
cmpb $0x1a, %bpl
movzbl %r11b, %r11d
cmovael %r14d, %r11d
cmpb %r11b, %bl
jb 0xde548
incq %r10
cmpb %r11b, %bl
jbe 0xde4e6
movl %r9d, %eax
jmp 0xde54b
movl %r8d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_vdbg_internal
static void de_vdbg_internal(deark *c, const char *fmt, va_list ap)
{
	char bars_and_spaces[128];
	size_t bpos;
	int nspaces;
	int nbars;
	const char *dprefix = "DEBUG: ";

	if(c) {
		if(c->dprefix) dprefix = c->dprefix;

		nbars = c->module_nesting_level - 1;
		if(nbars>10) nbars=10;

		nspaces = c->dbg_indent_amount;
		if(nspaces>50) nspaces=50;
	}
	else {
		nbars = 0;
		nspaces = 0;
	}

	bpos = 0;
	while(nbars>0) {
		// One or more vertical lines, to indicate module nesting
		bars_and_spaces[bpos++] = '\xe2'; // U+2502 Box drawings light vertical
		bars_and_spaces[bpos++] = '\x94';
		bars_and_spaces[bpos++] = '\x82';
		nbars--;
	}
	while(nspaces>0) {
		bars_and_spaces[bpos++] = ' ';
		nspaces--;
	}
	bars_and_spaces[bpos] = '\0';

	de_printf(c, DE_MSGTYPE_DEBUG, "%s%s", dprefix, bars_and_spaces);
	de_vprintf(c, DE_MSGTYPE_DEBUG, fmt, ap);
	de_puts(c, DE_MSGTYPE_DEBUG, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdi, %rdi
je 0xde977
movq 0x120(%rbx), %rax
testq %rax, %rax
leaq 0x5a725(%rip), %rcx     # 0x139079
cmovneq %rax, %rcx
movl 0x10(%rbx), %eax
movl 0xc8(%rbx), %edx
cmpl $0xb, %eax
pushq $0xb
popq %rsi
cmovll %eax, %esi
decl %esi
cmpl $0x32, %edx
pushq $0x32
popq %rax
cmovll %edx, %eax
jmp 0xde982
leaq 0x5a6fb(%rip), %rcx     # 0x139079
xorl %eax, %eax
xorl %esi, %esi
movq %rsp, %rdx
testl %esi, %esi
jle 0xde9a2
movw $0x94e2, (%rdx)         # imm = 0x94E2
movb $-0x7e, 0x2(%rdx)
decl %esi
addq $0x3, %rdx
jmp 0xde985
movb $0x20, (%rdx)
decl %eax
incq %rdx
testl %eax, %eax
jg 0xde99a
movb $0x0, (%rdx)
leaq 0x5a6ed(%rip), %rdx     # 0x13909d
pushq $0x3
popq %rbp
movq %rsp, %r8
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0xde7db
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xde85b
leaq 0x247ae(%rip), %rdx     # 0x103187
movq %rbx, %rdi
movl %ebp, %esi
callq 0xde567
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_render_hexbytes_from_mem
char *de_render_hexbytes_from_mem(const u8 *inbytes, i64 ilen,
	char *outbuf, size_t outbuf_len)
{
	i64 inpos;
	size_t outpos = 0;

	if(ilen<1) goto done;
	if(ilen > (i64)(outbuf_len/3)) {
		ilen = (i64)(outbuf_len/3);
	}

	for(inpos = 0; inpos<ilen; inpos++) {
		if(inpos>0) outbuf[outpos++] = ' ';
		outbuf[outpos++] = de_get_hexchar((int)(inbytes[inpos]/16));
		outbuf[outpos++] = de_get_hexchar((int)(inbytes[inpos]%16));
	}

done:
	outbuf[outpos] = '\0';
	return outbuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
jle 0xdec2b
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x3
popq %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
cmpq %r14, %rax
cmovbq %rax, %r14
xorl %r13d, %r13d
cmpq %r12, %r14
je 0xdec2e
testq %r12, %r12
je 0xdebff
movb $0x20, (%rbx,%r13)
incq %r13
movzbl (%r15,%r12), %edi
shrl $0x4, %edi
callq 0xe11b0
movb %al, (%rbx,%r13)
movzbl (%r15,%r12), %edi
andl $0xf, %edi
callq 0xe11b0
movb %al, 0x1(%rbx,%r13)
addq $0x2, %r13
incq %r12
jmp 0xdebed
xorl %r13d, %r13d
movb $0x0, (%rbx,%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_malloc
void *de_malloc(deark *c, i64 n)
{
	void *m;

	if(n==0) n=1;
	if(n<0 || n>DE_MAX_MALLOC) {
		de_err(c,"Out of memory (%"I64_FMT" bytes requested)", n);
		de_fatalerror(c);
		// NOTREACHED
		n = 1;
	}

	while(1) {
		m = calloc((size_t)n, 1);
		if(m) return m;

		de_err(c, "Memory allocation failed (%"I64_FMT" bytes)", n);
		de_fatalerror(c);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x1, %rsi
movq %rsi, %r14
adcq $0x0, %r14
cmpq $0x1dcd6501, %rsi       # imm = 0x1DCD6501
jb 0xdecf1
pushq $0x1
popq %r15
leaq 0x5a225(%rip), %rsi     # 0x138efe
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
callq 0xdf4d0
movq %r15, %r14
pushq $0x1
popq %r15
leaq 0x5a226(%rip), %r12     # 0x138f22
movq %r14, %rdi
movq %r15, %rsi
callq 0x18190
testq %rax, %rax
jne 0xded26
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
callq 0xdf4d0
jmp 0xdecfc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_dbg_hexdump
void de_dbg_hexdump(deark *c, dbuf *f, i64 pos1,
	i64 nbytes_avail, i64 max_nbytes_to_dump,
	const char *prefix1, unsigned int flags)
{
	struct hexdump_ctx hctx;

	hctx.flags = flags;
	hctx.prefix = (prefix1) ? prefix1 : "data";
	hctx.printlinefn = hexdump_printline_dbg;

	de_hexdump_internal(c, &hctx, f, pos1, nbytes_avail, max_nbytes_to_dump);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %r8, %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movl 0x130(%rsp), %r10d
testq %r9, %r9
leaq 0x4e2d2(%rip), %r11     # 0x12d031
cmovneq %r9, %r11
movq %rsp, %rsi
movl %r10d, 0x10(%rsi)
movq %r11, (%rsi)
leaq 0x14(%rip), %r9         # 0xded88
movq %r9, 0x18(%rsi)
movq %rax, %r9
callq 0xded9a
addq $0x128, %rsp            # imm = 0x128
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_hexdump2
void de_hexdump2(deark *c, dbuf *f, i64 pos1, i64 nbytes_avail,
	i64 max_nbytes_to_dump, unsigned int flags)
{
	struct hexdump_ctx hctx;

	hctx.flags = flags | 0x2;
	hctx.prefix = NULL;
	hctx.printlinefn = hexdump_printline_ext;
	de_hexdump_internal(c, &hctx, f, pos1, nbytes_avail, max_nbytes_to_dump);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %r8, %rax
movq %rcx, %r8
movq %rdx, %rcx
orl $0x2, %r9d
movq %rsp, %r10
movl %r9d, 0x10(%r10)
andq $0x0, (%r10)
movq %rsi, %rdx
leaq 0x17(%rip), %rsi        # 0xdf024
movq %rsi, 0x18(%r10)
movq %r10, %rsi
movq %rax, %r9
callq 0xded9a
addq $0x128, %rsp            # imm = 0x128
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_get_colorsample_code
char *de_get_colorsample_code(deark *c, de_color clr, char *csamp,
	size_t csamplen)
{
	unsigned int r, g, b;

	if(csamplen<8) {
		csamp[0]='\0';
		return csamp;
	}

	r = (unsigned int)DE_COLOR_R(clr);
	g = (unsigned int)DE_COLOR_G(clr);
	b = (unsigned int)DE_COLOR_B(clr);

	// Only the low 4 bits are significant. We add 16 so that the bits can't
	// all be 0; since we can't have NUL bytes in this NUL-terminated string.
	// Also, it's nice if the values are all <= 127, to make them UTF-8
	// compatible.
	csamp[0] = '\x03'; // refer to DE_CODEPOINT_RGBSAMPLE
	csamp[1] = 16 + (r>>4)%16;
	csamp[2] = 16 + r%16;
	csamp[3] = 16 + (g>>4)%16;
	csamp[4] = 16 + g%16;
	csamp[5] = 16 + (b>>4)%16;
	csamp[6] = 16 + b%16;
	csamp[7] = '\0';
	return csamp;
}

// Assembly:
movq %rdx, %rax
cmpq $0x8, %rcx
jae 0xdf0f8
xorl %ecx, %ecx
jmp 0xdf150
movl %esi, %ecx
shrl $0x10, %ecx
movl %esi, %edx
shrl $0x8, %edx
movl %esi, %edi
shrl $0x14, %edi
andb $0xf, %dil
orb $0x10, %dil
movb %dil, 0x1(%rax)
andb $0xf, %cl
orb $0x10, %cl
movb %cl, 0x2(%rax)
movl %esi, %ecx
shrl $0xc, %ecx
andb $0xf, %cl
orb $0x10, %cl
movb %cl, 0x3(%rax)
andb $0xf, %dl
orb $0x10, %dl
movb %dl, 0x4(%rax)
movl %esi, %ecx
shrb $0x4, %cl
orb $0x10, %cl
movb %cl, 0x5(%rax)
andb $0xf, %sil
orb $0x10, %sil
movb %sil, 0x6(%rax)
movb $0x0, 0x7(%rax)
movb $0x3, %cl
movb %cl, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_dbg_pal_entry2
void de_dbg_pal_entry2(deark *c, i64 idx, de_color clr,
	const char *txt_before, const char *txt_in, const char *txt_after)
{
	int r,g,b,a;
	char astr[32];
	char csamp[16];

	if(c->debug_level<2) return;
	if(!txt_before) txt_before="";
	if(!txt_in) txt_in="";
	if(!txt_after) txt_after="";
	r = (int)DE_COLOR_R(clr);
	g = (int)DE_COLOR_G(clr);
	b = (int)DE_COLOR_B(clr);
	a = (int)DE_COLOR_A(clr);
	if(a!=0xff) {
		de_snprintf(astr, sizeof(astr), ",A=%d", a);
	}
	else {
		astr[0] = '\0';
	}

	de_get_colorsample_code(c, clr, csamp, sizeof(csamp));
	de_dbg2(c, "pal[%3d] = %s(%3d,%3d,%3d%s%s)%s%s", (int)idx, txt_before,
		r, g, b, astr, txt_in, csamp, txt_after);
}

// Assembly:
cmpl $0x2, (%rdi)
jl 0xdf23a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
testq %rcx, %rcx
leaq 0x59c57(%rip), %rax     # 0x138de0
cmoveq %rax, %r15
testq %r8, %r8
cmoveq %rax, %rbx
testq %r9, %r9
cmoveq %rax, %r14
movl %edx, %r12d
shrl $0x10, %r12d
movl $0xff, %eax
andl %eax, %r12d
movl %edx, %r13d
shrl $0x8, %r13d
andl %eax, %r13d
movl %edx, %ecx
andl %eax, %ecx
movq %rcx, 0x8(%rsp)
movl %edx, %ecx
shrl $0x18, %ecx
cmpl %eax, %ecx
jne 0xdf1cd
movb $0x0, 0x20(%rsp)
jmp 0xdf1e3
leaq 0x59cc3(%rip), %rdx     # 0x138e97
leaq 0x20(%rsp), %rdi
pushq $0x20
popq %rsi
xorl %eax, %eax
callq 0xde40c
leaq 0x40(%rsp), %rdx
pushq $0x10
popq %rcx
movl %ebp, %esi
movq %rdx, %rbp
callq 0xdf0eb
subq $0x8, %rsp
leaq 0x28(%rsp), %r10
leaq 0x59c98(%rip), %rsi     # 0x138e9d
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq %r15, %rcx
movl %r12d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
pushq %r14
pushq %rbp
pushq %rbx
pushq %r10
pushq 0x30(%rsp)
callq 0xde9f1
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_verr
void de_verr(deark *c, const char *fmt, va_list ap)
{
	if(c) {
		c->error_count++;
	}

	de_puts(c, DE_MSGTYPE_ERROR, "Error: ");
	de_vprintf(c, DE_MSGTYPE_ERROR, fmt, ap);
	de_puts(c, DE_MSGTYPE_ERROR, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdi, %rdi
je 0xdf266
incl 0x48(%rbx)
leaq 0x59c53(%rip), %rdx     # 0x138ec0
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xde567
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xde85b
leaq 0x23ef6(%rip), %rdx     # 0x103187
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xde567
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_vwarn
void de_vwarn(deark *c, const char *fmt, va_list ap)
{
	if(!c->show_warnings) return;
	de_puts(c, DE_MSGTYPE_WARNING, "Warning: ");
	de_vprintf(c, DE_MSGTYPE_WARNING, fmt, ap);
	de_puts(c, DE_MSGTYPE_WARNING, "\n");
}

// Assembly:
cmpl $0x0, 0xc4(%rdi)
je 0xdf37e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x59b7f(%rip), %rdx     # 0x138ec8
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xde567
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xde85b
leaq 0x23e1d(%rip), %rdx     # 0x103187
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xde567
retq