LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0xe9925
movslq 0x1a8(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jle 0xe9925
movq %rsi, %r14
movq 0x1b0(%rdi), %r13
xorl %r12d, %r12d
leaq (%r12,%r12,8), %r15
movq (%r13,%r15,8), %rdi
movq %r14, %rsi
callq 0x181a0
testl %eax, %eax
je 0xe9922
movb $0x1, %bpl
leaq (,%r15,8), %r15
addq %r13, %r15
xorl %eax, %eax
movq 0x38(%r15,%rax,8), %rdi
testq %rdi, %rdi
je 0xe9917
movq %r14, %rsi
callq 0x181a0
testl %eax, %eax
je 0xe9922
movl $0x1, %eax
testb $0x1, %bpl
movl $0x0, %ebp
jne 0xe98f1
incq %r12
cmpq (%rsp), %r12
jne 0xe98cc
jmp 0xe9925
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/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 0xe999c
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0xe99a3
movq %rdx, %r14
movl 0x10(%rbx), %edx
cmpl $0xb, %edx
jl 0xe99c0
leaq 0x5cae5(%rip), %rsi     # 0x146470
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xe9a34
xorl %ebp, %ebp
jmp 0xe9a34
movq (%r15), %rdx
cmpl $0x2, %ecx
jne 0xe99fb
leaq 0x5ca8c(%rip), %rsi     # 0x14643e
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xe9a34
movl 0x24(%rbx), %ebp
movl %ecx, 0x24(%rbx)
movq 0x28(%rbx), %r12
testl %edx, %edx
jle 0xe9a10
xorps %xmm0, %xmm0
movq 0x30(%rbx), %r13
movups %xmm0, 0x28(%rbx)
cmpl $0x3, (%rbx)
jl 0xe9a14
movq (%r15), %rdx
leaq 0x5caaa(%rip), %rsi     # 0x146492
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe889f
movl 0x10(%rbx), %edx
movq 0x18(%r15), %rax
jmp 0xe9a14
leaq 0x5ca54(%rip), %rsi     # 0x146456
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
jmp 0xe9a34
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)
movl $0x1, %ebp
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_O3/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xe989a
testl %eax, %eax
js 0xe9a87
movq 0x1b0(%rbx), %rcx
testq %rcx, %rcx
je 0xe9a87
movl %eax, %eax
leaq (%rax,%rax,8), %rax
leaq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl $0x3, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xe995a
leaq 0x5ca16(%rip), %rsi     # 0x1464a4
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe9295
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe9ad9
cmpq %r9, 0x18(%rcx)
jne 0xe9ad9
movq %rcx, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe9a45
movl %eax, %ebp
jmp 0xe9b04
movq %rcx, %rdi
movq %r8, %rsi
movq %r9, %rdx
callq 0xf1388
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe9a45
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0xf052b
movq %r12, 0x18(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x70, %esi
callq 0xe8b2b
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 0xe9aa3
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_O3/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
movslq 0x1b8(%rdi), %r12
testq %r12, %r12
jle 0xe9bb7
movq %rsi, %r15
movq %rdi, %r14
shlq $0x4, %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x1c0(%r14,%r13), %rdi
movq %r15, %rsi
callq 0x181a0
testl %eax, %eax
je 0xe9bbb
addq $0x10, %r13
cmpq %r13, %r12
jne 0xe9b98
jmp 0xe9bc3
xorl %ebx, %ebx
jmp 0xe9bc3
movq 0x1c8(%r14,%r13), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe9b74
testq %rax, %rax
je 0xe9c22
movzbl (%rax), %ecx
movl $0x1, %eax
cmpl $0x45, %ecx
jle 0xe9c14
addl $-0x46, %ecx
cmpl $0x33, %ecx
ja 0xe9c22
movabsq $0x10100000101, %rdx    # imm = 0x10100000101
btq %rcx, %rdx
jb 0xe9c26
movabsq $0x8400000084000, %rdx  # imm = 0x8400000084000
btq %rcx, %rdx
jb 0xe9c28
jmp 0xe9c22
testl %ecx, %ecx
je 0xe9c28
cmpl $0x30, %ecx
je 0xe9c26
cmpl $0x31, %ecx
je 0xe9c28
movl %ebx, %eax
jmp 0xe9c28
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe9cd0
movq %rdi, %rax
cqto
idivq %rsi
testq %rdx, %rdx
je 0xe9cd0
addq %rdi, %rsi
subq %rdx, %rsi
movq %rsi, %rdi
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5beb2(%rip), %rbx     # 0x1462b0
testq %rdi, %rdi
je 0xea43d
movq %rdi, %r14
callq 0x180e0
cmpl $0x2, %eax
jl 0xea43d
addl $-0x2, %eax
leaq (%r14,%rax), %rcx
incq %rcx
incq %rax
movzbl -0x1(%rcx), %edx
cmpl $0x5c, %edx
je 0xea43d
cmpl $0x2f, %edx
je 0xea43d
cmpl $0x2e, %edx
je 0xea43a
decq %rcx
decq %rax
jg 0xea41d
jmp 0xea43d
movq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea456
leaq 0x5be5b(%rip), %rax     # 0x1462b0
retq
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0xea44e
cmpq $0x0, 0x68(%rdi)
jne 0xea44e
movq %rax, %rdi
jmp 0xea3f3
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-util.c
// Function: de_input_file_has_ext
int de_input_file_has_ext(deark *c, const char *ext)
{
	const char *e;

	e = de_get_input_file_ext(c);
	if(!de_strcasecmp(e, ext))
		return 1;
	return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rcx
leaq 0x5be11(%rip), %rdi     # 0x1462b0
cmpb $0x0, 0x7a(%rcx)
je 0xea4bc
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe8258
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
popq %rbx
retq
movq 0x50(%rcx), %rax
testq %rax, %rax
je 0xea4a5
cmpq $0x0, 0x68(%rcx)
jne 0xea4a5
movq %rax, %rdi
callq 0xea3f3
movq %rax, %rdi
jmp 0xea4a5
// File: /workspace/github_c_makefile_star2_O3/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 0xea501
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xea501
pushq %rax
movl %edx, %esi
callq 0x18100
movq %rax, %rcx
movl $0x1, %eax
testq %rcx, %rcx
leaq 0x8(%rsp), %rsp
je 0xea501
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea53e
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xea524
callq 0xf6753
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0xea535
callq 0xf6753
movq %rbx, %rdi
popq %rbx
jmp 0x18030
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea7d0
movl %r8d, %ebp
movq %rdx, %r12
movq %r15, %rdi
callq 0xf6410
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xf65e3
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
jmp 0xea7e0
xorl %edi, %edi
callq 0xf66ff
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xea566
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-util.c
// Function: de_unix_time_to_timestamp
void de_unix_time_to_timestamp(i64 ut, struct de_timestamp *ts, unsigned int flags)
{
	de_FILETIME_to_timestamp(
		(ut + ((i64)86400)*(369*365 + 89)) * 10000000,
		ts, flags);
	ts->precision = DE_TSPREC_UNKNOWN;
}

// Assembly:
imulq $0x989680, %rdi, %rcx   # imm = 0x989680
movabsq $0x19db1ded53e8000, %rax # imm = 0x19DB1DED53E8000
addq %rcx, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
testq %rax, %rax
jle 0xea824
movb $0x1, (%rsi)
movq %rax, 0x8(%rsi)
testb $0x1, %dl
je 0xea824
movb $0x1, 0x1(%rsi)
movb $0x0, 0x2(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea848
movb $0x1, (%rsi)
movq %rdi, 0x8(%rsi)
movb $0x28, 0x2(%rsi)
testb $0x1, %dl
je 0xea848
movb $0x1, 0x1(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea8b0
movq 0x8(%rdi), %rcx
xorl %esi, %esi
testq %rcx, %rcx
cmovleq %rsi, %rcx
movabsq $-0x29406b2a1a85bd43, %rdx # imm = 0xD6BF94D5E57A42BD
movq %rcx, %rax
mulq %rdx
shrq $0x17, %rdx
imulq $0x989680, %rdx, %rax   # imm = 0x989680
mulsd 0x27862(%rip), %xmm0    # 0x1120e0
addsd 0x2cfaa(%rip), %xmm0    # 0x117830
cvttsd2si %xmm0, %rdx
movl $0x98967f, %r8d         # imm = 0x98967F
cmpq %r8, %rdx
cmovlq %rdx, %r8
testq %r8, %r8
cmovleq %rsi, %r8
subq %rcx, %rax
addq %rcx, %rax
addq %r8, %rax
movq %rax, 0x8(%rdi)
movb $0x28, 0x2(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x17, %r8
ja 0xeaabe
leaq -0x186a0(%rsi), %rax
cmpq $-0x1805f, %rax         # imm = 0xFFFE7FA1
jb 0xeaabe
leaq -0x1(%rdx), %r10
cmpq $0xb, %r10
ja 0xeaabe
decq %rcx
cmpq $0x1e, %rcx
ja 0xeaabe
cmpq $0x3b, %r9
ja 0xeaabe
pushq %rbp
pushq %r14
pushq %rbx
movq 0x20(%rsp), %rax
cmpq $0x3c, %rax
ja 0xeaaba
imulq $0x16d, %rsi, %r11      # imm = 0x16D
leal -0x7b0(%rsi), %ebx
leal -0x7ad(%rsi), %ebp
testl %ebx, %ebx
cmovnsl %ebx, %ebp
sarl $0x2, %ebp
movslq %ebp, %rbx
addq %r11, %rbx
leaq 0x5b8af(%rip), %r11     # 0x1462c0
movslq -0x4(%r11,%rdx,4), %rdx
leal -0x76c(%rsi), %r11d
movslq %r11d, %r11
imulq $-0x51eb851f, %r11, %r11 # imm = 0xAE147AE1
movq %r11, %r14
shrq $0x3f, %r14
sarq $0x25, %r11
addl %r14d, %r11d
movslq %r11d, %r11
leal -0x640(%rsi), %r14d
imulq $0x51eb851f, %r14, %r14 # imm = 0x51EB851F
shrq $0x27, %r14
addq %rbx, %r14
addq %r11, %r14
addq %r14, %rdx
addq $-0xaf8ca, %rdx         # imm = 0xFFF50736
testb $0x3, %sil
jne 0xeaa7d
imull $0xc28f5c29, %esi, %r11d # imm = 0xC28F5C29
rorl $0x2, %r11d
cmpl $0x28f5c28, %r11d       # imm = 0x28F5C28
jbe 0xeaabf
cmpq $0x1, %r10
ja 0xeaa7d
decq %rdx
addq %rcx, %rdx
leaq (%rdx,%rdx,2), %rcx
leaq (%r8,%rcx,8), %rcx
imulq $0x3c, %rcx, %rcx
addq %r9, %rcx
imulq $0x3c, %rcx, %rcx
addq %rax, %rcx
imulq $0x989680, %rcx, %rcx   # imm = 0x989680
movabsq $0x19db1ded53e8000, %rax # imm = 0x19DB1DED53E8000
addq %rcx, %rax
testq %rax, %rax
jle 0xeaab6
movb $0x1, (%rdi)
movq %rax, 0x8(%rdi)
movb $0x0, 0x2(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
imull $0xc28f5c29, %esi, %esi # imm = 0xC28F5C29
rorl $0x4, %esi
cmpl $0xa3d70b, %esi         # imm = 0xA3D70B
setb %sil
cmpq $0x2, %r10
setb %r10b
testb %r10b, %sil
jne 0xeaa7a
jmp 0xeaa7d
// File: /workspace/github_c_makefile_star2_O3/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 0xeab11
leaq 0x5b9c1(%rip), %rsi     # 0x1464c7
movq %r14, %rdi
callq 0xf7105
addl $-0xf, %ebx
testb $0x1, %bl
je 0xeab27
leaq 0x44257(%rip), %rsi     # 0x12ed74
movq %r14, %rdi
callq 0xf7105
decl %ebx
testb $0x2, %bl
je 0xeab3e
leaq 0x43754(%rip), %rsi     # 0x12e287
movq %r14, %rdi
callq 0xf7105
addl $-0x2, %ebx
testb $0x4, %bl
je 0xeab55
leaq 0x366ca(%rip), %rsi     # 0x121214
movq %r14, %rdi
callq 0xf7105
addl $-0x4, %ebx
testb $0x8, %bl
je 0xeab6c
leaq 0x5e711(%rip), %rsi     # 0x149272
movq %r14, %rdi
callq 0xf7105
addl $-0x8, %ebx
testb $0x10, %bl
je 0xeab83
leaq 0x290aa(%rip), %rsi     # 0x113c22
movq %r14, %rdi
callq 0xf7105
addl $-0x10, %ebx
testb $0x20, %bl
je 0xeab9a
leaq 0x2c214(%rip), %rsi     # 0x116da3
movq %r14, %rdi
callq 0xf7105
addl $-0x20, %ebx
testl %ebx, %ebx
je 0xeabb8
leaq 0x5a156(%rip), %rsi     # 0x144cfb
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf7132
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
testl $0xe0c0, %r9d           # imm = 0xE0C0
sete %dl
testb %dl, %al
je 0xeac1f
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
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0xea98e
movb $0xf, 0x2(%rbx)
jmp 0xeac25
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeacfc
movq %rdx, %rcx
movzbl %dil, %eax
shlq $0x20, %rax
movl %esi, %esi
orq %rax, %rsi
movabsq $-0xedb250aa00, %rax    # imm = 0xFFFFFF124DAF5600
addq %rsi, %rax
movabsq $-0xba43b73f9c, %rdx    # imm = 0xFFFFFF45BC48C064
cmpq %rdx, %rax
jb 0xeacfc
movabsq $0x28f5c28f5c28f5d, %rdx # imm = 0x28F5C28F5C28F5D
movq %rsi, %rax
mulq %rdx
imull $0x64, %edx, %eax
subl %eax, %esi
imulq $0x989680, %rdx, %rdx   # imm = 0x989680
movabsq $0x14f373bfde04000, %rax # imm = 0x14F373BFDE04000
addq %rdx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
xorl %esi, %esi
divsd 0x34e3f(%rip), %xmm0    # 0x11fae8
movabsq $0x35afe535795e90b, %rdx # imm = 0x35AFE535795E90B
mulq %rdx
shrq $0x11, %rdx
imulq $0x989680, %rdx, %rax   # imm = 0x989680
mulsd 0x27417(%rip), %xmm0    # 0x1120e0
addsd 0x2cb5f(%rip), %xmm0    # 0x117830
cvttsd2si %xmm0, %rdx
movl $0x98967f, %edi         # imm = 0x98967F
cmpq %rdi, %rdx
cmovlq %rdx, %rdi
movq %rsi, (%rcx)
testq %rdi, %rdi
cmovleq %rsi, %rdi
movw $0x101, (%rcx)          # imm = 0x101
addq %rax, %rdi
movq %rdi, 0x8(%rcx)
movb $0x28, 0x2(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeafc0
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rsi
callq 0xead46
cmpl $0x0, (%r12)
je 0xeafed
movb 0x2(%r15), %al
cmpb $0x1f, %al
jb 0xeb031
movslq 0x1c(%rsp), %rax
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x2c, %rcx
addl %eax, %ecx
movl $0x3e7, %eax            # imm = 0x3E7
cmpl %eax, %ecx
cmovael %eax, %ecx
leaq 0x5b55e(%rip), %rdx     # 0x146507
leaq 0x20(%rsp), %rdi
movl $0x10, %esi
xorl %eax, %eax
callq 0xe8193
movb 0x2(%r15), %al
jmp 0xeb036
decq %r14
cmpq $0x13, %r14
movl $0x13, %r15d
cmovbq %r14, %r15
leaq 0x5b4fd(%rip), %rsi     # 0x1464d5
movq %rbx, %rdi
movq %r15, %rdx
callq 0x181e0
movb $0x0, (%rbx,%r15)
jmp 0xeb0c5
movq 0x8(%r15), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
movabsq $-0x29406b2a1a85bd43, %rcx # imm = 0xD6BF94D5E57A42BD
mulq %rcx
shrq $0x17, %rdx
movabsq $-0x2b6109100, %rcx     # imm = 0xFFFFFFFD49EF6F00
addq %rdx, %rcx
leaq 0x5b4ca(%rip), %rdx     # 0x1464e9
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe8193
jmp 0xeb0c5
movb $0x0, 0x20(%rsp)
decb %al
cmpb $0x9, %al
ja 0xeb063
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
incl %r8d
movl 0xc(%rsp), %r9d
leaq 0x5b4b9(%rip), %rdx     # 0x14650d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe8193
jmp 0xeb0c5
cmpb $0x1, 0x1(%r15)
leaq 0x59e43(%rip), %rax     # 0x144eb2
leaq 0x5b23a(%rip), %r10     # 0x1462b0
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 0x5b472(%rip), %rdx     # 0x14651c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r12
pushq %r15
pushq %r11
callq 0xe8193
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_O3/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 0xeb151
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jne 0xeb150
movq %rsi, %rdx
leaq 0x5b3ff(%rip), %rsi     # 0x14653e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9393
movl $0x1, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-util.c
// Function: de_declare_fmtf
void de_declare_fmtf(deark *c, const char *fmt, ...)
{
	va_list ap;
	char buf[128];

	va_start(ap, fmt);
	de_vsnprintf(buf, sizeof(buf), fmt, ap);
	de_declare_fmt(c, buf);
	va_end(ap);
}

// Assembly:
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rsi, %r10
movq %rdi, %rbx
leaq 0xa0(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xeb1bc
movaps %xmm0, 0xd0(%rsp)
movaps %xmm1, 0xe0(%rsp)
movaps %xmm2, 0xf0(%rsp)
movaps %xmm3, 0x100(%rsp)
movaps %xmm4, 0x110(%rsp)
movaps %xmm5, 0x120(%rsp)
movaps %xmm6, 0x130(%rsp)
movaps %xmm7, 0x140(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x160(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
leaq 0x20(%rsp), %rdi
movl $0x80, %esi
movq %r10, %rdx
callq 0x109360
cmpl $0x1, 0x10(%rbx)
jg 0xeb217
cmpl $0x0, 0x20(%rbx)
jne 0xeb217
leaq 0x5b33d(%rip), %rsi     # 0x14653e
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9393
movl $0x1, 0x20(%rbx)
addq $0x150, %rsp            # imm = 0x150
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %r8, %r8
jle 0xeb2a8
movq %rcx, %rax
leaq 0x7(%rsi), %rcx
testq %rsi, %rsi
cmovnsq %rsi, %rcx
sarq $0x3, %rcx
movzbl (%rdi,%rcx), %r9d
shll $0x3, %ecx
movl %esi, %r10d
subl %ecx, %r10d
movb $0x7, %cl
subb %r10b, %cl
movzbl %cl, %ecx
btl %ecx, %r9d
jae 0xeb29d
leaq 0x7(%rax), %r9
testq %rax, %rax
cmovnsq %rax, %r9
sarq $0x3, %r9
leal (,%r9,8), %ecx
movl %eax, %r10d
subl %ecx, %r10d
movb $0x7, %cl
subb %r10b, %cl
movl $0x1, %r10d
shll %cl, %r10d
orb %r10b, (%rdx,%r9)
incq %rax
incq %rsi
decq %r8
jne 0xeb243
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeb2f7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xeb2e1
movq 0x10(%rdi), %r15
callq 0x18030
movq %r15, (%rbx,%r14,8)
movq %r15, %rdi
testq %r15, %r15
jne 0xeb2cc
incq %r14
cmpq $0x47, %r14
jne 0xeb2c3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18030
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-util.c
// Function: de_inthashtable_get_item
int de_inthashtable_get_item(deark *c, struct de_inthashtable *ht, i64 key, void **pvalue)
{
	struct de_inthashtable_item *item;

	item = inthashtable_find_item(ht, key);
	if(item) {
		*pvalue = item->value;
		return 1;
	}
	*pvalue = NULL;
	return 0;
}

// Assembly:
testq %rsi, %rsi
je 0xeb344
movq %rdx, %rdi
movq %rdx, %r8
negq %r8
cmovsq %rdx, %r8
movabsq $-0x327a976fc64f52ed, %rdx # imm = 0xCD85689039B0AD13
movq %r8, %rax
mulq %rdx
movq %r8, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x6, %rax
imull $0x47, %eax, %eax
subl %eax, %r8d
movq (%rsi,%r8,8), %rax
testq %rax, %rax
je 0xeb344
cmpq %rdi, (%rax)
je 0xeb34c
movq 0x10(%rax), %rax
jmp 0xeb334
xorl %edx, %edx
xorl %eax, %eax
movq %rdx, (%rcx)
retq
movq 0x8(%rax), %rdx
movl $0x1, %eax
jmp 0xeb348
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdx, %r15
negq %r15
cmovsq %rdx, %r15
movabsq $-0x327a976fc64f52ed, %rcx # imm = 0xCD85689039B0AD13
movq %r15, %rax
mulq %rcx
movq %r15, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x6, %rax
imulq $0x47, %rax, %rax
subq %rax, %r15
movl %r15d, %eax
movq (%rsi,%rax,8), %rax
testq %rax, %rax
je 0xeb406
cmpq %r12, (%rax)
je 0xeb42a
movq 0x10(%rax), %rax
jmp 0xeb3f6
movl $0x18, %esi
callq 0xe8b2b
movq %r12, (%rax)
movq %r14, 0x8(%rax)
movq (%rbx,%r15,8), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx,%r15,8)
movl $0x1, %eax
jmp 0xeb42c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq (%rsi,%rax,8), %rdi
testq %rdi, %rdi
jne 0xeb46a
incq %rax
cmpq $0x47, %rax
jne 0xeb43d
testq %rdx, %rdx
je 0xeb45b
movq $0x0, (%rdx)
xorl %eax, %eax
testq %rcx, %rcx
je 0xeb469
movq $0x0, (%rcx)
retq
pushq %rax
testq %rdx, %rdx
je 0xeb476
movq (%rdi), %r8
movq %r8, (%rdx)
testq %rcx, %rcx
je 0xeb482
movq 0x8(%rdi), %rdx
movq %rdx, (%rcx)
movq 0x10(%rdi), %rcx
movq %rcx, (%rsi,%rax,8)
callq 0x18030
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl (%rdi), %eax
movzwl %ax, %r10d
shrl $0x10, %eax
testq %rdx, %rdx
jle 0xeb6a1
xorl %ecx, %ecx
movl $0x80078071, %r9d       # imm = 0x80078071
movzbl (%rsi,%rcx), %r8d
addl %r10d, %r8d
movq %r8, %r10
imulq %r9, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %r8d
addl %r8d, %eax
movq %rax, %r10
imulq %r9, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %eax
incq %rcx
movl %r8d, %r10d
cmpq %rcx, %rdx
jne 0xeb65f
jmp 0xeb6a4
movl %r10d, %r8d
shll $0x10, %eax
orl %r8d, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
jne 0xeb75a
movl %esi, %ebx
movq %rdi, %r14
incq %r15
movl $0x200, %esi            # imm = 0x200
callq 0xe8b2b
movq %rax, 0x2c0(%r14,%r15,8)
xorl %ecx, %ecx
movl $0x8, %edx
movl %ecx, %esi
movzwl %si, %edi
shrl %edi
andl $0x1, %esi
negl %esi
andl %ebx, %esi
xorl %edi, %esi
decl %edx
jne 0xeb738
movw %si, (%rax,%rcx,2)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xeb731
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
sete %cl
testq %rdx, %rdx
setle %r8b
orb %cl, %r8b
jne 0xeb79d
movl (%rdi), %r8d
xorl %ecx, %ecx
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
cmpq %rcx, %rdx
jne 0xeb77b
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
jle 0xeb7fd
movl 0x10(%rdi), %r8d
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %r9d
movl %r9d, %r10d
shll $0x8, %r10d
xorl %r11d, %r11d
testl %r8d, %r8d
sete %r11b
cmoveq %r9, %r10
addq %r10, %rax
movq %rax, 0x8(%rdi)
movl %r11d, 0x10(%rdi)
incq %rcx
movl %r11d, %r8d
cmpq %rcx, %rdx
jne 0xeb7cd
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl 0x4(%rdi), %eax
cmpl $0x21, %eax
jle 0xeb82e
leal -0x22(%rax), %ecx
cmpl $0x2, %ecx
jb 0xeb83d
cmpl $0x31, %eax
je 0xeb850
cmpl $0x32, %eax
jne 0xeb857
movl $0x1, 0x10(%rdi)
retq
leal -0x10(%rax), %ecx
cmpl $0x2, %ecx
jae 0xeb844
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
retq
movl $0xffff, (%rdi)         # imm = 0xFFFF
retq
cmpl $0x15, %eax
jne 0xeb857
movl $0x1, (%rdi)
retq
movl $0x0, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movl %ecx, %esi
callq 0xeb499
movq %rax, %rbx
leaq -0x44(%rip), %rcx       # 0xeb95f
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %r8
callq 0xef5e4
cmpb $0x0, 0x14(%rbx)
je 0xeb9d0
movl 0x8(%rbx), %ebp
movq %rbx, %rdi
callq 0x18030
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%rbx), %ebp
movl 0x4(%rbx), %eax
cmpl $0x22, %eax
je 0xeb9e3
cmpl $0x10, %eax
jne 0xeb9bd
notl %ebp
jmp 0xeb9bd
xorl $0xffff, %ebp           # imm = 0xFFFF
jmp 0xeb9bd
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-util.c
// Function: de_get_reproducible_timestamp
void de_get_reproducible_timestamp(deark *c, struct de_timestamp *ts)
{
	if(c->reproducible_timestamp.is_valid) {
		*ts = c->reproducible_timestamp;
		return;
	}

	// An arbitrary timestamp
	// $ date -u --date='2010-09-08 07:06:05' '+%s'
	de_unix_time_to_timestamp(1283929565LL, ts, 0x1);
}

// Assembly:
cmpb $0x0, 0xe0(%rdi)
je 0xeba02
addq $0xe0, %rdi
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
retq
movq $0x0, (%rsi)
movw $0x101, (%rsi)          # imm = 0x101
movabsq $0x1cb4f244da0ec80, %rax # imm = 0x1CB4F244DA0EC80
movq %rax, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x1, %eax
testq %rdx, %rdx
je 0xeba62
xorl %r8d, %r8d
movb (%rsi,%r8), %r9b
cmpb %cl, %r9b
je 0xeba5a
cmpb (%rdi,%r8), %r9b
jne 0xeba63
incq %r8
cmpq %r8, %rdx
jne 0xeba4b
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq $0x0, (%r9)
testq %rcx, %rcx
setle %al
cmpq %rsi, %rcx
setg %r10b
orb %al, %r10b
je 0xeba82
xorl %eax, %eax
retq
pushq %rbp
pushq %rbx
movb (%rdx), %al
subq %rcx, %rsi
incq %rsi
xorl %r10d, %r10d
movq %rdi, %r11
cmpb %r8b, %al
je 0xebaaa
cmpb (%rdi,%r10), %al
je 0xebaaa
incq %r10
incq %r11
cmpq %rsi, %r10
jne 0xeba92
jmp 0xebace
xorl %ebx, %ebx
movb (%rdx,%rbx), %bpl
cmpb %r8b, %bpl
je 0xebabb
cmpb (%r11,%rbx), %bpl
jne 0xeba9d
incq %rbx
cmpq %rbx, %rcx
jne 0xebaac
movq %r10, (%r9)
movl $0x1, %eax
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0xebacb
// File: /workspace/github_c_makefile_star2_O3/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 0xebb10
jle 0xebb0c
movq 0x30(%rbx), %rax
cmpl %esi, (%rax)
jge 0xebb16
xorl %eax, %eax
jmp 0xebb48
movq 0x18(%rbx), %rax
jmp 0xebb48
decl %esi
movq 0x8(%rax), %rcx
movl %esi, %r14d
shlq $0x4, %r14
movq 0x8(%rcx,%r14), %rax
testq %rax, %rax
jne 0xebb48
addq %r14, %rcx
movq (%rcx), %rsi
movq %rbx, %rdi
callq 0xf1114
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_O3/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 0xebb63
movq $0x0, (%rdx)
testl %esi, %esi
je 0xebb9e
jle 0xebb9e
movq 0x30(%rbx), %rax
cmpl %esi, (%rax)
jl 0xebb9e
decl %esi
movq 0x8(%rax), %rax
movl %esi, %r14d
shlq $0x4, %r14
movq 0x8(%rax,%r14), %rdi
testq %rdi, %rdi
je 0xebb9e
callq 0xf052b
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-data.c
// Function: de_decode_hex_digit
u8 de_decode_hex_digit(u8 x, int *errorflag)
{
	if(errorflag) *errorflag = 0;
	if(x>='0' && x<='9') return x-48;
	if(x>='A' && x<='F') return x-55;
	if(x>='a' && x<='f') return x-87;
	if(errorflag) *errorflag = 1;
	return 0;
}

// Assembly:
testq %rsi, %rsi
je 0xebbc7
movl $0x0, (%rsi)
leal -0x30(%rdi), %eax
cmpb $0xa, %al
jb 0xebbe8
leal -0x41(%rdi), %eax
cmpb $0x5, %al
ja 0xebbdb
addb $-0x37, %dil
jmp 0xebbe6
leal -0x61(%rdi), %eax
cmpb $0x5, %al
ja 0xebbe9
addb $-0x57, %dil
movl %edi, %eax
retq
testq %rsi, %rsi
je 0xebbf4
movl $0x1, (%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-data.c
// Function: de_latin2_to_unicode
static de_rune de_latin2_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;
	if(a<=0x9f) n = a;
	else if(a>=0xa0 && a<=0xbf) n = (de_rune)latin2table[a-0xa0];
	else if(a>=0x0c0 && a<=0xff) n = (de_rune)windows1250table[a-0x80];
	else n = DE_CODEPOINT_INVALID;
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	return n;
}

// Assembly:
cmpl $0xa0, %esi
jge 0xebd62
movl %esi, %eax
retq
cmpl $0xbf, %esi
ja 0xebd79
addl $0xffffff60, %esi       # imm = 0xFFFFFF60
leaq 0x5ab59(%rip), %rax     # 0x1468d0
jmp 0xebd90
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmpl $0xff, %esi
ja 0xebd61
addl $-0x80, %esi
leaq 0x5ab80(%rip), %rax     # 0x146910
leaq (%rax,%rsi,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
cmpw $-0x1, %cx
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-data.c
// Function: de_cp437c_to_unicode
static de_rune de_cp437c_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;
	if(a<=0x7f) n = a;
	else if(a>=0x80 && a<=0xff) n = (de_rune)cp437table[a];
	else n = DE_CODEPOINT_INVALID;
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	return n;
}

// Assembly:
cmpl $0x80, %esi
jge 0xebdb2
movl %esi, %eax
retq
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmpl $0xff, %esi
ja 0xebdcc
movl %esi, %eax
leaq 0x5ac48(%rip), %rcx     # 0x146a10
movzwl (%rcx,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-data.c
// Function: de_cp437h_to_unicode
static de_rune de_cp437h_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;

	if(a<32 && is_hybrid_codepoint(a)) n = a;
	else n = de_cp437g_to_unicode(NULL, a);
	return n;
}

// Assembly:
cmpl $0x1f, %esi
jg 0xebde4
cmpl $0xd, %esi
ja 0xebdf1
movl $0x2601, %eax           # imm = 0x2601
btl %esi, %eax
jae 0xebdf1
movl %esi, %eax
retq
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmpl $0xff, %esi
ja 0xebdff
movslq %esi, %rax
leaq 0x5ac15(%rip), %rcx     # 0x146a10
movzwl (%rcx,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-data.c
// Function: de_petscii_to_unicode
static de_rune de_petscii_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;
	if(a<=0xff) n = petscii1table[a];
	else n = DE_CODEPOINT_INVALID;
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	if(a==0x0a) {
		// This is a hack to make "-m plaintext -inenc petscii" work with the
		// output from the basic_c64 module.
		if(es->enc_subtype==DE_ENCSUBTYPE_HYBRID) {
			n = 0x0a;
		}
	}
	return n;
}

// Assembly:
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmpl $0xff, %esi
jg 0xebe6d
movslq %esi, %rax
leaq 0x5afc5(%rip), %rcx     # 0x146e10
movl (%rcx,%rax,4), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
cmpl $0xa, %esi
jne 0xebe6d
cmpl $0x3, 0x4(%rdi)
movl $0xa, %ecx
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/src/deark-data.c
// Function: de_windows1252_to_unicode
static de_rune de_windows1252_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;
	if(a>=0x80 && a<=0x9f) n = (de_rune)windows1252table[a-0x80];
	else if(a<=0xff) n = a;
	else n = DE_CODEPOINT_INVALID;
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	return n;
}

// Assembly:
movl %esi, %eax
andl $-0x20, %eax
cmpl $0x80, %eax
jne 0xebe8a
addl $-0x80, %esi
leaq 0x5b38c(%rip), %rax     # 0x147210
movzwl (%rax,%rsi,2), %ecx
jmp 0xebe98
cmpl $0x100, %esi            # imm = 0x100
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
cmovll %esi, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
retq