LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lha.c
// Function: arx_recalc_lh1
static void arx_recalc_lh1(deark *c, struct arx_ctx *d, struct arx_member_data *md)
{
	dbuf *outf = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;

	outf = dbuf_create_custom_dbuf(c, md->unc_data_len, 0);
	dbuf_set_writelistener(outf, de_writelistener_for_crc, (void*)d->crco);

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = md->hdr_endpos;
	dcmpri.len = md->compressed_data_len;
	dcmpro.f = outf;
	dcmpro.expected_len = md->unc_data_len;
	dcmpro.len_known = 1;

	fmtutil_lh1_codectype1(c, &dcmpri, &dcmpro, &dres, NULL);

	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %edx, %edx
callq 0x169220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0xa25b7(%rip), %rsi     # 0x1692d0
callq 0x169280
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18b940
movq -0x20(%rbp), %rdi
callq 0x1676a0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lha.c
// Function: do_check_ar001_header_crc
static void do_check_ar001_header_crc(deark *c, lctx *d, struct member_data *md, i64 basic_hdr_size)
{
	//if(!md->have_hdr_crc_reported) return;
	de_crcobj_reset(d->crco);

	// Everything before the CRC field:
	de_crcobj_addslice(d->crco, c->infile, md->member_pos+2, basic_hdr_size);

	md->hdr_crc_calc = de_crcobj_getval(d->crco);
	de_dbg(c, "header crc (calculated): 0x%04x", (UI)md->hdr_crc_calc);
	if(md->hdr_crc_calc != md->hdr_crc_reported) {
		de_err(c, "Wrong header CRC: reported=0x%04x, calculated=0x%04x",
				(UI)md->hdr_crc_reported, (UI)md->hdr_crc_calc);
	}
}

// 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)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15f250
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x2, %rdx
movq -0x20(%rbp), %rcx
callq 0x15f500
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15f340
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %edx
leaq 0xf3e9f(%rip), %rsi     # 0x1bb071
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x38(%rcx), %eax
je 0xc7209
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x38(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %ecx
leaq 0xf0d23(%rip), %rsi     # 0x1b7f25
movb $0x0, %al
callq 0x15bfb0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lha.c
// Function: slice_is_printable_ascii
static int slice_is_printable_ascii(dbuf *f, i64 pos, i64 len)
{
	i64 i;

	for(i=0; i<len; i++) {
		u8 b;

		b = dbuf_getbyte(f, pos+i);
		if(b<32 || b>126) 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 $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0xc7275
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
callq 0x165060
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x20, %eax
jl 0xc725c
movzbl -0x29(%rbp), %eax
cmpl $0x7e, %eax
jle 0xc7265
movl $0x0, -0x4(%rbp)
jmp 0xc727c
jmp 0xc7267
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc722c
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/modules/lha.c
// Function: looks_like_lharc_sfx_com
static int looks_like_lharc_sfx_com(deark *c, int *is_larc)
{
	u64 v;
	i64 pos = 0;
	u8 b;

	b = de_getbyte_p(&pos);
	if(b!=0xeb) return 0;
	b = de_getbyte_p(&pos);
	pos += (i64)b;
	// I don't know how good this test is, but I don't trust the text signature.
	// It's not formatted consistently. And because the source code was released,
	// who knows what weirdness is out there?
	if(b==0x60 || b==0x6c) {
		v = dbuf_getu64be(c->infile, pos);
		if(v==0xfcbc0001bb0601e8ULL) {
			return 1;
		}
	}
	else if(b==0x1c) {
		v = dbuf_getu64be(c->infile, pos);
		if(v==0xfc8cc8030602018eULL) {
			*is_larc = 1;
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165170
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xeb, %eax
je 0xc72d3
movl $0x0, -0x4(%rbp)
jmp 0xc7381
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165170
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x60, %eax
je 0xc7305
movzbl -0x29(%rbp), %eax
cmpl $0x6c, %eax
jne 0xc7335
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x1659b0
movq %rax, -0x20(%rbp)
movabsq $-0x343fffe44f9fe18, %rax # imm = 0xFCBC0001BB0601E8
cmpq %rax, -0x20(%rbp)
jne 0xc7333
movl $0x1, -0x4(%rbp)
jmp 0xc7381
jmp 0xc737a
movzbl -0x29(%rbp), %eax
cmpl $0x1c, %eax
jne 0xc7378
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x1659b0
movq %rax, -0x20(%rbp)
movabsq $-0x37337fcf9fdfe72, %rax # imm = 0xFC8CC8030602018E
cmpq %rax, -0x20(%rbp)
jne 0xc7376
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xc7381
jmp 0xc7378
jmp 0xc737a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lha.c
// Function: lhasfx_find_payload
static void lhasfx_find_payload(deark *c, struct lhasfx_context *d)
{
	if(d->sfx_container_is_larc) {
		if(is_lharc_data_at(c, 594, &d->payload_offs)) {
			goto done;
		}
	}
	else {
		if(is_lharc_data_at(c, 1260, &d->payload_offs) || // LHarc 1.12
			is_lharc_data_at(c, 1263, &d->payload_offs) || // LHarc 1.13-1.14
			is_lharc_data_at(c, 1290, &d->payload_offs)) // LHarc 1.00
		{
			goto done;
		}
	}

done:
	if(d->payload_offs==0) {
		d->errflag = 1;
		d->need_errmsg = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xc73c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl $0x252, %esi            # imm = 0x252
callq 0xc7440
cmpl $0x0, %eax
je 0xc73c7
jmp 0xc7420
jmp 0xc741e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl $0x4ec, %esi            # imm = 0x4EC
callq 0xc7440
cmpl $0x0, %eax
jne 0xc741a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl $0x4ef, %esi            # imm = 0x4EF
callq 0xc7440
cmpl $0x0, %eax
jne 0xc741a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl $0x50a, %esi            # imm = 0x50A
callq 0xc7440
cmpl $0x0, %eax
je 0xc741c
jmp 0xc7420
jmp 0xc741e
jmp 0xc7420
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc743a
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lha.c
// Function: is_lharc_data_at
static int is_lharc_data_at(deark *c, i64 pos, i64 *pfoundpos)
{
	u8 b[5];

	if(pos+21 > c->infile->len) return 0;
	de_read(b, pos+2, sizeof(b));
	if(b[0]!='-' || b[1]!='l' || b[4]!='-') return 0;
	if(b[2]!='h' && b[2]!='z') return 0;
	*pfoundpos = pos;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x15, %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0xc7473
movl $0x0, -0x4(%rbp)
jmp 0xc74e2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x25(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
movl $0x5, %ecx
callq 0x164d10
movzbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
jne 0xc74ac
movzbl -0x24(%rbp), %eax
cmpl $0x6c, %eax
jne 0xc74ac
movzbl -0x21(%rbp), %eax
cmpl $0x2d, %eax
je 0xc74b5
movl $0x0, -0x4(%rbp)
jmp 0xc74e2
movzbl -0x23(%rbp), %eax
cmpl $0x68, %eax
je 0xc74d0
movzbl -0x23(%rbp), %eax
cmpl $0x7a, %eax
je 0xc74d0
movl $0x0, -0x4(%rbp)
jmp 0xc74e2
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: de_module_j2c
void de_module_j2c(deark *c, struct deark_module_info *mi)
{
	mi->id = "j2c";
	mi->desc = "JPEG 2000 codestream";
	mi->run_fn = de_run_j2c;
	mi->identify_fn = de_identify_j2c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xdaaff(%rip), %rcx     # 0x1a2006
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xf0d19(%rip), %rcx     # 0x1b822e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xc7540
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x6d(%rip), %rcx        # 0xc75a0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: de_run_j2c
static void de_run_j2c(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	de_declare_fmt(c, "JPEG 2000 codestream");
	d = de_malloc(c, sizeof(lctx));
	do_j2c_internal(c, d);
	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xf0ccb(%rip), %rsi     # 0x1b822e
callq 0x15e380
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc75f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: do_j2c_internal
static void do_j2c_internal(deark *c, lctx *d)
{
	i64 pos;
	i64 bytes_consumed;

	pos = 0;
	if(pos >= c->infile->len) goto done;
	bytes_consumed = 0;
	do_j2c_page(c, d, pos, &bytes_consumed);
done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xc761c
jmp 0xc7639
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0xc7640
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: do_segment
static void do_segment(deark *c, lctx *d, struct page_ctx *pg, const struct marker_info *mi,
	i64 payload_pos, i64 payload_size)
{
	de_dbg(c, "segment 0x%02x (%s) at %d, dpos=%d, dlen=%d",
		(unsigned int)mi->seg_type, mi->longname, (int)(payload_pos-4),
		(int)payload_pos, (int)payload_size);

	if(mi->hfn) {
		// If a handler function is available, use it.
		de_dbg_indent(c, 1);
		mi->hfn(c, d, pg, mi, payload_pos, payload_size);
		de_dbg_indent(c, -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)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movzbl (%rax), %edx
movq -0x20(%rbp), %rcx
addq $0x14, %rcx
movq -0x28(%rbp), %rax
subq $0x4, %rax
movl %eax, %r8d
movq -0x28(%rbp), %rax
movl %eax, %r9d
movq -0x30(%rbp), %rax
leaq 0xef67f(%rip), %rsi     # 0x1b726f
movl %eax, (%rsp)
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xc7c43
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: handler_qcd
static void handler_qcd(deark *c, lctx *d, struct page_ctx *pg,
	const struct marker_info *mi, i64 pos1, i64 len)
{
	i64 pos = pos1;
	u8 q_style;

	if(len<1) goto done;
	q_style = de_getbyte_p(&pos);
	de_dbg(c, "quantization style: 0x%02x", (unsigned int)q_style);

	if(pos < pos1+len) {
		// TODO
		de_dbg2(c, "[not decoding the rest of this segment]");
	}
done:
	;
}

// 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 -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x1, -0x30(%rbp)
jge 0xc83b1
jmp 0xc8400
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165170
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x39(%rbp), %edx
leaq 0xf02c6(%rip), %rsi     # 0x1b869a
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jge 0xc83fe
movq -0x8(%rbp), %rdi
leaq 0xf01e7(%rip), %rsi     # 0x1b85de
movb $0x0, %al
callq 0x15b350
jmp 0xc8400
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: handler_qcc
static void handler_qcc(deark *c, lctx *d, struct page_ctx *pg,
	const struct marker_info *mi, i64 pos1, i64 len)
{
	i64 pos = pos1;
	i64 compnum;

	if(pg->ncomp<257) {
		compnum = de_getbyte_p(&pos);
	}
	else {
		compnum = de_getu16be_p(&pos);
	}
	de_dbg(c, "component number: %d", (int)compnum);

	if(pos < pos1+len) {
		// TODO
		de_dbg2(c, "[not decoding the rest of this segment]");
	}
}

// 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 -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x101, (%rax)          # imm = 0x101
jge 0xc845f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x40(%rbp)
jmp 0xc8474
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165210
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %edx
leaq 0xf0230(%rip), %rsi     # 0x1b86b5
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jge 0xc84af
movq -0x8(%rbp), %rdi
leaq 0xf0136(%rip), %rsi     # 0x1b85de
movb $0x0, %al
callq 0x15b350
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: handler_cme
static void handler_cme(deark *c, lctx *d, struct page_ctx *pg,
	const struct marker_info *mi, i64 pos, i64 data_size)
{
	i64 reg_val;
	i64 comment_pos;
	i64 comment_size;
	const char *name;

	if(data_size<2) goto done;

	reg_val = de_getu16be(pos);
	switch(reg_val) {
	case 0: name="binary"; break;
	case 1: name="text"; break;
	default: name="?";
	}
	de_dbg(c, "comment/extension type: %d (%s)", (int)reg_val, name);

	comment_pos = pos+2;
	comment_size = data_size-2;

	if(reg_val==1) {
		handle_comment(c, d, comment_pos, comment_size);
	}
	else {
		de_dbg_hexdump(c, c->infile, comment_pos, comment_size, 256, NULL, 0x1);
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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)
cmpq $0x2, -0x30(%rbp)
jge 0xc84ec
jmp 0xc85c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x1651d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
testq %rax, %rax
je 0xc851c
jmp 0xc8510
movq -0x58(%rbp), %rax
subq $0x1, %rax
je 0xc8529
jmp 0xc8536
leaq 0x103ad5(%rip), %rax    # 0x1cbff8
movq %rax, -0x50(%rbp)
jmp 0xc8541
leaq 0xf02a7(%rip), %rax     # 0x1b87d7
movq %rax, -0x50(%rbp)
jmp 0xc8541
leaq 0xef6f0(%rip), %rax     # 0x1b7c2d
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
movq -0x50(%rbp), %rcx
leaq 0xf0174(%rip), %rsi     # 0x1b86ca
movb $0x0, %al
callq 0x15b0d0
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x48(%rbp)
cmpq $0x1, -0x38(%rbp)
jne 0xc8593
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xc8700
jmp 0xc85be
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, (%rsp)
callq 0x15b840
jmp 0xc85c0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: handler_sot
static void handler_sot(deark *c, lctx *d, struct page_ctx *pg,
	const struct marker_info *mi, i64 pos1, i64 len)
{
	i64 x;
	i64 b;
	i64 pos = pos1;

	pg->j2c_sot_pos = 0;
	pg->j2c_sot_length = 0;
	if(len<8) return;

	pg->j2c_sot_pos = pos1 - 4;
	x = de_getu16be_p(&pos);
	de_dbg(c, "tile number: %d", (int)x);
	pg->j2c_sot_length = de_getu32be_p(&pos);
	de_dbg(c, "length: %u", (unsigned int)pg->j2c_sot_length);
	b = de_getbyte_p(&pos);
	de_dbg(c, "tile-part instance: %d", (int)b);
	b = de_getbyte_p(&pos);
	de_dbg(c, "number of tile-parts: %d", (int)b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x8, -0x30(%rbp)
jge 0xc861c
jmp 0xc86f1
movq -0x28(%rbp), %rcx
subq $0x4, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x165210
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
leaq 0xf0098(%rip), %rsi     # 0x1b86ea
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1654b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
leaq 0xf144d(%rip), %rsi     # 0x1b9ad7
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %edx
leaq 0xf0040(%rip), %rsi     # 0x1b86fa
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %edx
leaq 0xf0027(%rip), %rsi     # 0x1b8711
movb $0x0, %al
callq 0x15b0d0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/j2c.c
// Function: handle_comment
static void handle_comment(deark *c, lctx *d, i64 pos, i64 comment_size)
{
	int write_to_file;

	// If c->extract_level>=2, write the comment to a file;
	// otherwise if we have debugging output, write (at least part of) it
	// to the debug output;
	// otherwise do nothing.

	if(c->extract_level<2 && c->debug_level<1) return;
	if(comment_size<1) return;

	write_to_file = (c->extract_level>=2);

	if(write_to_file) {
		dbuf *outf = NULL;

		outf = dbuf_create_output_file(c, "comment.txt", NULL, DE_CREATEFLAG_IS_AUX);
		dbuf_copy_slice_convert_to_utf8(c->infile, pos, comment_size,
			DE_ENCODING_LATIN1, outf, 0x2);
		dbuf_close(outf);
	}
	else {
		de_ucstring *s = NULL;

		s = ucstring_create(c);
		dbuf_read_to_ucstring_n(c->infile, pos, comment_size, DE_DBG_MAX_STRLEN,
			s, 0, DE_ENCODING_LATIN1);
		de_dbg(c, "comment: \"%s\"", ucstring_getpsz_d(s));
		ucstring_destroy(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jge 0xc8733
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jge 0xc8733
jmp 0xc881b
cmpq $0x1, -0x20(%rbp)
jge 0xc873f
jmp 0xc881b
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xc87af
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xdbae2(%rip), %rsi     # 0x1a4250
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x166c60
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movl $0x5, %ecx
movl $0x2, %r9d
callq 0x169da0
movq -0x30(%rbp), %rdi
callq 0x1676a0
jmp 0xc881b
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %r8
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl $0x5, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x172650
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0xd7e41(%rip), %rsi     # 0x1a064c
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: do_vorbis_page
static void do_vorbis_page(deark *c, lctx *d, struct page_info *pgi, struct stream_info *si)
{
	u8 firstbyte;

	if(pgi->is_first_page) {
		// The first Ogg page of a bitstream usually contains enough data to be
		// useful. So, we'll try to process it directly, without reconstructing
		// the codec bitstream.
		do_vorbis_id_header(c, d, pgi, si);
	}

	// We want to save a copy of the Comment and Setup header data,
	// but not the Identification header which is handled elsewhere.

	if(si->stream_state!=0) {
		// We've already handled the Comment & Setup headers.
		goto done;
	}

	if(pgi->dlen<1) goto done;

	firstbyte = de_getbyte(pgi->dpos);

	if(si->page_count==0 || pgi->page_seq_num==0 || (pgi->hdr_type&0x02)) {
		// This appears to be the Identification header page. Skip it.
		goto done;
	}

	if(pgi->page_seq_num>=1 && (firstbyte&0x01)) {
		// This appears to be one of the pages we care about.
		// Save its data for later.
		if(!si->header_stream) {
			si->header_stream = dbuf_create_membuf(c, 1048576, 1);
		}
		dbuf_copy(c->infile, pgi->dpos, pgi->dlen, si->header_stream);
	}
	else if((firstbyte&0x01)==0) {
		// Reached the end of headers (by encountering a non-header page).
		// (There is required to be an Ogg page break immediately after the
		// Vorbis headers, so the start of the first data *page* must correspond
		// to the start of the first data *packet*. A Vorbis data packet always
		// begins with a byte whose low bit is 0.)
		do_theora_vorbis_after_headers(c, d, si);
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xc8867
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc8c60
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xc8876
jmp 0xc8951
movq -0x18(%rbp), %rax
cmpq $0x1, 0x28(%rax)
jge 0xc8886
jmp 0xc8951
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x165060
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc88c4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc88c4
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc88c9
jmp 0xc8951
movq -0x18(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jl 0xc8930
movzbl -0x21(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc8930
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xc8909
movq -0x8(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x1, %edx
callq 0x168020
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
callq 0x166070
jmp 0xc894f
movzbl -0x21(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xc894d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc8dc0
jmp 0xc894f
jmp 0xc8951
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: do_theora_page
static void do_theora_page(deark *c, lctx *d, struct page_info *pgi, struct stream_info *si)
{
	u8 firstbyte;

	if(pgi->is_first_page) {
		do_theora_id_header(c, d, pgi, si);
	}

	// We want to save a copy of the Comment and Setup header data,
	// but not the Identification header which is handled elsewhere.

	if(si->stream_state!=0) {
		// We've already handled the Comment & Setup headers.
		goto done;
	}

	if(pgi->dlen<1) goto done;

	firstbyte = de_getbyte(pgi->dpos);

	if(si->page_count==0 || pgi->page_seq_num==0 || (pgi->hdr_type&0x02)) {
		// This appears to be the Identification header page. Skip it.
		goto done;
	}

	if(pgi->page_seq_num>=1 && firstbyte>=0x80) {
		// This appears to be one of the pages we care about.
		// Save its data for later.
		if(!si->header_stream) {
			si->header_stream = dbuf_create_membuf(c, 1048576, 1);
		}
		dbuf_copy(c->infile, pgi->dpos, pgi->dlen, si->header_stream);
	}
	else if(firstbyte<0x80) {
		// Reached the end of headers (by encountering a non-header page).
		// (There is required to be an Ogg page break immediately after the
		// Theora headers, so the start of the first data *page* must correspond
		// to the start of the first data *packet*. A Theora data packet always
		// begins with a byte < 0x80.)
		do_theora_vorbis_after_headers(c, d, si);
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xc8997
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc90e0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xc89a6
jmp 0xc8a7f
movq -0x18(%rbp), %rax
cmpq $0x1, 0x28(%rax)
jge 0xc89b6
jmp 0xc8a7f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x165060
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc89f4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc89f4
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc89f9
jmp 0xc8a7f
movq -0x18(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jl 0xc8a5f
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jl 0xc8a5f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xc8a38
movq -0x8(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x1, %edx
callq 0x168020
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
callq 0x166070
jmp 0xc8a7d
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0xc8a7b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc8dc0
jmp 0xc8a7d
jmp 0xc8a7f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: de_module_ogg
void de_module_ogg(deark *c, struct deark_module_info *mi)
{
	mi->id = "ogg";
	mi->desc = "Ogg multimedia";
	mi->run_fn = de_run_ogg;
	mi->identify_fn = de_identify_ogg;
	mi->help_fn = de_help_ogg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xe5d97(%rip), %rcx     # 0x1ae83e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xefd50(%rip), %rcx     # 0x1b8805
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xc8af0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbd(%rip), %rcx        # 0xc8b90
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x14e(%rip), %rcx       # 0xc8c30
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: de_run_ogg
static void de_run_ogg(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	if(de_havemodcode(c, mparams, 'C')) {
		do_vorbis_comment_block(c, d, c->infile, 0);
		goto done;
	}

	run_ogg_internal(c, d);

done:
	if(d && d->streamtable) {
		destroy_streamtable(c, d);
	}
	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x43, %edx
callq 0x15d1d0
cmpl $0x0, %eax
je 0xc8b4c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xc8f20
jmp 0xc8b59
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc9370
cmpq $0x0, -0x18(%rbp)
je 0xc8b78
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc8b78
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc94f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: de_identify_ogg
static int de_identify_ogg(deark *c)
{
	i64 pos = 0;

	if(!c->detection_data->id3.detection_attempted) {
		de_err(c, "ogg detection requires id3 module");
		return 0;
	}

	if(c->detection_data->id3.has_id3v2) {
		pos = (i64)c->detection_data->id3.bytes_at_start;
	}

	if(!dbuf_memcmp(c->infile, pos, "OggS", 4))
		return 100;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpb $0x0, 0x14(%rax)
jne 0xc8bcd
movq -0x10(%rbp), %rdi
leaq 0xeff35(%rip), %rsi     # 0x1b8af2
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x4(%rbp)
jmp 0xc8c1c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpb $0x0, 0x15(%rax)
je 0xc8bea
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq 0xeff17(%rip), %rdx     # 0x1b8b14
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0xc8c15
movl $0x64, -0x4(%rbp)
jmp 0xc8c1c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: do_vorbis_id_header
static void do_vorbis_id_header(deark *c, lctx *d, struct page_info *pgi, struct stream_info *si)
{
	i64 pos = pgi->dpos;
	unsigned int u1;
	i64 x;

	pos += 7; // Skip signature
	u1 = (unsigned int)de_getu32le_p(&pos);
	de_dbg(c, "version: %u", u1);
	u1 = (unsigned int)de_getbyte_p(&pos);
	de_dbg(c, "channels: %u", u1);
	u1 = (unsigned int)de_getu32le_p(&pos);
	de_dbg(c, "sample rate: %u", u1);
	x = de_geti32le(pos); pos += 4;
	de_dbg(c, "max bitrate: %d", (int)x);
	x = de_geti32le(pos); pos += 4;
	de_dbg(c, "nominal bitrate: %d", (int)x);
	x = de_geti32le(pos); pos += 4;
	de_dbg(c, "min bitrate: %d", (int)x);
}

// 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 -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0xf99d4(%rip), %rsi     # 0x1c2686
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0xefb36(%rip), %rsi     # 0x1b8814
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0xefb1a(%rip), %rsi     # 0x1b8821
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x165600
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
leaq 0xefaf1(%rip), %rsi     # 0x1b8831
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x165600
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
leaq 0xefac8(%rip), %rsi     # 0x1b8841
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x165600
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
leaq 0xefaa3(%rip), %rsi     # 0x1b8855
movb $0x0, %al
callq 0x15b0d0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: do_theora_vorbis_after_headers
static void do_theora_vorbis_after_headers(deark *c, lctx *d, struct stream_info *si)
{
	i64 pos = 0;
	int saved_indent_level;
	dbuf *f = NULL;

	de_dbg_indent_save(c, &saved_indent_level);
	if(si->stream_state!=0) goto done;
	if(!si->header_stream) goto done;
	if(!si->sti) goto done;
	f = si->header_stream;

	de_dbg(c, "[decoding %s comment/setup headers, %d bytes]",
		si->sti->name, (int)si->header_stream->len);
	de_dbg_indent(c, 1);

	// Make sure the comment header signature is present.
	if(si->stream_type==STREAMTYPE_VORBIS) {
		if(dbuf_memcmp(f, 0, "\x03" "vorbis", 7)) {
			goto done;
		}
		pos += 7;
	}
	else if(si->stream_type==STREAMTYPE_THEORA) {
		if(dbuf_memcmp(f, 0, "\x81" "theora", 7)) {
			goto done;
		}
		pos += 7;
	}

	do_vorbis_comment_block(c, d, f, pos);

	// TODO: "Setup" header

done:
	si->stream_state = 1;
	dbuf_close(si->header_stream);
	si->header_stream = NULL;
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x15b580
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xc8e00
jmp 0xc8ee9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xc8e10
jmp 0xc8ee9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc8e20
jmp 0xc8ee9
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movl %eax, %ecx
leaq 0xefa14(%rip), %rsi     # 0x1b8865
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xc8e9d
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xefa15(%rip), %rdx     # 0x1b8893
movl $0x7, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xc8e8f
jmp 0xc8ee9
movq -0x20(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x20(%rbp)
jmp 0xc8ed4
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc8ed2
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xef9e6(%rip), %rdx     # 0x1b889b
movl $0x7, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xc8ec6
jmp 0xc8ee9
movq -0x20(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x20(%rbp)
jmp 0xc8ed4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc8f20
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1676a0
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x15b5a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: do_vorbis_comment_block
static void do_vorbis_comment_block(deark *c, lctx *d, dbuf *f, i64 pos1)
{
	i64 pos = pos1;
	i64 n;
	i64 ncomments;
	i64 k;
	de_ucstring *s = NULL;

	n = dbuf_getu32le_p(f, &pos);
	if(pos+n > f->len) goto done;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(f, pos, n, DE_DBG_MAX_STRLEN, s, 0, DE_ENCODING_UTF8);
	de_dbg(c, "vendor: \"%s\"", ucstring_getpsz_d(s));
	pos += n;

	ncomments = dbuf_getu32le_p(f, &pos);
	de_dbg(c, "number of comments: %d", (int)ncomments);

	for(k=0; k<ncomments; k++) {
		if(pos+4 > f->len) goto done;
		n = dbuf_getu32le_p(f, &pos);
		if(pos+n > f->len) goto done;
		ucstring_empty(s);
		dbuf_read_to_ucstring_n(f, pos, n, DE_DBG_MAX_STRLEN, s, 0, DE_ENCODING_UTF8);
		de_dbg(c, "comment[%d]: \"%s\"", (int)k, ucstring_getpsz_d(s));
		pos += n;
	}

done:
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0xc8f70
jmp 0xc90ca
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x48(%rbp), %r8
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl $0x2, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x172650
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0xef8e3(%rip), %rsi     # 0x1b88a3
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
leaq 0xef8bb(%rip), %rsi     # 0x1b88b0
movb $0x0, %al
callq 0x15b0d0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0xc90c8
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0xc9029
jmp 0xc90ca
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x165580
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0xc904e
jmp 0xc90ca
movq -0x48(%rbp), %rdi
callq 0x171210
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x48(%rbp), %r8
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl $0x2, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x54(%rbp)
movq -0x48(%rbp), %rdi
callq 0x172650
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %edx
movq %rax, %rcx
leaq 0xef823(%rip), %rsi     # 0x1b88c7
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xc9004
jmp 0xc90ca
movq -0x48(%rbp), %rdi
callq 0x171750
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: run_ogg_internal
static void run_ogg_internal(deark *c, lctx *d)
{
	i64 pos;
	i64 ogg_end;
	struct de_id3info id3i;

	d->always_hexdump = de_get_ext_option(c, "ogg:hexdump")?1:0;
	d->streamtable = de_inthashtable_create(c);

	fmtutil_handle_id3(c, c->infile, &id3i, 0);
	pos = id3i.main_start;
	ogg_end = id3i.main_end;

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

		if(pos >= ogg_end) break;
		sig = (u32)de_getu32be(pos);
		if(sig!=0x04f676753U) {
			de_err(c, "Ogg page signature not found at %"I64_FMT, pos);
			break;
		}
		de_dbg(c, "page at %"I64_FMT, pos);
		de_dbg_indent(c, 1);
		ret = do_ogg_page(c, d, pos, &bytes_consumed);
		de_dbg_indent(c, -1);
		if(!ret || bytes_consumed<=4) break;
		pos += bytes_consumed;
		d->total_page_count++;
	}

	if(!d->format_declared) declare_ogg_format(c, d);

	de_dbg(c, "number of bitstreams: %d", (int)d->bitstream_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xef60c(%rip), %rsi     # 0x1b8997
callq 0x15cb30
movq %rax, %rdx
xorl %ecx, %ecx
movl $0x1, %eax
cmpq $0x0, %rdx
cmovnel %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x15e600
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x38(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1753e0
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0xc93f9
jmp 0xc94a8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165470
movl %eax, -0x3c(%rbp)
cmpl $0x4f676753, -0x3c(%rbp) # imm = 0x4F676753
je 0xc942e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xef57e(%rip), %rsi     # 0x1b89a3
movb $0x0, %al
callq 0x15bfb0
jmp 0xc94a8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xe3bb6(%rip), %rsi     # 0x1acff3
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0xc9570
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
cmpl $0x0, -0x40(%rbp)
je 0xc9485
cmpq $0x4, -0x48(%rbp)
jg 0xc9487
jmp 0xc94a8
movq -0x48(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0xc93e2
movq -0x10(%rbp), %rax
cmpb $0x0, 0x20(%rax)
jne 0xc94bf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc9a70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
leaq 0xef4f3(%rip), %rsi     # 0x1b89c7
movb $0x0, %al
callq 0x15b0d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: destroy_streamtable
static void destroy_streamtable(deark *c, lctx *d)
{
	while(1) {
		i64 key;
		void *removed_item = NULL;
		struct stream_info *si;

		if(!de_inthashtable_remove_any_item(c, d->streamtable, &key, &removed_item)) {
			break;
		}
		si = (struct stream_info *)removed_item;
		destroy_bitstream(c, d, si);
	}

	de_inthashtable_destroy(c, d->streamtable);
	d->streamtable = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x15e9b0
cmpl $0x0, %eax
jne 0xc9528
jmp 0xc9543
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc9fd0
jmp 0xc9500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x15e630
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: declare_ogg_format
static void declare_ogg_format(deark *c, lctx *d)
{
	char tmps[80];
	const char *name = NULL;

	if(d->format_declared) return;
	d->format_declared = 1;

	// There's no nice way, that I know of, to characterize the contents of an Ogg
	// file. But I think it's worth trying.

	if(d->bitstream_count<1) {
		// If there are zero streams : "other"
	}
	else if(d->found_ogm) {
		// else if there's an OGM stream of any kind...
		name="OGM";
	}
	else if(d->found_skeleton) {
		// else If there's a Skeleton stream...
		name="Skeleton";
	}
	else if(d->first_stream_type_valid && d->first_stream_sti &&
		!d->has_unknown_or_multiple_stream_types)
	{
		// else if all streams are the same known type: that stream type
		name = d->first_stream_sti->name;
	}
	else if(d->found_theora && d->found_vorbis && !d->has_non_vorbis_non_theora_stream) {
		// else if there are Theora and Vorbis streams and nothing else...
		name="Theora+Vorbis";
	}
	else if(d->found_theora) {
		// else if there's a Theora stream...
		name="Theora+other";
	}
	// (else "other")

	de_snprintf(tmps, sizeof(tmps), "Ogg %s", name?name:"(other)");
	de_declare_fmt(c, tmps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x20(%rax)
je 0xc9a9a
jmp 0xc9bb2
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jge 0xc9ab2
jmp 0xc9b64
movq -0x10(%rbp), %rax
cmpb $0x0, 0x22(%rax)
je 0xc9acc
leaq 0xef009(%rip), %rax     # 0x1b8acc
movq %rax, -0x68(%rbp)
jmp 0xc9b62
movq -0x10(%rbp), %rax
cmpb $0x0, 0x21(%rax)
je 0xc9ae3
leaq 0xeec89(%rip), %rax     # 0x1b8766
movq %rax, -0x68(%rbp)
jmp 0xc9b60
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xc9b14
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xc9b14
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0xc9b14
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0xc9b5e
movq -0x10(%rbp), %rax
movzbl 0x24(%rax), %eax
cmpl $0x0, %eax
je 0xc9b45
movq -0x10(%rbp), %rax
movzbl 0x23(%rax), %eax
cmpl $0x0, %eax
je 0xc9b45
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0xc9b45
leaq 0xeef91(%rip), %rax     # 0x1b8ad0
movq %rax, -0x68(%rbp)
jmp 0xc9b5c
movq -0x10(%rbp), %rax
cmpb $0x0, 0x24(%rax)
je 0xc9b5a
leaq 0xeef88(%rip), %rax     # 0x1b8ade
movq %rax, -0x68(%rbp)
jmp 0xc9b5c
jmp 0xc9b5e
jmp 0xc9b60
jmp 0xc9b62
jmp 0xc9b64
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0xc9b7d
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0xc9b8a
leaq 0xed68f(%rip), %rax     # 0x1b7213
movq %rax, -0x78(%rbp)
jmp 0xc9b8a
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rcx
movl $0x50, %esi
leaq 0xeef4d(%rip), %rdx     # 0x1b8aeb
movb $0x0, %al
callq 0x15a980
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x15e380
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)