LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_sequence_of_members
static void do_sequence_of_members(deark *c, lctx *d, i64 pos1)
{
	int root_member_count = 0;
	i64 pos = pos1;

	while(1) {
		int ret;
		int is_root_member;
		i64 bytes_consumed = 0;

		if(pos+112 > c->infile->len) {
			if(d->subdir_level==0 && root_member_count!=d->nmembers) {
				de_warn(c, "Expected %d top-level member file(s), found %d",
					d->nmembers, root_member_count);
			}
			break;
		}

		// The "number of files" field appears to be untrustworthy, or its meaning
		// is not correctly understood.
		// FWIW, The Unarchiver also ignores it.
		//if((d->subdir_level==0) && (root_member_count >= d->nmembers)) break;

		is_root_member = (d->subdir_level==0);
		ret = do_member(c, d, pos, &bytes_consumed);
		if(ret==0) break;
		if(bytes_consumed<1) break;
		pos += bytes_consumed;
		if(is_root_member) root_member_count++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x70, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x13f5e5
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x13f5e3
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x13f5e3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movl -0x1c(%rbp), %ecx
leaq 0x8e757(%rip), %rsi     # 0x1cdd33
movb $0x0, %al
callq 0x15bc10
jmp 0x13f641
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x13f650
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x13f618
jmp 0x13f641
cmpq $0x1, -0x38(%rbp)
jge 0x13f621
jmp 0x13f641
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x13f63c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13f593
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_extract_folder
static void do_extract_folder(deark *c, lctx *d, struct member_data *md)
{
	dbuf *outf = NULL;
	de_finfo *fi = NULL;

	if(!md->is_folder) goto done;
	fi = de_finfo_create(c);
	fi->is_directory = 1;
	de_finfo_set_name_from_ucstring(c, fi, md->full_fname, DE_SNFLAG_FULLPATH);
	fi->original_filename_flag = 1;
	fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = md->mod_time;
	fi->timestamp[DE_TIMESTAMPIDX_CREATE] = md->create_time;
	outf = dbuf_create_output_file(c, NULL, fi, 0x0);
done:
	dbuf_close(outf);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x1400b2
jmp 0x14013c
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x15d2c0
movq -0x28(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x80(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x88(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x90(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x98(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d260
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: decode_cmpr_meth
static void decode_cmpr_meth(deark *c, lctx *d, struct fork_data *fk,
	de_ucstring *s)
{
	const char *name = NULL;
	u8 cmpr = fk->cmpr_meth_etc;

	if(d->file_fmt==1 && cmpr<32 && (cmpr & 16)) {
		fk->is_encrypted = 1;
		cmpr -= 16;
	}

	if(d->file_fmt==2 || cmpr<16) {
		fk->is_a_file = 1;
		fk->cmpr_meth = cmpr;
	}

	if(fk->is_a_file) {
		fk->cmi = find_cmpr_meth_info(c, fk->cmpr_meth);
	}

	if(fk->cmi) {
		name = fk->cmi->name;
	}
	else if(d->file_fmt==1 && fk->cmpr_meth_etc==32) {
		name = "folder";
	}
	else if(d->file_fmt==1 && fk->cmpr_meth_etc==33) {
		name = "end of folder marker";
	}

	if(!name) name="?";
	ucstring_append_flags_item(s, name);
	if(d->file_fmt==1 && fk->is_encrypted) {
		ucstring_append_flags_item(s, "encrypted");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1403da
movzbl -0x29(%rbp), %eax
cmpl $0x20, %eax
jge 0x1403da
movzbl -0x29(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1403da
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movzbl -0x29(%rbp), %eax
subl $0x10, %eax
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x1403ec
movzbl -0x29(%rbp), %eax
cmpl $0x10, %eax
jge 0x1403fe
movq -0x18(%rbp), %rax
movb $0x1, 0x2(%rax)
movb -0x29(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x2(%rax)
je 0x140424
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %esi
callq 0x1404e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x140441
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x140489
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x140464
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x140464
leaq 0x657f1(%rip), %rax     # 0x1a5c4f
movq %rax, -0x28(%rbp)
jmp 0x140487
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x140485
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x21, %eax
jne 0x140485
leaq 0x8d9b1(%rip), %rax     # 0x1cde32
movq %rax, -0x28(%rbp)
jmp 0x140487
jmp 0x140489
cmpq $0x0, -0x28(%rbp)
jne 0x14049b
leaq 0x77796(%rip), %rax     # 0x1b7c2d
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172680
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1404ce
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x1404ce
movq -0x20(%rbp), %rdi
leaq 0x8d97e(%rip), %rsi     # 0x1cde47
callq 0x172680
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: find_cmpr_meth_info
static const struct cmpr_meth_info *find_cmpr_meth_info(deark *c, u8 id)
{
	size_t k;

	for(k=0; k<DE_ARRAYCOUNT(cmpr_meth_info_arr); k++) {
		if(id == cmpr_meth_info_arr[k].id)
			return &cmpr_meth_info_arr[k];
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0xa, -0x20(%rbp)
jae 0x14053c
movzbl -0x11(%rbp), %eax
leaq 0xe3b08(%rip), %rcx     # 0x224010
imulq $0x18, -0x20(%rbp), %rdx
addq %rdx, %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x14052c
leaq 0xe3af2(%rip), %rax     # 0x224010
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x140544
jmp 0x14052e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1404f6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_decompr_lzw
static void do_decompr_lzw(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_UNIXCOMPRESS;
	// TODO: What are the right lzw settings?
	delzwp.max_code_size = 14;
	fmtutil_decompress_lzw(c, dcmpri, dcmpro, dres, &delzwp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x34(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x19140
movl $0x1, -0x34(%rbp)
movl $0xe, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x1843b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: my_advfile_cbfn
static int my_advfile_cbfn(deark *c, struct de_advfile *advf,
	struct de_advfile_cbparams *afp)
{
	struct advfudata *u = (struct advfudata*)advf->userdata;

	if(afp->whattodo == DE_ADVFILE_WRITEMAIN) {
		do_main_decompress_fork(c, u->d, u->md, &u->md->dfork, afp->outf);
	}
	else if(afp->whattodo == DE_ADVFILE_WRITERSRC) {
		do_main_decompress_fork(c, u->d, u->md, &u->md->rfork, afp->outf);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x14121a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0xe0, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x141320
jmp 0x141254
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x141252
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0xa0, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x141320
jmp 0x141254
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_post_decompress_fork
static void do_post_decompress_fork(deark *c, lctx *d, struct member_data *md,
	struct fork_data *frk)
{
	u32 crc_calc;

	if(!frk->decompress_succeeded) goto done;

	if(frk->is_rsrc_fork) {
		crc_calc = de_crcobj_getval(d->crco_rfork);
	}
	else {
		crc_calc = de_crcobj_getval(d->crco_dfork);
	}
	de_dbg(c, "%s crc (calculated): 0x%04x", frk->forkname, (unsigned int)crc_calc);
	if(crc_calc != frk->crc_reported) {
		de_err(c, "CRC check failed for file %s[%s fork]", ucstring_getpsz_d(md->full_fname),
			frk->forkname);
	}
done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x38(%rax)
jne 0x141287
jmp 0x14130f
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1412a2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15f340
movl %eax, -0x24(%rbp)
jmp 0x1412b2
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x15f340
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
movl -0x24(%rbp), %ecx
leaq 0x7a120(%rip), %rsi     # 0x1bb3e8
movb $0x0, %al
callq 0x15b0d0
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x14130d
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x172650
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x8cd2e(%rip), %rsi     # 0x1ce034
movb $0x0, %al
callq 0x15bfb0
jmp 0x14130f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_main_decompress_fork
static void do_main_decompress_fork(deark *c, lctx *d, struct member_data *md,
	struct fork_data *frk, dbuf *outf)
{
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);
	if(!frk || !frk->cmi || !frk->cmi->decompressor) {
		goto done;
	}

	de_dbg(c, "decompressing %s fork", frk->forkname);
	de_dbg_indent(c, 1);

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = frk->cmpr_pos;
	dcmpri.len = frk->cmpr_len;
	dcmpro.f = outf;
	dcmpro.len_known = 1;
	dcmpro.expected_len = frk->unc_len;
	frk->cmi->decompressor(c, &dcmpri, &dcmpro, &dres);
	dbuf_flush(dcmpro.f);
	if(dres.errcode) {
		de_err(c, "Decompression failed for file %s[%s fork]: %s", ucstring_getpsz_d(md->full_fname),
			frk->forkname, de_dfilter_get_errmsg(c, &dres));
		goto done;
	}
	frk->decompress_succeeded = 1;

done:
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc4(%rbp), %rsi
callq 0x15b580
cmpq $0x0, -0x20(%rbp)
je 0x141370
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x141370
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x141375
jmp 0x141492
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x5f626(%rip), %rsi     # 0x1a09ae
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x1, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq *%rax
movq -0x60(%rbp), %rdi
callq 0x167c30
cmpl $0x0, -0xc0(%rbp)
je 0x14148a
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x172650
movq %rax, -0xd8(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x177360
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rax, %r8
leaq 0x5f564(%rip), %rsi     # 0x1a09e5
movb $0x0, %al
callq 0x15bfb0
jmp 0x141492
movq -0x20(%rbp), %rax
movb $0x1, 0x38(%rax)
movq -0x8(%rbp), %rdi
movl -0xc4(%rbp), %esi
callq 0x15b5a0
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_v5_list_of_members
static void do_v5_list_of_members(deark *c, lctx *d, i64 first_member_pos,
	i64 num_members_expected)
{
	i64 member_count = 0;
	i64 pos = first_member_pos;

	while(1) {
		int ret;
		i64 next_pos = 0;

		if(pos==0) break;
		if(member_count >= num_members_expected) break;

		ret = do_v5_member(c, d, member_count, pos, &next_pos);
		if(!ret) break;
		if(next_pos==0) break;

		pos = next_pos;
		member_count++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1416a9
jmp 0x1416f8
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x1416b5
jmp 0x1416f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x141700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x1416d9
jmp 0x1416f8
cmpq $0x0, -0x40(%rbp)
jne 0x1416e2
jmp 0x1416f8
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x141698
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/stuffit.c
// Function: do_v5_comment
static void do_v5_comment(deark *c, lctx *d, struct member_data *md, i64 pos, i64 len)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, len, 4096, s, 0, d->input_encoding);
	de_dbg(c, "file comment: \"%s\"", ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x1000, %ecx           # imm = 0x1000
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x172650
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x5e02c(%rip), %rsi     # 0x1a0647
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rdi
callq 0x171750
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: de_module_sis
void de_module_sis(deark *c, struct deark_module_info *mi)
{
	mi->id = "sis";
	mi->desc = "SIS (EPOC/Symbian installation archive)";
	mi->run_fn = de_run_sis;
	mi->identify_fn = de_identify_sis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x6d629(%rip), %rcx     # 0x1afc80
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x8bdb1(%rip), %rcx     # 0x1ce416
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x142690
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xcd(%rip), %rcx        # 0x142750
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: de_run_sis
static void de_run_sis(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;

	d = de_malloc(c, sizeof(lctx));

	pos = 0;
	if(!do_file_header(c, d, pos)) goto done;

	do_language_records(c, d);
	do_component_name_record(c, d);
	do_requisite_records(c, d);
	do_file_records(c, d);
	do_certificate_records(c, d);

done:
	if(d) {
		de_free(c, d->langi);
	}
	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x68, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1427f0
cmpl $0x0, %eax
jne 0x1426da
jmp 0x14271b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x142e70
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x142f90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x143100
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1433b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x143480
cmpq $0x0, -0x18(%rbp)
je 0x142733
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: de_identify_sis
static int de_identify_sis(deark *c)
{
	if(!dbuf_memcmp(c->infile, 8, "\x19\x04\x00\x10", 4)) {
		if(!dbuf_memcmp(c->infile, 4, "\x6d\x00\x00\x10", 4))
			return 100;
		if(!dbuf_memcmp(c->infile, 4, "\x12\x3a\x00\x10", 4))
			return 100;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x8, %esi
leaq 0x8bc97(%rip), %rdx     # 0x1ce407
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x1427d5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %ecx
leaq 0x8bc79(%rip), %rdx     # 0x1ce40c
movq %rcx, %rsi
callq 0x166ab0
cmpl $0x0, %eax
jne 0x1427a9
movl $0x64, -0x4(%rbp)
jmp 0x1427dc
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %ecx
leaq 0x8bc54(%rip), %rdx     # 0x1ce411
movq %rcx, %rsi
callq 0x166ab0
cmpl $0x0, %eax
jne 0x1427d3
movl $0x64, -0x4(%rbp)
jmp 0x1427dc
jmp 0x1427d5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: do_language_records
static void do_language_records(deark *c, lctx *d)
{
	i64 k;
	i64 pos1 = d->languages_ptr;
	i64 pos = pos1;

	if(d->nlangs<1) return;
	de_dbg(c, "language records at %"I64_FMT, pos1);
	d->langi = de_mallocarray(c, d->nlangs, sizeof(struct lang_info));
	de_dbg_indent(c, 1);
	for(k=0; k<d->nlangs; k++) {
		unsigned int lc;
		lc = (unsigned int)de_getu16le_p(&pos);
		lookup_lang_namecode(lc, d->langi[k].sz, sizeof(d->langi[k].sz));
		de_dbg(c, "lang[%d] = %u (%s)", (int)k, lc, d->langi[k].sz);
	}
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jge 0x142ea4
jmp 0x142f7d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x8b75a(%rip), %rsi     # 0x1ce60d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x4, %edx
callq 0x15c450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x142f6f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1652c0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl $0x4, %edx
callq 0x1435a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %r8
movq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %r8
leaq 0x8b6cb(%rip), %rsi     # 0x1ce625
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x142ef1
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: do_component_name_record
static void do_component_name_record(deark *c, lctx *d)
{
	i64 pos1 = d->component_name_ptr;
	de_ucstring *s = NULL;
	i64 k;

	if(pos1<1 || pos1>=c->infile->len) return;
	if(d->nlangs<1) return;

	de_dbg(c, "component name record at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	s = ucstring_create(c);
	for(k=0; k<d->nlangs; k++) {
		i64 npos, nlen;
		nlen = de_getu32le(pos1+4*k);
		npos = de_getu32le(pos1+4*d->nlangs+4*k);
		ucstring_empty(s);
		read_sis_string(c, d, s, npos, nlen);
		de_dbg(c, "name[%d]: \"%s\"", (int)k, ucstring_getpsz_d(s));
	}
	de_dbg_indent(c, -1);
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x1, -0x18(%rbp)
jl 0x142fcd
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x142fd2
jmp 0x1430f6
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jge 0x142fe2
jmp 0x1430f6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8b647(%rip), %rsi     # 0x1ce638
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x1430df
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x165540
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x165540
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x171210
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x143600
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x172650
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %edx
movq %rax, %rcx
leaq 0x8b58e(%rip), %rsi     # 0x1ce655
movb $0x0, %al
callq 0x15b0d0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14301b
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x20(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: do_file_records
static void do_file_records(deark *c, lctx *d)
{
	i64 k;
	i64 pos1 = d->files_ptr;
	i64 pos = pos1;

	de_dbg(c, "file records at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	for(k=0; k<d->nfiles; k++) {
		i64 bytes_consumed = 0;

		if(pos >= c->infile->len) break;
		if(!do_file_record(c, d, k, pos, &bytes_consumed)) break;
		pos += bytes_consumed;
	}
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x8b2ea(%rip), %rsi     # 0x1ce6cd
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x143464
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x14342a
jmp 0x143464
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x143690
cmpl $0x0, %eax
jne 0x14344a
jmp 0x143464
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x143400
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: do_certificate_records
static void do_certificate_records(deark *c, lctx *d)
{
	i64 pos1 = d->certificates_ptr;
	i64 pos = pos1;
	i64 k;
	i64 ncerts;
	int z[6];

	if(pos1<1 || pos1>=c->infile->len) return;
	de_dbg(c, "certificate records at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	for(k=0; k<6; k++) {
		z[k] = (int)de_getu16le_p(&pos);
	}

	// The documentation I have does not explain how the month is encoded.
	// I.e., is January month #0, or month #1?
	// I found a file that has the month set to 0, so I assume that must be
	// January.
	de_dbg(c, "timestamp: %04d-%02d-%02d %02d:%02d:%02d",
		z[0], z[1]+1, z[2],
		z[3], z[4], z[5]);
	ncerts = de_getu32le_p(&pos);
	de_dbg(c, "number of certs: %d", (int)ncerts);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x18(%rbp)
jl 0x1434bd
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x1434c2
jmp 0x14358b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8b391(%rip), %rsi     # 0x1ce862
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x28(%rbp)
cmpq $0x6, -0x28(%rbp)
jge 0x14351e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1652c0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x50(%rbp,%rax,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1434ee
movq -0x8(%rbp), %rdi
movl -0x50(%rbp), %edx
movl -0x4c(%rbp), %ecx
addl $0x1, %ecx
movl -0x48(%rbp), %r8d
movl -0x44(%rbp), %r9d
movl -0x40(%rbp), %r10d
movl -0x3c(%rbp), %eax
leaq 0x8b33c(%rip), %rsi     # 0x1ce87d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165580
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
leaq 0x8b330(%rip), %rsi     # 0x1ce8a6
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: lookup_lang_namecode
static void lookup_lang_namecode(unsigned int lc, char *nc, size_t nc_len)
{
	static const char codes[99*2+1] =
	 "XXENFRGESPITSWDANOFIAMSFSGPOTUICRUHUDUBLAUBGASNZIFCSSKPLSLTCHKZH"
	 "JATHAFSQAHARHYTLBEBNBGMYCAHRCEIESFETFACFGDKAELCGGUHEHIINGASZKNKK"
	 "KMKOLOLVLTMKMSMLMRMOMNNNBPPAROSRSISOOSLSSHFSXXTATEBOTICTTKUKURXX"
	 "VICYZU";

	if(lc>=99) lc=0;
	nc[0] = codes[2*lc];
	nc[1] = codes[2*lc+1];
	nc[2] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x63, -0x4(%rbp)
jb 0x1435bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x8ad74(%rip), %rax     # 0x1ce340
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x8ad58(%rip), %rax     # 0x1ce340
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x2(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: get_file_rec_type_name
static const char *get_file_rec_type_name(unsigned int t)
{
	const char *s = NULL;
	switch(t) {
	case 0: s="simple file"; break;
	case 1: s="multi-language file set"; break;
	case 2: s="options"; break;
	case 3: s="*if*"; break;
	case 4: s="*elseif*"; break;
	case 5: s="*else*"; break;
	case 6: s="*endif*"; break;
	}
	return s?s:"?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x143949
movq -0x18(%rbp), %rax
leaq 0x8aa19(%rip), %rcx     # 0x1ce300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8ae55(%rip), %rax     # 0x1ce74c
movq %rax, -0x10(%rbp)
jmp 0x143949
leaq 0x8ae54(%rip), %rax     # 0x1ce758
movq %rax, -0x10(%rbp)
jmp 0x143949
leaq 0x71150(%rip), %rax     # 0x1b4a61
movq %rax, -0x10(%rbp)
jmp 0x143949
leaq 0x8ae52(%rip), %rax     # 0x1ce770
movq %rax, -0x10(%rbp)
jmp 0x143949
leaq 0x8ae4a(%rip), %rax     # 0x1ce775
movq %rax, -0x10(%rbp)
jmp 0x143949
leaq 0x8ae46(%rip), %rax     # 0x1ce77e
movq %rax, -0x10(%rbp)
jmp 0x143949
leaq 0x8ae40(%rip), %rax     # 0x1ce785
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14395a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x143967
leaq 0x742cc(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0x143967
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: get_file_type_name
static const char *get_file_type_name(unsigned int t)
{
	const char *s = NULL;
	switch(t) {
	case 0: s="standard file"; break;
	case 1: s="text file displayed during install"; break;
	case 2: s="SIS component file"; break;
	case 3: s="file run during install"; break;
	case 4: s="file to be created during install"; break;
	case 5: s="open file"; break;
	}
	return s?s:"?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x143e2c
movq -0x18(%rbp), %rax
leaq 0x8a545(%rip), %rcx     # 0x1ce31c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8a9f3(%rip), %rax     # 0x1ce7da
movq %rax, -0x10(%rbp)
jmp 0x143e2c
leaq 0x8a9f4(%rip), %rax     # 0x1ce7e8
movq %rax, -0x10(%rbp)
jmp 0x143e2c
leaq 0x8aa0a(%rip), %rax     # 0x1ce80b
movq %rax, -0x10(%rbp)
jmp 0x143e2c
leaq 0x8aa10(%rip), %rax     # 0x1ce81e
movq %rax, -0x10(%rbp)
jmp 0x143e2c
leaq 0x8aa1b(%rip), %rax     # 0x1ce836
movq %rax, -0x10(%rbp)
jmp 0x143e2c
leaq 0x8aa30(%rip), %rax     # 0x1ce858
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x143e3d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x143e4a
leaq 0x73de9(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0x143e4a
movq -0x20(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: make_output_filename
static void make_output_filename(deark *c, lctx *d, struct file_rec *fr)
{
	i64 k;
	i64 pathlen = 0;
	i64 basenamelen;
	de_ucstring *s;

	if(fr->name_to_use) return;
	if(!fr->name_dest || !fr->name_src) return;
	fr->name_to_use = ucstring_create(c);

	// s will point to either fr->name_dest or fr->name_src, whichever
	// one looks better.
	if(fr->name_src->len>0) {
		s = fr->name_src;
	}
	else {
		s = fr->name_dest;
	}

	if((fr->file_type==0 || fr->file_type==3) && fr->name_dest->len>0) {
		s = fr->name_dest;
	}

	for(k=s->len-1; k>=0; k--) {
		if(s->str[k]=='\\' ||
			s->str[k]=='/')
		{
			pathlen = k+1;
			break;
		}
	}
	basenamelen = s->len - pathlen;

	if(basenamelen>1) {
		ucstring_append_substring(fr->name_to_use, s, pathlen, basenamelen);
	}
	else {
		ucstring_append_ucstring(fr->name_to_use, s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x143e7c
jmp 0x143f9f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x143e92
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x143e97
jmp 0x143f9f
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x10(%rax)
jle 0x143ec8
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x143ed4
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x143ee8
movq -0x18(%rbp), %rax
cmpl $0x3, 0x14(%rax)
jne 0x143f03
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x10(%rax)
jle 0x143f03
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x143f5c
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpl $0x5c, (%rax,%rcx,4)
je 0x143f3e
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpl $0x2f, (%rax,%rcx,4)
jne 0x143f4c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x143f5c
jmp 0x143f4e
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x143f13
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
jle 0x143f8e
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x144210
jmp 0x143f9f
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x171460
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sis.c
// Function: ucstring_append_substring
static void ucstring_append_substring(de_ucstring *s1, const de_ucstring *s2,
	i64 pos, i64 len)
{
	i64 i;

	if(!s2) return;
	if(pos<0) return;
	for(i=0; i<len; i++) {
		if(pos+i >= s2->len) break;
		ucstring_append_char(s1, s2->str[pos+i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x144231
jmp 0x14428a
cmpq $0x0, -0x18(%rbp)
jge 0x14423a
jmp 0x14428a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x14428a
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jl 0x144260
jmp 0x14428a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
addq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1714c0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x144242
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: de_module_sauce
void de_module_sauce(deark *c, struct deark_module_info *mi)
{
	mi->id = "sauce";
	mi->desc = "SAUCE metadata";
	mi->run_fn = de_run_sauce;
	mi->identify_fn = de_identify_sauce;
	mi->flags |= DE_MODFLAG_HIDDEN | DE_MODFLAG_SHAREDDETECTION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x8a639(%rip), %rcx     # 0x1ce8e0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x8a631(%rip), %rcx     # 0x1ce8e6
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x1442f0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x5d(%rip), %rcx        # 0x144330
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x11, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: de_identify_sauce
static int de_identify_sauce(deark *c)
{
	c->detection_data->SAUCE_detection_attempted = 1;
	if(fmtutil_detect_SAUCE(c, c->infile, &c->detection_data->sauce, 0)) {
		// This module should have a very low priority, but other modules can use
		// the results of its detection.
		return 2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movb $0x1, 0x5(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
addq $0x10, %rdx
xorl %ecx, %ecx
callq 0x173ca0
cmpl $0x0, %eax
je 0x144375
movl $0x2, -0x4(%rbp)
jmp 0x14437c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: run_sauce_as_submodule
static void run_sauce_as_submodule(deark *c, de_module_params *mparams)
{
	struct de_SAUCE_info *si_local = NULL;
	struct de_SAUCE_info *si_to_use;

	if(mparams && mparams->out_params.obj1) {
		si_to_use = (struct de_SAUCE_info*)mparams->out_params.obj1;
	}
	else {
		si_local = fmtutil_create_SAUCE(c);
		si_to_use = si_local;
	}

	do_read_SAUCE(c, c->infile, si_to_use);

	fmtutil_free_SAUCE(c, si_local);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1443c8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1443c8
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1443dd
movq -0x8(%rbp), %rdi
callq 0x173e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1444f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x173e40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: run_sauce_direct
static void run_sauce_direct(deark *c, de_module_params *mparams)
{
	struct de_SAUCE_info *si = NULL;
	struct de_SAUCE_detection_data sdd;
	int ret;

	fmtutil_detect_SAUCE(c, c->infile, &sdd, 0x1);
	if(!sdd.has_SAUCE) {
		if(c->module_disposition==DE_MODDISP_EXPLICIT) {
			de_err(c, "No SAUCE record found");
		}
		goto done;
	}

	si = fmtutil_create_SAUCE(c);
	de_dbg_indent(c, 1);
	ret = do_read_SAUCE(c, c->infile, si);
	de_dbg_indent(c, -1);
	if(ret && c->module_disposition==DE_MODDISP_AUTODETECT) {
		de_err(c, "This file has a SAUCE metadata record that identifies it as "
			"DataType %d, FileType %d, but it is not a supported format.",
			(int)si->data_type, (int)si->file_type);
	}

done:
	fmtutil_free_SAUCE(c, si);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x1b(%rbp), %rdx
movl $0x1, %ecx
callq 0x173ca0
cmpb $0x0, -0x1b(%rbp)
jne 0x144466
movq -0x8(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x144464
movq -0x8(%rbp), %rdi
leaq 0x8a685(%rip), %rsi     # 0x1ceae2
movb $0x0, %al
callq 0x15bfb0
jmp 0x1444db
movq -0x8(%rbp), %rdi
callq 0x173e20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1444f0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
cmpl $0x0, -0x20(%rbp)
je 0x1444d9
movq -0x8(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x1444d9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x38(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x39(%rax), %ecx
leaq 0x8a626(%rip), %rsi     # 0x1ceaf8
movb $0x0, %al
callq 0x15bfb0
jmp 0x1444db
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x173e40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: sauce_get_string_length
static i64 sauce_get_string_length(const u8 *buf, i64 len, int respect_trailing_spaces)
{
	i64 i;
	i64 last_nonpadding_char_pos = -1;

	for(i=len-1; i>=0; i--) {
		// Spec says to use spaces for padding, and for nonexistent data.
		// But some files use NUL bytes.
		if((buf[i]==0x20 && !respect_trailing_spaces) || buf[i]==0x00) {
			;
		}
		else {
			last_nonpadding_char_pos = i;
			break;
		}
	}
	return last_nonpadding_char_pos+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x144cee
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x144cc1
cmpl $0x0, -0x14(%rbp)
je 0x144cd2
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x144cd4
jmp 0x144cde
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x144cee
jmp 0x144ce0
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x144ca3
movq -0x28(%rbp), %rax
addq $0x1, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: sauce_is_valid_date_string
static int sauce_is_valid_date_string(const u8 *buf, i64 len)
{
	i64 i;

	for(i=0; i<len; i++) {
		if(buf[i]>='0' && buf[i]<='9') continue;
		// Spaces aren't allowed, but some files use them.
		if(buf[i]==' ' && (i==4 || i==6)) continue;
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x144dba
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x144d82
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x144d82
jmp 0x144dac
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x144da3
cmpq $0x4, -0x20(%rbp)
je 0x144da1
cmpq $0x6, -0x20(%rbp)
jne 0x144da3
jmp 0x144dac
movl $0x0, -0x4(%rbp)
jmp 0x144dc1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x144d54
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: do_SAUCE_creation_date
static void do_SAUCE_creation_date(deark *c, struct de_SAUCE_info *si,
	const u8 *date_raw, size_t date_raw_len)
{
	i64 yr, mon, mday;
	char timestamp_buf[64];
	char scanbuf[16];

	if(date_raw_len!=8) return;

	// Convert to de_timestamp format

	// year
	de_memcpy(scanbuf, &date_raw[0], 4);
	scanbuf[4] = '\0';
	yr = de_atoi64(scanbuf);

	// month
	de_memcpy(scanbuf, &date_raw[4], 2);
	scanbuf[2] = '\0';
	mon = de_atoi64(scanbuf);

	// day of month
	de_memcpy(scanbuf, &date_raw[6], 2);
	scanbuf[2] = '\0';
	mday = de_atoi64(scanbuf);

	de_make_timestamp(&si->creation_date, yr, mon, mday, 12, 0, 0);
	si->creation_date.precision = DE_TSPREC_1DAY;

	de_timestamp_to_string(&si->creation_date, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "creation date: %s", timestamp_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
je 0x144df7
jmp 0x144ec8
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x90(%rbp)
movb $0x0, -0x8c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x15ccc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movw 0x4(%rax), %ax
movw %ax, -0x90(%rbp)
movb $0x0, -0x8e(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x15ccc0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movw 0x6(%rax), %ax
movw %ax, -0x90(%rbp)
movb $0x0, -0x8e(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x15ccc0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0xc, %r8d
xorl %eax, %eax
movl %eax, %r9d
movq $0x0, (%rsp)
callq 0x15d830
movq -0x10(%rbp), %rax
movb $0xa, 0x22(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x80(%rbp), %rsi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rdx
leaq 0x89b44(%rip), %rsi     # 0x1cea05
movb $0x0, %al
callq 0x15b0d0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sauce.c
// Function: get_sauce_datatype_name
static const char *get_sauce_datatype_name(u8 dt)
{
	const char *n = "?";

	switch(dt) {
	case 0: n="undefined"; break;
	case 1: n="character"; break;
	case 2: n="bitmap graphics"; break;
	case 3: n="vector graphics"; break;
	case 4: n="audio"; break;
	case 5: n="BinaryText"; break;
	case 6: n="XBIN"; break;
	case 7: n="archive"; break;
	case 8: n="executable"; break;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
leaq 0x72d3c(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x8, %rax
ja 0x144f8e
movq -0x18(%rbp), %rax
leaq 0x899aa(%rip), %rcx     # 0x1ce8bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x85e50(%rip), %rax     # 0x1cad72
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x70553(%rip), %rax     # 0x1b5482
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x89adb(%rip), %rax     # 0x1cea17
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x89ade(%rip), %rax     # 0x1cea27
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x73870(%rip), %rax     # 0x1b87c6
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x89ad4(%rip), %rax     # 0x1cea37
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x89ad2(%rip), %rax     # 0x1cea42
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x5dc26(%rip), %rax     # 0x1a2ba3
movq %rax, -0x10(%rbp)
jmp 0x144f8e
leaq 0x63822(%rip), %rax     # 0x1a87ac
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/xfer.c
// Function: de_module_base16
void de_module_base16(deark *c, struct deark_module_info *mi)
{
	mi->id = "base16";
	mi->id_alias[0] = "hex";
	mi->desc = "Base16";
	mi->run_fn = de_run_base16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x895f9(%rip), %rcx     # 0x1ceb70
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x8bd77(%rip), %rcx     # 0x1d12fc
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0x895e3(%rip), %rcx     # 0x1ceb77
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0xd(%rip), %rcx         # 0x1455b0
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)