LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/lzhuf.h
// Function: lzhuf_decodesubtree_node
static void lzhuf_decodesubtree_node(struct lzahuf_ctx *cctx, UI p1, u64 val, UI val_nbits,
	char *b2buf, size_t b2buf_len)
{
	if(cctx->son[p1] < cctx->lzhuf_T) { // [pointer node]
		lzhuf_decodesubtree_nodepair(cctx, cctx->son[p1], val, val_nbits, b2buf, b2buf_len);
	}
	else { // [leaf node]
		de_dbg(cctx->c, "code: \"%s\" = %d [%u]",
			de_print_base2_fixed(b2buf, b2buf_len, val, val_nbits),
			(int)cctx->son[p1], (UI)(cctx->son[p1]-cctx->lzhuf_T));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzwl 0xcd6(%rax,%rcx,2), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jae 0x18c7cf
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzwl 0xcd6(%rax,%rcx,2), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x18c830
jmp 0x18c82a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x15cf60
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzwl 0xcd6(%rax,%rcx,2), %ecx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %esi
movzwl 0xcd6(%rax,%rsi,2), %r8d
movq -0x8(%rbp), %rax
subl 0x3c(%rax), %r8d
leaq 0x4b422(%rip), %rsi     # 0x1d7c45
movb $0x0, %al
callq 0x15b0d0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-iff.c
// Function: fmtutil_read_iff_format
void fmtutil_read_iff_format(struct de_iffctx *ictx, i64 pos, i64 len)
{
	deark *c = ictx->c;
	struct iff_parser_data *pctx = NULL;

	if(!ictx->f || !ictx->handle_chunk_fn) return; // Internal error

	ictx->level = 0;
	fourcc_clear(&ictx->main_fmt4cc);
	fourcc_clear(&ictx->main_contentstype4cc);
	fourcc_clear(&ictx->curr_container_fmt4cc);
	fourcc_clear(&ictx->curr_container_contentstype4cc);
	if(ictx->alignment==0) {
		ictx->alignment = 2;
	}
	if(ictx->sizeof_len==0) {
		ictx->sizeof_len = 4;
	}

	if(ictx->input_encoding==DE_ENCODING_UNKNOWN) {
		ictx->input_encoding = DE_ENCODING_ASCII;
	}

	pctx = de_malloc(c, sizeof(struct iff_parser_data));
	ictx->private_data = (void*)pctx;
	do_iff_chunk_sequence(c, ictx, NULL, pos, len, 0);
	ictx->private_data = NULL;
	de_free(c, pctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x18c95d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x18c962
jmp 0x18ca40
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x18ca50
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq 0x18ca50
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x18ca50
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
callq 0x18ca50
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x18c9c1
movq -0x8(%rbp), %rax
movq $0x2, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x18c9d8
movq -0x8(%rbp), %rax
movq $0x4, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x18c9ed
movq -0x8(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x20(%rbp), %rdi
movl $0x50, %esi
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
xorl %r9d, %r9d
callq 0x18ca80
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-iff.c
// Function: fmtutil_default_iff_chunk_identify
static void fmtutil_default_iff_chunk_identify(struct de_iffctx *ictx)
{
	const char *name = NULL;

	switch(ictx->chunkctx->chunk4cc.id) {
	case CODE__c_ : name="copyright"; break;
	case CODE_ANNO: name="annotation"; break;
	case CODE_AUTH: name="author"; break;
	}

	if(name) {
		ictx->chunkctx->chunk_name = name;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x28632920, %eax       # imm = 0x28632920
je 0x18d272
jmp 0x18d25a
movl -0x14(%rbp), %eax
subl $0x414e4e4f, %eax       # imm = 0x414E4E4F
je 0x18d27f
jmp 0x18d266
movl -0x14(%rbp), %eax
subl $0x41555448, %eax       # imm = 0x41555448
je 0x18d28c
jmp 0x18d297
leaq 0x11536(%rip), %rax     # 0x19e7af
movq %rax, -0x10(%rbp)
jmp 0x18d297
leaq 0x4aafb(%rip), %rax     # 0x1d7d81
movq %rax, -0x10(%rbp)
jmp 0x18d297
leaq 0x21c83(%rip), %rax     # 0x1aef16
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18d2b1
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rcx, 0x58(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-iff.c
// Function: do_iff_text_chunk
static void do_iff_text_chunk(deark *c, struct de_iffctx *ictx, i64 dpos, i64 dlen,
	const char *name)
{
	de_ucstring *s = NULL;

	if(dlen<1) return;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(ictx->f,
		dpos, dlen, DE_DBG_MAX_STRLEN,
		s, DE_CONVFLAG_STOP_AT_NUL, ictx->input_encoding);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x18d51d
jmp 0x18d593
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl $0x1f4, %ecx            # imm = 0x1F4
movl $0x1, %r9d
movl %eax, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x172500
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x2a683(%rip), %rsi     # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-iff.c
// Function: do_iff_anno
static void do_iff_anno(deark *c, struct de_iffctx *ictx, i64 pos, i64 len)
{
	i64 foundpos;

	if(len<1) return;

	// Some ANNO chunks seem to be padded with one or more NUL bytes. Probably
	// best not to save them.
	if(dbuf_search_byte(ictx->f, 0x00, pos, len, &foundpos)) {
		len = foundpos - pos;
	}
	if(len<1) return;
	if(c->extract_level>=2) {
		dbuf_create_file_from_slice(ictx->f, pos, len, "anno.txt", NULL, DE_CREATEFLAG_IS_AUX);
	}
	else {
		de_ucstring *s = NULL;
		s = ucstring_create(c);
		dbuf_read_to_ucstring_n(ictx->f, pos, len, DE_DBG_MAX_STRLEN, s, 0, ictx->input_encoding);
		de_dbg(c, "annotation: \"%s\"", ucstring_getpsz(s));
		ucstring_destroy(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x18d5c4
jmp 0x18d6a1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %esi, %esi
leaq -0x28(%rbp), %r8
callq 0x1667a0
cmpl $0x0, %eax
je 0x18d5f0
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x18d5fc
jmp 0x18d6a1
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jl 0x18d632
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x4a76c(%rip), %rcx     # 0x1d7d8c
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %r9d
callq 0x166be0
jmp 0x18d6a1
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x172500
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x269a7(%rip), %rsi     # 0x1b4038
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rdi
callq 0x171750
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_register_modules
void de_register_modules(deark *c)
{
	// The real register_modules function (de_register_modules_internal) is
	// only called indirectly, to help simplify dependencies.
	if(!c->module_register_fn) {
		de_internal_err_fatal(c, "module_register_fn not set");
		return;
	}
	c->module_register_fn(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1a0(%rax)
jne 0x18d8ae
movq -0x8(%rbp), %rdi
leaq 0x4a539(%rip), %rsi     # 0x1d7dde
movb $0x0, %al
callq 0x15c2a0
jmp 0x18d8bf
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: module_compare_fn
static int module_compare_fn(const void *a, const void *b)
{
	struct sort_data_struct *m1, *m2;
	deark *c;

	m1 = (struct sort_data_struct *)a;
	m2 = (struct sort_data_struct *)b;
	c = m1->c;
	return de_strcasecmp(c->module_info[m1->module_index].id,
		c->module_info[m2->module_index].id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1b0(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x1b0(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x15aaa0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: do_modhelp
static void do_modhelp(deark *c)
{
	struct deark_module_info *module_to_use = NULL;

	de_register_modules(c);
	module_to_use = de_get_module_by_id(c, c->input_format_req);
	if(!module_to_use) {
		de_err(c, "Unknown module \"%s\"", c->input_format_req);
		goto done;
	}

	if(de_strcmp(c->input_format_req, module_to_use->id)) {
		de_msg(c, "\"%s\" is an alias for module \"%s\"",
			c->input_format_req, module_to_use->id);
	}

	do_modhelp_internal(c, module_to_use);

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18d880
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
callq 0x15c790
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x18e2d5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdx
leaq 0x49b48(%rip), %rsi     # 0x1d7e14
movb $0x0, %al
callq 0x15bfb0
jmp 0x18e31c
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x191a0
cmpl $0x0, %eax
je 0x18e30f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x49e2c(%rip), %rsi     # 0x1d8134
movb $0x0, %al
callq 0x15c190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18e6a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: open_extrlist
static void open_extrlist(deark *c)
{
	unsigned int flags = 0;

	if(c->extrlist_dbuf || !c->extrlist_filename) return;

	if(de_get_ext_option(c, "extrlist:append")) {
		flags |= 0x1;
	}

	c->extrlist_dbuf = dbuf_create_unmanaged_file(c, c->extrlist_filename,
		DE_OVERWRITEMODE_STANDARD, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x148(%rax)
jne 0x18e35f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x168(%rax)
jne 0x18e361
jmp 0x18e3aa
movq -0x8(%rbp), %rdi
leaq 0x49de9(%rip), %rsi     # 0x1d8155
callq 0x15cb30
cmpq $0x0, %rax
je 0x18e380
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rsi
movl -0xc(%rbp), %ecx
movl $0x2, %edx
callq 0x1679e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x148(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: do_special_overlay_startpos
static int do_special_overlay_startpos(deark *c)
{
	i64 lfb, nblocks;
	i64 overlay_pos, overlay_len;
	int retval = 0;
	u8 sig[2];

	// Maybe we should use fmtutil_collect_exe_info() here, but it's not
	// exactly what we want, and might add a dependency on fmtutil.
	dbuf_read(c->infile, sig, 0, 2);
	if((sig[0]=='M' && sig[1]=='Z') || (sig[0]=='Z' && sig[1]=='M')) {
		;
	}
	else {
		goto done;
	}
	lfb = dbuf_getu16le(c->infile, 2);
	nblocks = dbuf_getu16le(c->infile, 4);
	nblocks &= 0x7ff;
	if(lfb==0) {
		overlay_pos = 512*nblocks;
	}
	else if(lfb<512 && nblocks>0) {
		overlay_pos = 512*(nblocks-1) + lfb;
	}
	else {
		goto done;
	}
	overlay_len = c->infile->len - overlay_pos;
	if(overlay_len<0) goto done;
	de_dbg2(c, "overlay at %"I64_FMT", len=%"I64_FMT, overlay_pos, overlay_len);
	c->slice_start_req = overlay_pos;
	c->suppress_detection_by_filename = 1;
	retval = 1;

done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x2e(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %ecx
callq 0x164d10
movzbl -0x2e(%rbp), %eax
cmpl $0x4d, %eax
jne 0x18e3ef
movzbl -0x2d(%rbp), %eax
cmpl $0x5a, %eax
je 0x18e401
movzbl -0x2e(%rbp), %eax
cmpl $0x5a, %eax
jne 0x18e403
movzbl -0x2d(%rbp), %eax
cmpl $0x4d, %eax
jne 0x18e403
jmp 0x18e408
jmp 0x18e4d4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x165280
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x165280
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x7ff, %rax            # imm = 0x7FF
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x18e457
movq -0x18(%rbp), %rax
shlq $0x9, %rax
movq %rax, -0x20(%rbp)
jmp 0x18e482
cmpq $0x200, -0x10(%rbp)     # imm = 0x200
jge 0x18e47e
cmpq $0x0, -0x18(%rbp)
jle 0x18e47e
movq -0x18(%rbp), %rax
subq $0x1, %rax
shlq $0x9, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x18e480
jmp 0x18e4d4
jmp 0x18e482
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x18e49f
jmp 0x18e4d4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x49cb3(%rip), %rsi     # 0x1d8165
movb $0x0, %al
callq 0x15b350
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x7a(%rax)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_create_internal
deark *de_create_internal(void)
{
	deark *c;
	c = de_malloc(NULL,sizeof(deark));
	c->show_infomessages = 1;
	c->show_warnings = 1;
	c->write_bom = 1;
	c->write_density = 1;
	c->filenames_from_file = 1;
	c->append_riscos_type = 0xff;
	c->preserve_file_times = 1;
	c->preserve_file_times_archives = 1;
	c->preserve_file_times_internal = 1;
	c->max_output_files = DE_MAX_OUTPUT_FILES_HARD_LIMIT;
	c->max_image_dimension = DE_DEFAULT_MAX_IMAGE_DIMENSION;
	c->max_output_file_size = DE_DEFAULT_MAX_FILE_SIZE;
	c->max_total_output_size = DE_DEFAULT_MAX_TOTAL_OUTPUT_SIZE;
	c->current_time.is_valid = 0;
	c->can_decode_fltpt = -1; // = unknown
	c->host_is_le = -1; // = unknown
	c->input_encoding = DE_ENCODING_UNKNOWN;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
movl $0x2f0, %esi            # imm = 0x2F0
callq 0x15b780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0xc0(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc4(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xcc(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xcd(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xd0(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0xd4(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xdc(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xdd(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xde(%rax)
movq -0x8(%rbp), %rax
movl $0x3d090, 0x9c(%rax)    # imm = 0x3D090
movq -0x8(%rbp), %rax
movq $0x2710, 0xa8(%rax) # imm = 0x2710
movq -0x8(%rbp), %rax
movabsq $0x280000000, %rcx      # imm = 0x280000000
movq %rcx, 0xb0(%rax)
movq -0x8(%rbp), %rax
movabsq $0x3c0000000, %rcx      # imm = 0x3C0000000
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x190(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xf0(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xf4(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0xfc(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_filename_pattern
void de_set_output_filename_pattern(deark *c, const char *dirname, const char *fn,
	unsigned int flags)
{
	if(c->base_output_filename) de_free(c, c->base_output_filename);
	c->base_output_filename = NULL;
	if(!fn && !dirname) return;
	if(!fn) fn = "output";
	if(c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
		flags |= 0x4;
	}
	c->base_output_filename = make_output_filename(c, dirname, fn, NULL, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
je 0x18ec79
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rax
movq $0x0, 0x150(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x18ec98
cmpq $0x0, -0x10(%rbp)
jne 0x18ec98
jmp 0x18ece4
cmpq $0x0, -0x18(%rbp)
jne 0x18ecaa
leaq 0x4891c(%rip), %rax     # 0x1d75c2
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
jne 0x18ecbd
movl -0x1c(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %r8d
xorl %eax, %eax
movl %eax, %ecx
callq 0x18ecf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x150(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_special_1st_filename
void de_set_output_special_1st_filename(deark *c, const char *dirname, const char *fn)
{
	if(c->special_1st_filename) {
		de_free(c, c->special_1st_filename);
		c->special_1st_filename = NULL;
	}
	if(fn) {
		UI flags = 0;

		if(c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
			flags |= 0x4;
		}

		c->special_1st_filename = make_output_filename(c, dirname, fn, NULL, flags);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x18ef15
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rax
movq $0x0, 0x158(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x18ef5d
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
jne 0x18ef36
movl -0x1c(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %r8d
xorl %eax, %eax
movl %eax, %ecx
callq 0x18ecf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x158(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_archive_filename
void de_set_output_archive_filename(deark *c, const char *dname, const char *fn,
	unsigned int flags)
{
	const char *suffix = NULL;
	if(c->output_archive_filename) de_free(c, c->output_archive_filename);

	if(flags&0x10) {
		c->archive_to_stdout = 1;
		return;
	}

	if((flags & 0x20) && c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
		if(c->archive_fmt==DE_ARCHIVEFMT_ZIP) {
			suffix = ".zip";
		}
		else if(c->archive_fmt==DE_ARCHIVEFMT_TAR) {
			suffix = ".tar";
		}
		else {
			suffix = ".err";
		}
	}

	c->output_archive_filename = make_output_filename(c, dname, fn, suffix, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x160(%rax)
je 0x18efb1
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rsi
callq 0x15b820
movl -0x1c(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x18efc9
movq -0x8(%rbp), %rax
movb $0x1, 0x88(%rax)
jmp 0x18f048
movl -0x1c(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x18f021
movq -0x8(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
jne 0x18f021
movq -0x8(%rbp), %rax
cmpl $0x1, 0x80(%rax)
jne 0x18eff8
leaq 0x45ad4(%rip), %rax     # 0x1d4ac6
movq %rax, -0x28(%rbp)
jmp 0x18f01f
movq -0x8(%rbp), %rax
cmpl $0x2, 0x80(%rax)
jne 0x18f012
leaq 0x45c54(%rip), %rax     # 0x1d4c60
movq %rax, -0x28(%rbp)
jmp 0x18f01d
leaq 0x49107(%rip), %rax     # 0x1d8120
movq %rax, -0x28(%rbp)
jmp 0x18f01f
jmp 0x18f021
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %r8d
callq 0x18ecf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x160(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_extrlist_filename
void de_set_extrlist_filename(deark *c, const char *fn)
{
	if(c->extrlist_filename) de_free(c, c->extrlist_filename);
	c->extrlist_filename = NULL;
	if(fn) {
		c->extrlist_filename = de_strdup(c, fn);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x168(%rax)
je 0x18f082
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rax
movq $0x0, 0x168(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x18f0b3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15c630
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x168(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_add_input_filename_mp
static void de_add_input_filename_mp(deark *c, const char *fn)
{
	int prev_count, new_count;
	int new_idx;

	if(!c->mp_data) {
		c->mp_data = de_malloc(c, sizeof(struct de_mp_data));
	}
	prev_count = c->mp_data->count;
	if(prev_count >= DE_MAX_MP_FILES) {
		de_err(c, "Too many input files");
		c->serious_error_flag = 1;
		return;
	}

	new_count = prev_count+1;
	if(new_count > c->mp_data->alloc) {
		int new_alloc;

		new_alloc = new_count+15;
		c->mp_data->item = de_reallocarray(c, c->mp_data->item,
			(i64)c->mp_data->count, sizeof(struct de_mp_item), (i64)new_alloc);

		c->mp_data->alloc = new_alloc;
	}

	new_idx = prev_count;
	c->mp_data->item[new_idx].fn = fn;
	c->mp_data->count = new_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x18f2e4
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x15b780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x7ff, -0x14(%rbp)     # imm = 0x7FF
jl 0x18f319
movq -0x8(%rbp), %rdi
leaq 0x48f54(%rip), %rsi     # 0x1d8259
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rax
movb $0x1, 0x4c(%rax)
jmp 0x18f3b2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jle 0x18f381
movl -0x18(%rbp), %eax
addl $0xf, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq (%rax), %rdx
movslq -0x20(%rbp), %r8
movl $0x10, %ecx
callq 0x15c4d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_input_encoding
int de_set_input_encoding(deark *c, const char *encname, int reserved)
{
	de_encoding enc;

	enc = de_encoding_name_to_code(encname);
	if(enc==DE_ENCODING_UNKNOWN) {
		return 0;
	}
	c->input_encoding = enc;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x161de0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x18f3ee
movl $0x0, -0x4(%rbp)
jmp 0x18f402
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xfc(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_output_style
void de_set_output_style(deark *c, int x, int subtype)
{
	c->output_style = x;
	if(c->output_style==DE_OUTPUTSTYLE_ARCHIVE) {
		c->archive_fmt = subtype;
	}
	else {
		c->archive_fmt = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
jne 0x18f4d1
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x80(%rax)
jmp 0x18f4df
movq -0x8(%rbp), %rax
movl $0x0, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_max_output_files
void de_set_max_output_files(deark *c, i64 n)
{
	if(n>DE_MAX_OUTPUT_FILES_HARD_LIMIT) {
		c->max_output_files = DE_MAX_OUTPUT_FILES_HARD_LIMIT;
	}
	else if(n<0) {
		c->max_output_files = 0;
	}
	else {
		c->max_output_files = (int)n;
	}
	c->user_set_max_output_files = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x3d090, -0x10(%rbp)   # imm = 0x3D090
jle 0x18f556
movq -0x8(%rbp), %rax
movl $0x3d090, 0x9c(%rax)    # imm = 0x3D090
jmp 0x18f57f
cmpq $0x0, -0x10(%rbp)
jge 0x18f56d
movq -0x8(%rbp), %rax
movl $0x0, 0x9c(%rax)
jmp 0x18f57d
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
jmp 0x18f57f
movq -0x8(%rbp), %rax
movb $0x1, 0xa0(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_max_output_file_size
void de_set_max_output_file_size(deark *c, i64 n)
{
	if(n<0) n=0;
	c->max_output_file_size = n;
	if(c->max_total_output_size < n) {
		c->max_total_output_size = n;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x18f5ab
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
cmpq -0x10(%rbp), %rax
jge 0x18f5da
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_preserve_file_times
void de_set_preserve_file_times(deark *c, int setting, int x)
{
	if(setting==0) {
		// For files written directly to the filesystem.
		c->preserve_file_times = x?1:0;
	}
	else if(setting==1) {
		// For member files written to .zip/.tar files.
		// I can't think of a good reason why a user would want to disable
		// this, but it's allowed for consistency, and it doesn't hurt
		// anything.
		c->preserve_file_times_archives = x?1:0;
	}
	else if(setting==2) {
		// For the tIME chunk in PNG files we generate, and other internal timestamps.
		// (Not currently used.)
		// TODO: I'm undecided about whether this should be a user option, or
		// just always be on.
		// TODO: If we allow this setting to be turned off, it would be
		// consistent to rename it, and use it for all "converted" formats,
		// including e.g. the "Date" header item in ANSI Art files converted
		// to HTML.
		c->preserve_file_times_internal = x?1:0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x18f692
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xdc(%rax)
jmp 0x18f6dc
cmpl $0x1, -0xc(%rbp)
jne 0x18f6b6
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xdd(%rax)
jmp 0x18f6da
cmpl $0x2, -0xc(%rbp)
jne 0x18f6d8
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xde(%rax)
jmp 0x18f6da
jmp 0x18f6dc
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: de_set_ext_option
void de_set_ext_option(deark *c, const char *name, const char *val)
{
	int n;

	n = c->num_ext_options;
	if(n>=DE_MAX_EXT_OPTIONS) return;
	if(!name || !val) return;

	c->ext_option[n].name = de_strdup(c, name);
	c->ext_option[n].val = de_strdup(c, val);
	c->num_ext_options++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x1b8(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jl 0x18f709
jmp 0x18f77d
cmpq $0x0, -0x10(%rbp)
je 0x18f717
cmpq $0x0, -0x18(%rbp)
jne 0x18f719
jmp 0x18f77d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15c630
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq $0x1c0, %rax            # imm = 0x1C0
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15c630
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq $0x1c0, %rax            # imm = 0x1C0
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x1b8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1b8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-user.c
// Function: get_basename_ptr
static const char *get_basename_ptr(const char *fn)
{
	size_t i;
	const char *basenameptr = fn;

	for(i=0; fn[i]; i++) {
		if(is_pathsep(fn[i])) {
			basenameptr = &fn[i+1];
		}
	}
	return basenameptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x18f913
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x18f920
cmpl $0x0, %eax
je 0x18f903
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x18f905
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x18f8cc
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: de_fopen_for_read
FILE* de_fopen_for_read(deark *c, const char *fn, i64 *len,
	char *errmsg, size_t errmsg_len, unsigned int *returned_flags)
{
	int ret;
	FILE *f;

	f = de_fopen(c, fn, "rb", errmsg, errmsg_len);
	if(!f) {
		return NULL;
	}

	ret = de_examine_file_by_fd(c, fileno(f), len, errmsg, errmsg_len,
		returned_flags);
	if(!ret) {
		de_fclose(f);
		return NULL;
	}

	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0x1dcfc(%rip), %rdx     # 0x1ad763
callq 0x18fae0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x18fa81
movq $0x0, -0x8(%rbp)
jmp 0x18fad1
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x191f0
movq -0x50(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x18fb50
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x18fac9
movq -0x48(%rbp), %rdi
callq 0x18fc60
movq $0x0, -0x8(%rbp)
jmp 0x18fad1
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: de_fopen
static FILE* de_fopen(deark *c, const char *fn, const char *mode,
	char *errmsg, size_t errmsg_len)
{
	FILE *f;
	int errcode;

	f = fopen(fn, mode);
	if(!f) {
		errcode = errno;
		de_strlcpy(errmsg, strerror(errcode), errmsg_len);
	}
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x191d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x18fb3e
callq 0x19040
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %edi
callq 0x192b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
callq 0x15aa30
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: de_examine_file_by_fd
static int de_examine_file_by_fd(deark *c, int fd, i64 *len,
	char *errmsg, size_t errmsg_len, unsigned int *returned_flags)
{
	struct stat stbuf;

	*returned_flags = 0;
	de_zeromem(&stbuf, sizeof(struct stat));

	if(0 != fstat(fd, &stbuf)) {
		de_strlcpy(errmsg, strerror(errno), errmsg_len);
		return 0;
	}

	if(S_ISFIFO(stbuf.st_mode)) {
		*returned_flags |= 0x1;
		*len = 0;
		return 1;
	}
	else if(!S_ISREG(stbuf.st_mode)) {
		de_strlcpy(errmsg, "Not a regular file", errmsg_len);
		return 0;
	}

	*len = (i64)stbuf.st_size;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x19140
movl -0x14(%rbp), %edi
leaq -0xc8(%rbp), %rsi
callq 0x192a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x18fbd9
movq -0x28(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0x19040
movl (%rax), %edi
callq 0x192b0
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x15aa30
movl $0x0, -0x4(%rbp)
jmp 0x18fc50
movl -0xb0(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x18fc0a
movq -0x38(%rbp), %rax
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x18fc50
movl -0xb0(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0x18fc39
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x1ef09(%rip), %rsi     # 0x1aeb34
callq 0x15aa30
movl $0x0, -0x4(%rbp)
jmp 0x18fc50
jmp 0x18fc3b
movq -0x98(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: de_fopen_for_write
FILE* de_fopen_for_write(deark *c, const char *fn,
	char *errmsg, size_t errmsg_len, int overwrite_mode,
	unsigned int flags)
{
	const char *mode;

	// A simple check to make it harder to accidentally overwrite the input
	// file. (But it can easily be defeated.)
	// TODO?: Make this more robust.
	if(c->input_filename && !de_strcmp(fn, c->input_filename)) {
		de_err(c, "Refusing to write to %s: Same as input filename", fn);
		de_fatalerror(c);
		de_strlcpy(errmsg, "", errmsg_len);
		return NULL;
	}

	if(overwrite_mode!=DE_OVERWRITEMODE_STANDARD) {
		// Check if the file already exists.
		struct stat stbuf;
		int s_ret;

		de_zeromem(&stbuf, sizeof(struct stat));
#if DE_USE_LSTAT
		s_ret = lstat(fn, &stbuf);
#else
		s_ret = stat(fn, &stbuf);
#endif

		 // s_ret==0 = "success"
		if(s_ret==0 && overwrite_mode==DE_OVERWRITEMODE_NEVER) {
			de_strlcpy(errmsg, "Output file already exists", errmsg_len);
			return NULL;
		}

		if(s_ret==0 && overwrite_mode==DE_OVERWRITEMODE_DEFAULT) {
			if(S_ISLNK(stbuf.st_mode)) {
				de_strlcpy(errmsg, "Output file is a symlink", errmsg_len);
				return NULL;
			}
		}
	}

	mode = (flags&0x1) ? "ab" : "wb";
	return de_fopen(c, fn, mode, errmsg, errmsg_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x18fd04
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x191a0
cmpl $0x0, %eax
jne 0x18fd04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x485a5(%rip), %rsi     # 0x1d8278
movb $0x0, %al
callq 0x15bfb0
movq -0x10(%rbp), %rdi
callq 0x15c250
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x40ede(%rip), %rsi     # 0x1d0bd0
callq 0x15aa30
movq $0x0, -0x8(%rbp)
jmp 0x18fde3
cmpl $0x2, -0x2c(%rbp)
je 0x18fda7
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x19140
movq -0x18(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x190c0
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
jne 0x18fd64
cmpl $0x1, -0x2c(%rbp)
jne 0x18fd64
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x48553(%rip), %rsi     # 0x1d82a8
callq 0x15aa30
movq $0x0, -0x8(%rbp)
jmp 0x18fde3
cmpl $0x0, -0xcc(%rbp)
jne 0x18fda5
cmpl $0x0, -0x2c(%rbp)
jne 0x18fda5
movl -0xb0(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0x18fda3
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x4852f(%rip), %rsi     # 0x1d82c3
callq 0x15aa30
movq $0x0, -0x8(%rbp)
jmp 0x18fde3
jmp 0x18fda5
jmp 0x18fda7
movl -0x30(%rbp), %edx
andl $0x1, %edx
leaq 0x48528(%rip), %rax     # 0x1d82dc
leaq 0x3ae6a(%rip), %rcx     # 0x1cac25
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x18fae0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: de_update_file_attribs
void de_update_file_attribs(dbuf *f, u8 preserve_file_times)
{
	struct upd_attr_ctx uactx;

	de_zeromem(&uactx, sizeof(struct upd_attr_ctx));

	update_file_perms(&uactx, f);
	if(preserve_file_times) {
		update_file_time(&uactx, f);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x19140
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x18feb0
cmpb $0x0, -0x9(%rbp)
je 0x18fe9e
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x190010
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: update_file_perms
static void update_file_perms(struct upd_attr_ctx *uactx, dbuf *f)
{
	mode_t oldmode, newmode;

	if(f->btype!=DBUF_TYPE_OFILE) return;
	if(!f->fi_copy) return;
	if(!f->name) return;
	if(!(f->fi_copy->mode_flags&DE_MODEFLAG_NONEXE) &&!(f->fi_copy->mode_flags&DE_MODEFLAG_EXE)) return;

	uactx->stat_ret = stat(f->name, &uactx->stbuf);
	uactx->tried_stat = 1;
	if(uactx->stat_ret != 0) {
		return;
	}

	oldmode = uactx->stbuf.st_mode;
	newmode = oldmode;

	// Start by turning off the executable bits in the tentative new mode.
	newmode &= ~(S_IXUSR|S_IXGRP|S_IXOTH);

	if(f->fi_copy->mode_flags&DE_MODEFLAG_EXE) {
		// Set an Executable bit if its corresponding Read bit is set.
		if(oldmode & S_IRUSR) newmode |= S_IXUSR;
		if(oldmode & S_IRGRP) newmode |= S_IXGRP;
		if(oldmode & S_IROTH) newmode |= S_IXOTH;
	}

	if(newmode != oldmode) {
		de_dbg2(f->c, "changing file mode from %03o to %03o",
			(unsigned int)oldmode, (unsigned int)newmode);
		chmod(f->name, newmode);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x18fece
jmp 0x18fffc
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x18fee1
jmp 0x18fffc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x18fef1
jmp 0x18fffc
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movl 0x14(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x18ff22
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x18ff22
jmp 0x18fffc
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x190f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x18ff59
jmp 0x18fffc
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $-0x4a, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x18ffc8
movl -0x14(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x18ff9e
movl -0x18(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x18ffb2
movl -0x18(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x18ffc6
movl -0x18(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18ffc8
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x18fffc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x482fa(%rip), %rsi     # 0x1d82df
movb $0x0, %al
callq 0x15b350
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x19250
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: update_file_time
static void update_file_time(struct upd_attr_ctx *uactx, dbuf *f)
{
	const struct de_timestamp *ts;
	struct timeval times[2];

	if(f->btype!=DBUF_TYPE_OFILE) return;
	if(!f->fi_copy) return;
	ts = &f->fi_copy->timestamp[DE_TIMESTAMPIDX_MODIFY];
	if(!ts->is_valid) return;
	if(!f->name) return;

	if(!uactx->tried_stat) {
		uactx->stat_ret = stat(f->name, &uactx->stbuf);
		uactx->tried_stat = 1;
	}

	de_zeromem(&times, sizeof(times));
	// times[0] = access time
	// times[1] = mod time
	times[1].tv_sec = (time_t)de_timestamp_to_unix_time(ts);
	if(ts->precision>DE_TSPREC_1SEC) {
		times[1].tv_usec = (suseconds_t)(de_timestamp_get_subsec(ts)/10);
	}

	// We don't want to set the access time, but unfortunately the utimes()
	// function forces us to.
	if(uactx->tried_stat && (uactx->stat_ret==0)) {
		// If we have the file's current access time recorded, use that.
		times[0].tv_sec = uactx->stbuf.st_atime;
		times[0].tv_usec = 0;
	}
	else {
		// Otherwise use the mod time.
		times[0] = times[1];
	}
	utimes(f->name, times);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x19002e
jmp 0x19012e
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x190041
jmp 0x19012e
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x190062
jmp 0x19012e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x190072
jmp 0x19012e
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1900a3
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x190f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x19140
movq -0x18(%rbp), %rdi
callq 0x15dd00
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x1e, %eax
jle 0x1900e4
movq -0x18(%rbp), %rdi
callq 0x15d6a0
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19010d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x19010d
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x19011d
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x19180
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-unix.c
// Function: de_current_time_to_timestamp
void de_current_time_to_timestamp(struct de_timestamp *ts)
{
	struct timeval tv;
	int ret;

	de_zeromem(&tv, sizeof(struct timeval));
	ret = gettimeofday(&tv, NULL);
	if(ret!=0) {
		de_zeromem(ts, sizeof(struct de_timestamp));
		return;
	}

	de_unix_time_to_timestamp((i64)tv.tv_sec, ts, 0x1);
	de_timestamp_set_subsec(ts, ((double)tv.tv_usec)/1000000.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x190184
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
jmp 0x1901b1
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x15d530
movq -0x8(%rbp), %rdi
cvtsi2sdq -0x10(%rbp), %xmm0
movsd 0x480c8(%rip), %xmm1    # 0x1d8270
divsd %xmm1, %xmm0
callq 0x15d5e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)