LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
setae %sil
testl %ecx, %ecx
sete %r8b
orb %sil, %r8b
jne 0xea891
decl %ecx
xorl %esi, %esi
btq %rcx, %rdx
setae %r8b
xorb $0x31, %r8b
movb %r8b, (%rax,%rsi)
incq %rsi
decl %ecx
cmpq %rsi, %rdi
jne 0xea875
jmp 0xea893
xorl %esi, %esi
movb $0x0, (%rax,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b49d(%rip), %rbx     # 0x145d40
testq %rdi, %rdi
je 0xea8e2
movq %rdi, %r14
callq 0x180e0
cmpl $0x2, %eax
jl 0xea8e2
addl $-0x2, %eax
leaq (%r14,%rax), %rcx
incq %rcx
incq %rax
movzbl -0x1(%rcx), %edx
cmpl $0x5c, %edx
je 0xea8e2
cmpl $0x2f, %edx
je 0xea8e2
cmpl $0x2e, %edx
je 0xea8df
decq %rcx
decq %rax
jg 0xea8c2
jmp 0xea8e2
movq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xea8fb
leaq 0x5b446(%rip), %rax     # 0x145d40
retq
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0xea8f3
cmpq $0x0, 0x68(%rdi)
jne 0xea8f3
movq %rax, %rdi
jmp 0xea898
// File: /workspace/github_c_makefile_star2_O1/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 0x5b3fc(%rip), %rdi     # 0x145d40
cmpb $0x0, 0x7a(%rcx)
je 0xea961
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe8e2c
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
popq %rbx
retq
movq 0x50(%rcx), %rax
testq %rax, %rax
je 0xea94a
cmpq $0x0, 0x68(%rcx)
jne 0xea94a
movq %rax, %rdi
callq 0xea898
movq %rax, %rdi
jmp 0xea94a
// File: /workspace/github_c_makefile_star2_O1/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 0xea9a6
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xea9a6
pushq %rax
movl %edx, %esi
callq 0x18100
movq %rax, %rcx
movl $0x1, %eax
testq %rcx, %rcx
leaq 0x8(%rsp), %rsp
je 0xea9a6
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xea9e3
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xea9c9
callq 0xf6bb0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0xea9da
callq 0xf6bb0
movq %rbx, %rdi
popq %rbx
jmp 0x18030
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeacbd
movl %r8d, %ebp
movq %rdx, %r12
movq %r15, %rdi
callq 0xf6870
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xf6a40
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
jmp 0xeaccd
xorl %edi, %edi
callq 0xf6b5c
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 0xeaa0b
// File: /workspace/github_c_makefile_star2_O1/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 0xead15
movb $0x1, (%rsi)
movq %rax, 0x8(%rsi)
movb $0x28, 0x2(%rsi)
testb $0x1, %dl
je 0xead15
movb $0x1, 0x1(%rsi)
movb $0x0, 0x2(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xead39
movb $0x1, (%rsi)
movq %rdi, 0x8(%rsi)
movb $0x28, 0x2(%rsi)
testb $0x1, %dl
je 0xead39
movb $0x1, 0x1(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeadb5
cmpq $0x0, 0x8(%rdi)
jns 0xead4e
movq $0x0, 0x8(%rdi)
movq 0x8(%rdi), %rcx
movabsq $-0x29406b2a1a85bd43, %rdx # imm = 0xD6BF94D5E57A42BD
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x17, %rdx
addq %rax, %rdx
mulsd 0x27355(%rip), %xmm0    # 0x1120d0
addsd 0x2c94d(%rip), %xmm0    # 0x1176d0
imulq $0x989680, %rdx, %rax   # imm = 0x989680
cvttsd2si %xmm0, %rdx
movl $0x98967f, %esi         # imm = 0x98967F
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
xorl %edx, %edx
testq %rsi, %rsi
cmovgq %rsi, %rdx
subq %rcx, %rax
addq %rcx, %rax
addq %rdx, %rax
movq %rax, 0x8(%rdi)
movb $0x28, 0x2(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeae8b
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 0xeae97
movb $0x14, 0x2(%rbx)
jmp 0xeae91
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb018
leaq -0x186a0(%rsi), %rax
cmpq $-0x1805f, %rax         # imm = 0xFFFE7FA1
jb 0xeb018
pushq %r15
pushq %r14
pushq %rbx
leaq -0x1(%rdx), %rbx
cmpq $0xb, %rbx
ja 0xeb013
decq %rcx
cmpq $0x1e, %rcx
ja 0xeb013
cmpq $0x3b, %r9
ja 0xeb013
movq 0x20(%rsp), %r11
cmpq $0x3c, %r11
ja 0xeb013
addq $-0xd, %rdx
xorl %eax, %eax
cmpq $-0xc, %rdx
cmovbq %rax, %rbx
imulq $0x16d, %rsi, %rax      # imm = 0x16D
leaq -0x7b0(%rsi), %rdx
leaq -0x7ad(%rsi), %r15
testq %rdx, %rdx
cmovnsq %rdx, %r15
sarq $0x2, %r15
addq %rax, %r15
leaq 0x5ae25(%rip), %rax     # 0x145d50
movslq (%rax,%rbx,4), %r14
leaq -0x76c(%rsi), %rax
movabsq $0x5c28f5c28f5c28f5, %rdx # imm = 0x5C28F5C28F5C28F5
imulq %rdx
movq %rdx, %r10
subq %rsi, %r10
addq $0x76c, %r10            # imm = 0x76C
movq %r10, %rax
shrq $0x3f, %rax
sarq $0x6, %r10
addq %rax, %r10
addq %r15, %r10
leaq -0x640(%rsi), %rax
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0xA3D70A3D70A3D70B
imulq %rdx
leaq (%rdx,%rsi), %rax
addq $-0x640, %rax           # imm = 0xF9C0
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x8, %rax
addq %rdx, %rax
addq %r10, %rax
addq %r14, %rax
addq $-0xaf8ca, %rax         # imm = 0xFFF50736
testb $0x3, %sil
jne 0xeafcc
movabsq $-0x70a3d70a3d70a3d7, %rdx # imm = 0x8F5C28F5C28F5C29
imulq %rdx, %rsi
movq %rsi, %rdx
rorq $0x2, %rdx
movabsq $0x28f5c28f5c28f5c, %r10 # imm = 0x28F5C28F5C28F5C
cmpq %r10, %rdx
jbe 0xeb019
cmpq $0x1, %rbx
jg 0xeafcc
decq %rax
addq %rcx, %rax
leaq (%rax,%rax,2), %rax
leaq (%r8,%rax,8), %rax
imulq $0x3c, %rax, %rax
addq %r9, %rax
imulq $0x3c, %rax, %rax
addq %r11, %rax
imulq $0x989680, %rax, %rcx   # imm = 0x989680
movabsq $0x19db1ded53e8000, %rax # imm = 0x19DB1DED53E8000
addq %rcx, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
testq %rax, %rax
jle 0xeb00f
movb $0x1, (%rdi)
movq %rax, 0x8(%rdi)
movb $0x28, 0x2(%rdi)
movb $0x0, 0x2(%rdi)
popq %rbx
popq %r14
popq %r15
retq
rorq $0x4, %rsi
movabsq $0xa3d70a3d70a3d8, %rdx # imm = 0xA3D70A3D70A3D8
cmpq %rdx, %rsi
setb %dl
cmpq $0x2, %rbx
setl %sil
testb %sil, %dl
jne 0xeafc9
jmp 0xeafcc
// File: /workspace/github_c_makefile_star2_O1/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 0xeb06c
leaq 0x5aef6(%rip), %rsi     # 0x145f57
movq %r14, %rdi
callq 0xf7566
addl $-0xf, %ebx
testb $0x1, %bl
je 0xeb082
leaq 0x439ec(%rip), %rsi     # 0x12ea64
movq %r14, %rdi
callq 0xf7566
decl %ebx
testb $0x2, %bl
je 0xeb099
leaq 0x42f01(%rip), %rsi     # 0x12df8f
movq %r14, %rdi
callq 0xf7566
addl $-0x2, %ebx
testb $0x4, %bl
je 0xeb0b0
leaq 0x3605f(%rip), %rsi     # 0x121104
movq %r14, %rdi
callq 0xf7566
addl $-0x4, %ebx
testb $0x8, %bl
je 0xeb0c7
leaq 0x5dc1e(%rip), %rsi     # 0x148cda
movq %r14, %rdi
callq 0xf7566
addl $-0x8, %ebx
testb $0x10, %bl
je 0xeb0de
leaq 0x28a9f(%rip), %rsi     # 0x113b72
movq %r14, %rdi
callq 0xf7566
addl $-0x10, %ebx
testb $0x20, %bl
je 0xeb0f5
leaq 0x2bc09(%rip), %rsi     # 0x116cf3
movq %r14, %rdi
callq 0xf7566
addl $-0x20, %ebx
testl %ebx, %ebx
je 0xeb113
leaq 0x5971b(%rip), %rsi     # 0x14481b
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf7593
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb17a
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 0xeae97
movb $0xf, 0x2(%rbx)
jmp 0xeb180
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb295
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 0xeb295
movupd %xmm0, (%rcx)
movabsq $0x28f5c28f5c28f5d, %rdx # imm = 0x28F5C28F5C28F5D
movq %rsi, %rax
mulq %rdx
imulq $0x989680, %rdx, %rax   # imm = 0x989680
movabsq $0x14f373bfde04000, %rdi # imm = 0x14F373BFDE04000
addq %rax, %rdi
movb $0x1, (%rcx)
movq %rdi, 0x8(%rcx)
movb $0x0, 0x2(%rcx)
xorl %eax, %eax
testb %al, %al
jne 0xeb291
imull $0x64, %edx, %eax
subl %eax, %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd 0x2f35d(%rip), %xmm0    # 0x11a578
cmpq $0x0, 0x8(%rcx)
jns 0xeb22a
movq $0x0, 0x8(%rcx)
movq 0x8(%rcx), %rsi
movabsq $-0x29406b2a1a85bd43, %rdx # imm = 0xD6BF94D5E57A42BD
movq %rsi, %rax
imulq %rdx
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x17, %rdx
addq %rax, %rdx
mulsd 0x26e79(%rip), %xmm0    # 0x1120d0
addsd 0x2c471(%rip), %xmm0    # 0x1176d0
imulq $0x989680, %rdx, %rax   # imm = 0x989680
cvttsd2si %xmm0, %rdx
movl $0x98967f, %edi         # imm = 0x98967F
cmpq %rdi, %rdx
cmovlq %rdx, %rdi
xorl %edx, %edx
testq %rdi, %rdi
cmovgq %rdi, %rdx
subq %rsi, %rax
addq %rsi, %rax
addq %rdx, %rax
movq %rax, 0x8(%rcx)
movb $0x28, 0x2(%rcx)
movb $0x1, 0x1(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb56d
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rsi
callq 0xeb2df
cmpl $0x0, (%r12)
je 0xeb59a
cmpb $0x1f, 0x2(%r15)
jb 0xeb5de
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 0x5aa3d(%rip), %rdx     # 0x145f97
leaq 0x20(%rsp), %rdi
movl $0x10, %esi
xorl %eax, %eax
callq 0xe8d67
jmp 0xeb5e3
decq %r14
cmpq $0x13, %r14
movl $0x13, %r15d
cmovbq %r14, %r15
leaq 0x5a9e0(%rip), %rsi     # 0x145f65
movq %rbx, %rdi
movq %r15, %rdx
callq 0x181e0
movb $0x0, (%rbx,%r15)
jmp 0xeb676
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 0x5a9ad(%rip), %rdx     # 0x145f79
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe8d67
jmp 0xeb676
movb $0x0, 0x20(%rsp)
movb 0x2(%r15), %al
decb %al
cmpb $0x9, %al
ja 0xeb614
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
incl %r8d
movl 0xc(%rsp), %r9d
leaq 0x5a998(%rip), %rdx     # 0x145f9d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe8d67
jmp 0xeb676
cmpb $0x1, 0x1(%r15)
leaq 0x593b2(%rip), %rax     # 0x1449d2
leaq 0x5a719(%rip), %r10     # 0x145d40
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 0x5a951(%rip), %rdx     # 0x145fac
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r12
pushq %r15
pushq %r11
callq 0xe8d67
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_O1/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 0xeb702
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jne 0xeb701
movq %rsi, %rdx
leaq 0x5a8de(%rip), %rsi     # 0x145fce
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9ef5
movl $0x1, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb76d
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 0x109878
cmpl $0x1, 0x10(%rbx)
jg 0xeb7c8
cmpl $0x0, 0x20(%rbx)
jne 0xeb7c8
leaq 0x5a81c(%rip), %rsi     # 0x145fce
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9ef5
movl $0x1, 0x20(%rbx)
addq $0x150, %rsp            # imm = 0x150
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb859
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 0xeb84e
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 0xeb7f4
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb8a8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xeb892
movq 0x10(%rdi), %r15
callq 0x18030
movq %r15, (%rbx,%r14,8)
movq %r15, %rdi
testq %r15, %r15
jne 0xeb87d
incq %r14
cmpq $0x47, %r14
jne 0xeb874
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18030
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %r8d, %r8d
testq %rsi, %rsi
je 0xeb8f8
movq %rdx, %rdi
movq %rdx, %r9
negq %r9
cmovsq %rdx, %r9
movabsq $-0x327a976fc64f52ed, %rdx # imm = 0xCD85689039B0AD13
movq %r9, %rax
mulq %rdx
movq %r9, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x6, %rax
imull $0x47, %eax, %eax
subl %eax, %r9d
movq (%rsi,%r9,8), %rax
testq %rax, %rax
je 0xeb8fa
cmpq %rdi, (%rax)
je 0xeb8fa
movq 0x10(%rax), %rax
jmp 0xeb8e8
xorl %eax, %eax
testq %rax, %rax
je 0xeb90b
movq 0x8(%rax), %rax
movl $0x1, %r8d
jmp 0xeb90d
xorl %eax, %eax
movq %rax, (%rcx)
movl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeb9c3
cmpq %r12, (%rax)
je 0xeb9e7
movq 0x10(%rax), %rax
jmp 0xeb9b3
movl $0x18, %esi
callq 0xe969b
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 0xeb9e9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeba27
incq %rax
cmpq $0x47, %rax
jne 0xeb9fa
testq %rdx, %rdx
je 0xeba18
movq $0x0, (%rdx)
xorl %eax, %eax
testq %rcx, %rcx
je 0xeba26
movq $0x0, (%rcx)
retq
pushq %rax
testq %rdx, %rdx
je 0xeba33
movq (%rdi), %r8
movq %r8, (%rdx)
testq %rcx, %rcx
je 0xeba3f
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_O1/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
sete %cl
testq %rdx, %rdx
setle %r8b
orb %cl, %r8b
jne 0xebc10
movl (%rdi), %r9d
xorl %ecx, %ecx
movl %r9d, %r8d
shrl $0x8, %r8d
movzbl %r9b, %r9d
movzbl (%rsi,%rcx), %r10d
xorl %r9d, %r10d
xorl (%rax,%r10,4), %r8d
movl %r8d, (%rdi)
incq %rcx
movl %r8d, %r9d
cmpq %rcx, %rdx
jne 0xebbee
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xebc69
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 0xebc27
jmp 0xebc6c
movl %r10d, %r8d
shll $0x10, %eax
orl %r8d, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
sete %cl
testq %rdx, %rdx
setle %r8b
orb %cl, %r8b
jne 0xebcba
movl (%rdi), %r8d
xorl %ecx, %ecx
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
cmpq %rcx, %rdx
jne 0xebc90
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x8408, %esi           # imm = 0x8408
sete %al
addl %eax, %eax
leaq 0x1(%rax), %r14
cmpq $0x0, 0x2c8(%rdi,%rax,8)
jne 0xebd24
movl %esi, %ebp
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
callq 0xe969b
movq %rax, 0x2c0(%rbx,%r14,8)
xorl %ecx, %ecx
movw %cx, (%rax,%rcx,2)
movl $0x8, %edx
movl %ecx, %esi
movzwl %si, %edi
shrl %edi
andl $0x1, %esi
negl %esi
andl %ebp, %esi
xorl %edi, %esi
decl %edx
jne 0xebd02
movw %si, (%rax,%rcx,2)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xebcf7
movq 0x2c0(%rbx,%r14,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xebd6e
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 0xebd4c
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xebdc2
movl 0x10(%rdi), %ecx
xorl %eax, %eax
movzbl (%rsi,%rax), %r8d
testl %ecx, %ecx
je 0xebda6
shll $0x8, %r8d
addq %r8, 0x8(%rdi)
xorl %r8d, %r8d
testl %ecx, %ecx
sete %r8b
movl %r8d, 0x10(%rdi)
incq %rax
movl %r8d, %ecx
cmpq %rax, %rdx
jne 0xebd99
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xebdf3
leal -0x22(%rax), %ecx
cmpl $0x2, %ecx
jb 0xebe02
cmpl $0x31, %eax
je 0xebe15
cmpl $0x32, %eax
jne 0xebe1c
movl $0x1, 0x10(%rdi)
retq
leal -0x10(%rax), %ecx
cmpl $0x2, %ecx
jae 0xebe09
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
retq
movl $0xffff, (%rdi)         # imm = 0xFFFF
retq
cmpl $0x15, %eax
jne 0xebe1c
movl $0x1, (%rdi)
retq
movl $0x0, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeba56
movq %rax, %rbx
leaq -0x44(%rip), %rcx       # 0xebf24
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %r8
callq 0xefc28
cmpb $0x0, 0x14(%rbx)
je 0xebf9a
movl 0x8(%rbx), %ebp
testq %rbx, %rbx
je 0xebf8f
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 0xebfad
cmpl $0x10, %eax
jne 0xebf82
notl %ebp
jmp 0xebf82
xorl $0xffff, %ebp           # imm = 0xFFFF
jmp 0xebf82
// File: /workspace/github_c_makefile_star2_O1/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 0xebfcc
addq $0xe0, %rdi
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movw $0x101, (%rsi)          # imm = 0x101
movabsq $0x1cb4f244da0ec80, %rax # imm = 0x1CB4F244DA0EC80
movq %rax, 0x8(%rsi)
movb $0x0, 0x2(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec040
xorl %r8d, %r8d
movb (%rsi,%r8), %r10b
movl $0x4, %r9d
cmpb %cl, %r10b
je 0xec032
xorl %r9d, %r9d
cmpb (%rdi,%r8), %r10b
setne %r9b
testb $0x3, %r9b
jne 0xec041
incq %r8
cmpq %r8, %rdx
jne 0xec018
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec060
xorl %eax, %eax
retq
pushq %rbp
pushq %rbx
subq %rcx, %rsi
incq %rsi
xorl %eax, %eax
movq %rdi, %r10
movb (%rdx), %bl
cmpb %r8b, %bl
je 0xec07f
movl $0x4, %r11d
cmpb (%rdi,%rax), %bl
jne 0xec0b4
xorl %r11d, %r11d
movb (%rdx,%r11), %bpl
movl $0x4, %ebx
cmpb %r8b, %bpl
je 0xec099
xorl %ebx, %ebx
cmpb (%r10,%r11), %bpl
setne %bl
testb $0x3, %bl
jne 0xec0b1
incq %r11
cmpq %r11, %rcx
jne 0xec082
movq %rax, (%r9)
movl $0x1, %r11d
jmp 0xec0b4
xorl %r11d, %r11d
testb $0x3, %r11b
jne 0xec0c9
incq %rax
incq %r10
cmpq %rsi, %rax
jne 0xec06d
xorl %eax, %eax
jmp 0xec0ce
movl $0x1, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec10e
jle 0xec10a
movq 0x30(%rbx), %rax
cmpl %esi, (%rax)
jge 0xec114
xorl %eax, %eax
jmp 0xec157
addq $0x18, %rbx
jmp 0xec154
decl %esi
movq 0x8(%rax), %rax
movl %esi, %r14d
shlq $0x4, %r14
cmpq $0x0, 0x8(%rax,%r14)
jne 0xec144
addq %r14, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xf1717
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x8(%rcx,%r14)
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
leaq (%rax,%r14), %rbx
addq $0x8, %rbx
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec172
movq $0x0, (%rdx)
testl %esi, %esi
je 0xec1ad
jle 0xec1ad
movq 0x30(%rbx), %rax
cmpl %esi, (%rax)
jl 0xec1ad
decl %esi
movq 0x8(%rax), %rax
movl %esi, %r14d
shlq $0x4, %r14
movq 0x8(%rax,%r14), %rdi
testq %rdi, %rdi
je 0xec1ad
callq 0xf0b13
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xec1d7
movl $0x0, (%rsi)
leal -0x30(%rdi), %eax
cmpb $0xa, %al
jb 0xec1f8
leal -0x41(%rdi), %eax
cmpb $0x5, %al
ja 0xec1eb
addb $-0x37, %dil
jmp 0xec1f6
leal -0x61(%rdi), %eax
cmpb $0x5, %al
ja 0xec1f9
addb $-0x57, %dil
movl %edi, %eax
retq
testq %rsi, %rsi
je 0xec204
movl $0x1, (%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec36e
movl %esi, %ecx
jmp 0xec3a3
cmpl $0xbf, %esi
jg 0xec385
addl $0xffffff60, %esi       # imm = 0xFFFFFF60
leaq 0x59fdd(%rip), %rax     # 0x146360
jmp 0xec39c
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
cmpl $0xff, %esi
jg 0xec3a3
addl $-0x80, %esi
leaq 0x5a004(%rip), %rax     # 0x1463a0
leaq (%rax,%rsi,2), %rax
movzwl (%rax), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec3be
movl %esi, %ecx
jmp 0xec3d8
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
cmpl $0xff, %esi
jg 0xec3d8
movl %esi, %eax
leaq 0x5a0cc(%rip), %rcx     # 0x1464a0
movzwl (%rcx,%rax,2), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %eax
cmpl $0x1f, %esi
jg 0xec3fe
cmpl $0xd, %eax
ja 0xec3fe
movl $0x2601, %ecx           # imm = 0x2601
btl %eax, %ecx
jae 0xec3fe
retq
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movl $0xfffffff, %edx        # imm = 0xFFFFFFF
cmpl $0xff, %eax
jg 0xec41c
cltq
leaq 0x5a088(%rip), %rdx     # 0x1464a0
movzwl (%rdx,%rax,2), %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
cmovnel %edx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
cmpl $0xff, %esi
jg 0xec489
movslq %esi, %rcx
leaq 0x5a41a(%rip), %rdx     # 0x1468a0
movl (%rdx,%rcx,4), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
cmovnel %ecx, %eax
cmpl $0xa, %esi
jne 0xec4a3
cmpl $0x3, 0x4(%rdi)
movl $0xa, %ecx
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec4c0
addl $-0x80, %esi
leaq 0x5a7e6(%rip), %rax     # 0x146ca0
movzwl (%rax,%rsi,2), %ecx
jmp 0xec4ce
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
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-data.c
// Function: de_ext_ascii_to_unicode
static de_rune de_ext_ascii_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)((struct ext_ascii_pvt_data*)es->fn_pvt_data)->tbl[a-0x80];
	else n = DE_CODEPOINT_INVALID;
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	return n;
}

// Assembly:
cmpl $0x80, %esi
jge 0xec4e9
movl %esi, %ecx
jmp 0xec507
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
cmpl $0xff, %esi
jg 0xec507
movq 0x10(%rdi), %rax
movq (%rax), %rax
movl %esi, %ecx
movzwl -0x100(%rax,%rcx,2), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-data.c
// Function: de_windows874_to_unicode
static de_rune de_windows874_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n = 0xffff;
	if(a<=0x7f || a==0xa0) n = a;
	else if(a==0x80 || a==0x85 || (a>=0x91 && a<=0x97)) n = (de_rune)windows1252table[a-0x80];
	else if((a>=0xa1 && a<=0xda) || (a>=0xdf && a<=0xfb)) n = a + (0xe01 - 0xa1);
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	return n;
}

// Assembly:
cmpl $0x80, %esi
setl %al
cmpl $0xa0, %esi
sete %cl
orb %al, %cl
jne 0xec555
cmpl $0x80, %esi
je 0xec547
cmpl $0x85, %esi
je 0xec547
leal -0x91(%rsi), %eax
cmpl $0x6, %eax
ja 0xec564
addl $-0x80, %esi
leaq 0x5a74f(%rip), %rax     # 0x146ca0
movzwl (%rax,%rsi,2), %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %esi, %eax
retq
leal -0xa1(%rsi), %eax
leal -0xdf(%rsi), %ecx
addl $0xd60, %esi            # imm = 0xD60
cmpl $0x1d, %ecx
movl $0xffff, %ecx           # imm = 0xFFFF
cmovbl %esi, %ecx
cmpl $0x3a, %eax
cmovbl %esi, %ecx
movl %ecx, %esi
jmp 0xec555
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-data.c
// Function: de_atarist_to_unicode
static de_rune de_atarist_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;

	if(a<=0x1f || a==0x7f) {
		if (es->enc_subtype==DE_ENCSUBTYPE_HYBRID || es->enc_subtype==DE_ENCSUBTYPE_CONTROLS) {
			return a;
		}
	}
	if(a<=0x1f) n = atarist_table_lo[a];
	else if(a>=0xb0 && a<=0xff) n = (de_rune)atarist_table_hi[a-0xb0];
	else if(a==0x7f) n = 0x0394;
	else if(a==0x9e) n = 0x00df;
	else n = de_cp437g_to_unicode(NULL, a);
	if(n==0xffff) n = DE_CODEPOINT_INVALID;
	return n;
}

// Assembly:
movl %esi, %eax
cmpl $0x20, %esi
setge %cl
cmpl $0x7f, %esi
setne %dl
testb %dl, %cl
jne 0xec5a8
movl 0x4(%rdi), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
je 0xec620
cmpl $0x1f, %eax
jg 0xec5bb
cltq
leaq 0x5ab2a(%rip), %rcx     # 0x1470e0
movl (%rcx,%rax,4), %ecx
jmp 0xec612
leal -0xb0(%rax), %ecx
cmpl $0x4f, %ecx
ja 0xec5d5
movl %ecx, %eax
leaq 0x5ab91(%rip), %rcx     # 0x147160
movzwl (%rcx,%rax,2), %ecx
jmp 0xec612
movl $0x394, %ecx            # imm = 0x394
cmpl $0x7f, %eax
je 0xec612
movl $0xdf, %ecx
cmpl $0x9e, %eax
je 0xec612
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movl $0xfffffff, %edx        # imm = 0xFFFFFFF
cmpl $0xff, %eax
jg 0xec609
movl %eax, %eax
leaq 0x59e9b(%rip), %rdx     # 0x1464a0
movzwl (%rdx,%rax,2), %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
cmovnel %edx, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-data.c
// Function: de_palmcs_to_unicode
static de_rune de_palmcs_to_unicode(struct de_encconv_state *es, i32 a)
{
	de_rune n;
	// This is not perfect, but the diamond/club/heart/spade characters seem to
	// be about the only printable characters common to all versions of this
	// encoding, that differ from Windows-1252.
	if(a>=0x8d && a<=0x90) n = (de_rune)palmcstable[a-0x8d];
	else n = de_windows1252_to_unicode(NULL, a);
	return n;
}

// Assembly:
leal -0x8d(%rsi), %eax
cmpl $0x3, %eax
ja 0xec63a
movl %eax, %eax
leaq 0x5c13b(%rip), %rcx     # 0x148770
movzwl (%rcx,%rax,2), %eax
retq
movl %esi, %eax
andl $-0x20, %eax
cmpl $0x80, %eax
jne 0xec656
addl $-0x80, %esi
leaq 0x5a650(%rip), %rax     # 0x146ca0
movzwl (%rax,%rsi,2), %ecx
jmp 0xec664
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