LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_sz_has_ext
int de_sz_has_ext(const char *sz, const char *ext)
{
	const char *e;

	e = de_get_sz_ext(sz);
	if(!de_strcasecmp(e, ext))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15d000
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15aaa0
cmpl $0x0, %eax
jne 0x15d168
movl $0x1, -0x4(%rbp)
jmp 0x15d16f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15d0c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15aaa0
cmpl $0x0, %eax
jne 0x15d1b8
movl $0x1, -0x4(%rbp)
jmp 0x15d1bf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15d212
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15d212
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x15abe0
cmpq $0x0, %rax
je 0x15d212
movl $0x1, -0x4(%rbp)
jmp 0x15d219
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15d279
jmp 0x15d2ba
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15d28f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x15d2ad
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15d4f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x15d2c0
jmp 0x15d529
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x1715e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x15d300
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movabsq $0x2b6109100, %rax      # imm = 0x2B6109100
addq -0x8(%rbp), %rax
imulq $0x989680, %rax, %rdi   # imm = 0x989680
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x15d580
movq -0x10(%rbp), %rax
movb $0x0, 0x2(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
cmpq $0x0, -0x8(%rbp)
jg 0x15d5ac
jmp 0x15d5da
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x28, 0x2(%rax)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15d5da
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x15d5fb
jmp 0x15d692
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jge 0x15d612
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x989680, %ecx         # imm = 0x989680
cqto
idivq %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movsd 0x40b60(%rip), %xmm1    # 0x19e1a0
mulsd %xmm1, %xmm0
movsd 0x45fec(%rip), %xmm1    # 0x1a3638
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x18(%rbp)
cmpq $0x989680, -0x18(%rbp)  # imm = 0x989680
jl 0x15d66b
movq $0x98967f, -0x18(%rbp)  # imm = 0x98967F
cmpq $0x0, -0x18(%rbp)
jge 0x15d67a
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x28, 0x2(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15d787
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x15d81d
movq -0x10(%rbp), %rax
andq $0xfe00, %rax           # imm = 0xFE00
sarq $0x9, %rax
addq $0x7bc, %rax            # imm = 0x7BC
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0x1e0, %rax            # imm = 0x1E0
sarq $0x5, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
andq $0x1f, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0xf800, %rax           # imm = 0xF800
sarq $0xb, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
andq $0x7e0, %rax            # imm = 0x7E0
sarq $0x5, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
andq $0x1f, %rax
shlq %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %rax
movq %rax, (%rsp)
callq 0x15d830
movq -0x8(%rbp), %rax
movb $0x14, 0x2(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_make_timestamp
void de_make_timestamp(struct de_timestamp *ts,
	i64 yr, i64 mo, i64 da,
	i64 hr, i64 mi, i64 se)
{
	i64 result;
	i64 tm_mon;
	static const int cumulative_days[12] =
		{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };

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

	de_unix_time_to_timestamp(result, ts, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x15dd50
cmpl $0x0, %eax
jne 0x15d88b
jmp 0x15d9db
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jl 0x15d8a5
cmpq $0xb, -0x40(%rbp)
jle 0x15d8ad
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
subq $0x7b2, %rax            # imm = 0x7B2
imulq $0x16d, %rax, %rax      # imm = 0x16D
movq -0x40(%rbp), %rdx
leaq 0x744d7(%rip), %rcx     # 0x1d1da0
movslq (%rcx,%rdx,4), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
subq $0x7b0, %rax            # imm = 0x7B0
movl $0x4, %ecx
cqto
idivq %rcx
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
subq $0x76c, %rax            # imm = 0x76C
movl $0x64, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
subq $0x640, %rax            # imm = 0x640
movl $0x190, %ecx            # imm = 0x190
cqto
idivq %rcx
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x15d97d
movq -0x10(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x15d96a
movq -0x10(%rbp), %rax
movl $0x190, %ecx            # imm = 0x190
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x15d97d
cmpq $0x2, -0x40(%rbp)
jge 0x15d97d
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
imulq $0x18, -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
imulq $0x3c, -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
imulq $0x3c, -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x15d530
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15da3b
movl -0x20(%rbp), %eax
andl $0x3f, %eax
cmpl $0xf, %eax
jne 0x15da3b
movq -0x18(%rbp), %rdi
leaq 0x74582(%rip), %rsi     # 0x1d1faf
callq 0x172680
movl -0x20(%rbp), %eax
subl $0xf, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15da5f
movq -0x18(%rbp), %rdi
leaq 0x5ce29(%rip), %rsi     # 0x1ba87a
callq 0x172680
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x15da83
movq -0x18(%rbp), %rdi
leaq 0x5c330(%rip), %rsi     # 0x1b9da5
callq 0x172680
movl -0x20(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x15daa7
movq -0x18(%rbp), %rdi
leaq 0x4f320(%rip), %rsi     # 0x1acdb9
callq 0x172680
movl -0x20(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x15dacb
movq -0x18(%rbp), %rdi
leaq 0x772f9(%rip), %rsi     # 0x1d4db6
callq 0x172680
movl -0x20(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x15daef
movq -0x18(%rbp), %rdi
leaq 0x42076(%rip), %rsi     # 0x19fb57
callq 0x172680
movl -0x20(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x15db13
movq -0x18(%rbp), %rdi
leaq 0x4509e(%rip), %rsi     # 0x1a2ba3
callq 0x172680
movl -0x20(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x15db2e
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq 0x72cf4(%rip), %rsi     # 0x1d081b
movb $0x0, %al
callq 0x1726d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15db6b
movq -0x18(%rbp), %rax
andq $0xe0c0, %rax           # imm = 0xE0C0
cmpq $0x0, %rax
je 0x15db87
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x15dc10
movq -0x10(%rbp), %rax
andq $0xfe00, %rax           # imm = 0xFE00
sarq $0x9, %rax
addq $0x76c, %rax            # imm = 0x76C
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0x1e0, %rax            # imm = 0x1E0
sarq $0x5, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
andq $0x1f, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x1f00, %rax           # imm = 0x1F00
sarq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %rax
movq %rax, (%rsp)
callq 0x15d830
movq -0x8(%rbp), %rax
movb $0xf, 0x2(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movl -0x4(%rbp), %eax
andl $0xfff00000, %eax       # imm = 0xFFF00000
cmpl $0xfff00000, %eax       # imm = 0xFFF00000
je 0x15dc56
jmp 0x15dcf5
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
shlq $0x20, %rax
movl -0x8(%rbp), %ecx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movabsq $0x83aa7e80, %rcx       # imm = 0x83AA7E80
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x15dcbf
movabsq $0x1dcd65000, %rax      # imm = 0x1DCD65000
cmpq %rax, -0x18(%rbp)
jl 0x15dcc1
jmp 0x15dcf5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x15d530
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x485e4(%rip), %xmm1    # 0x1a62c8
divsd %xmm1, %xmm0
callq 0x15d5e0
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: is_valid_time
static int is_valid_time(i64 yr, i64 mo, i64 da, i64 hr, i64 mi, i64 se)
{
	if(yr<1601|| yr>99999) return 0;
	if(mo<1 || mo>12) return 0;
	// Next line could be improved, but it's not important.
	if(da<1 || da>31) return 0;
	if(hr<0 || hr>23) return 0;
	if(mi<0 || mi>59) return 0;
	if(se<0 || se>60) return 0; // (tolerate a leap second)
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x641, -0x10(%rbp)     # imm = 0x641
jl 0x15dd80
cmpq $0x1869f, -0x10(%rbp)   # imm = 0x1869F
jle 0x15dd89
movl $0x0, -0x4(%rbp)
jmp 0x15de03
cmpq $0x1, -0x18(%rbp)
jl 0x15dd97
cmpq $0xc, -0x18(%rbp)
jle 0x15dda0
movl $0x0, -0x4(%rbp)
jmp 0x15de03
cmpq $0x1, -0x20(%rbp)
jl 0x15ddae
cmpq $0x1f, -0x20(%rbp)
jle 0x15ddb7
movl $0x0, -0x4(%rbp)
jmp 0x15de03
cmpq $0x0, -0x28(%rbp)
jl 0x15ddc5
cmpq $0x17, -0x28(%rbp)
jle 0x15ddce
movl $0x0, -0x4(%rbp)
jmp 0x15de03
cmpq $0x0, -0x30(%rbp)
jl 0x15dddc
cmpq $0x3b, -0x30(%rbp)
jle 0x15dde5
movl $0x0, -0x4(%rbp)
jmp 0x15de03
cmpq $0x0, -0x38(%rbp)
jl 0x15ddf3
cmpq $0x3c, -0x38(%rbp)
jle 0x15ddfc
movl $0x0, -0x4(%rbp)
jmp 0x15de03
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_dbg_timestamp_to_string
char *de_dbg_timestamp_to_string(deark *c, const struct de_timestamp *ts,
	char *buf, size_t buf_len, unsigned int flags)
{
	if(c->debug_level<1) {
		buf[0] = '\0';
		return buf;
	}
	return de_timestamp_to_string(ts, buf, buf_len, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jge 0x15e306
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15e31e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x15e130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x15e39c
jmp 0x15e3c9
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x15e3a8
jmp 0x15e3c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x73c6f(%rip), %rsi     # 0x1d2026
movb $0x0, %al
callq 0x15c0c0
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_get_input_encoding
de_encoding de_get_input_encoding(deark *c, de_module_params *mparams,
	de_encoding dflt)
{
	if(mparams && mparams->in_params.input_encoding!=DE_ENCODING_UNKNOWN) {
		return mparams->in_params.input_encoding;
	}
	if(c->input_encoding!=DE_ENCODING_UNKNOWN) {
		return c->input_encoding;
	}
	return dflt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15e4cc
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x15e4cc
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x15e4ee
movq -0x10(%rbp), %rax
cmpl $0x0, 0xfc(%rax)
je 0x15e4e8
movq -0x10(%rbp), %rax
movl 0xfc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x15e4ee
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_copy_bits
void de_copy_bits(const u8 *src, i64 srcbitnum,
	u8 *dst, i64 dstbitnum, i64 bitstocopy)
{
	i64 i;
	u8 b;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x15e5f1
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x40(%rbp), %rax
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movl -0x38(%rbp), %eax
movl $0x7, %ecx
subq %rdx, %rcx
sarl %cl, %eax
andl $0x1, %eax
movb %al, -0x31(%rbp)
cmpb $0x0, -0x31(%rbp)
je 0x15e5de
movzbl -0x31(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movl -0x4c(%rbp), %eax
movl $0x7, %ecx
subq %rdx, %rcx
shll %cl, %eax
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %esi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x15e5e0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15e520
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15e649
jmp 0x15e69c
movq $0x0, -0x18(%rbp)
cmpq $0x47, -0x18(%rbp)
jge 0x15e68f
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x15e67f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x15e6b0
jmp 0x15e681
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x15e651
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: inthashtable_destroy_items_in_bucket
static void inthashtable_destroy_items_in_bucket(deark *c, struct de_inthashtable_bucket *bkt)
{
	struct de_inthashtable_item *next_item;

	while(bkt->first_item) {
		next_item = bkt->first_item->next;
		inthashtable_destroy_item(c, bkt->first_item);
		bkt->first_item = next_item;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15e6f6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x15ea90
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x15e6c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15e770
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x15e748
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x15e75a
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15e8b0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x15e900
cmpq $0x0, %rax
je 0x15e859
movl $0x0, -0x4(%rbp)
jmp 0x15e89a
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x15e960
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: inthashtable_find_item_in_bucket
static struct de_inthashtable_item *inthashtable_find_item_in_bucket(struct de_inthashtable *ht,
	struct de_inthashtable_bucket *bkt, i64 key)
{
	struct de_inthashtable_item *p;

	p = bkt->first_item;
	while(p && (p->key != key)) {
		p = p->next;
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x15e938
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x15e941
jmp 0x15e94f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15e91b
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x47, -0x30(%rbp)
jge 0x15ea56
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x15e9f0
jmp 0x15ea45
cmpq $0x0, -0x20(%rbp)
je 0x15ea05
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x15ea1b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x15ea90
movl $0x1, -0x4(%rbp)
jmp 0x15ea81
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15e9d0
cmpq $0x0, -0x20(%rbp)
je 0x15ea68
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x15ea7a
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: get_crc32_table
static const u32 *get_crc32_table(deark *c)
{
	UI i, j;
	u32 *tbl;

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

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

	for(i=0; i<256; i++) {
		u32 k = (u32)i;

		for(j=0; j<8; j++) {
			if(k & 1) {
				k = (k>>1) ^ 0xedb88320U;
			}
			else {
				k >>= 1;
			}
		}
		tbl[i] = k;
	}

done:
	return (const u32*)c->persistent_item[DE_PERSISTENT_ITEM_CRC32_TBL];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2c0(%rax)
je 0x15ec4f
jmp 0x15eceb
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x4, %edx
callq 0x15c450
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2c0(%rax)
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x15ece9
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jae 0x15ecd1
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15ecbc
movl -0x1c(%rbp), %eax
shrl %eax
xorl $0xedb88320, %eax       # imm = 0xEDB88320
movl %eax, -0x1c(%rbp)
jmp 0x15ecc4
movl -0x1c(%rbp), %eax
shrl %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ecc6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15ec9c
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15ec86
jmp 0x15eceb
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x15ed1d
jmp 0x15ed73
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x15ed73
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
movl (%rdx), %edx
andl $0xff, %edx
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
movzbl (%rsi,%rdi), %esi
xorl %esi, %edx
movl %edx, %edx
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15ed25
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x15edfe
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15edb7
movl -0x20(%rbp), %ecx
shll $0x10, %ecx
addl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: get_crc16xmodem_table
static const u16 *get_crc16xmodem_table(deark *c)
{
	const UI poly = 0x1021;
	const UI pi_idx = DE_PERSISTENT_ITEM_CRC16XMODEM_TBL;
	u16 *tbl;
	UI i;

	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<128; i++) {
		UI carry = tbl[i] & 0x8000;
		UI temp = (tbl[i] << 1) & 0xffff;
		tbl[i * 2 + (carry ? 0 : 1)] = temp ^ poly;
		tbl[i * 2 + (carry ? 1 : 0)] = temp;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1021, -0xc(%rbp)     # imm = 0x1021
movl $0x2, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2d0(%rax)
je 0x15ee3d
jmp 0x15ef10
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x2, %edx
callq 0x15c450
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2d0(%rax)
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x80, -0x1c(%rbp)
jae 0x15ef0e
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
shll %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
xorl $0x1021, %eax           # imm = 0x1021
movw %ax, %dx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
movl -0x20(%rbp), %r8d
movl $0x1, %esi
xorl %edi, %edi
cmpl $0x0, %r8d
cmovnel %edi, %esi
addl %esi, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movl -0x24(%rbp), %eax
movw %ax, %dx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
movl -0x20(%rbp), %r8d
xorl %esi, %esi
movl $0x1, %edi
cmpl $0x0, %r8d
cmovnel %edi, %esi
addl %esi, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ee74
jmp 0x15ef10
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x15ef4d
jmp 0x15efaf
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x15efaf
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll $0x8, %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdx
movl (%rdx), %edx
shrl $0x8, %edx
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
movzbl (%rsi,%rdi), %esi
xorl %esi, %edx
andl $0xff, %edx
movl %edx, %edx
movzwl (%rax,%rdx,2), %eax
xorl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15ef55
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x8408, %eax           # imm = 0x8408
jne 0x15efe7
movl $0x3, -0x24(%rbp)
jmp 0x15efee
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
cmpq $0x0, 0x2c0(%rax,%rcx,8)
je 0x15f005
jmp 0x15f0d5
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x2, %edx
callq 0x15c450
movq %rax, %rdx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, 0x2c0(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x2c0(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jae 0x15f0d3
movl -0x10(%rbp), %eax
movw %ax, %dx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0x15f0c3
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
sarl %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15f09b
movzwl -0xa(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x15f0a2
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15f0a2
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
xorl %ecx, %eax
movw %ax, %dx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15f069
jmp 0x15f0c5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15f044
jmp 0x15f0d5
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x2c0(%rax,%rcx,8), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x15f10d
jmp 0x15f166
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x15f166
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdx
movl (%rdx), %edx
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
movzbl (%rsi,%rdi), %esi
xorl %esi, %edx
andl $0xff, %edx
movl %edx, %edx
movzwl (%rax,%rdx,2), %eax
xorl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15f115
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x15f24d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x15f20c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
shlq $0x8, %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x15f226
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15f1d8
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl $-0x10, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x22, %eax
ja 0x15f2d3
movq -0x10(%rbp), %rax
leaq 0x72a7e(%rip), %rcx     # 0x1d1d0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x15f2d3
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
jmp 0x15f2d3
movq -0x8(%rbp), %rax
movl $0xffff, (%rax)         # imm = 0xFFFF
jmp 0x15f2d3
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x15f2d3
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: crcobj_getval32_internal
static u32 crcobj_getval32_internal(struct de_crcobj *crco)
{
	switch(crco->crctype) {
	case DE_CRCOBJ_CRC32_IEEE:
		return ~(crco->val);
	case DE_CRCOBJ_CRC16_IBMSDLC:
		return crco->val ^ 0xffff;
	}
	return crco->val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x10, %eax
je 0x15f3c3
jmp 0x15f3b9
movl -0x14(%rbp), %eax
subl $0x22, %eax
je 0x15f3d1
jmp 0x15f3e1
movq -0x10(%rbp), %rax
movl (%rax), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15f3ea
movq -0x10(%rbp), %rax
movl (%rax), %eax
xorl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x4(%rbp)
jmp 0x15f3ea
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x15eac0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x15f500
movq -0x28(%rbp), %rdi
callq 0x15f340
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x15f2e0
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0xe0(%rax)
je 0x15f61c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rdx
movq %rdx, (%rax)
movq 0xe8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x15f62f
movq -0x10(%rbp), %rsi
movl $0x4c8735dd, %edi       # imm = 0x4C8735DD
movl $0x1, %edx
callq 0x15d530
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-util.c
// Function: de_archive_initialize
int de_archive_initialize(deark *c)
{
	if(c->output_style!=DE_OUTPUTSTYLE_ARCHIVE) return 0;
	switch(c->archive_fmt) {
	case DE_ARCHIVEFMT_ZIP:
		return de_zip_create_file(c);
	case DE_ARCHIVEFMT_TAR:
		return de_tar_create_file(c);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
je 0x15f65f
movl $0x0, -0x4(%rbp)
jmp 0x15f6a0
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x15f67d
jmp 0x15f673
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x15f68b
jmp 0x15f699
movq -0x10(%rbp), %rdi
callq 0x162310
movl %eax, -0x4(%rbp)
jmp 0x15f6a0
movq -0x10(%rbp), %rdi
callq 0x163900
movl %eax, -0x4(%rbp)
jmp 0x15f6a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)