LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dskdcmps_run
static void dskdcmps_run(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct dd_Ctl *Ctl = NULL;

	Ctl = de_malloc(c, sizeof(struct dd_Ctl));
	Ctl->c = c;
	Ctl->modname = "ibmlzw";
	Ctl->dcmpri = dcmpri;
	Ctl->dcmpro = dcmpro;
	Ctl->dres = dres;
	Ctl->inf_pos = dcmpri->pos;
	Ctl->inf_endpos = dcmpri->pos + dcmpri->len;

	dd_Decompress(Ctl);

	de_free(c, Ctl);
}

// 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 -0x8(%rbp), %rdi
movl $0x2050, %esi           # imm = 0x2050
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x53118(%rip), %rcx     # 0x1d78c0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rdi
callq 0x186b70
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_finish
static void delzw_finish(delzwctx *dc)
{
	const char *reason;

	if(dc->output_len_known && (dc->uncmpr_nbytes_written==dc->output_expected_len)) {
		reason = "end of input and sufficient output";
	}
	else {
		reason = "end of input";
	}

	delzw_stop(dc, reason);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x31(%rax), %eax
cmpl $0x0, %eax
je 0x184858
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x184858
leaq 0x52d54(%rip), %rax     # 0x1d75a6
movq %rax, -0x10(%rbp)
jmp 0x184863
leaq 0x52d6a(%rip), %rax     # 0x1d75c9
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x184880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_debugmsg
static void delzw_debugmsg(delzwctx *dc, int level, const char *fmt, ...)
{
	va_list ap;
	char msg[200];

	if(level>dc->debug_level) return;

	va_start(ap, fmt);
	de_vsnprintf(msg, sizeof(msg), fmt, ap);
	va_end(ap);

	de_dbg(dc->c, "[delzw:i%"I64_FMT"/o%"I64_FMT"] %s",
		(i64)dc->total_nbytes_processed, (i64)dc->uncmpr_nbytes_written, msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
testb %al, %al
je 0x184917
movaps %xmm0, -0x180(%rbp)
movaps %xmm1, -0x170(%rbp)
movaps %xmm2, -0x160(%rbp)
movaps %xmm3, -0x150(%rbp)
movaps %xmm4, -0x140(%rbp)
movaps %xmm5, -0x130(%rbp)
movaps %xmm6, -0x120(%rbp)
movaps %xmm7, -0x110(%rbp)
movq %r9, -0x188(%rbp)
movq %r8, -0x190(%rbp)
movq %rcx, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x184945
jmp 0x1849b2
leaq -0x30(%rbp), %rax
leaq -0x1b0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x100(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0xc8, %esi
callq 0x18f9b0
leaq -0x30(%rbp), %rax
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
leaq -0x100(%rbp), %r8
leaq 0x52c3e(%rip), %rsi     # 0x1d75e9
movb $0x0, %al
callq 0x15b0d0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_addbuf
static void delzw_addbuf(delzwctx *dc, const u8 *buf, i64 buf_len)
{
	i64 i;

	if(dc->debug_level>=3) {
		delzw_debugmsg(dc, 3, "received %"I64_FMT" bytes of input", buf_len);
	}

	for(i=0; i<buf_len; i++) {
		if(dc->errcode) break;
		if(dc->state == DELZW_STATE_FINISHED) break;
		if(delzw_have_enough_output(dc)) {
			delzw_stop(dc, "sufficient output");
			break;
		}
		delzw_process_byte(dc, buf[i]);
		dc->total_nbytes_processed++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jl 0x1849f9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x3, %esi
leaq 0x52c0c(%rip), %rdx     # 0x1d75fe
movb $0x0, %al
callq 0x1848d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x184a76
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x184a17
jmp 0x184a76
movq -0x8(%rbp), %rax
cmpl $0x3, 0x64(%rax)
jne 0x184a23
jmp 0x184a76
movq -0x8(%rbp), %rdi
callq 0x184a80
cmpl $0x0, %eax
je 0x184a43
movq -0x8(%rbp), %rdi
leaq 0x52b7b(%rip), %rsi     # 0x1d75b7
callq 0x184880
jmp 0x184a76
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x184ac0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x184a01
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_have_enough_output
static int delzw_have_enough_output(delzwctx *dc)
{
	if(dc->output_len_known) {
		if(dc->uncmpr_nbytes_written >= dc->output_expected_len) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x31(%rax)
je 0x184aaf
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jl 0x184aad
movl $0x1, -0x4(%rbp)
jmp 0x184ab6
jmp 0x184aaf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_on_decompression_start
static void delzw_on_decompression_start(delzwctx *dc)
{
	if(dc->fmt!=DE_LZWFMT_ZIPSHRINK &&
		dc->fmt!=DE_LZWFMT_GIF &&
		dc->fmt!=DE_LZWFMT_UNIXCOMPRESS &&
		dc->fmt!=DE_LZWFMT_ZOOLZD &&
		dc->fmt!=DE_LZWFMT_TIFFNEW &&
		dc->fmt!=DE_LZWFMT_TIFFOLD &&
		dc->fmt!=DE_LZWFMT_ARC5 &&
		dc->fmt!=DE_LZWFMT_DWC &&
		dc->fmt!=DE_LZWFMT_SHRINKIT1 &&
		dc->fmt!=DE_LZWFMT_SHRINKIT2 &&
		dc->fmt!=DE_LZWFMT_PAKLEO &&
		dc->fmt!=DE_LZWFMT_ASC2COM)
	{
		delzw_set_error(dc, DELZW_ERRCODE_UNSUPPORTED_OPTION, "Unsupported LZW format");
		goto done;
	}

	if(dc->fmt==DE_LZWFMT_UNIXCOMPRESS) {
		if(dc->delzwp_copy.flags & DE_LZWFLAG_HAS3BYTEHEADER) {
			dc->header_type = DELZW_HEADERTYPE_UNIXCOMPRESS3BYTE;
			dc->header_size = 3;
		}
		else if(dc->delzwp_copy.flags & DE_LZWFLAG_HAS1BYTEHEADER) {
			dc->unixcompress_has_clear_code = 1;
			dc->header_type = DELZW_HEADERTYPE_ARC1BYTE;
			dc->header_size = 1;
		}
		else {
			dc->unixcompress_has_clear_code = 1;
			dc->max_codesize = dc->delzwp_copy.max_code_size;
		}

		if((dc->delzwp_copy.flags & DE_LZWFLAG_TOLERATETRAILINGJUNK) &&
			!dc->output_len_known)
		{
			dc->stop_on_invalid_code = 1;
		}
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x2, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x1, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x4, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x6, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x5, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x7, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x8, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0x9, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0xa, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0xb, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rax
cmpl $0xc, 0x14(%rax)
je 0x184d02
movq -0x8(%rbp), %rdi
movl $0x9, %esi
leaq 0x52922(%rip), %rdx     # 0x1d761a
callq 0x185850
jmp 0x184da5
movq -0x8(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jne 0x184da3
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x184d38
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq $0x3, 0x50(%rax)
jmp 0x184d80
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x184d68
movq -0x8(%rbp), %rax
movb $0x1, 0x41(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x50(%rax)
jmp 0x184d7e
movq -0x8(%rbp), %rax
movb $0x1, 0x41(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
jmp 0x184d80
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x184da1
movq -0x8(%rbp), %rax
cmpb $0x0, 0x31(%rax)
jne 0x184da1
movq -0x8(%rbp), %rax
movb $0x1, 0x30(%rax)
jmp 0x184da3
jmp 0x184da5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_set_error
static void delzw_set_error(delzwctx *dc, int errcode, const char *msg)
{
	delzw_stop(dc, "error");
	if(dc->errcode) return;
	dc->errcode = errcode;
	if(!msg || !msg[0]) {
		msg = "LZW decompression error";
	}
	de_strlcpy(dc->errmsg, msg, sizeof(dc->errmsg));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x537b1(%rip), %rsi     # 0x1d901f
callq 0x184880
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x18587f
jmp 0x1858bd
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x185899
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x1858a4
leaq 0x51d91(%rip), %rax     # 0x1d7631
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x15aa30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_process_unixcompress_3byteheader
static void delzw_process_unixcompress_3byteheader(delzwctx *dc)
{
	if(dc->header_buf[0]!=0x1f || dc->header_buf[1]!=0x9d) {
		delzw_set_error(dc, DELZW_ERRCODE_BAD_CDATA, "Not in compress format");
		return;
	}

	dc->header_unixcompress_mode = dc->header_buf[2];
	dc->header_unixcompress_max_codesize = (dc->header_unixcompress_mode & 0x1f);
	dc->header_unixcompress_block_mode = (dc->header_unixcompress_mode & 0x80) ? 1 : 0;
	delzw_debugmsg(dc, 2, "LZW mode=0x%02x, maxbits=%u, blockmode=%u",
		(UI)dc->header_unixcompress_mode,
		(UI)dc->header_unixcompress_max_codesize,
		(UI)dc->header_unixcompress_block_mode);

	dc->max_codesize = (UI)dc->header_unixcompress_max_codesize;
	dc->unixcompress_has_clear_code = dc->header_unixcompress_block_mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xe0(%rax), %eax
cmpl $0x1f, %eax
jne 0x1858fe
movq -0x8(%rbp), %rax
movzbl 0xe1(%rax), %eax
cmpl $0x9d, %eax
je 0x185918
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x51d90(%rip), %rdx     # 0x1d769e
callq 0x185850
jmp 0x1859af
movq -0x8(%rbp), %rax
movb 0xe2(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5c(%rax)
movq -0x8(%rbp), %rax
movzbl 0x5c(%rax), %eax
andl $0x1f, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5d(%rax)
movq -0x8(%rbp), %rax
movzbl 0x5c(%rax), %edx
andl $0x80, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5e(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x5c(%rax), %ecx
movq -0x8(%rbp), %rax
movzbl 0x5d(%rax), %r8d
movq -0x8(%rbp), %rax
movzbl 0x5e(%rax), %r9d
movl $0x2, %esi
leaq 0x51d2a(%rip), %rdx     # 0x1d76b5
movb $0x0, %al
callq 0x1848d0
movq -0x8(%rbp), %rax
movzbl 0x5d(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rax
movb 0x5e(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: lzw_after_header_parsed
static void lzw_after_header_parsed(delzwctx *dc)
{
	deark *c = dc->c;

	if(dc->header_type==DELZW_HEADERTYPE_UNIXCOMPRESS3BYTE) {
		de_dbg(c, "LZW mode: 0x%02x", (UI)dc->header_unixcompress_mode);
		de_dbg_indent(c, 1);
		de_dbg(c, "maxbits: %u", (UI)dc->header_unixcompress_max_codesize);
		de_dbg(c, "blockmode: %d", (int)dc->header_unixcompress_block_mode);
		if(!dc->header_unixcompress_block_mode) {
			de_warn(c, "This file uses an obsolete compress'd format, which "
				"might not be decompressed correctly");
		}
		de_dbg_indent(c, -1);
	}
	else if(dc->header_type==DELZW_HEADERTYPE_ARC1BYTE) {
		de_dbg(c, "LZW maxbits: %u", (UI)dc->header_unixcompress_max_codesize);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x185acd
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x5c(%rax), %edx
leaq 0x51c99(%rip), %rsi     # 0x1d76f1
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x5d(%rax), %edx
leaq 0x51cec(%rip), %rsi     # 0x1d776c
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x5e(%rax), %edx
leaq 0x51c68(%rip), %rsi     # 0x1d7702
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
cmpb $0x0, 0x5e(%rax)
jne 0x185abd
movq -0x10(%rbp), %rdi
leaq 0x51c5a(%rip), %rsi     # 0x1d7710
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
jmp 0x185af3
movq -0x8(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0x185af1
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x5d(%rax), %edx
leaq 0x51c7e(%rip), %rsi     # 0x1d7768
movb $0x0, %al
callq 0x15b0d0
jmp 0x185af3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_set_errorf
static void delzw_set_errorf(delzwctx *dc, int errcode, const char *fmt, ...)
{
	va_list ap;

	delzw_stop(dc, "error");
	if(dc->errcode) return;
	dc->errcode = errcode;
	va_start(ap, fmt);
	de_vsnprintf(dc->errmsg, sizeof(dc->errmsg), fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x185b38
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x534bc(%rip), %rsi     # 0x1d901f
callq 0x184880
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x185b74
jmp 0x185bc3
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x50, %esi
callq 0x18f9b0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: set_std_static_codes
static void set_std_static_codes(delzwctx *dc)
{
	DELZW_CODE i;

	for(i=0; i<256; i++) {
		dc->ct[i].codetype = DELZW_CODETYPE_STATIC;
		dc->ct[i].value = (u8)i;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x185c29
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x3(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x185bdf
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_hashed_add_root_code_to_dict
static void delzw_hashed_add_root_code_to_dict(delzwctx *dc, u8 value)
{
	int idx;

	idx = delzw_get_hashed_code(dc, 0xffff, value);
	if(dc->errcode) return;

	dc->ct[idx].value = value;
	dc->ct[idx].codetype = DELZW_CODETYPE_STATIC;
	dc->ct_code_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
movzbl -0x9(%rbp), %edx
callq 0x185cc0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x185c63
jmp 0x185cac
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x10(%rbp), %rdx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x3(%rax)
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xcc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_increase_codesize
static void delzw_increase_codesize(delzwctx *dc)
{
	if(dc->fmt==DE_LZWFMT_UNIXCOMPRESS) {
		delzw_unixcompress_end_bitgroup(dc);
	}
	else if(dc->fmt==DE_LZWFMT_ASC2COM) {
		bbll_skip_to_byte_boundary(&dc->bbll);
	}

	if(dc->curr_codesize<dc->max_codesize) {
		dc->curr_codesize++;
		delzw_debugmsg(dc, 2, "increased code size to %u", dc->curr_codesize);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jne 0x185e81
movq -0x8(%rbp), %rdi
callq 0x1862e0
jmp 0x185e9d
movq -0x8(%rbp), %rax
cmpl $0xc, 0x14(%rax)
jne 0x185e9b
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
callq 0x186400
jmp 0x185e9d
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jae 0x185ee4
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
movl $0x2, %esi
leaq 0x518fe(%rip), %rdx     # 0x1d77db
movb $0x0, %al
callq 0x1848d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_partial_clear
static void delzw_partial_clear(delzwctx *dc)
{
	DELZW_CODE i;

	delzw_debugmsg(dc, 2, "partial clear code");

	for(i=dc->first_dynamic_code; i<=dc->highest_code_ever_used; i++) {
		// If this code is in use
		if(dc->ct[i].codetype==DELZW_CODETYPE_DYN_USED) {
			// and its parent is a dynamic code,
			//   mark its parent as having a child
			if(dc->ct[i].parent>=257) {
				dc->ct[dc->ct[i].parent].flags = 1;
			}
		}
	}

	for(i=dc->first_dynamic_code; i<=dc->highest_code_ever_used; i++) {
		if(dc->ct[i].flags==0) {
			// If this code has no children, clear it
			delzw_clear_one_dynamic_code(dc, i);
		}
		else {
			// Leave all flags clear, for next time
			dc->ct[i].flags = 0;
		}
	}

	dc->free_code_search_start = dc->first_dynamic_code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x518fa(%rip), %rdx     # 0x1d7806
movb $0x0, %al
callq 0x1848d0
movq -0x8(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
ja 0x185fac
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzbl 0x3(%rax), %eax
cmpl $0x3, %eax
jne 0x185f9c
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
cmpl $0x101, %eax            # imm = 0x101
jl 0x185f9a
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xd0(%rcx), %rcx
movl -0xc(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x4(%rax)
jmp 0x185f9c
jmp 0x185f9e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x185f20
movq -0x8(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
ja 0x18601a
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x185ff4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x186440
jmp 0x18600d
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4(%rax)
jmp 0x18600f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x185fb9
movq -0x8(%rbp), %rax
movl 0xac(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xa8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_clear
static void delzw_clear(delzwctx *dc)
{
	DELZW_CODE i;

	delzw_debugmsg(dc, 2, "clear code");

	if(dc->fmt==DE_LZWFMT_UNIXCOMPRESS) {
		delzw_unixcompress_end_bitgroup(dc);
	}

	for(i=dc->first_dynamic_code; i<=dc->highest_code_ever_used; i++) {
		delzw_clear_one_dynamic_code(dc, i);
	}

	dc->curr_codesize = dc->min_codesize;
	dc->free_code_search_start = dc->first_dynamic_code;
	dc->have_oldcode = 0;
	dc->oldcode = 0;
	dc->last_code_added = 0;
	dc->last_value = 0;

	delzw_debugmsg(dc, 2, "code size: %u", dc->curr_codesize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x51602(%rip), %rdx     # 0x1d780e
movb $0x0, %al
callq 0x1848d0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jne 0x186226
movq -0x8(%rbp), %rdi
callq 0x1862e0
movq -0x8(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
ja 0x186259
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x186440
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x186233
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl 0xac(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x94(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x9c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
movl $0x2, %esi
leaq 0x25858(%rip), %rdx     # 0x1abb22
movb $0x0, %al
callq 0x1848d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_clear_one_dynamic_code
static void delzw_clear_one_dynamic_code(delzwctx *dc, DELZW_CODE code)
{
	if(code<dc->first_dynamic_code || code>=dc->ct_capacity) return;
	dc->ct[code].codetype = DELZW_CODETYPE_DYN_UNUSED;
	dc->ct[code].parent = 0;
	dc->ct[code].value = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xac(%rcx), %eax
jb 0x186469
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc8(%rcx), %eax
jb 0x18646b
jmp 0x1864b7
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x2, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movw $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x2(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_code_is_in_table
static int delzw_code_is_in_table(delzwctx *dc, DELZW_CODE code)
{
	u8 codetype = dc->ct[code].codetype;

	if(codetype==DELZW_CODETYPE_STATIC) return 1;
	if(codetype==DELZW_CODETYPE_DYN_USED) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb 0x3(%rax), %al
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x1, %eax
jne 0x186698
movl $0x1, -0x4(%rbp)
jmp 0x1866b1
movzbl -0x15(%rbp), %eax
cmpl $0x3, %eax
jne 0x1866aa
movl $0x1, -0x4(%rbp)
jmp 0x1866b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_dumptable
static void delzw_dumptable(delzwctx *dc)
{
	DELZW_CODE k;
	for(k=0; k<dc->highest_code_ever_used; k++) {
		delzw_debugmsg(dc, 4, "[%d] ty=%d p=%d v=%d f=%d",
			(int)k, (int)dc->ct[k].codetype, (int)dc->ct[k].parent,
			(int)dc->ct[k].value, (int)dc->ct[k].flags);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
jae 0x18693c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movzbl 0x3(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movzwl (%rax), %r9d
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movzbl 0x2(%rax), %r10d
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0xc(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movzbl 0x4(%rax), %eax
movl $0x4, %esi
leaq 0x50f6b(%rip), %rdx     # 0x1d788a
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x1848d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x186893
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_write
static void delzw_write(delzwctx *dc, const u8 *buf, size_t n1)
{
	i64 n;

	if(dc->errcode) return;
	n = (i64)n1;

	if(dc->output_len_known) {
		if(dc->uncmpr_nbytes_written + n > dc->output_expected_len) {
			n = dc->output_expected_len - dc->uncmpr_nbytes_written;
		}
	}
	if(n<1) return;
	if(n==1) {
		dbuf_writebyte(dc->dfctx->dcmpro->f, buf[0]);
	}
	else {
		dbuf_write(dc->dfctx->dcmpro->f, buf, n);
	}
	dc->uncmpr_nbytes_written += n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x186973
jmp 0x186a0a
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x31(%rax)
je 0x1869b1
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jle 0x1869af
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x70(%rcx), %rax
movq %rax, -0x20(%rbp)
jmp 0x1869b1
cmpq $0x1, -0x20(%rbp)
jge 0x1869ba
jmp 0x186a0a
cmpq $0x1, -0x20(%rbp)
jne 0x1869de
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
callq 0x168380
jmp 0x1869fa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x166170
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_hashed_add_code_to_dict
static void delzw_hashed_add_code_to_dict(delzwctx *dc, DELZW_CODE code, u8 value)
{
	DELZW_CODE idx;

	if(dc->ct_code_count >= dc->ct_capacity) {
		return;
	}

	idx = delzw_get_hashed_code(dc, code, value);
	if(dc->errcode) return;

	dc->ct[idx].parent = (DELZW_CODE_MINRANGE)dc->oldcode;
	dc->ct[idx].value = value;
	dc->ct[idx].codetype = DELZW_CODETYPE_DYN_USED;
	dc->ct_code_count++;
	dc->last_code_added = idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc8(%rcx), %eax
jb 0x186a3f
jmp 0x186ad7
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movzbl -0xd(%rbp), %edx
callq 0x185cc0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x186a5e
jmp 0x186ad7
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x14(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movb -0xd(%rbp), %cl
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x14(%rbp), %edx
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movb $0x3, 0x3(%rax)
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xcc(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-lzw.c
// Function: delzw_find_first_free_entry
static void delzw_find_first_free_entry(delzwctx *dc, DELZW_CODE *pentry)
{
	DELZW_CODE k;

	for(k=dc->free_code_search_start; k<dc->ct_capacity; k++) {
		if(dc->ct[k].codetype==DELZW_CODETYPE_DYN_UNUSED) {
			*pentry = (DELZW_CODE)k;
			return;
		}
	}

	*pentry = (DELZW_CODE)(dc->ct_capacity-1);
	delzw_set_error(dc, DELZW_ERRCODE_BAD_CDATA, "LZW table unexpectedly full");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc8(%rcx), %eax
jae 0x186b42
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzbl 0x3(%rax), %eax
cmpl $0x2, %eax
jne 0x186b35
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x186b6a
jmp 0x186b37
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x186afd
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x50d3f(%rip), %rdx     # 0x1d78a4
callq 0x185850
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_Decompress
static void dd_Decompress (struct dd_Ctl *Ctl)
{
	struct dd_codet * ct;
	u16 newcode;

	ct = dd_DInit(Ctl);

	while(1) {
		newcode = dd_GetNextcode(Ctl, ct);
		if(Ctl->c->debug_level>=3) {
			de_dbg(Ctl->c, "%"I64_FMT" [i%"I64_FMT"/o%"I64_FMT"] code=%u oc=%u",
				Ctl->code_counter,
				Ctl->inf_pos, Ctl->nbytes_written,
				(UI)newcode, (UI)ct->oldcode);
		}
		if(newcode==0 || Ctl->eof_flag || Ctl->err_flag) break;
		if (ct->oldcode > 0)
			dd_BuildEntry(Ctl, ct, newcode);
		if(Ctl->err_flag) break;
		dd_OutputString(Ctl, ct, newcode);
		ct->oldcode = newcode;
		Ctl->code_counter++;
	}

	if(Ctl->err_flag) {
		de_dfilter_set_errorf(Ctl->c, Ctl->dres, Ctl->modname, "Bad compressed data");
	}
	dd_DFree(Ctl, ct);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x186ca0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x186de0
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
jl 0x186be3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %r8
movzwl -0x12(%rbp), %r9d
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
leaq 0x50cee(%rip), %rsi     # 0x1d78c7
movl %eax, (%rsp)
movb $0x0, %al
callq 0x15b0d0
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
je 0x186c00
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x186c00
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x186c02
jmp 0x186c5e
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0x186c20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzwl -0x12(%rbp), %edx
callq 0x186ef0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x186c2c
jmp 0x186c5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzwl -0x12(%rbp), %edx
callq 0x187050
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x186b89
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x186c8d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x50c5f(%rip), %rcx     # 0x1d78e5
movb $0x0, %al
callq 0x177450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1871d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_DInit
static struct dd_codet * dd_DInit (struct dd_Ctl *Ctl)
{
	struct dd_codet * ct;
	u16 code;

	ct = (struct dd_codet *) de_malloc(Ctl->c, sizeof(struct dd_codet));
	for (code = 1; code <= 256; code++) {
		ct->valfirst[code] = (u8)(code-1);
		ct->value[code] = (u8)(code-1);
		ct->size[code] = 1;
		// Maybe this is set to 1 just to prevent it from ever getting down
		// to 0. So it doesn't get re-used.
		ct->usecount[code] = 1;
	}
	for (code = 257; code <= 4095; code++) {
		if(code<4095) {
			ct->newer[code] = code + 1;
		}
		if(code>257) {
			ct->older[code] = code - 1;
		}
	}
	ct->oldest = 257;
	ct->newest = 4095;
	ct->j = 1;
	ct->oldcode = 0;
	ct->hold = 0;
	return (ct);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x10010, %esi          # imm = 0x10010
callq 0x15b780
movq %rax, -0x10(%rbp)
movw $0x1, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jg 0x186d36
movzwl -0x12(%rbp), %eax
subl $0x1, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movb %dl, 0xe010(%rax,%rcx)
movzwl -0x12(%rbp), %eax
subl $0x1, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movb %dl, 0xf010(%rax,%rcx)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movl $0x1, 0xa010(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movl $0x1, 0x6010(%rax,%rcx,4)
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x186cc7
movw $0x101, -0x12(%rbp)     # imm = 0x101
movzwl -0x12(%rbp), %eax
cmpl $0xfff, %eax            # imm = 0xFFF
jg 0x186d9e
movzwl -0x12(%rbp), %eax
cmpl $0xfff, %eax            # imm = 0xFFF
jge 0x186d6c
movzwl -0x12(%rbp), %eax
addl $0x1, %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movw %dx, 0x200e(%rax,%rcx,2)
movzwl -0x12(%rbp), %eax
cmpl $0x101, %eax            # imm = 0x101
jle 0x186d8e
movzwl -0x12(%rbp), %eax
subl $0x1, %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movw %dx, 0xe(%rax,%rcx,2)
jmp 0x186d90
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x186d3c
movq -0x10(%rbp), %rax
movw $0x101, 0xa(%rax)       # imm = 0x101
movq -0x10(%rbp), %rax
movw $0xfff, 0xc(%rax)       # imm = 0xFFF
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movw $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_GetNextcode
static u16 dd_GetNextcode (struct dd_Ctl *Ctl, struct dd_codet * ct)
{
	u16 code;

	if(Ctl->inf_pos >= Ctl->inf_endpos) {
		Ctl->eof_flag = 1;
		return 0;
	}

	if (ct->j) {
		code = (u16)dbuf_getbyte_p(Ctl->dcmpri->f, &Ctl->inf_pos) << 4;
		ct->hold = (u16)dbuf_getbyte_p(Ctl->dcmpri->f, &Ctl->inf_pos);
		code |= (ct->hold >> 4);
	}
	else {
		code = (ct->hold & 0x0f) << 8;
		code |= (u16)dbuf_getbyte_p(Ctl->dcmpri->f, &Ctl->inf_pos);
		ct->hold = 0;
	}
	ct->j = !ct->j;
	return (code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jl 0x186e18
movq -0x10(%rbp), %rax
movl $0x1, 0x48(%rax)
movw $0x0, -0x2(%rbp)
jmp 0x186ee5
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x186e82
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x165170
movzbl %al, %eax
movzwl %ax, %eax
shll $0x4, %eax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x165170
movzbl %al, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rax
movzwl (%rax), %ecx
sarl $0x4, %ecx
movzwl -0x1a(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
jmp 0x186ec4
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0xf, %eax
shll $0x8, %eax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x165170
movzbl %al, %eax
movzwl %ax, %ecx
movzwl -0x1a(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movw $0x0, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movw -0x1a(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_BuildEntry
static void dd_BuildEntry (struct dd_Ctl *Ctl, struct dd_codet * ct, u16 newcode)
{
	u16 lruentry, tcode;
	int old_codesize;
	int new_codesize;
	u8 *codestr = NULL;

	lruentry = dd_GetLRU(Ctl, ct);
	old_codesize = ct->size[ct->oldcode];
	if(old_codesize<1) {
		Ctl->err_flag = 1;
		goto done;
	}
	new_codesize = old_codesize + 1;
	if(new_codesize > DD_MAXTABLE) {
		Ctl->err_flag = 1;
		goto done;
	}

	if (newcode != lruentry) {
		tcode = newcode;
	}
	else {
		tcode = ct->oldcode;
	}

	ct->valfirst[lruentry] = ct->valfirst[ct->oldcode];
	ct->value[lruentry] = ct->valfirst[tcode];

	ct->size[lruentry] = new_codesize;
	ct->charlink[lruentry] = ct->oldcode;
	dd_ReserveEntry(Ctl, ct, ct->oldcode);
	ct->usecount[lruentry] = 0;
	dd_AddMRU (Ctl, ct, lruentry);

done:
	if(codestr) {
		de_free(Ctl->c, codestr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x187200
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
movl 0xa010(%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x186f4c
movq -0x8(%rbp), %rax
movl $0x1, 0x4c(%rax)
jmp 0x187033
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x1000, -0x20(%rbp)    # imm = 0x1000
jle 0x186f6e
movq -0x8(%rbp), %rax
movl $0x1, 0x4c(%rax)
jmp 0x187033
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
je 0x186f84
movw -0x12(%rbp), %ax
movw %ax, -0x16(%rbp)
jmp 0x186f90
movq -0x10(%rbp), %rax
movw 0x8(%rax), %ax
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
movb 0xe010(%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movb %dl, 0xe010(%rax,%rcx)
movq -0x10(%rbp), %rax
movzwl -0x16(%rbp), %ecx
movb 0xe010(%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movb %dl, 0xf010(%rax,%rcx)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movl %edx, 0xa010(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movw 0x8(%rax), %dx
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movw %dx, 0x400e(%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %edx
callq 0x1872d0
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movl $0x0, 0x6010(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzwl -0x14(%rbp), %edx
callq 0x187340
cmpq $0x0, -0x28(%rbp)
je 0x18704a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_OutputString
static void dd_OutputString(struct dd_Ctl *Ctl, struct dd_codet * ct, u16 tcode)
{
	size_t i;
	size_t valbuf_pos = DD_MAXTABLE;
	u16 curcode = tcode;

	if(ct->size[tcode]<1 || ct->size[tcode]>DD_MAXTABLE-256) {
		Ctl->err_flag = 1;
		goto done;
	}

	for(i=0; i<(size_t)ct->size[tcode]; i++) {
		if(curcode>=DD_MAXTABLE || curcode<1) {
			Ctl->err_flag = 1;
			goto done;
		}

		if(ct->size[curcode] != ct->size[tcode]-i) {
			Ctl->err_flag = 1;
			goto done;
		}

		valbuf_pos--;
		Ctl->valbuf[valbuf_pos] = ct->value[curcode];

		// Traverse the tree, back toward the root codes.
		curcode = ct->charlink[curcode];
	}

	dbuf_write(Ctl->dcmpro->f, &Ctl->valbuf[valbuf_pos], ct->size[tcode]);
	Ctl->nbytes_written += (i64)ct->size[tcode];

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq $0x1000, -0x28(%rbp)    # imm = 0x1000
movw -0x12(%rbp), %ax
movw %ax, -0x2a(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
cmpl $0x1, 0xa010(%rax,%rcx,4)
jb 0x18709e
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
cmpl $0xf00, 0xa010(%rax,%rcx,4) # imm = 0xF00
jbe 0x1870ae
movq -0x8(%rbp), %rax
movl $0x1, 0x4c(%rax)
jmp 0x1871c3
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl -0x12(%rbp), %edx
movl 0xa010(%rcx,%rdx,4), %ecx
cmpq %rcx, %rax
jae 0x187179
movzwl -0x2a(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x1870e6
movzwl -0x2a(%rbp), %eax
cmpl $0x1, %eax
jge 0x1870f6
movq -0x8(%rbp), %rax
movl $0x1, 0x4c(%rax)
jmp 0x1871c3
movq -0x10(%rbp), %rax
movzwl -0x2a(%rbp), %ecx
movl 0xa010(%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movzwl -0x12(%rbp), %edx
movl 0xa010(%rcx,%rdx,4), %ecx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
je 0x18712d
movq -0x8(%rbp), %rax
movl $0x1, 0x4c(%rax)
jmp 0x1871c3
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x2a(%rbp), %ecx
movb 0xf010(%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, 0x50(%rax,%rcx)
movq -0x10(%rbp), %rax
movzwl -0x2a(%rbp), %ecx
movw 0x400e(%rax,%rcx,2), %ax
movw %ax, -0x2a(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1870b6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
addq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movl 0xa010(%rax,%rcx,4), %eax
movl %eax, %edx
callq 0x166170
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movl 0xa010(%rax,%rcx,4), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_GetLRU
static u16 dd_GetLRU (struct dd_Ctl *Ctl, struct dd_codet * ct)
{
	u16 tcode, xcode;

	dd_ValidateLinkChains(Ctl, ct, ct->oldest);
	tcode = ct->oldest;
	if (ct->usecount[tcode] != 0) {
		dd_tmsg(Ctl, "Usecount not zero in GetLRU, code: %4x", tcode);
	}
	xcode = ct->charlink[tcode];
	dd_UnlinkCode (Ctl, ct, tcode);

	if (xcode != 0) {
		ct->usecount[xcode] --;
		if (ct->usecount[xcode] == 0) {
			dd_AddMRU (Ctl, ct, xcode);
		}
	}

	return (tcode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movzwl 0xa(%rax), %edx
callq 0x1873d0
movq -0x10(%rbp), %rax
movw 0xa(%rax), %ax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
cmpl $0x0, 0x6010(%rax,%rcx,4)
je 0x187259
movq -0x8(%rbp), %rdi
movzwl -0x12(%rbp), %edx
leaq 0x506a7(%rip), %rsi     # 0x1d78f9
movb $0x0, %al
callq 0x1874f0
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movw 0x400e(%rax,%rcx,2), %ax
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzwl -0x12(%rbp), %edx
callq 0x1875d0
movzwl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x1872c5
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movl 0x6010(%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, 0x6010(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
cmpl $0x0, 0x6010(%rax,%rcx,4)
jne 0x1872c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzwl -0x14(%rbp), %edx
callq 0x187340
jmp 0x1872c5
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_ReserveEntry
static void dd_ReserveEntry (struct dd_Ctl *Ctl, struct dd_codet * ct, u16 tcode)
{
	if (ct->usecount[tcode] > 0) {
		ct->usecount[tcode] ++;
	}
	else {
		dd_UnlinkCode(Ctl, ct, tcode);
		ct->usecount[tcode] = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
cmpl $0x0, 0x6010(%rax,%rcx,4)
jle 0x187314
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movl 0x6010(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x6010(%rax,%rcx,4)
jmp 0x187338
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzwl -0x12(%rbp), %edx
callq 0x1875d0
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movl $0x1, 0x6010(%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/../foreign/dskdcmps.h
// Function: dd_AddMRU
static void dd_AddMRU (struct dd_Ctl *Ctl, struct dd_codet * ct, u16 tcode)
{
	if (ct->usecount[tcode] != 0) {
		dd_tmsg(Ctl, "Usecount not zero in AddMRU, code: %4x", tcode);
	}
	ct->newer[ct->newest] = tcode;
	ct->older[tcode] = ct->newest;
	ct->newer[tcode] = 0;
	ct->newest = tcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
cmpl $0x0, 0x6010(%rax,%rcx,4)
je 0x18737f
movq -0x8(%rbp), %rdi
movzwl -0x12(%rbp), %edx
leaq 0x505e7(%rip), %rsi     # 0x1d795f
movb $0x0, %al
callq 0x1874f0
movw -0x12(%rbp), %dx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
movw %dx, 0x200e(%rax,%rcx,2)
movq -0x10(%rbp), %rax
movw 0xc(%rax), %dx
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movw %dx, 0xe(%rax,%rcx,2)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movw $0x0, 0x200e(%rax,%rcx,2)
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq