LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_cus_p
i64 fmtutil_hlp_get_cus_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;

	x1 = (i64)dbuf_getbyte_p(f, ppos);
	if(x1%2 == 0) {
		// If it's even, divide by two.
		return x1>>1;
	}
	// If it's odd, divide by two, and add 128 times the value of
	// the next byte.
	x2 = (i64)dbuf_getbyte_p(f, ppos);
	return (x1>>1) | (x2<<7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x176115
movq -0x20(%rbp), %rax
sarq %rax
movq %rax, -0x8(%rbp)
jmp 0x17613f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
sarq %rax
movq -0x28(%rbp), %rcx
shlq $0x7, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_css_p
i64 fmtutil_hlp_get_css_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;

	x1 = (i64)dbuf_getbyte_p(f, ppos);
	if(x1%2 == 0) {
		// If it's even, divide by two, and subtract 64
		return (x1>>1) - 64;
	}
	// If it's odd, divide by two, add 128 times the value of
	// the next byte, and subtract 16384.
	x1 >>= 1;
	x2 = (i64)dbuf_getbyte_p(f, ppos);
	x1 += x2 * 128;
	x1 -= 16384;
	return x1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x176199
movq -0x20(%rbp), %rax
sarq %rax
subq $0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0x1761de
movq -0x20(%rbp), %rax
sarq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0x7, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x4000, %rax           # imm = 0x4000
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_cul_p
i64 fmtutil_hlp_get_cul_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;
	x1 = dbuf_getu16le_p(f, ppos);
	if(x1%2 == 0) {
		// If it's even, divide by two.
		return x1>>1;
	}
	// If it's odd, divide by two, and add 32768 times the value of
	// the next two bytes.
	x2 = dbuf_getu16le_p(f, ppos);
	return (x1>>1) | (x2<<15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x176232
movq -0x20(%rbp), %rax
sarq %rax
movq %rax, -0x8(%rbp)
jmp 0x176259
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
sarq %rax
movq -0x28(%rbp), %rcx
shlq $0xf, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_hlp_get_csl_p
i64 fmtutil_hlp_get_csl_p(dbuf *f, i64 *ppos)
{
	i64 x1, x2;

	x1 = dbuf_getu16le_p(f, ppos);

	if(x1%2 == 0) {
		// If it's even, divide by two, and subtract 16384
		return (x1>>1) - 16384;
	}
	// If it's odd, divide by two, add 32768 times the value of
	// the next two bytes, and subtract 67108864.
	x1 >>= 1;
	x2 = dbuf_getu16le_p(f, ppos);
	x1 += x2*32768;
	x1 -= 67108864;
	return x1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x1762b8
movq -0x20(%rbp), %rax
sarq %rax
subq $0x4000, %rax           # imm = 0x4000
movq %rax, -0x8(%rbp)
jmp 0x1762fa
movq -0x20(%rbp), %rax
sarq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0xf, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x4000000, %rax        # imm = 0x4000000
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_scan_for_arj_data
int fmtutil_scan_for_arj_data(dbuf *f, i64 startpos, i64 max_skip,
	UI flags, i64 *pfoundpos)
{
	struct de_crcobj *crco = NULL;
	i64 curpos, endpos;
	int retval = 0;

	curpos = startpos;
	endpos = startpos + max_skip + 2; // Search space includes the 2-byte signature
	if(endpos-2 > f->len-ARJ_MIN_FILE_SIZE) endpos = (f->len-ARJ_MIN_FILE_SIZE)+2;

	while(curpos<=(endpos-2)) {
		int ret;

		ret = dbuf_search(f, (const u8*)"\x60\xea", 2, curpos, endpos-curpos,
			pfoundpos);
		if(!ret) goto done;

		if(crco) {
			de_crcobj_reset(crco);
		}
		else {
			crco = de_crcobj_create(f->c, DE_CRCOBJ_CRC32_IEEE);
		}
		if(is_arj_data_at1(f, *pfoundpos, crco)) {
			retval = 1;
			goto done;
		}
		curpos = *pfoundpos+2; // Continue the search here
	}

done:
	de_crcobj_destroy(crco);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
subq $0x2, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x54, %rcx
cmpq %rcx, %rax
jle 0x17637f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x54, %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0x176381
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jg 0x176424
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
subq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x2d930(%rip), %rsi     # 0x1a3ce1
movl $0x2, %edx
callq 0x169370
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0x1763c6
jmp 0x176426
cmpq $0x0, -0x30(%rbp)
je 0x1763d8
movq -0x30(%rbp), %rdi
callq 0x15f250
jmp 0x1763ee
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x10, %esi
callq 0x15eac0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x176440
cmpl $0x0, %eax
je 0x176410
movl $0x1, -0x44(%rbp)
jmp 0x176426
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
jmp 0x176381
jmp 0x176426
movq -0x30(%rbp), %rdi
callq 0x15f2e0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: is_arj_data_at1
static int is_arj_data_at1(dbuf *f, i64 pos1, struct de_crcobj *crco)
{
	i64 basic_hdr_size;
	int retval = 0;
	u32 crc_calc, crc_reported;

	basic_hdr_size = dbuf_getu16le(f, pos1+2);
	if(basic_hdr_size>ARJ_MAX_BASIC_HEADER_SIZE || basic_hdr_size<ARJ_MIN_BASIC_HEADER_SIZE) goto done;
	if(dbuf_getbyte(f, pos1+10) != 2) goto done; // "file type"
	de_crcobj_addslice(crco, f, pos1+4, basic_hdr_size);
	crc_calc = de_crcobj_getval(crco);
	crc_reported = (u32)dbuf_getu32le(f, pos1+4+basic_hdr_size);
	if(crc_calc!=crc_reported) goto done;
	retval = 1;

done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
cmpq $0xa28, -0x20(%rbp)     # imm = 0xA28
jg 0x176481
cmpq $0x1e, -0x20(%rbp)
jge 0x176483
jmp 0x1764ec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa, %rsi
callq 0x165060
movzbl %al, %eax
cmpl $0x2, %eax
je 0x17649e
jmp 0x1764ec
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
movq -0x20(%rbp), %rcx
callq 0x15f500
movq -0x18(%rbp), %rdi
callq 0x15f340
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
addq -0x20(%rbp), %rsi
callq 0x165540
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x1764e5
jmp 0x1764ec
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_get_std_jpeg_qtable
void fmtutil_get_std_jpeg_qtable(UI tbl_id, u8 tbl[64])
{
	const u8 *src_tbl;

	switch(tbl_id) {
	case 0:
		src_tbl = example_dqt_data0;
		break;
	case 1:
		src_tbl = example_dqt_data1;
		break;
	default:
		de_zeromem(tbl, 64);
		return;
	}
	de_memcpy(tbl, src_tbl, 64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x176525
jmp 0x17651b
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x176532
jmp 0x17653f
leaq 0x5f674(%rip), %rax     # 0x1d5ba0
movq %rax, -0x18(%rbp)
jmp 0x176551
leaq 0x5f6a7(%rip), %rax     # 0x1d5be0
movq %rax, -0x18(%rbp)
jmp 0x176551
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x19140
jmp 0x176563
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x191e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtutil_write_std_jpeg_dht
void fmtutil_write_std_jpeg_dht(dbuf *outf, UI tbl_id)
{
	const u8 *tbl_data;
	UI tbl_len;

	switch(tbl_id) {
	case 0:
		tbl_data = jpegtbl_dht0;
		tbl_len = 16+12;
		break;
	case 1:
		tbl_data = jpegtbl_dht1;
		tbl_len = 16+162;
		break;
	case 2:
		tbl_data = jpegtbl_dht2;
		tbl_len = 16+12;
		break;
	case 3:
		tbl_data = jpegtbl_dht3;
		tbl_len = 16+162;
		break;
	default:
		return;
	}

	dbuf_write(outf, tbl_data, tbl_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x1765f0
movq -0x28(%rbp), %rax
leaq 0x5f5e5(%rip), %rcx     # 0x1d5b7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5f679(%rip), %rax     # 0x1d5c20
movq %rax, -0x18(%rbp)
movl $0x1c, -0x1c(%rbp)
jmp 0x1765f2
leaq 0x5f685(%rip), %rax     # 0x1d5c40
movq %rax, -0x18(%rbp)
movl $0xb2, -0x1c(%rbp)
jmp 0x1765f2
leaq 0x5f731(%rip), %rax     # 0x1d5d00
movq %rax, -0x18(%rbp)
movl $0x1c, -0x1c(%rbp)
jmp 0x1765f2
leaq 0x5f73d(%rip), %rax     # 0x1d5d20
movq %rax, -0x18(%rbp)
movl $0xb2, -0x1c(%rbp)
jmp 0x1765f2
jmp 0x176604
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x166170
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: fmtid_is_dll
static int fmtid_is_dll(deark *c, struct fmtutil_fmtid_ctx *idctx)
{
	int retval = 0;
	dbuf *tmpf = NULL;
	struct fmtutil_exe_info *ei = NULL;

	if(!idctx->inf) goto done;
	if(de_getu32le_direct(&idctx->bof64bytes[60]) == 0) goto done;

	tmpf = dbuf_open_input_subfile(idctx->inf, idctx->inf_pos, idctx->inf_len);
	ei = de_malloc(c, sizeof(struct fmtutil_exe_info));
	fmtutil_collect_exe_info(c, tmpf, ei);
	if(ei->is_dll) {
		retval = 1;
	}

done:
	de_free(c, ei);
	dbuf_close(tmpf);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x176cf4
jmp 0x176d64
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
addq $0x3c, %rdi
callq 0x165500
cmpq $0x0, %rax
jne 0x176d0d
jmp 0x176d64
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1691b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0xf0, %esi
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x188930
movq -0x28(%rbp), %rax
cmpb $0x0, 0x63(%rax)
je 0x176d62
movl $0x1, -0x14(%rbp)
jmp 0x176d64
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
movq -0x20(%rbp), %rdi
callq 0x1676a0
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil.c
// Function: spectrum512_FindIndex
static unsigned int spectrum512_FindIndex(i64 x, unsigned int c)
{
	i64 x1;

	x1 = 10 * (i64)c;

	if (c & 1)  /* If c is odd */
		x1 = x1 - 5;
	else        /* If c is even */
		x1 = x1 + 1;

	if (x >= x1 && x < x1+160)
		c = c + 16;
	else if (x >= x1+160)
		c = c + 32;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
imulq $0xa, %rax, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1772ff
movq -0x18(%rbp), %rax
subq $0x5, %rax
movq %rax, -0x18(%rbp)
jmp 0x17730b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jl 0x177334
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0xa0, %rcx
cmpq %rcx, %rax
jge 0x177334
movl -0xc(%rbp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rbp)
jmp 0x177353
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0xa0, %rcx
cmpq %rcx, %rax
jl 0x177351
movl -0xc(%rbp), %eax
addl $0x20, %eax
movl %eax, -0xc(%rbp)
jmp 0x177353
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_get_errmsg
const char *de_dfilter_get_errmsg(deark *c, struct de_dfilter_results *dres)
{
	if(dres->errcode==0) {
		return "No error";
	}
	if(dres->errmsg[0]) {
		return dres->errmsg;
	}
	return "Unspecified error";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x177382
leaq 0x5f1d0(%rip), %rax     # 0x1d654c
movq %rax, -0x8(%rbp)
jmp 0x1773a5
movq -0x18(%rbp), %rax
cmpb $0x0, 0x10(%rax)
je 0x17739a
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x1773a5
leaq 0x5f1b4(%rip), %rax     # 0x1d6555
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_results_clear
void de_dfilter_results_clear(deark *c, struct de_dfilter_results *dres)
{
	dres->errcode = 0;
	dres->bytes_consumed_valid = 0;
	dres->bytes_consumed = 0;
	dres->errmsg[0] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_init_objects
void de_dfilter_init_objects(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	if(dcmpri)
		de_zeromem(dcmpri, sizeof(struct de_dfilter_in_params));
	if(dcmpro)
		de_zeromem(dcmpro, sizeof(struct de_dfilter_out_params));
	if(dres)
		de_dfilter_results_clear(c, dres);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17741f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x19140
cmpq $0x0, -0x18(%rbp)
je 0x177436
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x19140
cmpq $0x0, -0x20(%rbp)
je 0x17744a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1773b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_set_errorf
void de_dfilter_set_errorf(deark *c, struct de_dfilter_results *dres, const char *modname,
	const char *fmt, ...)
{
	va_list ap;

	if(dres->errcode != 0) return; // Only record the first error
	dres->errcode = 1;

	va_start(ap, fmt);
	if(modname) {
		char tmpbuf[80];

		de_vsnprintf(tmpbuf, sizeof(tmpbuf), fmt, ap);
		de_snprintf(dres->errmsg, sizeof(dres->errmsg), "[%s] %s", modname, tmpbuf);
	}
	else {
		de_vsnprintf(dres->errmsg, sizeof(dres->errmsg), fmt, ap);
	}
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
testb %al, %al
je 0x177497
movaps %xmm0, -0x110(%rbp)
movaps %xmm1, -0x100(%rbp)
movaps %xmm2, -0xf0(%rbp)
movaps %xmm3, -0xe0(%rbp)
movaps %xmm4, -0xd0(%rbp)
movaps %xmm5, -0xc0(%rbp)
movaps %xmm6, -0xb0(%rbp)
movaps %xmm7, -0xa0(%rbp)
movq %r9, -0x118(%rbp)
movq %r8, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1774c3
jmp 0x177557
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
leaq -0x40(%rbp), %rax
leaq -0x140(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x177539
leaq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movl $0x50, %esi
callq 0x18f9b0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rcx
leaq -0x90(%rbp), %r8
movl $0x50, %esi
leaq 0x5124e(%rip), %rdx     # 0x1c877e
movb $0x0, %al
callq 0x15a980
jmp 0x177553
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movl $0x50, %esi
callq 0x18f9b0
leaq -0x40(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_create
struct de_dfilter_ctx *de_dfilter_create(deark *c,
	dfilter_codec_type codec_init_fn, void *codec_private_params,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dfilter_ctx *dfctx = NULL;

	dfctx = de_malloc(c, sizeof(struct de_dfilter_ctx));
	dfctx->c = c;
	dfctx->dres = dres;
	dfctx->dcmpro = dcmpro;

	if(codec_init_fn) {
		codec_init_fn(dfctx, codec_private_params);
	}
	// TODO: How should we handle failure to initialize a codec?

	return dfctx;
}

// 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 %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x50, %esi
callq 0x15b780
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x17760e
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_addbuf
void de_dfilter_addbuf(struct de_dfilter_ctx *dfctx,
	const u8 *buf, i64 buf_len)
{
	if(dfctx->finished_flag) return;

	if(dfctx->codec_addbuf_fn && (buf_len>0)) {
		dfctx->codec_addbuf_fn(dfctx, buf, buf_len);

		if(dfctx->dres->errcode) {
			dfctx->finished_flag = 1;
		}
	}
}

// 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
cmpb $0x0, 0x20(%rax)
je 0x177640
jmp 0x17767f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x17767f
cmpq $0x0, -0x18(%rbp)
jle 0x17767f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0x17767d
movq -0x8(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x17767f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_command
void de_dfilter_command(struct de_dfilter_ctx *dfctx, int cmd, UI flags)
{
	// Non-codec-specific things:

	if(cmd==DE_DFILTER_COMMAND_REINITIALIZE) {
		dfctx->finished_flag = 0;
		dfctx->dres->bytes_consumed_valid = 0;
	}

	// Codec-specific things:

	if(dfctx->codec_command_fn) {
		dfctx->codec_command_fn(dfctx, cmd, flags);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x1776bc
movq -0x8(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1776db
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_destroy
void de_dfilter_destroy(struct de_dfilter_ctx *dfctx)
{
	deark *c;

	if(!dfctx) return;
	c = dfctx->c;
	if(dfctx->codec_destroy_fn) {
		dfctx->codec_destroy_fn(dfctx);
	}

	de_free(c, dfctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x177735
jmp 0x177766
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x177759
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_dfilter_addslice_buffered_read_cbfn
static int my_dfilter_addslice_buffered_read_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	struct de_dfilter_ctx *dfctx = (struct de_dfilter_ctx *)brctx->userdata;

	de_dfilter_addbuf(dfctx, buf, buf_len);
	if(dfctx->finished_flag) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x177620
movq -0x28(%rbp), %rax
cmpb $0x0, 0x20(%rax)
je 0x177803
movl $0x0, -0x4(%rbp)
jmp 0x17780a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: de_dfilter_decompress_oneshot
void de_dfilter_decompress_oneshot(deark *c,
	dfilter_codec_type codec_init_fn, void *codec_private_params,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_dfilter_ctx *dfctx = NULL;

	dfctx = de_dfilter_create(c, codec_init_fn, codec_private_params,
		dcmpro, dres);
	dfctx->input_file_offset = dcmpri->pos;
	de_dfilter_addslice(dfctx, dcmpri->f, dcmpri->pos, dcmpri->len);
	de_dfilter_finish(dfctx);
	de_dfilter_destroy(dfctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1775a0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x177770
movq -0x38(%rbp), %rdi
callq 0x1776f0
movq -0x38(%rbp), %rdi
callq 0x177720
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: fmtutil_decompress_uncompressed
void fmtutil_decompress_uncompressed(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres, UI flags)
{
	i64 len;
	i64 nbytes_avail;

	nbytes_avail = de_min_int(dcmpri->len, dcmpri->f->len - dcmpri->pos);

	if(dcmpro->len_known) {
		len = dcmpro->expected_len;
	}
	else {
		len = dcmpri->len;
	}

	if(len>nbytes_avail) len = nbytes_avail;
	if(len<0) len = 0;

	dbuf_copy(dcmpri->f, dcmpri->pos, len, dcmpro->f);
	dres->bytes_consumed = len;
	dres->bytes_consumed_valid = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x15ccf0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x177908
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x177914
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x177926
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x177935
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
callq 0x166070
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: dfilter_packbits_codec
void dfilter_packbits_codec(struct de_dfilter_ctx *dfctx, void *codec_private_params)
{
	struct packbitsctx *rctx = NULL;
	struct de_packbits_params *pbparams = (struct de_packbits_params*)codec_private_params;

	rctx = de_malloc(dfctx->c, sizeof(struct packbitsctx));
	rctx->modname = "packbits";

	dfctx->codec_private = (void*)rctx;
	dfctx->codec_addbuf_fn = my_packbits_codec_addbuf;
	dfctx->codec_finish_fn = my_packbits_codec_finish;
	dfctx->codec_command_fn = my_packbits_codec_command;
	dfctx->codec_destroy_fn = my_packbits_codec_destroy;

	rctx->nbytes_per_unit = 1;
	if(pbparams) {
		if(pbparams->nbytes_per_unit>DE_PACKBITS_MAX_NBYTES_PER_UNIT) {
			de_dfilter_set_generic_error(dfctx->c, dfctx->dres, rctx->modname);
		}
		else if(pbparams->nbytes_per_unit>1) {
			rctx->nbytes_per_unit = pbparams->nbytes_per_unit;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x48, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x5ebb7(%rip), %rcx     # 0x1d6567
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0x95(%rip), %rcx        # 0x177a60
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq 0x326(%rip), %rcx       # 0x177d00
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x357(%rip), %rcx       # 0x177d40
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
leaq 0x3c8(%rip), %rcx       # 0x177dc0
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x177a51
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
jbe 0x177a35
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdx
callq 0x177560
jmp 0x177a4f
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jbe 0x177a4d
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x177a4f
jmp 0x177a51
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_packbits_codec_finish
static void my_packbits_codec_finish(struct de_dfilter_ctx *dfctx)
{
	struct packbitsctx *rctx = (struct packbitsctx*)dfctx->codec_private;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x177d1d
jmp 0x177d3d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x4(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_packbits_codec_command
static void my_packbits_codec_command(struct de_dfilter_ctx *dfctx, int cmd, UI flags)
{
	struct packbitsctx *rctx = (struct packbitsctx*)dfctx->codec_private;

	if(cmd==DE_DFILTER_COMMAND_SOFTRESET || cmd==DE_DFILTER_COMMAND_REINITIALIZE) {
		// "soft reset" - reset the low-level compression state, but don't update
		// dres, or the total-bytes counters, etc.
		rctx->state = PACKBITS_STATE_NEUTRAL;
		rctx->nbytes_in_unitbuf = 0;
		rctx->nliteral_bytes_remaining = 0;
		rctx->repeat_count = 0;
	}
	if(cmd==DE_DFILTER_COMMAND_REINITIALIZE) {
		rctx->total_nbytes_processed = 0;
		rctx->nbytes_written = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
je 0x177d66
cmpl $0x2, -0xc(%rbp)
jne 0x177d95
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
cmpl $0x2, -0xc(%rbp)
jne 0x177db3
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: my_packbits_codec_destroy
static void my_packbits_codec_destroy(struct de_dfilter_ctx *dfctx)
{
	struct packbitsctx *rctx = (struct packbitsctx*)dfctx->codec_private;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x177def
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: fmtutil_decompress_packbits
int fmtutil_decompress_packbits(dbuf *f, i64 pos1, i64 len,
	dbuf *unc_pixels, i64 *cmpr_bytes_consumed)
{
	struct de_dfilter_results dres;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;

	if(cmpr_bytes_consumed) *cmpr_bytes_consumed = 0;
	de_dfilter_init_objects(f->c, &dcmpri, &dcmpro, &dres);

	dcmpri.f = f;
	dcmpri.pos = pos1;
	dcmpri.len = len;
	dcmpro.f = unc_pixels;
	if(unc_pixels->has_len_limit) {
		dcmpro.len_known = 1;
		dbuf_flush(unc_pixels);
		dcmpro.expected_len = unc_pixels->len_limit - unc_pixels->len;
	}

	de_dfilter_decompress_oneshot(f->c, dfilter_packbits_codec, NULL,
		&dcmpri, &dcmpro, &dres);

	if(cmpr_bytes_consumed && dres.bytes_consumed_valid) {
		*cmpr_bytes_consumed = dres.bytes_consumed;
	}
	if(dres.errcode != 0) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x177e91
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x1773f0
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x177f10
movb $0x1, -0xc0(%rbp)
movq -0x28(%rbp), %rdi
callq 0x167c30
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x5af(%rip), %rsi      # 0x177970
xorl %eax, %eax
movl %eax, %edx
leaq -0xb0(%rbp), %rcx
leaq -0xc8(%rbp), %r8
leaq -0x90(%rbp), %r9
callq 0x177820
cmpq $0x0, -0x30(%rbp)
je 0x177f5e
movzbl -0x8c(%rbp), %eax
cmpl $0x0, %eax
je 0x177f5e
movq -0x88(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x90(%rbp)
je 0x177f70
movl $0x0, -0x4(%rbp)
jmp 0x177f77
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: dfilter_rle90_codec
void dfilter_rle90_codec(struct de_dfilter_ctx *dfctx, void *codec_private_params)
{
	struct rle90ctx *rctx = NULL;

	rctx = de_malloc(dfctx->c, sizeof(struct rle90ctx));
	dfctx->codec_private = (void*)rctx;
	dfctx->codec_addbuf_fn = my_rle90_codec_addbuf;
	dfctx->codec_finish_fn = my_rle90_codec_finish;
	dfctx->codec_destroy_fn = my_rle90_codec_destroy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x178050
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq 0x1fd(%rip), %rcx       # 0x178230
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x22e(%rip), %rcx       # 0x178270
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17824d
jmp 0x17826c
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x4(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17829f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x15b780
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x178659
jmp 0x1786ad
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpb $0x0, 0x8(%rax)
je 0x17868b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jl 0x178689
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x1786ad
jmp 0x17868b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movzbl -0x9(%rbp), %esi
callq 0x168380
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: lzss_init_window_lz5
static void lzss_init_window_lz5(struct de_lz77buffer *ringbuf)
{
	size_t wpos;
	int i;

	de_zeromem(ringbuf->buf, 4096);
	wpos = 13;
	for(i=1; i<256; i++) {
		de_memset(&ringbuf->buf[wpos], i, 13);
		wpos += 13;
	}
	for(i=0; i<256; i++) {
		ringbuf->buf[wpos++] = i;
	}
	for(i=255; i>=0; i--) {
		ringbuf->buf[wpos++] = i;
	}
	wpos += 128;
	de_memset(&ringbuf->buf[wpos], 0x20, 110);
	//wpos += 110;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x19140
movq $0xd, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x17872b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
addq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl $0xd, %edx
movzbl %al, %esi
callq 0x19140
movq -0x10(%rbp), %rax
addq $0xd, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1786ef
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x178765
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rbp)
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x178732
movl $0xff, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x17879c
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rbp)
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17876c
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
addq -0x10(%rbp), %rdi
movl $0x20, %esi
movl $0x6e, %edx
callq 0x19140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jle 0x178843
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x17886f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x165170
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movzbl -0x11(%rbp), %esi
callq 0x16a230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
andl 0x14(%rcx), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x178941
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %esi
callq 0x178880
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
andl 0x14(%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x178906
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: squeeze_read_codes
static int squeeze_read_codes(deark *c, struct squeeze_ctx *sqctx)
{
	int retval = 0;

	de_dbg(c, "huffman-compressed data at %"I64_FMT, sqctx->bitrd.curpos);
	sqctx->bitrd.bbll.is_lsb = 1;
	de_bitbuf_lowlevel_empty(&sqctx->bitrd.bbll);

	if(fmtutil_huffman_get_max_bits(sqctx->ht->bk) < 1) {
		// Empty tree? Assume this is an empty file.
		retval = 1;
		goto done;
	}

	while(1) {
		int ret;
		fmtutil_huffman_valtype val = 0;

		ret = fmtutil_huffman_read_next_value(sqctx->ht->bk, &sqctx->bitrd, &val, NULL);
		if(!ret || val<0 || val>256) {
			if(sqctx->bitrd.eof_flag) {
				retval = 1;
			}
			else {
				de_dfilter_set_errorf(c, sqctx->dres, sqctx->modname, "Huffman decode error");
			}
			goto done;
		}

		if(val>=0 && val<=255) {
			dbuf_writebyte(sqctx->dcmpro->f, (u8)val);
			sqctx->nbytes_written++;
			if(sqctx->dcmpro->len_known && (sqctx->nbytes_written >= sqctx->dcmpro->expected_len)) {
				retval = 1;
				goto done;
			}
		}
		else if(val==256) { // STOP code
			retval = 1;
			goto done;
		}
	}

done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x5d446(%rip), %rsi     # 0x1d6770
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rax
movb $0x1, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
addq $0x20, %rdi
callq 0x16a360
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1876b0
cmpl $0x1, %eax
jae 0x17936c
movl $0x1, -0x14(%rbp)
jmp 0x179468
jmp 0x17936e
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
leaq -0x1c(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x187bc0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x1793ae
cmpl $0x0, -0x1c(%rbp)
jl 0x1793ae
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jle 0x1793e8
movq -0x10(%rbp), %rax
cmpb $0x0, 0x58(%rax)
je 0x1793c1
movl $0x1, -0x14(%rbp)
jmp 0x1793e3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x4a7dc(%rip), %rcx     # 0x1c3bb8
movb $0x0, %al
callq 0x177450
jmp 0x179468
cmpl $0x0, -0x1c(%rbp)
jl 0x17944f
cmpl $0xff, -0x1c(%rbp)
jg 0x17944f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movzbl %al, %esi
callq 0x168380
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x17944d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jl 0x17944d
movl $0x1, -0x14(%rbp)
jmp 0x179468
jmp 0x179463
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jne 0x179461
movl $0x1, -0x14(%rbp)
jmp 0x179468
jmp 0x179463
jmp 0x17936e
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x30, -0x14(%rbp)
jbe 0x179747
movq -0x8(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x8(%rbp), %rax
movzbl 0x50(%rax), %eax
cmpl $0x0, %eax
jne 0x17975e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x179763
jmp 0x179873
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0x16a390
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x50(%rax)
je 0x179787
jmp 0x179873
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x1797e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
shlq %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x179720
movq -0x8(%rbp), %rax
movzbl 0x50(%rax), %eax
cmpl $0x0, %eax
jne 0x1797bd
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x1797c2
jmp 0x179873
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
shlq %rsi
orq $0x1, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x179720
jmp 0x179873
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movl $0x8, %esi
callq 0x16a390
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jl 0x17983a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl $0x48, %esi
callq 0x15cf60
movq -0x78(%rbp), %rdi
movq %rax, %rdx
movl -0x20(%rbp), %ecx
leaq 0x307e1(%rip), %rsi     # 0x1aa014
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0x187720
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x179871
movq -0x8(%rbp), %rax
movl $0x1, 0x30(%rax)
jmp 0x179873
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/fmtutil-cmpr.c
// Function: fmtutil_xpk_ismethodsupported
int fmtutil_xpk_ismethodsupported(u32 method)
{
	switch(method) {
	case CODE_NONE:
	case CODE_MASH:
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x4d415348, %eax       # imm = 0x4D415348
je 0x179a72
jmp 0x179a66
movl -0xc(%rbp), %eax
subl $0x4e4f4e45, %eax       # imm = 0x4E4F4E45
jne 0x179a7b
jmp 0x179a72
movl $0x1, -0x4(%rbp)
jmp 0x179a82
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)