LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_rle90_codec_addbuf
static void my_rle90_codec_addbuf(struct de_dfilter_ctx *dfctx,
	const u8 *buf, i64 buf_len)
{
	int i;
	u8 b;
	struct rle90ctx *rctx = (struct rle90ctx*)dfctx->codec_private;

	if(!rctx) return;

	for(i=0; i<buf_len; i++) {
		if(dfctx->dcmpro->len_known &&
			(rctx->nbytes_written >= dfctx->dcmpro->expected_len))
		{
			dfctx->finished_flag = 1;
			break;
		}

		b = buf[i];
		rctx->total_nbytes_processed++;

		if(rctx->countcode_pending && b==0) {
			// Not RLE, just an escaped 0x90 byte.
			dbuf_writebyte(dfctx->dcmpro->f, 0x90);
			rctx->nbytes_written++;
			rctx->last_output_byte = 0x90;
			rctx->countcode_pending = 0;
		}
		else if(rctx->countcode_pending) {
			i64 count;

			// RLE. We already emitted one byte (because the byte to repeat
			// comes before the repeat count), so write countcode-1 bytes.
			count = (i64)(b-1);
			if(dfctx->dcmpro->len_known &&
				(rctx->nbytes_written+count > dfctx->dcmpro->expected_len))
			{
				count = dfctx->dcmpro->expected_len - rctx->nbytes_written;
			}
			dbuf_write_run(dfctx->dcmpro->f, rctx->last_output_byte, count);
			rctx->nbytes_written += count;

			rctx->countcode_pending = 0;
		}
		else if(b==0x90) {
			rctx->countcode_pending = 1;
		}
		else {
			dbuf_writebyte(dfctx->dcmpro->f, b);
			rctx->nbytes_written++;
			rctx->last_output_byte = b;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r13
testq %r13, %r13
je 0xeef6f
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebp, %ebp
testq %rdx, %rdx
cmovleq %rbp, %rbx
cmpq %rbp, %rbx
je 0xeef6f
movq 0x10(%r14), %rax
movb 0x8(%rax), %cl
testb %cl, %cl
je 0xeeec5
movq 0x8(%r13), %rdx
cmpq 0x10(%rax), %rdx
jge 0xeef6a
movb (%r15,%rbp), %dl
incq (%r13)
movl 0x14(%r13), %esi
testl %esi, %esi
setne %dil
testb %dl, %dl
sete %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0xeeefe
movq (%rax), %rdi
movl $0x90, %esi
callq 0xe5bc5
incq 0x8(%r13)
movb $-0x70, 0x10(%r13)
jmp 0xeef39
movzbl %dl, %r12d
testl %esi, %esi
je 0xeef46
decq %r12
testb %cl, %cl
je 0xeef25
movq 0x8(%r13), %rcx
movq 0x10(%rax), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %r12, %rcx
cmpq %rdx, %rcx
cmovgq %rsi, %r12
movq (%rax), %rdi
movzbl 0x10(%r13), %esi
movq %r12, %rdx
callq 0xe5e40
addq %r12, 0x8(%r13)
andl $0x0, 0x14(%r13)
incq %rbp
jmp 0xeeea3
cmpb $-0x70, %dl
jne 0xeef55
movl $0x1, 0x14(%r13)
jmp 0xeef3e
movq (%rax), %rdi
movl %r12d, %esi
callq 0xe5bc5
incq 0x8(%r13)
movb %r12b, 0x10(%r13)
jmp 0xeef3e
movb $0x1, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_rle90_codec_finish
static void my_rle90_codec_finish(struct de_dfilter_ctx *dfctx)
{
	struct rle90ctx *rctx = (struct rle90ctx*)dfctx->codec_private;

	if(!rctx) return;
	dfctx->dres->bytes_consumed = rctx->total_nbytes_processed;
	dfctx->dres->bytes_consumed_valid = 1;
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xeef96
movq (%rax), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movb $0x1, 0x4(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_rle90_codec_destroy
static void my_rle90_codec_destroy(struct de_dfilter_ctx *dfctx)
{
	struct rle90ctx *rctx = (struct rle90ctx*)dfctx->codec_private;

	if(rctx) {
		de_free(dfctx->c, rctx);
	}
	dfctx->codec_private = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0xeefac
movq (%rbx), %rdi
callq 0xded32
andq $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_lz77buffer_create
struct de_lz77buffer *de_lz77buffer_create(deark *c, UI bufsize)
{
	struct de_lz77buffer *rb;

	rb = de_malloc(c, sizeof(struct de_lz77buffer));
	rb->buf = de_malloc(c, (i64)bufsize);
	rb->bufsize = bufsize;
	rb->mask = bufsize - 1;
	return rb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x28
popq %rsi
callq 0xdecaf
movq %rax, %r15
movl %ebx, %esi
movq %r14, %rdi
callq 0xdecaf
movq %rax, 0x20(%r15)
movl %ebx, 0x18(%r15)
decl %ebx
movl %ebx, 0x14(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: lzss_lz77buf_writebytecb
static void lzss_lz77buf_writebytecb(struct de_lz77buffer *rb, const u8 n)
{
	struct lzss_ctx *sctx = (struct lzss_ctx*)rb->userdata;

	if(sctx->stop_flag) return;
	if(sctx->dcmpro->len_known) {
		if(sctx->nbytes_written >= sctx->dcmpro->expected_len) {
			sctx->stop_flag = 1;
			return;
		}
	}

	dbuf_writebyte(sctx->dcmpro->f, n);
	sctx->nbytes_written++;
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
cmpl $0x0, 0x8(%rbx)
jne 0xef2e7
movq 0x18(%rbx), %rax
cmpb $0x0, 0x8(%rax)
je 0xef2cf
movq (%rbx), %rcx
cmpq 0x10(%rax), %rcx
jge 0xef2e0
movq (%rax), %rdi
movzbl %sil, %esi
callq 0xe5bc5
incq (%rbx)
jmp 0xef2e7
movl $0x1, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: lzss_fill_bitbuf
static void lzss_fill_bitbuf(deark *c, struct lzss_ctx *sctx)
{
	u8 b;

	if(sctx->cur_ipos+1 > sctx->endpos) {
		sctx->stop_flag = 1;
		return;
	}
	b = dbuf_getbyte_p(sctx->dcmpri->f, &sctx->cur_ipos);
	de_bitbuf_lowlevel_add_byte(&sctx->bbll, b);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jge 0xef32d
leaq 0x28(%rbx), %rsi
movq 0x10(%rbx), %rax
movq (%rax), %rdi
callq 0xe3f2a
addq $0x38, %rbx
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xe69c4
movl $0x1, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_lz77buffer_copy_from_hist
void de_lz77buffer_copy_from_hist(struct de_lz77buffer *rb,
	UI startpos, UI count)
{
	UI frompos;
	UI i;

	frompos = startpos & rb->mask;
	for(i=0; i<count; i++) {
		de_lz77buffer_add_literal_byte(rb, rb->buf[frompos]);
		frompos = (frompos+1) & rb->mask;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
andl 0x14(%rdi), %ebp
subl $0x1, %ebx
jb 0xef390
movq 0x20(%r14), %rax
movl %ebp, %ecx
movzbl (%rax,%rcx), %esi
movq %r14, %rdi
callq 0xef336
incl %ebp
andl 0x14(%r14), %ebp
jmp 0xef371
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: sit_huff_read_tree
static void sit_huff_read_tree(struct sit_huffctx *hctx, u64 curr_code, UI curr_code_nbits)
{
	u8 x;

	if(curr_code_nbits>FMTUTIL_HUFFMAN_MAX_CODE_LENGTH) {
		hctx->errflag = 1;
	}
	if(hctx->bitrd.eof_flag || hctx->errflag) return;

	x = (u8)de_bitreader_getbits(&hctx->bitrd, 1);
	if(hctx->bitrd.eof_flag) return;

	if(x==0) {
		sit_huff_read_tree(hctx, curr_code<<1, curr_code_nbits+1);
		if(hctx->bitrd.eof_flag || hctx->errflag) return;
		sit_huff_read_tree(hctx, (curr_code<<1) | 1, curr_code_nbits+1);
	}
	else {
		int ret;
		fmtutil_huffman_valtype val;

		val = (fmtutil_huffman_valtype)de_bitreader_getbits(&hctx->bitrd, 8);
		if(hctx->c->debug_level>=2) {
			char b2buf[72];

			de_dbg(hctx->c, "code: \"%s\" = %d",
				de_print_base2_fixed(b2buf, sizeof(b2buf), curr_code, curr_code_nbits),
				(int)val);
		}
		ret = fmtutil_huffman_add_code(hctx->c, hctx->ht->bk, curr_code, curr_code_nbits, val);
		if(!ret) {
			hctx->errflag = 1;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
pushq $0x1
popq %r12
cmpl $0x31, %ebp
jb 0xefbc3
movl $0x1, 0x30(%rbx)
cmpb $0x0, 0x50(%rbx)
jne 0xefc79
cmpl $0x0, 0x30(%rbx)
jne 0xefc79
movq %r15, %rdi
movl %r12d, %esi
callq 0xe6a4a
cmpb $0x0, 0x50(%rbx)
jne 0xefc79
testb %al, %al
jne 0xefc14
addq %r14, %r14
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xefb9b
cmpb $0x0, 0x50(%rbx)
jne 0xefc79
orq $0x1, %r14
cmpl $0x0, 0x30(%rbx)
je 0xefbb7
jmp 0xefc79
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0xe6a4a
movq %rax, %r15
movq (%rbx), %r12
cmpl $0x2, (%r12)
jl 0xefc56
movq %rsp, %rdi
pushq $0x48
popq %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xdfc03
leaq 0x2174d(%rip), %rsi     # 0x111390
movq %r12, %rdi
movq %rax, %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0xde896
movq (%rbx), %r12
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0xf7e56
testl %eax, %eax
jne 0xefc79
movl $0x1, 0x30(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: fmtutil_decompress_exepack_reloc_tbl
int fmtutil_decompress_exepack_reloc_tbl(deark *c, i64 pos1, i64 endpos, dbuf *outf)
{
	i64 pos = pos1;
	i64 seg = 0;
	int reloc_count = 0;
	int retval = 0;
	int saved_indent_level;
	dbuf *inf = c->infile;

	de_dbg_indent_save(c, &saved_indent_level);
	de_dbg(c, "compressed reloc table: pos=%"I64_FMT", end=%"I64_FMT, pos1, endpos);
	if(endpos > inf->len) goto done;
	de_dbg_indent(c, 1);

	for(seg=0; seg<0x10000; seg+=0x1000) {
		i64 count;
		i64 i;

		if(pos>=endpos) {
			goto done;
		}
		count = dbuf_getu16le_p(inf, &pos);
		de_dbg2(c, "seg %04x count: %u", (UI)seg, (UI)count);

		de_dbg_indent(c, 1);
		for(i=0; i<count; i++) {
			i64 offs;

			if(pos>=endpos || reloc_count>=65535) goto done;
			offs = dbuf_getu16le_p(inf, &pos);
			de_dbg2(c, "reloc: %04x:%04x", (UI)seg, (UI)offs);
			dbuf_writeu16le(outf, offs);
			dbuf_writeu16le(outf, seg);
			reloc_count++;
		}
		de_dbg_indent(c, -1);
	}

	retval = 1;
	de_dbg(c, "reloc count: %d", (int)reloc_count);

done:
	de_dbg_indent_restore(c, saved_indent_level);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x18(%rdi), %r13
leaq 0x14(%rsp), %rsi
callq 0xdebae
leaq 0x4da0a(%rip), %rsi     # 0x13d6c4
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xde896
movq %r15, 0x20(%rsp)
movq %r13, 0x18(%rsp)
cmpq %r15, 0x18(%r13)
jl 0xefdd2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq $0xffff, %rbp           # imm = 0xFFFF
ja 0xefdef
movq 0x20(%rsp), %rax
cmpq %rax, 0x8(%rsp)
jge 0xefdd0
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe3fc4
movq %rax, %r12
movq %rbx, %rdi
leaq 0x4d9c4(%rip), %rsi     # 0x13d6ed
movl %ebp, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0xde9f1
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0xdeba7
testq %r12, %r12
movl $0x0, %eax
cmovleq %rax, %r12
leal (%r12,%r13), %eax
movl %eax, 0x10(%rsp)
subq $0x1, %r12
jb 0xefdb2
movq 0x20(%rsp), %rax
cmpq %rax, 0x8(%rsp)
jge 0xefdd0
cmpl $0xfffe, %r13d          # imm = 0xFFFE
jg 0xefdd0
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe3fc4
movq %rax, %r15
movq %rbx, %rdi
leaq 0x4d975(%rip), %rsi     # 0x13d700
movl %ebp, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0xde9f1
movq %r14, %rdi
movq %r15, %rsi
callq 0xe5f08
movq %r14, %rdi
movq %rbp, %rsi
callq 0xe5f08
incl %r13d
jmp 0xefd54
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0xdeba7
addq $0x1000, %rbp           # imm = 0x1000
movl 0x10(%rsp), %eax
movl %eax, %r13d
jmp 0xefcf0
xorl %ebp, %ebp
movl 0x14(%rsp), %esi
movq %rbx, %rdi
callq 0xdebb7
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3222d(%rip), %rsi     # 0x122023
movq %rbx, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rbp
jmp 0xefdd2
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: squeeze_interpret_node
static void squeeze_interpret_node(struct squeeze_ctx *sqctx,
	i64 nodenum, u64 currcode, UI currcode_nbits)
{
	// TODO: Report errors?
	if(nodenum<0 || nodenum>=sqctx->nodecount) return;
	if(sqctx->tmpnodes[nodenum].in_use) return; // Loops are bad
	if(currcode_nbits>=FMTUTIL_HUFFMAN_MAX_CODE_LENGTH) return;

	sqctx->tmpnodes[nodenum].in_use = 1;
	squeeze_interpret_dval(sqctx, sqctx->tmpnodes[nodenum].child[0].dval, currcode<<1, currcode_nbits+1);
	squeeze_interpret_dval(sqctx, sqctx->tmpnodes[nodenum].child[1].dval, ((currcode<<1) | 1), currcode_nbits+1);
	sqctx->tmpnodes[nodenum].in_use = 0;
}

// Assembly:
testq %rsi, %rsi
js 0xf06d5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq %rsi, 0x30(%rdi)
jle 0xf06ca
movl %ecx, %ebx
cmpl $0x2f, %ecx
ja 0xf06ca
imulq $0x6, %rsi, %rax
cmpb $0x0, 0x70(%r14,%rax)
jne 0xf06ca
movq %rdx, %r15
leaq (%r14,%rax), %r12
addq $0x70, %r12
movb $0x1, (%r12)
movswl 0x2(%r12), %esi
addq %rdx, %rdx
incl %ebx
movq %r14, %rdi
movl %ebx, %ecx
callq 0xf06d6
movswl 0x4(%r12), %esi
leaq 0x1(,%r15,2), %rdx
movq %r14, %rdi
movl %ebx, %ecx
callq 0xf06d6
movb $0x0, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: squeeze_interpret_dval
static void squeeze_interpret_dval(struct squeeze_ctx *sqctx,
	i16 dval, u64 currcode, UI currcode_nbits)
{
	char b2buf[72];

	if(dval>=0) { // a pointer to a node
		if((i64)dval < sqctx->nodecount) {
			squeeze_interpret_node(sqctx, (i64)dval, currcode, currcode_nbits);
		}
	}
	else if(dval>=(-257) && dval<=(-1)) {
		fmtutil_huffman_valtype adj_value;

		//  -257 => 256 (stop code)
		//  -256 => 255 (byte value)
		//  -255 => 254 (byte value)
		//  ...
		//  -1   => 0   (byte value)
		adj_value = -(((fmtutil_huffman_valtype)dval)+1);
		if(sqctx->c->debug_level>=3) {
			de_dbg3(sqctx->c, "code: \"%s\" = %d",
				de_print_base2_fixed(b2buf, sizeof(b2buf), currcode, currcode_nbits),
				(int)adj_value);
		}
		fmtutil_huffman_add_code(sqctx->c, sqctx->ht->bk, currcode, currcode_nbits, adj_value);
	}
	// TODO: Report errors?
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
testw %si, %si
js 0xf0711
movzwl %si, %esi
cmpq %rsi, 0x30(%r15)
jle 0xf0768
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf065f
cmpw $0xfeff, %si            # imm = 0xFEFF
jb 0xf0768
notl %esi
movzwl %si, %ebp
movq (%r15), %r12
cmpl $0x3, (%r12)
jl 0xf0750
movq %rsp, %rdi
pushq $0x48
popq %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0xdfc03
leaq 0x20c52(%rip), %rsi     # 0x111390
movq %r12, %rdi
movq %rax, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xdea83
movq (%r15), %r12
movq 0x38(%r15), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0xf7e56
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: xpk_xor1_cbfn
static int xpk_xor1_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	u8 *pn = (u8*)brctx->userdata;
	i64 i;

	for(i=0; i<buf_len; i++) {
		*pn ^= buf[i];
	}
	return 1;
}

// Assembly:
movq (%rdi), %rax
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
cmpq %rcx, %rdx
je 0xf0792
movb (%rsi,%rcx), %dil
xorb %dil, (%rax)
incq %rcx
jmp 0xf0781
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: xpk_xor2_cbfn
static int xpk_xor2_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	UI *pn = (UI*)brctx->userdata;
	UI align;
	i64 i;

	align = brctx->offset & 0x1;

	for(i=0; i<buf_len; i++) {
		if(align) {
			*pn ^= buf[i];
		}
		else {
			*pn ^= ((UI)buf[i])<<8;
		}
		align = !align;
	}
	return 1;
}

// Assembly:
movq (%rdi), %rax
movl 0x10(%rdi), %ecx
andl $0x1, %ecx
xorl %edi, %edi
testq %rdx, %rdx
cmovleq %rdi, %rdx
cmpq %rdi, %rdx
je 0xf07c8
movzbl (%rsi,%rdi), %r8d
testl %ecx, %ecx
jne 0xf07ba
shll $0x8, %r8d
xorl (%rax), %r8d
movl %r8d, (%rax)
xorl $0x1, %ecx
incq %rdi
jmp 0xf07a8
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-advfile.c
// Function: de_advfile_create
struct de_advfile *de_advfile_create(deark *c)
{
	struct de_advfile *advf = NULL;

	advf = de_malloc(c, sizeof(struct de_advfile));
	advf->c = c;
	advf->filename = ucstring_create(c);
	advf->mainfork.fi = de_finfo_create(c);
	advf->rsrcfork.fi = de_finfo_create(c);
	return advf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x98, %esi
callq 0xdecaf
movq %rax, %r14
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0xeac74
movq %rax, 0x68(%r14)
movq %rbx, %rdi
callq 0xdfd1a
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0xdfd1a
movq %rax, 0x48(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-advfile.c
// Function: de_advfile_destroy
void de_advfile_destroy(struct de_advfile *advf)
{
	deark *c;

	if(!advf) return;
	c = advf->c;
	ucstring_destroy(advf->filename);
	de_finfo_destroy(c, advf->mainfork.fi);
	de_finfo_destroy(c, advf->rsrcfork.fi);
	de_free(c, advf->orig_filename);
	de_free(c, advf);
}

// Assembly:
testq %rdi, %rdi
je 0xf0863
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x68(%rdi), %rdi
callq 0xeaf3c
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xdfd24
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0xdfd24
movq 0x88(%rbx), %rsi
movq %r14, %rdi
callq 0xded32
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-advfile.c
// Function: de_advfile_set_orig_filename
void de_advfile_set_orig_filename(struct de_advfile *advf, const char *fn, size_t fnlen)
{
	deark *c = advf->c;

	if(advf->orig_filename) {
		de_free(c, advf->orig_filename);
		advf->orig_filename = NULL;
	}

	if(fnlen<1) return;
	advf->orig_filename_len = fnlen;
	if(advf->orig_filename_len>1024)
		advf->orig_filename_len = 1024;
	advf->orig_filename = de_malloc(c, advf->orig_filename_len);
	de_memcpy(advf->orig_filename, fn, advf->orig_filename_len);

	if(advf->orig_filename[0]<32) {
		// This is to ensure that our applesd module won't incorrectly guess that
		// this is a Pascal string.
		advf->orig_filename[0] = '_';
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x88(%rdi), %rsi
testq %rsi, %rsi
je 0xf0894
movq %r15, %rdi
callq 0xded32
andq $0x0, 0x88(%rbx)
testq %r12, %r12
je 0xf08dc
movl $0x400, %esi            # imm = 0x400
cmpq %rsi, %r12
cmovbq %r12, %rsi
movq %rsi, 0x80(%rbx)
movq %r15, %rdi
callq 0xdecaf
movq %rax, 0x88(%rbx)
movq 0x80(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x181e0
movq 0x88(%rbx), %rax
cmpb $0x1f, (%rax)
ja 0xf08dc
movb $0x5f, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_create_md
struct de_arch_member_data *de_arch_create_md(deark *c, de_arch_lctx *d)
{
	struct de_arch_member_data *md;

	md = de_malloc(c, sizeof(struct de_arch_member_data));
	md->c = c;
	md->d = d;
	md->filename = ucstring_create(c);
	md->name_for_msgs = ucstring_create(c);
	md->fi = de_finfo_create(c);
	return md;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0xc8, %esi
callq 0xdecaf
movq %rax, %r15
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, %rdi
callq 0xeac74
movq %rax, 0x58(%r15)
movq %r14, %rdi
callq 0xeac74
movq %rax, 0x60(%r15)
movq %r14, %rdi
callq 0xdfd1a
movq %rax, 0x50(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_destroy_md
void de_arch_destroy_md(deark *c, struct de_arch_member_data *md)
{
	if(!md) return;
	ucstring_destroy(md->filename);
	ucstring_destroy(md->name_for_msgs);
	ucstring_destroy(md->tmpfn_base);
	ucstring_destroy(md->tmpfn_path);
	de_finfo_destroy(c, md->fi);
	de_free(c, md);
}

// Assembly:
testq %rsi, %rsi
je 0xf16cd
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rsi), %rdi
callq 0xeaf3c
movq 0x60(%rbx), %rdi
callq 0xeaf3c
movq 0x68(%rbx), %rdi
callq 0xeaf3c
movq 0x70(%rbx), %rdi
callq 0xeaf3c
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xdfd24
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_create_lctx
de_arch_lctx *de_arch_create_lctx(deark *c)
{
	de_arch_lctx *d;

	d = de_malloc(c, sizeof(de_arch_lctx));
	d->c = c;
	d->inf = c->infile;
	return d;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x70
popq %rsi
callq 0xdecaf
movq %rbx, (%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_fixup_path
void de_arch_fixup_path(de_ucstring *s, UI flags)
{
	i64 i;

	for(i=0; i<s->len; i++) {
		if(s->str[i]=='\\') {
			s->str[i] = '/';
		}
	}

	if(s->len>0 && (flags & 0x1)) {
		if(s->str[s->len-1]!='/') {
			ucstring_append_char(s, '/');
		}
	}
}

// Assembly:
movq 0x10(%rdi), %rax
xorl %ecx, %ecx
testq %rax, %rax
movl $0x0, %edx
cmovgq %rax, %rdx
cmpq %rcx, %rdx
je 0xf1741
movq 0x8(%rdi), %r8
cmpl $0x5c, (%r8,%rcx,4)
jne 0xf173c
movl $0x2f, (%r8,%rcx,4)
incq %rcx
jmp 0xf1724
testq %rax, %rax
setle %cl
testb $0x1, %sil
sete %dl
orb %cl, %dl
jne 0xf175d
movq 0x8(%rdi), %rcx
cmpl $0x2f, -0x4(%rcx,%rax,4)
jne 0xf175e
retq
pushq $0x2f
popq %rsi
jmp 0xeada5
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_read_field_orig_len_p
void de_arch_read_field_orig_len_p(struct de_arch_member_data *md, i64 *ppos)
{
	i64 n;

	n = dbuf_getu32x(md->d->inf, *ppos, md->d->is_le);
	*ppos += 4;
	handle_field_orig_len(md, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rsi), %rsi
movl 0x10(%rax), %edx
callq 0xe41cb
addq $0x4, (%rbx)
movq %rax, 0x38(%r14)
movb $0x1, 0x4c(%r14)
movq (%r14), %rdi
leaq 0x19962(%rip), %rsi     # 0x10b0fc
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_read_field_cmpr_len_p
void de_arch_read_field_cmpr_len_p(struct de_arch_member_data *md, i64 *ppos)
{
	i64 n;

	n = dbuf_getu32x(md->d->inf, *ppos, md->d->is_le);
	*ppos += 4;
	handle_field_cmpr_len(md, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rsi), %rsi
movl 0x10(%rax), %edx
callq 0xe41cb
addq $0x4, (%rbx)
movq %rax, 0x30(%r14)
movq (%r14), %rdi
leaq 0x1faed(%rip), %rsi     # 0x1112c7
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde896
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_handle_field_dos_attr
void de_arch_handle_field_dos_attr(struct de_arch_member_data *md, UI attr)
{
	de_ucstring *descr = NULL;

	md->dos_attribs = attr;
	md->has_dos_attribs = 1;
	descr = ucstring_create(md->c);
	de_describe_dos_attribs(md->c, md->dos_attribs, descr, 0);
	de_dbg(md->c, "DOS attribs: 0x%02x (%s)", md->dos_attribs, ucstring_getpsz_d(descr));
	ucstring_destroy(descr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x7c(%rdi)
movb $0x1, 0x81(%rdi)
movq (%rdi), %rdi
callq 0xeac74
movq %rax, %r14
movq (%rbx), %rdi
movl 0x7c(%rbx), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xe0298
movq (%rbx), %r15
movl 0x7c(%rbx), %ebx
movq %r14, %rdi
callq 0xeb877
leaq 0x44c4b(%rip), %rsi     # 0x136478
movq %r15, %rdi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: de_arch_good_cmpr_data_pos
int de_arch_good_cmpr_data_pos(struct de_arch_member_data *md)
{
	if(md->cmpr_pos<0 || md->cmpr_len<0 ||
		md->cmpr_pos+md->cmpr_len > md->d->inf->len)
	{
		ensure_name_for_msgs_is_set(md);
		de_err(md->c, "%s: Data goes beyond end of file",
			ucstring_getpsz_d(md->name_for_msgs));
		return 0;
	}
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
js 0xf19ff
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
js 0xf19ff
addq %rax, %rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rax), %rcx
jle 0xf1a33
movq %rbx, %rdi
callq 0xf1a38
movq (%rbx), %r14
movq 0x60(%rbx), %rdi
callq 0xeb877
leaq 0x16153(%rip), %rsi     # 0x107b6d
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdf2a5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %rbx
jmp 0xf1a29
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-arch.c
// Function: ensure_name_for_msgs_is_set
static void ensure_name_for_msgs_is_set(struct de_arch_member_data *md)
{
	if(md->name_for_msgs_flag) return;

	if(ucstring_isnonempty(md->filename)) {
		ucstring_empty(md->name_for_msgs);
		ucstring_append_ucstring(md->name_for_msgs, md->filename);
	}
	else {
		if(ucstring_isempty(md->name_for_msgs)) {
			ucstring_append_sz(md->name_for_msgs, "(unknown filename)", DE_ENCODING_LATIN1);
		}
	}
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x4d(%rdi)
je 0xf1a41
popq %rbx
retq
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0xeaf8a
movq 0x60(%rbx), %rdi
testl %eax, %eax
je 0xf1a68
callq 0xeac85
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0xead71
callq 0xeaf76
testl %eax, %eax
je 0xf1a3f
movq 0x60(%rbx), %rdi
leaq 0x4bfe3(%rip), %rsi     # 0x13da5f
pushq $0x5
popq %rdx
popq %rbx
jmp 0xeae42
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/ozunreduce.h
// Function: ozur_flush
static void ozur_flush(ozur_ctx *ozur)
{
	size_t ret;
	size_t n;

	if(ozur->error_code) return;
	n = ozur->circbuf_pos;
	if(n<1 || n>OZUR_CIRCBUF_SIZE) return;
	ret = ozur->cb_write(ozur, ozur->circbuf, n);
	if(ret != n) {
		ozur_set_error(ozur, OZUR_ERRCODE_WRITE_FAILED);
		return;
	}
	ozur->uncmpr_nbytes_written += (OZUR_OFF_T)ret;
}

// Assembly:
cmpl $0x0, 0x38(%rdi)
je 0xf217d
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2278(%rdi), %r14
leaq -0x1001(%r14), %rax
cmpq $-0x1000, %rax          # imm = 0xF000
jb 0xf21c2
leaq 0x2280(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x28(%rbx)
cmpq %r14, %rax
jne 0xf21b5
addq %r14, 0x40(%rbx)
jmp 0xf21c2
cmpl $0x0, 0x38(%rbx)
jne 0xf21c2
movl $0x7, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/ozunreduce.h
// Function: ozur_bitreader_getbits
static OZUR_UINT8 ozur_bitreader_getbits(ozur_ctx *ozur, unsigned int nbits)
{
	OZUR_UINT8 n;

	if(nbits<1 || nbits>8) return 0;

	if(ozur->bitreader_nbits_in_buf < nbits) {
		OZUR_UINT8 b;

		b = ozur_nextbyte(ozur);
		if(ozur->error_code) return 0;
		ozur->bitreader_buf |= ((unsigned int)b)<<ozur->bitreader_nbits_in_buf;
		ozur->bitreader_nbits_in_buf += 8;
	}

	n = (OZUR_UINT8)(ozur->bitreader_buf & (0xff >> (8-nbits)));
	ozur->bitreader_buf >>= nbits;
	ozur->bitreader_nbits_in_buf -= nbits;
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leal -0x9(%r14), %eax
cmpl $-0x8, %eax
jb 0xf22de
movq %rdi, %rbx
movl 0x64(%rdi), %edx
cmpl %r14d, %edx
jae 0xf2277
cmpl $0x0, 0x38(%rbx)
jne 0xf22de
movq 0x10(%rbx), %r15
cmpq %r15, 0x48(%rbx)
jge 0xf2298
movq 0x3280(%rbx), %rcx
xorl %eax, %eax
cmpq 0x3288(%rbx), %rcx
jb 0xf22bc
leaq 0x3280(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
subq 0x50(%rbx), %r15
movl $0x400, %eax            # imm = 0x400
cmpq %rax, %r15
cmovgeq %rax, %r15
leaq -0x401(%r15), %rcx
xorl %ebp, %ebp
movl $0x0, %eax
cmpq $-0x400, %rcx           # imm = 0xFC00
jb 0xf22b2
leaq 0x3290(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x20(%rbx)
cmpq %r15, %rax
jne 0xf22a1
addq %r15, 0x50(%rbx)
movq %r15, 0x3288(%rbx)
movl 0x38(%rbx), %eax
jmp 0xf22bc
movl 0x60(%rbx), %ebp
movb $0x8, %cl
subb %r14b, %cl
movl $0xff, %eax
shrl %cl, %eax
andl %ebp, %eax
movl %r14d, %ecx
shrl %cl, %ebp
movl %ebp, 0x60(%rbx)
subl %r14d, %edx
movl %edx, 0x64(%rbx)
jmp 0xf22e0
movl $0x8, 0x38(%rbx)
jmp 0xf22de
movl 0x38(%rbx), %eax
testl %eax, %eax
jne 0xf22b2
movl $0x6, 0x38(%rbx)
pushq $0x6
popq %rax
cmpq $0x0, 0x3288(%rbx)
je 0xf22da
movq 0x3280(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x3280(%rbx)
movzbl 0x3290(%rbx,%rcx), %ebp
incq 0x48(%rbx)
testl %eax, %eax
je 0xf22eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x64(%rbx), %edx
movl %edx, %ecx
shll %cl, %ebp
orl 0x60(%rbx), %ebp
addl $0x8, %edx
jmp 0xf227a
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/ozunreduce.h
// Function: ozur_emit_byte
static void ozur_emit_byte(ozur_ctx *ozur, OZUR_UINT8 x)
{
	ozur->circbuf[ozur->circbuf_pos++] = x;
	if(ozur->circbuf_pos >= OZUR_CIRCBUF_SIZE) {
		ozur_flush(ozur);
		ozur->circbuf_pos = 0;
	}
	ozur->uncmpr_nbytes_emitted++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2278(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2278(%rdi)
movb %sil, 0x2280(%rdi,%rax)
cmpq $0x1000, 0x2278(%rdi) # imm = 0x1000
jb 0xf2335
movq %rbx, %rdi
callq 0xf2176
andq $0x0, 0x2278(%rbx)
incq 0x58(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-fax.c
// Function: init_fax34_bitreader
static void init_fax34_bitreader(deark *c, struct fax_ctx *fc)
{
	de_zeromem(&fc->bitrd, sizeof(struct de_bitreader));
	fc->bitrd.f = fc->dcmpri->f;
	fc->bitrd.curpos = fc->dcmpri->pos;
	fc->bitrd.endpos = fc->dcmpri->pos + fc->dcmpri->len;
	fc->bitrd.bbll.is_lsb = fc->fax34params->is_lsb;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x48(%rdi)
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq (%rax), %rdx
movq %rdx, 0x48(%rdi)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rdi)
addq 0x10(%rax), %rdx
movq %rdx, 0x58(%rdi)
movb 0x1c(%rcx), %al
movb %al, 0x68(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-fax.c
// Function: fax34_on_eol
static void fax34_on_eol(deark *c, struct fax_ctx *fc, int is_real)
{
	i64 i;

	de_dbg3(c, "%sEOL", is_real?"":"implicit ");

	if(fc->ypos >= fc->image_height) goto done;

	// [Pack curr_row into bits (tmp_row_packed)]
	de_zeromem(fc->tmp_row_packed, (size_t)fc->rowspan_final);
	for(i=0; i<fc->image_width; i++) {
		if(fc->curr_row[i]) {
			fc->tmp_row_packed[i/8] |= 1U<<(7-i%8);
		}
	}

	// [Write tmp_row_packed to fc->dcmpro]
	dbuf_write(fc->dcmpro->f, fc->tmp_row_packed, fc->rowspan_final);
	fc->nbytes_written += fc->rowspan_final;

	if(fc->is_2d) {
		de_memcpy(fc->prev_row, fc->curr_row, (size_t)fc->image_width);
	}

	// initialize curr_row
	de_zeromem(fc->curr_row, (size_t)fc->image_width);

	fc->ypos++;
done:
	fc->a0 = -1;
	fc->a0_color = 0;
	fc->pending_run_len = 0;
	fc->f2d_h_codes_remaining = 0;
	fc->have_read_tag_bit = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
leaq 0x4b17d(%rip), %rax     # 0x13dcc1
leaq 0x45115(%rip), %rdx     # 0x137c60
cmoveq %rax, %rdx
leaq 0x4b165(%rip), %rsi     # 0x13dcbb
xorl %eax, %eax
callq 0xdea83
movq 0xa8(%rbx), %rax
cmpq 0x38(%rbx), %rax
jge 0xf2c0e
movq 0x88(%rbx), %rdx
movq 0x90(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x18140
cmpq 0x30(%rbx), %r14
jge 0xf2bb9
movq 0x78(%rbx), %rax
cmpb $0x0, (%rax,%r14)
je 0xf2bb4
movl %r14d, %ecx
notb %cl
andb $0x7, %cl
movb $0x1, %al
shlb %cl, %al
movq 0x90(%rbx), %rcx
movq %r14, %rdx
shrq $0x3, %rdx
orb %al, (%rcx,%rdx)
incq %r14
jmp 0xf2b86
movq 0x8(%rbx), %rax
movq 0x88(%rbx), %rdx
movq (%rax), %rdi
movq 0x90(%rbx), %rsi
callq 0xe46ba
movq 0x88(%rbx), %rax
addq %rax, 0x40(%rbx)
cmpb $0x0, 0x2a(%rbx)
je 0xf2bf8
movq 0x80(%rbx), %rdi
movq 0x30(%rbx), %rdx
movq 0x78(%rbx), %rsi
callq 0x181e0
movq 0x30(%rbx), %rdx
movq 0x78(%rbx), %rdi
xorl %esi, %esi
callq 0x18140
incq 0xa8(%rbx)
orq $-0x1, 0xb0(%rbx)
andw $0x0, 0xb8(%rbx)
andq $0x0, 0x98(%rbx)
andl $0x0, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-fax.c
// Function: find_b1
static void find_b1(struct fax_ctx *fc)
{
	i64 i;

	for(i=fc->a0+1; i<fc->image_width; i++) {
		if(i<0) continue;

		// first prev_row pixel to the right of a0, of opposite color to a0_color
		if(fc->prev_row[i]==fc->a0_color) continue;

		// Looking for a "changing element". I.e. if both it and the pixel to the left
		// exist, they must have different colors.
		if(i==0) {
			// Leftmost pixel is "changing" if it is black
			if(fc->prev_row[i]==0) continue;
		}
		else {
			if(fc->prev_row[i-1] == fc->prev_row[i]) continue;
		}

		fc->b1 = i;
		return;
	}
	fc->b1 = fc->image_width;
}

// Assembly:
movq 0x30(%rdi), %rax
movq 0xb0(%rdi), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rdx
jge 0xf2c8a
leaq -0x1(%rdx), %rsi
incq %rcx
cmpq $-0x1, %rsi
jl 0xf2c7d
movq 0x80(%rdi), %r8
movb (%r8,%rdx), %sil
cmpb 0xb8(%rdi), %sil
je 0xf2c7d
testq %rdx, %rdx
je 0xf2c78
cmpb %sil, -0x1(%r8,%rdx)
je 0xf2c7d
jmp 0xf2c82
testb %sil, %sil
jne 0xf2c87
incq %rdx
jmp 0xf2c44
movq %rdx, %rax
jmp 0xf2c8a
movq %rcx, %rax
movq %rax, 0xc0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-fax.c
// Function: fax34_record_run
static void fax34_record_run(deark *c, struct fax_ctx *fc, i64 run_len,
	int respect_negative_a0)
{
	i64 i;
	u8 color = fc->a0_color;

	de_dbg3(c, "run c=%u len=%d", (UI)color, (int)run_len);

	if(fc->a0<0) {
		if(respect_negative_a0) {
			run_len += fc->a0;
		}
		fc->a0 = 0;
	}

	if(color==0) { // Pixels are initialized to 0, don't need to set them.
		fc->a0 += run_len;
	}
	else {
		for(i=0; (i<run_len) && (fc->a0 < fc->image_width); i++) {
			fc->curr_row[fc->a0++] = color;
		}
	}

	if(fc->a0 > fc->image_width) {
		fc->a0 = fc->image_width;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movb 0xb8(%rsi), %r15b
movzbl %r15b, %edx
leaq 0x4b018(%rip), %rsi     # 0x13dccb
movl %r14d, %ecx
xorl %eax, %eax
callq 0xdea83
movq 0xb0(%rbx), %rax
testq %rax, %rax
jns 0xf2cde
xorl %ecx, %ecx
testl %ebp, %ebp
cmoveq %rcx, %rax
addq %rax, %r14
andq $0x0, 0xb0(%rbx)
xorl %eax, %eax
testb %r15b, %r15b
je 0xf2d14
xorl %ecx, %ecx
testq %r14, %r14
cmovgq %r14, %rcx
subq $0x1, %rcx
jb 0xf2d1e
cmpq 0x30(%rbx), %rax
jge 0xf2d1e
movq 0x78(%rbx), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0xb0(%rbx)
movb %r15b, (%rdx,%rax)
movq 0xb0(%rbx), %rax
jmp 0xf2cec
addq %r14, %rax
movq %rax, 0xb0(%rbx)
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
jle 0xf2d2e
movq %rcx, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-fax.c
// Function: fax34_finish_sync
static int fax34_finish_sync(deark *c, struct fax_ctx *fc, i64 max_bits_to_search,
	i64 *pnbits_read)
{
	i64 nbits_searched = 0;
	int retval = 0;

	while(1) {
		u64 n;

		if(nbits_searched >= max_bits_to_search) {
			goto done;
		}

		n = de_bitreader_getbits(&fc->bitrd, 1);
		if(fc->bitrd.eof_flag) goto done;
		nbits_searched++;
		if(n!=0) {
			retval = 1;
			goto done;
		}
	}
done:
	if(pnbits_read) *pnbits_read = nbits_searched;
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x48(%rdi), %r13
xorl %r15d, %r15d
testq %rsi, %rsi
cmovleq %r15, %rbx
pushq $0x1
popq %rbp
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0xf2d8c
movq %r13, %rdi
movl %ebp, %esi
callq 0xe6a4a
cmpb $0x0, 0x60(%r12)
jne 0xf2d89
incq %r14
testq %rax, %rax
je 0xf2d62
movq %r14, %rbx
movl %ebp, %r15d
jmp 0xf2d8c
movq %r14, %rbx
movq (%rsp), %rax
testq %rax, %rax
je 0xf2d98
movq %rbx, (%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: destroy_lzh_ctx
static void destroy_lzh_ctx(struct lzh_ctx *cctx)
{
	deark *c;

	if(!cctx) return;
	c = cctx->c;
	lzh_destroy_trees(cctx);
	if(cctx->ringbuf && !cctx->ringbuf_owned_by_caller) {
		de_lz77buffer_destroy(c, cctx->ringbuf);
		cctx->ringbuf = NULL;
	}
	if(cctx->crco) de_crcobj_destroy(cctx->crco);
	de_free(c, cctx);
}

// Assembly:
testq %rdi, %rdi
je 0xf38d8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
callq 0xf5e7a
movq 0x70(%rbx), %rsi
testq %rsi, %rsi
je 0xf38b5
cmpl $0x0, 0x78(%rbx)
jne 0xf38b5
movq %r14, %rdi
callq 0xef395
andq $0x0, 0x70(%rbx)
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0xf38c6
callq 0xe0e8d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: fmtutil_deflate_codectype1
void fmtutil_deflate_codectype1(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres,
	void *codec_private_params)
{
	struct de_deflate_params *deflparams = (struct de_deflate_params*)codec_private_params;
	int must_use_miniz = 0;
	int must_use_native = 0;

	if(!deflparams) return;

	if(deflparams->ringbuf_to_use || (deflparams->flags & DE_DEFLATEFLAG_DEFLATE64)) {
		must_use_native = 1;
	}

	if(must_use_miniz && must_use_native) return;

	if(must_use_miniz) {
		fmtutil_deflate_codectype1_miniz(c, dcmpri, dcmpro, dres, codec_private_params);
		return;
	}
	if(must_use_native) {
		fmtutil_deflate_codectype1_native(c, dcmpri, dcmpro, dres, codec_private_params);
		return;
	}

	if(c->deflate_decoder_id==0) {
		const char *o;

		o = de_get_ext_option(c, "deflatecodec");
		if(o && !de_strcmp(o, "native")) {
			c->deflate_decoder_id = 2;
		}
		else {
			c->deflate_decoder_id = 1;
		}
	}

	if(c->deflate_decoder_id==2) {
		fmtutil_deflate_codectype1_native(c, dcmpri, dcmpro, dres, codec_private_params);
	}
	else {
		fmtutil_deflate_codectype1_miniz(c, dcmpri, dcmpro, dres, codec_private_params);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %r8, %r8
je 0xf393d
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpq $0x0, 0x8(%r8)
jne 0xf3954
testb $0x4, (%rbx)
jne 0xf3954
movb 0x128(%r13), %al
testb %al, %al
jne 0xf3950
leaq 0x4a4ed(%rip), %rsi     # 0x13de06
movq %r13, %rdi
callq 0xdfa87
testq %rax, %rax
je 0xf3939
leaq 0x4a6e9(%rip), %rsi     # 0x13e016
movq %rax, %rdi
callq 0x181a0
testl %eax, %eax
je 0xf3947
movb $0x1, %al
jmp 0xf3949
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x2, %al
movb %al, 0x128(%r13)
cmpb $0x2, %al
jne 0xf396e
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf398b
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x100b89
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: fmtutil_decompress_deflate
int fmtutil_decompress_deflate(dbuf *inf, i64 inputstart, i64 inputsize, dbuf *outf,
	i64 maxuncmprsize, i64 *bytes_consumed, unsigned int flags)
{
	deark *c = inf->c;
	struct de_dfilter_results dres;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_deflate_params deflparams;

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	if(bytes_consumed) *bytes_consumed = 0;

	dcmpri.f = inf;
	dcmpri.pos = inputstart;
	dcmpri.len = inputsize;

	dcmpro.f = outf;
	if(flags & DE_DEFLATEFLAG_USEMAXUNCMPRSIZE) {
		dcmpro.len_known = 1;
		dcmpro.expected_len = maxuncmprsize;
		flags -= DE_DEFLATEFLAG_USEMAXUNCMPRSIZE;
	}

	de_zeromem(&deflparams, sizeof(struct de_deflate_params));
	deflparams.flags = flags;
	fmtutil_deflate_codectype1(c, &dcmpri, &dcmpro, &dres, (void*)&deflparams);

	if(bytes_consumed && dres.bytes_consumed_valid) {
		*bytes_consumed = dres.bytes_consumed;
	}

	if(dres.errcode != 0) {
		de_err(c, "%s", de_dfilter_get_errmsg(c, &dres));
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r14
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movl 0x100(%rsp), %r12d
movq 0x8(%rdi), %rbx
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
callq 0xee7ee
testq %r14, %r14
je 0xf468b
andq $0x0, (%r14)
movq %r15, 0x30(%rsp)
movq %rbp, 0x38(%rsp)
movq %r13, 0x40(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x2, %r12b
je 0xf46bd
movb $0x1, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
addl $-0x2, %r12d
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movl %r12d, (%r8)
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
callq 0xf38de
testq %r14, %r14
je 0xf46f7
cmpb $0x0, 0x6c(%rsp)
je 0xf46f7
movq 0x70(%rsp), %rax
movq %rax, (%r14)
cmpl $0x0, 0x68(%rsp)
je 0xf4723
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0xee7bc
leaq 0x135ed(%rip), %rsi     # 0x107cff
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdf2a5
jmp 0xf4726
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: lzh_lz77buf_writebytecb
static void lzh_lz77buf_writebytecb(struct de_lz77buffer *rb, u8 n)
{
	struct lzh_ctx *cctx = (struct lzh_ctx*)rb->userdata;

	if(lzh_have_enough_output(cctx)) {
		return;
	}
	dbuf_writebyte(cctx->dcmpro->f, n);
	if(cctx->crco) lzh_update_crc(cctx, n);
	cctx->nbytes_written++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0xf5ddd
testl %eax, %eax
jne 0xf52d1
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movzbl %bpl, %ebp
movl %ebp, %esi
callq 0xe5bc5
cmpq $0x0, 0xc0(%rbx)
je 0xf52cd
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf61c6
incq 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: lzh_lz77buf_writebytecb_flagerrors
static void lzh_lz77buf_writebytecb_flagerrors(struct de_lz77buffer *rb, u8 n)
{
	struct lzh_ctx *cctx = (struct lzh_ctx*)rb->userdata;

	if(lzh_have_enough_output(cctx)) {
		cctx->err_flag = 1;
		return;
	}
	dbuf_writebyte(cctx->dcmpro->f, n);
	if(cctx->crco) lzh_update_crc(cctx, n);
	cctx->nbytes_written++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0xf5ddd
testl %eax, %eax
je 0xf5650
movl $0x1, 0x30(%rbx)
jmp 0xf567a
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movzbl %bpl, %ebp
movl %ebp, %esi
callq 0xe5bc5
cmpq $0x0, 0xc0(%rbx)
je 0xf5676
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf61c6
incq 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: mash_lz77buf_writebytecb
static void mash_lz77buf_writebytecb(struct de_lz77buffer *rb, u8 n)
{
	struct lzh_ctx *cctx = (struct lzh_ctx*)rb->userdata;

	if(lzh_have_enough_output(cctx)) {
		// This ought to be an error, but in practice there's often an extra
		// decompressed byte that we have to ignore.
		return;
	}
	dbuf_writebyte(cctx->dcmpro->f, n);
	cctx->nbytes_written++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0xf5ddd
testl %eax, %eax
jne 0xf58ef
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movzbl %bpl, %esi
callq 0xe5bc5
incq 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: read_next_code_using_tree
static UI read_next_code_using_tree(struct lzh_ctx *cctx, struct lzh_tree_wrapper *tree)
{
	fmtutil_huffman_valtype val = 0;
	UI bitcount = 0;
	int ret;

	if(!tree->ht) {
		return 0;
	}

	ret = fmtutil_huffman_read_next_value(tree->ht->bk, &cctx->bitrd, &val, &bitcount);
	if(cctx->bitrd.eof_flag) {
		de_dfilter_set_errorf(cctx->c, cctx->dres, cctx->modname,
			"Unexpected end of compressed data");
		lzh_set_err_flag(cctx);
		val = 0;
		goto done;
	}
	else if(!ret) {
		de_dfilter_set_errorf(cctx->c, cctx->dres, cctx->modname,
			"Huffman decoding error");
		lzh_set_err_flag(cctx);
		val = 0;
		goto done;
	}

done:
	return (UI)val;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
andl $0x0, (%rsp)
andl $0x0, 0x4(%rsp)
movq (%rsi), %rax
testq %rax, %rax
je 0xf5e52
movq %rdi, %rbx
movq 0x8(%rax), %rdi
leaq 0x38(%rbx), %rsi
movq %rsp, %rdx
leaq 0x4(%rsp), %rcx
callq 0xf8071
cmpb $0x0, 0x50(%rbx)
je 0xf5e56
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1b32a(%rip), %rcx     # 0x111166
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xee823
movb $0x1, 0x50(%rbx)
movl $0x1, 0x30(%rbx)
jmp 0xf5e5d
xorl %ebp, %ebp
jmp 0xf5e5d
testl %eax, %eax
je 0xf5e66
movl (%rsp), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1b310(%rip), %rcx     # 0x111188
jmp 0xf5e3c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: lzh_destroy_trees
static void lzh_destroy_trees(struct lzh_ctx *cctx)
{
	if(cctx->meta_tree.ht) {
		fmtutil_huffman_destroy_decoder(cctx->c, cctx->meta_tree.ht);
		cctx->meta_tree.ht = NULL;
	}
	if(cctx->literals_tree.ht) {
		fmtutil_huffman_destroy_decoder(cctx->c, cctx->literals_tree.ht);
		cctx->literals_tree.ht = NULL;
	}
	if(cctx->offsets_tree.ht) {
		fmtutil_huffman_destroy_decoder(cctx->c, cctx->offsets_tree.ht);
		cctx->offsets_tree.ht = NULL;
	}
	if(cctx->matchlengths_tree.ht) {
		fmtutil_huffman_destroy_decoder(cctx->c, cctx->matchlengths_tree.ht);
		cctx->matchlengths_tree.ht = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
testq %rsi, %rsi
je 0xf5e9a
movq (%rbx), %rdi
callq 0xf86b0
andq $0x0, 0x90(%rbx)
movq 0x98(%rbx), %rsi
testq %rsi, %rsi
je 0xf5eb6
movq (%rbx), %rdi
callq 0xf86b0
andq $0x0, 0x98(%rbx)
movq 0xa0(%rbx), %rsi
testq %rsi, %rsi
je 0xf5ed2
movq (%rbx), %rdi
callq 0xf86b0
andq $0x0, 0xa0(%rbx)
movq 0xa8(%rbx), %rsi
testq %rsi, %rsi
je 0xf5eee
movq (%rbx), %rdi
callq 0xf86b0
andq $0x0, 0xa8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-lzh.c
// Function: lh5x_read_a_code_length
static UI lh5x_read_a_code_length(struct lzh_ctx *cctx)
{
	UI n;

	n = (UI)lzh_getbits(cctx, 3);
	if(n==7) {
		while(1) {
			UI b;

			b = (UI)lzh_getbits(cctx, 1);
			if(cctx->bitrd.eof_flag) break;
			if(b==0) break;
			n++;
			// TODO: What is the length limit?
			if(n>FMTUTIL_HUFFMAN_MAX_CODE_LENGTH) {
				lzh_set_err_flag(cctx);
				return FMTUTIL_HUFFMAN_MAX_CODE_LENGTH;
			}
		}
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0xe6a4a
movq %rax, %r14
cmpl $0x7, %r14d
jne 0xf5f48
pushq $0x7
popq %r14
pushq $0x1
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0xe6a4a
cmpb $0x0, 0x50(%rbx)
jne 0xf5f48
movl %eax, %eax
testq %rax, %rax
je 0xf5f48
incl %r14d
cmpl $0x31, %r14d
jne 0xf5f19
movb $0x1, 0x50(%rbx)
movl $0x1, 0x30(%rbx)
pushq $0x30
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq