LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_info
void de_info(deark *c, const char *fmt, ...)
{
	va_list ap;

	if(!c->show_infomessages) return;
	va_start(ap, fmt);
	de_vprintf(c, DE_MSGTYPE_MESSAGE, fmt, ap);
	va_end(ap);
	de_puts(c, DE_MSGTYPE_MESSAGE, "\n");
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xdf3d6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x0, 0xc0(%rdi)
je 0xdf425
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
xorl %esi, %esi
movq %r10, %rdx
callq 0xde85b
leaq 0x23d6c(%rip), %rdx     # 0x103187
movq %rbx, %rdi
xorl %esi, %esi
callq 0xde567
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_internal_err_fatal
void de_internal_err_fatal(deark *c, const char *fmt, ...)
{
	va_list ap;

	de_puts(c, DE_MSGTYPE_ERROR, "Internal error: ");
	va_start(ap, fmt);
	de_vprintf(c, DE_MSGTYPE_ERROR, fmt, ap);
	va_end(ap);
	de_puts(c, DE_MSGTYPE_ERROR, "\n");
	de_fatalerror(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0xdf553
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x59978(%rip), %rdx     # 0x138ed2
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0xde567
movq %rsp, %rcx
movq %r15, 0x10(%rcx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xde85b
leaq 0x23bef(%rip), %rdx     # 0x103187
movq %rbx, %rdi
movl %ebp, %esi
callq 0xde567
movq %rbx, %rdi
callq 0xdf4d0
addq $0xd8, %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_mallocarray
void *de_mallocarray(deark *c, i64 nmemb, size_t membsize)
{
	if(nmemb>DE_MAX_MALLOC || nmemb<0 || membsize>DE_MAX_MALLOC) {
		de_err(c, "Out of memory");
		de_fatalerror(c);
		// NOTREACHED
		return de_malloc(c, 1);
	}

	return de_malloc(c, nmemb*(i64)membsize);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1dcd6501, %eax       # imm = 0x1DCD6501
cmpq %rax, %rsi
setb %cl
cmpq %rax, %rdx
setb %al
testb %al, %cl
jne 0xdf6a6
leaq 0x59861(%rip), %rsi     # 0x138ef0
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
callq 0xdf4d0
pushq $0x1
popq %rdx
jmp 0xdf6aa
imulq %rsi, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
jmp 0xdecaf
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_reallocarray
void *de_reallocarray(deark *c, void *m, i64 oldnmemb, size_t membsize,
	i64 newnmemb)
{
	if(newnmemb>DE_MAX_MALLOC || newnmemb<0 || oldnmemb<0 || membsize>DE_MAX_MALLOC) {
		de_err(c, "Out of memory");
		de_fatalerror(c);
		// NOTREACHED
		return de_malloc(c, 1);
	}

	return de_realloc(c, m,
		oldnmemb*(i64)membsize,
		newnmemb*(i64)membsize);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x1dcd6500, %rcx       # imm = 0x1DCD6500
ja 0xdf6e5
testq %rdx, %rdx
js 0xdf6e5
cmpq $0x1dcd6501, %r8        # imm = 0x1DCD6501
jae 0xdf6e5
imulq %rcx, %rdx
imulq %rcx, %r8
movq %rbx, %rdi
movq %r8, %rcx
popq %rbx
jmp 0xdf70a
leaq 0x59804(%rip), %rsi     # 0x138ef0
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
callq 0xdf4d0
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xdecaf
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_realloc
void *de_realloc(deark *c, void *oldmem, i64 oldsize, i64 newsize)
{
	void *newmem;

	if(!oldmem) {
		return de_malloc(c, newsize);
	}

	newmem = realloc(oldmem, (size_t)newsize);
	if(!newmem) {
		de_err(c, "Memory reallocation failed (%"I64_FMT" bytes)", newsize);
		free(oldmem);
		de_fatalerror(c);
		// NOTREACHED
		return de_malloc(c, newsize);
	}

	if(oldsize<newsize) {
		// zero out any newly-allocated bytes
		de_zeromem(&((u8*)newmem)[oldsize], (size_t)(newsize-oldsize));
	}

	return newmem;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xdf77d
movq %rdx, %r12
movq %rsi, %r15
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x18250
testq %rax, %rax
je 0xdf759
movq %rax, %r13
subq %r12, %rbx
jle 0xdf74c
movq %r13, %rdi
addq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x18140
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x597e7(%rip), %rsi     # 0x138f47
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xdf2a5
movq %r15, %rdi
callq 0x18030
movq %r14, %rdi
callq 0xdf4d0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xdecaf
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_get_module_idx_by_id
int de_get_module_idx_by_id(deark *c, const char *module_id)
{
	int i;
	int k;

	if(!module_id) return -1;

	for(i=0; i<c->num_modules; i++) {
		if(!de_strcmp(c->module_info[i].id, module_id)) {
			return i;
		}
		for(k=0; k<DE_MAX_MODULE_ALIASES; k++) {
			if(!c->module_info[i].id_alias[k]) break;
			if(!de_strcmp(c->module_info[i].id_alias[k], module_id)) {
				return i;
			}
		}
	}
	return -1;
}

// Assembly:
pushq $-0x1
popq %rax
testq %rsi, %rsi
je 0xdf85f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl 0x1a8(%rdi), %r13d
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
pushq $0x38
popq %rbp
movq %rdi, (%rsp)
cmpq %r13, %r12
je 0xdf860
movq 0x1b0(%r15), %rbx
imulq $0x48, %r12, %rax
movq (%rbx,%rax), %rdi
movq %r14, %rsi
callq 0x181a0
testl %eax, %eax
je 0xdf84e
addq %rbp, %rbx
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0xdf841
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0xdf841
movq %r14, %rsi
callq 0x181a0
incq %r15
testl %eax, %eax
jne 0xdf821
jmp 0xdf84e
incq %r12
addq $0x48, %rbp
movq (%rsp), %r15
jmp 0xdf7fb
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0xdf851
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_run_module
int de_run_module(deark *c, struct deark_module_info *mi, de_module_params *mparams,
	enum de_moddisp_enum moddisp)
{
	enum de_moddisp_enum old_moddisp;
	struct de_detection_data_struct *old_detection_data;
	struct de_mp_data *old_mp_data;

	if(!mi) return 0;
	if(!mi->run_fn) {
		if(moddisp==DE_MODDISP_EXPLICIT) {
			de_err(c, "Module '%s' is disabled", mi->id);
		}
		else { // presumably DE_MODDISP_INTERNAL
			de_dbg(c, "[module '%s' is disabled]", mi->id);
		}
		return 0;
	}
	// Note that c->module_nesting_level is 0 when we are not in a module,
	// 1 when in the top-level module, 2 for a first-level submodule, etc.
	if(c->module_nesting_level >= 1+DE_MAX_SUBMODULE_NESTING_LEVEL) {
		de_err(c, "Max module nesting level exceeded");
		return 0;
	}

	old_moddisp = c->module_disposition;
	c->module_disposition = moddisp;
	old_detection_data = c->detection_data;
	if(c->module_nesting_level > 0) {
		c->detection_data = NULL;
	}

	old_mp_data = c->mp_data;
	if(c->module_nesting_level > 0) {
		c->mp_data = NULL;
	}

	if(c->module_nesting_level>0 && c->debug_level>=3) {
		de_dbg3(c, "[using %s module]", mi->id);
	}
	c->module_nesting_level++;
	mi->run_fn(c, mparams);
	c->module_nesting_level--;
	c->module_disposition = old_moddisp;
	c->detection_data = old_detection_data;
	c->mp_data = old_mp_data;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xdf8c7
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0xdf8ce
movq %rdx, %r14
movl 0x10(%rbx), %edx
cmpl $0xb, %edx
jl 0xdf8eb
leaq 0x596ea(%rip), %rsi     # 0x138fa0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
jmp 0xdf95d
xorl %ebp, %ebp
jmp 0xdf95d
movq (%r15), %rdx
cmpl $0x2, %ecx
jne 0xdf926
leaq 0x59691(%rip), %rsi     # 0x138f6e
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
jmp 0xdf95d
movl 0x24(%rbx), %ebp
movl %ecx, 0x24(%rbx)
movq 0x28(%rbx), %r12
testl %edx, %edx
jle 0xdf93b
xorps %xmm0, %xmm0
movq 0x30(%rbx), %r13
movups %xmm0, 0x28(%rbx)
cmpl $0x3, (%rbx)
jl 0xdf93f
movq (%r15), %rdx
leaq 0x596af(%rip), %rsi     # 0x138fc2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdea83
movl 0x10(%rbx), %edx
movq 0x18(%r15), %rax
jmp 0xdf93f
leaq 0x59659(%rip), %rsi     # 0x138f86
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
jmp 0xdf95d
movq 0x30(%rbx), %r13
incl %edx
movl %edx, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
decl 0x10(%rbx)
movl %ebp, 0x24(%rbx)
movq %r12, 0x28(%rbx)
movq %r13, 0x30(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_run_module_by_id
int de_run_module_by_id(deark *c, const char *id, de_module_params *mparams)
{
	struct deark_module_info *module_to_use;

	module_to_use = de_get_module_by_id(c, id);
	if(!module_to_use) {
		de_err(c, "Unknown or unsupported format \"%s\"", id);
		return 0;
	}

	return de_run_module(c, module_to_use, mparams, DE_MODDISP_INTERNAL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xdf865
testq %rax, %rax
je 0xdf99c
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xdf885
leaq 0x59631(%rip), %rsi     # 0x138fd4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xdf2a5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_run_module_by_id_on_slice
int de_run_module_by_id_on_slice(deark *c, const char *id, de_module_params *mparams,
	dbuf *f, i64 pos, i64 len)
{
	dbuf *old_ifile;
	int ret;

	old_ifile = c->infile;

	if(pos==0 && len==f->len) {
		// Optimization: We don't need a subfile in this case
		c->infile = f;
		ret = de_run_module_by_id(c, id, mparams);
	}
	else {
		c->infile = dbuf_open_input_subfile(f, pos, len);
		ret = de_run_module_by_id(c, id, mparams);
		dbuf_close(c->infile);
	}

	c->infile = old_ifile;
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %r12
testq %r8, %r8
jne 0xdf9ee
cmpq %r9, 0x18(%rcx)
jne 0xdf9ee
movq %rcx, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xdf96e
movl %eax, %ebp
jmp 0xdfa19
movq %rcx, %rdi
movq %r8, %rsi
movq %r9, %rdx
callq 0xe6248
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xdf96e
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0xe5591
movq %r12, 0x18(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_run_module_by_id_on_slice2
int de_run_module_by_id_on_slice2(deark *c, const char *id, const char *codes,
	dbuf *f, i64 pos, i64 len)
{
	de_module_params *mparams = NULL;
	int ret;

	mparams = de_malloc(c, sizeof(de_module_params));
	mparams->in_params.codes = codes;
	ret = de_run_module_by_id_on_slice(c, id, mparams, f, pos, len);
	de_free(c, mparams);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
pushq $0x70
popq %rsi
callq 0xdecaf
movq %rax, %rbx
movq %r12, (%rax)
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r8
movq (%rsp), %r9
callq 0xdf9b8
movl %eax, %ebp
movq %rbx, %rdi
callq 0x18030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_get_ext_option
const char *de_get_ext_option(deark *c, const char *name)
{
	int i;

	for(i=0; i<c->num_ext_options; i++) {
		if(!de_strcmp(c->ext_option[i].name, name)) {
			return c->ext_option[i].val;
		}
	}
	return NULL; // Option name not found.
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x1b8(%rdi), %r12d
xorl %ebx, %ebx
testl %r12d, %r12d
cmovlel %ebx, %r12d
movq %rsi, %r15
shlq $0x4, %r12
addq $0x10, %r12
xorl %ecx, %ecx
leaq 0x10(%rcx), %r13
cmpq %r13, %r12
je 0xdfad8
movq 0x1c0(%r14,%rcx), %rdi
movq %r15, %rsi
callq 0x181a0
movq %r13, %rcx
testl %eax, %eax
jne 0xdfab0
movq 0x1b8(%r14,%r13), %rbx
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_get_ext_option_bool
int de_get_ext_option_bool(deark *c, const char *name, int defaultval)
{
	const char *val;

	val = de_get_ext_option(c, name);
	if(!val) return defaultval;
	if(val[0]=='\0' || val[0]=='1' || val[0]=='y' || val[0]=='Y' ||
		val[0]=='t' || val[0]=='T')
	{
		return 1;
	}
	if(val[0]=='0' || val[0]=='n' || val[0]=='N' || val[0]=='f' ||
		val[0]=='F')
	{
		return 0;
	}
	return defaultval;
}

// Assembly:
pushq %rbx
movl %edx, %ebx
callq 0xdfa87
testq %rax, %rax
je 0xdfb32
movzbl (%rax), %ecx
pushq $0x1
popq %rax
leal -0x46(%rcx), %edx
cmpl $0x33, %edx
ja 0xdfb20
movabsq $0x10100000101, %rsi    # imm = 0x10100000101
btq %rdx, %rsi
jb 0xdfb2e
movabsq $0x8400000084000, %rsi  # imm = 0x8400000084000
btq %rdx, %rsi
jb 0xdfb34
testl %ecx, %ecx
je 0xdfb34
cmpl $0x31, %ecx
je 0xdfb34
cmpl $0x30, %ecx
jne 0xdfb32
xorl %eax, %eax
jmp 0xdfb34
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_pad_to_n
i64 de_pad_to_n(i64 x, i64 n)
{
	i64 r;
	if(n<2)
		return x;
	r = x%n;
	if(r==0)
		return x;
	return x - r + n;
}

// Assembly:
cmpq $0x2, %rsi
jl 0xdfbd2
movq %rdi, %rax
cqto
idivq %rsi
testq %rdx, %rdx
je 0xdfbd2
addq %rdi, %rsi
subq %rdx, %rsi
movq %rsi, %rdi
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_log2_rounded_up
i64 de_log2_rounded_up(i64 n)
{
	i64 i;

	if(n<=2) return 1;
	for(i=2; i<32; i++) {
		if(n <= (((i64)1)<<i)) return i;
	}
	return 32;
}

// Assembly:
cmpq $0x3, %rdi
jge 0xdfbe0
pushq $0x1
popq %rax
retq
pushq $0x2
popq %rcx
pushq $0x20
popq %rax
pushq $0x1
popq %rdx
cmpq $0x20, %rcx
je 0xdfc02
movq %rdx, %rsi
shlq %cl, %rsi
cmpq %rdi, %rsi
jae 0xdfbff
incq %rcx
jmp 0xdfbe9
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_print_base2_fixed
char *de_print_base2_fixed(char *buf, size_t buf_len, u64 n, UI bitcount)
{
	UI x;
	size_t bpos = 0;

	if(buf_len<(size_t)bitcount+1) {
		goto done;
	}

	for(x=0; x<bitcount; x++) {
		buf[bpos++] = (n & (1ULL<<(bitcount-1-x))) ? '1' : '0';
	}
done:
	buf[bpos] = '\0';
	return buf;
}

// Assembly:
movq %rdi, %rax
movl %ecx, %edi
cmpq %rsi, %rdi
jae 0xdfc37
movq %rdi, %rsi
negq %rsi
decl %ecx
xorl %r8d, %r8d
movq %rsi, %r9
addq %r8, %r9
je 0xdfc39
btq %rcx, %rdx
setae %r9b
xorb $0x31, %r9b
movb %r9b, (%rax,%r8)
incq %r8
decl %ecx
jmp 0xdfc18
xorl %edi, %edi
movb $0x0, (%rax,%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_get_sz_ext
const char *de_get_sz_ext(const char *sz)
{
	int len;
	int pos;

	if(!sz) return g_empty_string;

	len = (int)de_strlen(sz);
	if(len<2) return g_empty_string;

	// Find the position of the last ".", that's after the last "/"
	pos = len-2;

	while(pos>=0) {
		if(sz[pos]=='.') {
			return &sz[pos+1];
		}
		if(sz[pos]=='/' || sz[pos]=='\\')
			break;
		pos--;
	}
	return g_empty_string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x59197(%rip), %rbx     # 0x138de0
testq %rdi, %rdi
je 0xdfc5b
movq %rdi, %r14
callq 0x180e0
cmpl $0x2, %eax
jge 0xdfc66
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addl $-0x2, %eax
testl %eax, %eax
js 0xdfc5b
movl %eax, %ecx
movzbl (%r14,%rcx), %edx
cmpl $0x5c, %edx
je 0xdfc5b
cmpl $0x2f, %edx
je 0xdfc5b
cmpl $0x2e, %edx
je 0xdfc87
decl %eax
jmp 0xdfc69
leaq (%r14,%rcx), %rbx
incq %rbx
jmp 0xdfc5b
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_get_input_file_ext
const char *de_get_input_file_ext(deark *c)
{
	if(c->suppress_detection_by_filename) return g_empty_string;

	if(!c->input_filename) return g_empty_string;

	// If we skipped over the first part of the file, assume we're reading
	// an embedded format that's not indicated by the file extension.
	if(c->slice_start_req) return g_empty_string;

	return de_get_sz_ext(c->input_filename);
}

// Assembly:
cmpb $0x0, 0x7a(%rdi)
je 0xdfc9e
leaq 0x59143(%rip), %rax     # 0x138de0
retq
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0xdfc96
cmpq $0x0, 0x68(%rdi)
jne 0xdfc96
movq %rax, %rdi
jmp 0xdfc3e
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_havemodcode
int de_havemodcode(deark *c, de_module_params *mparams, int code)
{
	if(mparams &&
		mparams->in_params.codes &&
		de_strchr(mparams->in_params.codes, code))
	{
		return 1;
	}
	return 0;
}

// Assembly:
testq %rsi, %rsi
je 0xdfd17
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xdfd17
pushq %rax
movl %edx, %esi
callq 0x18100
testq %rax, %rax
leaq 0x8(%rsp), %rsp
je 0xdfd17
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_finfo_destroy
void de_finfo_destroy(deark *c, de_finfo *fi)
{
	if(!fi) return;
	if(fi->file_name_internal) ucstring_destroy(fi->file_name_internal);
	if(fi->name_other) ucstring_destroy(fi->name_other);
	de_free(c, fi);
}

// Assembly:
testq %rsi, %rsi
je 0xdfd54
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xdfd3a
callq 0xeaf3c
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0xdfd4b
callq 0xeaf3c
movq %rbx, %rdi
popq %rbx
jmp 0x18030
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_finfo_set_name_from_sz
void de_finfo_set_name_from_sz(deark *c, de_finfo *fi, const char *name1,
	unsigned int flags, de_ext_encoding ee)
{
	de_ucstring *fname;

	if(!name1) {
		de_finfo_set_name_from_ucstring(c, fi, NULL, flags);
		return;
	}
	fname = ucstring_create(c);
	ucstring_append_sz(fname, name1, ee);
	de_finfo_set_name_internal(c, fi, fname, flags);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xe0011
movl %r8d, %ebp
movq %rdx, %r12
movq %r15, %rdi
callq 0xeac74
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xeae42
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdfd7c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdfd55
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_FILETIME_to_timestamp
void de_FILETIME_to_timestamp(i64 ft, struct de_timestamp *ts, unsigned int flags)
{
	de_zeromem(ts, sizeof(struct de_timestamp));
	if(ft<=0) return;
	ts->is_valid = 1;
	ts->ts_FILETIME = ft;
	ts->precision = DE_TSPREC_HIGH;
	if(flags&0x1) ts->tzcode = DE_TZCODE_UTC;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
testq %rdi, %rdi
jle 0xe0070
movb $0x1, (%rsi)
movq %rdi, 0x8(%rsi)
movb $0x28, 0x2(%rsi)
testb $0x1, %dl
je 0xe0070
movb $0x1, 0x1(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_timestamp_set_subsec
void de_timestamp_set_subsec(struct de_timestamp *ts, double frac)
{
	i64 subsec;

	if(!ts->is_valid) return;
	if(ts->ts_FILETIME<0) ts->ts_FILETIME=0;

	// Subtract off any existing fractional second.
	ts->ts_FILETIME -= (ts->ts_FILETIME%10000000);

	subsec = (i64)(0.5+frac*10000000.0);
	if(subsec>=10000000) subsec=9999999;
	if(subsec<0) subsec=0;
	ts->ts_FILETIME += subsec;
	ts->precision = DE_TSPREC_HIGH;
}

// Assembly:
cmpb $0x0, (%rdi)
je 0xe00c8
movq 0x8(%rdi), %rcx
xorl %esi, %esi
testq %rcx, %rcx
cmovleq %rsi, %rcx
movl $0x989680, %r8d         # imm = 0x989680
movq %rcx, %rax
xorl %edx, %edx
divq %r8
mulsd 0x25027(%rip), %xmm0    # 0x1050c0
addsd 0x2a69f(%rip), %xmm0    # 0x10a740
cvttsd2si %xmm0, %rax
movl $0x98967f, %r8d         # imm = 0x98967F
cmpq %r8, %rax
cmovlq %rax, %r8
testq %r8, %r8
cmovleq %rsi, %r8
addq %rcx, %r8
subq %rdx, %r8
movq %r8, 0x8(%rdi)
movb $0x28, 0x2(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_dos_datetime_to_timestamp
void de_dos_datetime_to_timestamp(struct de_timestamp *ts,
   i64 ddate, i64 dtime)
{
	i64 yr, mo, da, hr, mi, se;

	if(ddate==0) {
		de_zeromem(ts, sizeof(struct de_timestamp));
		ts->is_valid = 0;
		return;
	}
	yr = 1980+((ddate&0xfe00)>>9);
	mo = (ddate&0x01e0)>>5;
	da = (ddate&0x001f);
	hr = (dtime&0xf800)>>11;
	mi = (dtime&0x07e0)>>5;
	se = 2*(dtime&0x001f);
	de_make_timestamp(ts, yr, mo, da, hr, mi, se);
	ts->precision = DE_TSPREC_2SEC;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0xe0168
movq %rsi, %rcx
shrl $0x9, %esi
andl $0x7f, %esi
addq $0x7bc, %rsi            # imm = 0x7BC
movl %ecx, %eax
shrl $0x5, %eax
andl $0xf, %eax
andl $0x1f, %ecx
movl %edx, %r8d
shrl $0xb, %r8d
andl $0x1f, %r8d
movl %edx, %r9d
shrl $0x5, %r9d
andl $0x3f, %r9d
addl %edx, %edx
andl $0x3e, %edx
movq %rdx, (%rsp)
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe0174
movb $0x14, 0x2(%rbx)
jmp 0xe016e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_make_timestamp
void de_make_timestamp(struct de_timestamp *ts,
	i64 yr, i64 mo, i64 da,
	i64 hr, i64 mi, i64 se)
{
	i64 result;
	i64 tm_mon;
	static const int cumulative_days[12] =
		{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };

	de_zeromem(ts, sizeof(struct de_timestamp));
	if(!is_valid_time(yr, mo, da, hr, mi, se)) {
		return;
	}
	tm_mon = mo-1;
	if(tm_mon<0 || tm_mon>11) tm_mon=0;
	result = (yr - 1970) * 365 + cumulative_days[tm_mon];
	result += (yr - 1968) / 4;
	result -= (yr - 1900) / 100;
	result += (yr - 1600) / 400;
	if ((yr%4)==0 && ((yr%100)!=0 || (yr%400)==0) && tm_mon<2) {
		result--;
	}
	result += da-1;
	result *= 24;
	result += hr;
	result *= 60;
	result += mi;
	result *= 60;
	result += se;

	de_unix_time_to_timestamp(result, ts, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x17, %r8
ja 0xe0274
leaq -0x186a0(%rsi), %rax
cmpq $-0x1805f, %rax         # imm = 0xFFFE7FA1
jb 0xe0274
movq %rdx, %r11
movq %rdi, %r10
leaq -0x1(%rdx), %rdi
cmpq $0xb, %rdi
ja 0xe0274
decq %rcx
cmpq $0x1e, %rcx
ja 0xe0274
cmpq $0x3b, %r9
ja 0xe0274
cmpq $0x3c, %rbx
ja 0xe0274
imulq $0x16d, %rsi, %r14      # imm = 0x16D
leal -0x7b0(%rsi), %eax
movl $0x4, %ebp
cltd
idivl %ebp
movslq %eax, %r15
addq %r14, %r15
leaq 0x58bf7(%rip), %rax     # 0x138df0
movslq -0x4(%rax,%r11,4), %r11
leal -0x76c(%rsi), %eax
movl $0xffffff9c, %ebp       # imm = 0xFFFFFF9C
cltd
idivl %ebp
movslq %eax, %r14
leal -0x640(%rsi), %eax
movl $0x190, %ebp            # imm = 0x190
xorl %edx, %edx
divl %ebp
addq %r14, %rax
addq %r15, %rax
addq %rax, %r11
addq $-0xaf8ca, %r11         # imm = 0xFFF50736
testb $0x3, %sil
jne 0xe024c
movl $0x64, %ebp
movl %esi, %eax
xorl %edx, %edx
divl %ebp
testl %edx, %edx
je 0xe027b
cmpq $0x1, %rdi
ja 0xe024c
decq %r11
addq %rcx, %r11
imulq $0x18, %r11, %rax
addq %r8, %rax
imulq $0x3c, %rax, %rax
addq %r9, %rax
imulq $0x3c, %rax, %rdi
addq %rbx, %rdi
movq %r10, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe002e
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x190, %ebp            # imm = 0x190
movl %esi, %eax
xorl %edx, %edx
divl %ebp
testl %edx, %edx
sete %al
cmpq $0x2, %rdi
setb %dl
testb %dl, %al
jne 0xe0249
jmp 0xe024c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_describe_dos_attribs
void de_describe_dos_attribs(deark *c, UI attr, de_ucstring *s, UI flags)
{
	unsigned int bf = attr;

	if((flags & 0x1) && (bf & 0x3f)==0x0f) {
		ucstring_append_flags_item(s, "long filename");
		bf -= 0x0f;
	}
	if(bf & 0x01) {
		ucstring_append_flags_item(s, "read-only");
		bf -= 0x01;
	}
	if(bf & 0x02) {
		ucstring_append_flags_item(s, "hidden");
		bf -= 0x02;
	}
	if(bf & 0x04) {
		ucstring_append_flags_item(s, "system");
		bf -= 0x04;
	}
	if(bf & 0x08) {
		ucstring_append_flags_item(s, "volume label");
		bf -= 0x08;
	}
	if(bf & 0x10) {
		ucstring_append_flags_item(s, "directory");
		bf -= 0x10;
	}
	if(bf & 0x20) {
		ucstring_append_flags_item(s, "archive");
		bf -= 0x20;
	}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
testb $0x1, %cl
sete %al
movl %esi, %ecx
andl $0x3f, %ecx
cmpl $0xf, %ecx
setne %cl
orb %al, %cl
jne 0xe02c8
leaq 0x58d3a(%rip), %rsi     # 0x138ff7
movq %r14, %rdi
callq 0xeb884
addl $-0xf, %ebx
testb $0x1, %bl
je 0xe02de
leaq 0x41818(%rip), %rsi     # 0x121aec
movq %r14, %rdi
callq 0xeb884
decl %ebx
testb $0x2, %bl
je 0xe02f5
leaq 0x40d2d(%rip), %rsi     # 0x121017
movq %r14, %rdi
callq 0xeb884
addl $-0x2, %ebx
testb $0x4, %bl
je 0xe030c
leaq 0x33e23(%rip), %rsi     # 0x114124
movq %r14, %rdi
callq 0xeb884
addl $-0x4, %ebx
testb $0x8, %bl
je 0xe0323
leaq 0x5ba8a(%rip), %rsi     # 0x13bda2
movq %r14, %rdi
callq 0xeb884
addl $-0x8, %ebx
testb $0x10, %bl
je 0xe033a
leaq 0x26893(%rip), %rsi     # 0x106bc2
movq %r14, %rdi
callq 0xeb884
addl $-0x10, %ebx
testb $0x20, %bl
je 0xe0351
leaq 0x299cd(%rip), %rsi     # 0x109d13
movq %r14, %rdi
callq 0xeb884
addl $-0x20, %ebx
testl %ebx, %ebx
je 0xe036f
leaq 0x5754f(%rip), %rsi     # 0x1378ab
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeb8af
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_prodos_datetime_to_timestamp
void de_prodos_datetime_to_timestamp(struct de_timestamp *ts,
	i64 ddate, i64 dtime)
{
	i64 yr, mo, da, hr, mi, se;

	if(ddate==0 || (dtime&0xe0c0)!=0) {
		de_zeromem(ts, sizeof(struct de_timestamp));
		ts->is_valid = 0;
		return;
	}

	yr = 1900+((ddate&0xfe00)>>9);
	mo = (ddate&0x01e0)>>5;
	da = (ddate&0x001f);
	hr = (dtime&0x1f00)>>8;
	mi = (dtime&0x003f);
	se = 0;
	de_make_timestamp(ts, yr, mo, da, hr, mi, se);
	ts->precision = DE_TSPREC_1MIN;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r9
movq %rdi, %rbx
testq %rsi, %rsi
setne %al
testw $0xe0c0, %r9w           # imm = 0xE0C0
sete %dl
testb %dl, %al
je 0xe03d2
movq %rsi, %rcx
shrl $0x9, %esi
andl $0x7f, %esi
addq $0x76c, %rsi            # imm = 0x76C
movl %ecx, %edx
shrl $0x5, %edx
andl $0xf, %edx
andl $0x1f, %ecx
movl %r9d, %r8d
shrl $0x8, %r8d
andl $0x1f, %r8d
andl $0x3f, %r9d
andq $0x0, (%rsp)
movq %rbx, %rdi
callq 0xe0174
movb $0xf, 0x2(%rbx)
jmp 0xe03d8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_riscos_loadexec_to_timestamp
void de_riscos_loadexec_to_timestamp(u32 load_addr,
	u32 exec_addr, struct de_timestamp *ts)
{
	i64 t;
	unsigned int centiseconds;

	de_zeromem(ts, sizeof(struct de_timestamp));
	if((load_addr&0xfff00000U)!=0xfff00000U) return;

	t = (((i64)(load_addr&0xff))<<32) | (i64)exec_addr;
	// t now = number of centiseconds since the beginning of 1900

	// Remember centiseconds.
	centiseconds = (unsigned int)(t%100);
	// Convert t to seconds.
	t = t/100;

	// Convert 1900 epoch to 1970 epoch.
	// (There were 17 leap days between Jan 1900 and Jan 1970.)
	t -= (365*70 + 17)*(i64)86400;

	if(t<=0 || t>=8000000000LL) return; // sanity check

	de_unix_time_to_timestamp(t, ts, 0);
	de_timestamp_set_subsec(ts, ((double)centiseconds)/100.0);
	ts->tzcode = DE_TZCODE_UTC;
}

// Assembly:
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdx)
cmpl $0xfff00000, %edi       # imm = 0xFFF00000
jb 0xe0460
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movzbl %dil, %ecx
shlq $0x20, %rcx
movl %esi, %eax
orq %rcx, %rax
movabsq $-0xedb250aa00, %rcx    # imm = 0xFFFFFF124DAF5600
addq %rax, %rcx
movabsq $-0xba43b73f9c, %rdx    # imm = 0xFFFFFF45BC48C064
cmpq %rdx, %rcx
jb 0xe0459
pushq $0x64
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
movabsq $-0x83aa7e80, %rdi      # imm = 0xFFFFFFFF7C558180
addq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe002e
cvtsi2sd %r14d, %xmm0
divsd 0x325cb(%rip), %xmm0    # 0x112a18
movq %rbx, %rdi
callq 0xe0071
movb $0x1, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_timestamp_to_string
char *de_timestamp_to_string(const struct de_timestamp *ts,
	char *buf, size_t buf_len, unsigned int flags)
{
	const char *tzlabel;
	char subsec[16];
	struct de_struct_tm tm2;

	if(!ts->is_valid) {
		de_strlcpy(buf, "[invalid timestamp]", buf_len);
		goto done;
	}

	de_gmtime(ts, &tm2);
	if(!tm2.is_valid) {
		de_snprintf(buf, buf_len, "[timestamp out of range: %"I64_FMT"]",
			de_timestamp_to_unix_time(ts));
		goto done;
	}

	if(ts->precision>DE_TSPREC_1SEC) {
		unsigned int ms;
		ms = (unsigned int)(tm2.tm_subsec/10000);
		if(ms>=1000) ms=999;
		de_snprintf(subsec, sizeof(subsec), ".%03u", ms);
	}
	else {
		subsec[0] = '\0';
	}

	tzlabel = (ts->tzcode==DE_TZCODE_UTC)?" UTC":"";
	if(ts->precision!=DE_TSPREC_UNKNOWN && ts->precision<=DE_TSPREC_1DAY) { // date only
		de_snprintf(buf, buf_len, "%04d-%02d-%02d",
			tm2.tm_fullyear, 1+tm2.tm_mon, tm2.tm_mday);
		goto done;
	}
	de_snprintf(buf, buf_len, "%04d-%02d-%02d %02d:%02d:%02d%s%s",
		tm2.tm_fullyear, 1+tm2.tm_mon, tm2.tm_mday,
		tm2.tm_hour, tm2.tm_min, tm2.tm_sec, subsec, tzlabel);
done:
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rbx
cmpb $0x0, (%rdi)
je 0xe06af
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rsi
callq 0xe04a6
cmpl $0x0, (%r12)
je 0xe06c6
movb 0x2(%r15), %al
cmpb $0x1f, %al
jb 0xe0703
movl 0x1c(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
movl $0x3e7, %ecx            # imm = 0x3E7
cmpl %ecx, %eax
cmovbl %eax, %ecx
leaq 0x5899d(%rip), %rdx     # 0x139037
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rsi
xorl %eax, %eax
callq 0xde40c
movb 0x2(%r15), %al
jmp 0xe0708
leaq 0x5894f(%rip), %rsi     # 0x139005
movq %rbx, %rdi
movq %r14, %rdx
callq 0xde492
jmp 0xe0797
movq 0x8(%r15), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
movl $0x989680, %ecx         # imm = 0x989680
xorl %edx, %edx
divq %rcx
movabsq $-0x2b6109100, %rcx     # imm = 0xFFFFFFFD49EF6F00
addq %rax, %rcx
leaq 0x58928(%rip), %rdx     # 0x139019
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xde40c
jmp 0xe0797
movb $0x0, 0x20(%rsp)
decb %al
cmpb $0x9, %al
ja 0xe0735
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
incl %r8d
movl 0xc(%rsp), %r9d
leaq 0x58917(%rip), %rdx     # 0x13903d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xde40c
jmp 0xe0797
cmpb $0x1, 0x1(%r15)
leaq 0x57321(%rip), %rax     # 0x137a62
leaq 0x58698(%rip), %r10     # 0x138de0
cmoveq %rax, %r10
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
incl %r8d
movl 0xc(%rsp), %r9d
movl 0x10(%rsp), %r11d
movl 0x14(%rsp), %r15d
movl 0x18(%rsp), %r12d
subq $0x8, %rsp
leaq 0x28(%rsp), %r13
leaq 0x588d0(%rip), %rdx     # 0x13904c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r12
pushq %r15
pushq %r11
callq 0xde40c
addq $0x30, %rsp
movq %rbx, %rax
addq $0x30, %rsp
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_declare_fmt
void de_declare_fmt(deark *c, const char *fmtname)
{
	if(c->module_nesting_level > 1) {
		return; // Only allowed for the top-level module
	}
	if(c->format_declared) return;
	de_info(c, "Format: %s", fmtname);
	c->format_declared = 1;
}

// Assembly:
cmpl $0x1, 0x10(%rdi)
jg 0xe0823
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jne 0xe0822
movq %rsi, %rdx
leaq 0x5885d(%rip), %rsi     # 0x13906e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf37f
movl $0x1, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_copy_bits
void de_copy_bits(const u8 *src, i64 srcbitnum,
	u8 *dst, i64 dstbitnum, i64 bitstocopy)
{
	i64 i;
	u8 b;

	for(i=0; i<bitstocopy; i++) {
		b = src[(srcbitnum+i)/8];
		b = (b>>(7-(srcbitnum+i)%8))&0x1;
		if(b) {
			b = b<<(7-(dstbitnum+i)%8);
			dst[(dstbitnum+i)/8] |= b;
		}
	}
}

// Assembly:
pushq %rbx
movq %rcx, %r10
movq %rdx, %r9
xorl %r11d, %r11d
testq %r8, %r8
cmovgq %r8, %r11
movabsq $0x8, %r8
movl $0x1, %ebx
subq $0x1, %r11
jb 0xe0953
movq %rsi, %rax
cqto
idivq %r8
movzbl (%rdi,%rax), %eax
movb $0x7, %cl
subb %dl, %cl
movzbl %cl, %ecx
btl %ecx, %eax
jae 0xe094b
movq %r10, %rax
cqto
idivq %r8
leal (,%rax,8), %ecx
movl %r10d, %edx
subl %ecx, %edx
movb $0x7, %cl
subb %dl, %cl
movl %ebx, %edx
shll %cl, %edx
orb %dl, (%r9,%rax)
incq %rsi
incq %r10
jmp 0xe090d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_inthashtable_destroy
void de_inthashtable_destroy(deark *c, struct de_inthashtable *ht)
{
	i64 i;

	if(!ht) return;
	for(i=0; i<DE_INTHASHTABLE_NBUCKETS; i++) {
		if(ht->buckets[i].first_item)
			inthashtable_destroy_items_in_bucket(c, &ht->buckets[i]);
	}
	de_free(c, ht);
}

// Assembly:
testq %rsi, %rsi
je 0xe09a7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
cmpq $0x47, %r14
je 0xe099a
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xe0995
testq %rdi, %rdi
je 0xe0995
movq 0x10(%rdi), %r15
callq 0x18030
movq %r15, (%rbx,%r14,8)
movq %r15, %rdi
jmp 0xe097e
incq %r14
jmp 0xe096f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18030
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: inthashtable_find_item
static struct de_inthashtable_item *inthashtable_find_item(struct de_inthashtable *ht, i64 key)
{
	struct de_inthashtable_bucket *bkt;

	if(!ht) return NULL;
	bkt = inthashtable_find_bucket(ht, key);
	return inthashtable_find_item_in_bucket(ht, bkt, key);
}

// Assembly:
testq %rdi, %rdi
je 0xe09f0
movq %rsi, %rax
negq %rax
cmovsq %rsi, %rax
pushq $0x47
popq %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
leaq (%rdi,%rax,8), %rdi
jmp 0xe0a77
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_inthashtable_add_item
int de_inthashtable_add_item(deark *c, struct de_inthashtable *ht, i64 key, void *value)
{
	struct de_inthashtable_bucket *bkt;
	struct de_inthashtable_item *new_item;

	bkt = inthashtable_find_bucket(ht, key);
	if(inthashtable_find_item_in_bucket(ht, bkt, key)) {
		// Item already exist. Don't add it again.
		// TODO: This may eventually need to be changed to modify the existing item,
		// or delete-then-add the new item, instead of doing nothing.
		return 0;
	}

	new_item = de_malloc(c, sizeof(struct de_inthashtable_item));
	new_item->key = key;
	new_item->value = value;
	inthashtable_add_item_to_bucket(ht, bkt, new_item);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
xorl %r12d, %r12d
pushq $0x47
popq %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
leaq (%rsi,%rax,8), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xe0a77
testq %rax, %rax
jne 0xe0a6a
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0xdecaf
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq (%r13), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%r13)
pushq $0x1
popq %r12
movl %r12d, %eax
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_inthashtable_remove_any_item
int de_inthashtable_remove_any_item(deark *c, struct de_inthashtable *ht, i64 *pkey, void **pvalue)
{
	i64 i;

	for(i=0; i<DE_INTHASHTABLE_NBUCKETS; i++) {
		struct de_inthashtable_item *item;

		item = ht->buckets[i].first_item;
		if(!item) continue;

		// Found an item. Copy it, for the caller.
		if(pkey) *pkey = item->key;
		if(pvalue) *pvalue = item->value;

		// Delete our copy of it.
		ht->buckets[i].first_item = item->next;
		inthashtable_destroy_item(c, item);
		return 1;
	}

	// No items in hashtable.
	if(pkey) *pkey = 0;
	if(pvalue) *pvalue = NULL;
	return 0;
}

// Assembly:
xorl %eax, %eax
cmpq $0x47, %rax
je 0xe0aa7
movq (%rsi,%rax,8), %rdi
testq %rdi, %rdi
jne 0xe0abc
incq %rax
jmp 0xe0a93
testq %rdx, %rdx
je 0xe0ab0
andq $0x0, (%rdx)
xorl %eax, %eax
testq %rcx, %rcx
je 0xe0abb
andq $0x0, (%rcx)
retq
pushq %rax
testq %rdx, %rdx
je 0xe0ac8
movq (%rdi), %r8
movq %r8, (%rdx)
testq %rcx, %rcx
je 0xe0ad4
movq 0x8(%rdi), %rdx
movq %rdx, (%rcx)
movq 0x10(%rdi), %rcx
movq %rcx, (%rsi,%rax,8)
callq 0x18030
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_crc32_continue
static void de_crc32_continue(struct de_crcobj *crco, const u8 *buf, i64 buf_len)
{
	i64 i;

	if(!crco->table32s) return;

	for(i=0; i<buf_len; i++) {
		crco->val = (crco->val>>8) ^ crco->table32s[(crco->val & 0xff)^buf[i]];
	}
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xe0ca9
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
cmpq %rcx, %rdx
je 0xe0ca9
movl (%rdi), %r8d
movzbl %r8b, %r9d
shrl $0x8, %r8d
movzbl (%rsi,%rcx), %r10d
xorl %r9d, %r10d
xorl (%rax,%r10,4), %r8d
movl %r8d, (%rdi)
incq %rcx
jmp 0xe0c85
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: adler32_continue
static void adler32_continue(struct de_crcobj *crco, const u8 *buf, i64 buf_len)
{
	u32 s1 = crco->val & 0xffff;
	u32 s2 = (crco->val >> 16) & 0xffff;
	i64 i;

	for(i = 0; i<buf_len; i++) {
		s1 = (s1 + buf[i]) % 65521;
		s2 = (s2 + s1) % 65521;
	}
	crco->val = (s2 << 16) + s1;
}

// Assembly:
movq %rdx, %rcx
movl (%rdi), %r9d
movzwl %r9w, %r8d
shrl $0x10, %r9d
xorl %r10d, %r10d
testq %rdx, %rdx
cmovleq %r10, %rcx
movl $0xfff1, %r11d          # imm = 0xFFF1
cmpq %r10, %rcx
je 0xe0cf3
movzbl (%rsi,%r10), %eax
addl %eax, %r8d
movl %r8d, %eax
xorl %edx, %edx
divl %r11d
movl %edx, %r8d
addl %edx, %r9d
movl %r9d, %eax
xorl %edx, %edx
divl %r11d
incq %r10
movl %edx, %r9d
jmp 0xe0cc8
shll $0x10, %r9d
orl %r8d, %r9d
movl %r9d, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_crc16xmodem_continue
static void de_crc16xmodem_continue(struct de_crcobj *crco, const u8 *buf, i64 buf_len)
{
	i64 k;

	if(!crco->table16s) return;
	for(k=0; k<buf_len; k++) {
		crco->val = ((crco->val<<8)&0xffff) ^
			(u32)crco->table16s[((crco->val>>8) ^ (u32)buf[k]) & 0xff];
	}
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xe0d3f
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
cmpq %rcx, %rdx
je 0xe0d3f
movl (%rdi), %r8d
movl %r8d, %r9d
shll $0x8, %r9d
movzwl %r9w, %r9d
shrl $0x8, %r8d
xorb (%rsi,%rcx), %r8b
movzbl %r8b, %r8d
movzwl (%rax,%r8,2), %r8d
xorl %r9d, %r8d
movl %r8d, (%rdi)
incq %rcx
jmp 0xe0d10
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: get_crc16arc_table
static const u16 *get_crc16arc_table(deark *c, u16 poly)
{
	UI i, k;
	u16 *tbl;
	UI pi_idx;

	if(poly==0x8408) {
		pi_idx = DE_PERSISTENT_ITEM_CRC16SDLC_TBL;
	}
	else {
		pi_idx = DE_PERSISTENT_ITEM_CRC16ARC_TBL;
	}

	if(c->persistent_item[pi_idx]) {
		goto done;
	}

	c->persistent_item[pi_idx] = de_mallocarray(c, 256, sizeof(u16));
	tbl = (u16*)c->persistent_item[pi_idx];

	for(i=0; i<256; i++) {
		tbl[i] = i;
		for(k=0; k<8; k++)
			tbl[i] = (tbl[i]>>1) ^ ((tbl[i] & 1) ? poly : 0);
	}

done:
	return (const u16*)c->persistent_item[pi_idx];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %r15d, %r15d
cmpl $0x8408, %esi           # imm = 0x8408
sete %r15b
addl %r15d, %r15d
movq 0x2c8(%rdi,%r15,8), %rax
testq %rax, %rax
je 0xe0d68
popq %rbx
popq %r14
popq %r15
retq
movl %esi, %ebx
movq %rdi, %r14
incq %r15
movl $0x200, %esi            # imm = 0x200
callq 0xdecaf
movq %rax, 0x2c0(%r14,%r15,8)
xorl %ecx, %ecx
pushq $0x8
popq %rdx
cmpq $0x100, %rcx            # imm = 0x100
je 0xe0d62
movl %edx, %edi
movl %ecx, %esi
subl $0x1, %edi
jb 0xe0dac
movzwl %si, %r8d
shrl %r8d
andl $0x1, %esi
negl %esi
andl %ebx, %esi
xorl %r8d, %esi
jmp 0xe0d94
movw %si, (%rax,%rcx,2)
incq %rcx
jmp 0xe0d87
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_crc16arc_continue
static void de_crc16arc_continue(struct de_crcobj *crco, const u8 *buf, i64 buf_len)
{
	i64 k;

	if(!crco->table16s) return;
	for(k=0; k<buf_len; k++) {
		crco->val = ((crco->val>>8) ^
			(u32)crco->table16s[(crco->val ^ buf[k]) & 0xff]);
	}
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xe0dee
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
cmpq %rcx, %rdx
je 0xe0dee
movl (%rdi), %r8d
movl %r8d, %r9d
shrl $0x8, %r9d
xorb (%rsi,%rcx), %r8b
movzbl %r8b, %r8d
movzwl (%rax,%r8,2), %r8d
xorl %r9d, %r8d
movl %r8d, (%rdi)
incq %rcx
jmp 0xe0dc7
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: cksum_u16_continue
static void cksum_u16_continue(struct de_crcobj *crco, const u8 *buf, i64 buf_len)
{
	i64 k;

	for(k=0; k<buf_len; k++) {
		if(crco->align) {
			crco->val64 += (u64)buf[k] << 8;
		}
		else {
			crco->val64 += (u64)buf[k];
		}
		crco->align = !crco->align;
	}
}

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
cmovleq %rax, %rdx
cmpq %rax, %rdx
je 0xe0e43
movl 0x10(%rdi), %ecx
movzbl (%rsi,%rax), %r8d
testl %ecx, %ecx
je 0xe0e29
shll $0x8, %r8d
addq 0x8(%rdi), %r8
xorl %r9d, %r9d
testl %ecx, %ecx
sete %r9b
movq %r8, 0x8(%rdi)
movl %r9d, 0x10(%rdi)
incq %rax
jmp 0xe0e14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_crcobj_reset
void de_crcobj_reset(struct de_crcobj *crco)
{
	crco->val = 0;
	crco->val64 = 0;

	switch(crco->crctype) {
	case DE_CRCOBJ_CRC32_IEEE:
	case DE_CRCOBJ_CRC32_JAMCRC:
		crco->val = 0xffffffffU;
		break;
	case DE_CRCOBJ_ADLER32:
		crco->val = 1;
		break;
	case DE_CRCOBJ_CRC16_IBMSDLC:
	case DE_CRCOBJ_CRC16_IBM3740:
		crco->val = 0xffff;
		break;
	case DE_CRCOBJ_SUM_U16LE:
		crco->align = 0;
		break;
	case DE_CRCOBJ_SUM_U16BE:
		crco->align = 1;
		break;
	}
}

// Assembly:
andl $0x0, (%rdi)
andq $0x0, 0x8(%rdi)
movl 0x4(%rdi), %eax
leal -0x10(%rax), %ecx
cmpl $0x2, %ecx
jb 0xe0e7d
leal -0x22(%rax), %ecx
cmpl $0x2, %ecx
jb 0xe0e76
cmpl $0x15, %eax
je 0xe0e86
cmpl $0x31, %eax
je 0xe0e81
cmpl $0x32, %eax
jne 0xe0e85
movl $0x1, 0x10(%rdi)
retq
movl $0xffff, (%rdi)         # imm = 0xFFFF
retq
orl $-0x1, (%rdi)
retq
andl $0x0, 0x10(%rdi)
retq
movl $0x1, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_calccrc_oneshot
u32 de_calccrc_oneshot(dbuf *f, i64 pos, i64 len, UI type_and_flags)
{
	struct de_crcobj *crco;
	u32 val;

	crco = de_crcobj_create(f->c, type_and_flags);
	de_crcobj_addslice(crco, f, pos, len);
	val = de_crcobj_getval(crco);
	de_crcobj_destroy(crco);
	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movl %ecx, %esi
callq 0xe0ae9
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xe0f33
movq %r12, %rdi
callq 0xe0e95
movl %eax, %ebx
movq %r12, %rdi
callq 0x18030
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/src/deark-util.c
// Function: de_memmatch
int de_memmatch(const u8 *mem, const u8 *pattern, size_t pattern_len,
	u8 wildcard, UI flags)
{
	size_t i;

	for(i=0; i<pattern_len; i++) {
		u8 m = mem[i];
		u8 p = pattern[i];

		if(p==wildcard) continue;
		if(p!=m) return 0;
	}
	return 1;
}

// Assembly:
xorl %r8d, %r8d
pushq $0x1
popq %rax
cmpq %r8, %rdx
je 0xe1020
movb (%rsi,%r8), %r9b
cmpb %cl, %r9b
je 0xe1019
cmpb (%rdi,%r8), %r9b
jne 0xe101e
incq %r8
jmp 0xe1005
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_memsearch_match
int de_memsearch_match(const u8 *mem, i64 mem_len,
	const u8 *pattern, i64 pattern_len, u8 wildcard, i64 *pfoundpos)
{
	i64 num_start_positions_to_search;
	i64 i;

	*pfoundpos = 0;
	if(pattern_len<1 || pattern_len>mem_len) return 0;
	num_start_positions_to_search = mem_len-pattern_len+1;

	for(i=0; i<num_start_positions_to_search; i++) {
		int ret;

		if(pattern[0]!=mem[i] && pattern[0]!=wildcard) continue;
		ret = de_memmatch(&mem[i], pattern, (size_t)pattern_len, wildcard, 0);
		if(ret) {
			*pfoundpos = i;
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
andq $0x0, (%r9)
movq %rsi, %r12
testq %rcx, %rcx
setle %dl
subq %rcx, %r12
setl %cl
xorl %eax, %eax
orb %dl, %cl
jne 0xe10a2
movl %r8d, %ebp
movq %rdi, %r13
movq %r9, 0x10(%rsp)
movzbl %bpl, %eax
movl %eax, 0xc(%rsp)
xorl %ebx, %ebx
cmpq %r12, %rbx
jg 0xe1093
movb (%r15), %al
cmpb %bpl, %al
je 0xe1077
cmpb (%r13,%rbx), %al
jne 0xe108e
leaq (%rbx,%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl 0xc(%rsp), %ecx
callq 0xe0fff
testl %eax, %eax
jne 0xe1097
incq %rbx
jmp 0xe1063
xorl %eax, %eax
jmp 0xe10a2
movq 0x10(%rsp), %rax
movq %rbx, (%rax)
pushq $0x1
popq %rax
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/src/deark-util.c
// Function: de_mp_acquire_dbuf
dbuf *de_mp_acquire_dbuf(deark *c, int xidx)
{
	int mpidx;

	if(xidx==0) return c->infile;
	mpidx = xidx-1;
	if(mpidx<0 || mpidx>=c->mp_data->count) return NULL;
	if(!c->mp_data->item[mpidx].f) {
		c->mp_data->item[mpidx].f = dbuf_open_input_file(c, c->mp_data->item[mpidx].fn);
	}
	return c->mp_data->item[mpidx].f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0xe10f0
jle 0xe10ec
movq 0x30(%rbx), %rax
cmpl %esi, (%rax)
jge 0xe10f6
xorl %eax, %eax
jmp 0xe1128
movq 0x18(%rbx), %rax
jmp 0xe1128
decl %esi
movq 0x8(%rax), %rcx
movl %esi, %r14d
shlq $0x4, %r14
movq 0x8(%rcx,%r14), %rax
testq %rax, %rax
jne 0xe1128
addq %r14, %rcx
movq (%rcx), %rsi
movq %rbx, %rdi
callq 0xe600b
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x8(%rcx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util.c
// Function: de_mp_release_dbuf
void de_mp_release_dbuf(deark *c, int xidx, dbuf **p_oldf)
{
	int mpidx;

	if(p_oldf) {
		*p_oldf = NULL;
	}
	if(xidx==0) goto done;
	mpidx = xidx-1;
	if(mpidx<0 || mpidx>=c->mp_data->count) goto done;
	if(c->mp_data->item[mpidx].f) {
		dbuf_close(c->mp_data->item[mpidx].f);
		c->mp_data->item[mpidx].f = NULL;
	}
done:
	;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0xe1140
andq $0x0, (%rdx)
testl %esi, %esi
je 0xe1178
jle 0xe1178
movq 0x30(%rbx), %rax
cmpl %esi, (%rax)
jl 0xe1178
decl %esi
movq 0x8(%rax), %rax
movl %esi, %r14d
shlq $0x4, %r14
movq 0x8(%rax,%r14), %rdi
testq %rdi, %rdi
je 0xe1178
callq 0xe5591
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
andq $0x0, 0x8(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq