LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: destroy_lctx
static void destroy_lctx(deark *c, lctx *d)
{
	if(!d) return;
	de_crcobj_destroy(d->crco);
	de_strarray_destroy(d->curpath);
	if(d->pak16sfx_outf) {
		dbuf_close(d->pak16sfx_outf);
	}
	if(d->persistent_md) {
		i64 i;

		for(i=0; i<d->num_top_level_members; i++) {
			ucstring_destroy(d->persistent_md[i].comment);
			ucstring_destroy(d->persistent_md[i].path);
		}
		de_free(c, d->persistent_md);
	}
	de_free(c, d);
}

// Assembly:
testq %rsi, %rsi
je 0x27153
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rdi
callq 0xebe1d
movq 0x50(%rbx), %rdi
callq 0xf7689
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x270f5
callq 0xf0b13
cmpq $0x0, 0x58(%rbx)
je 0x2713d
cmpq $0x0, 0x38(%rbx)
jle 0x27131
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0xf6bb0
movq 0x58(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
callq 0xf6bb0
incq %r12
addq $0x10, %r15
cmpq 0x38(%rbx), %r12
jl 0x27109
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0xe9752
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe9752
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: member_cb_for_pak16sfx
static void member_cb_for_pak16sfx(deark *c, lctx *d, struct member_parser_data *mpd)
{
	de_dbg2(c, "pak16sfx member at %"I64_FMT", type=0x%02x", mpd->member_pos,
		(UI)mpd->magic);
	de_dbg_indent(c, 1);

	// This is not perfect. We throw away the extended info, instead of converting
	// it to extended records.
	if(mpd->magic==0x1a) {
		if(!d->pak16sfx_outf) {
			d->pak16sfx_outf = dbuf_create_output_file(c, "pak", NULL, 0);
		}
		dbuf_copy(c->infile, mpd->member_pos, mpd->member_len, d->pak16sfx_outf);
	}
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %rdx
movzbl 0x8(%r15), %ecx
leaq 0xed228(%rip), %rsi     # 0x1145a2
xorl %eax, %eax
callq 0xe93cf
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
cmpb $0x1a, 0x8(%r15)
jne 0x273c8
cmpq $0x0, 0x60(%r14)
jne 0x273b3
leaq 0xed223(%rip), %rsi     # 0x1145c6
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf037a
movq %rax, 0x60(%r14)
movq 0x18(%rbx), %rdi
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq 0x60(%r14), %rcx
callq 0xefabc
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0xe9585
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: do_sequence_of_members
static void do_sequence_of_members(deark *c, lctx *d, i64 pos1, i64 len, int nesting_level)
{
	if(nesting_level >= MAX_NESTING_LEVEL) {
		de_err(c, "Max subdir nesting level exceeded");
		return;
	}

	de_dbg(c, "archive at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	parse_member_sequence(c, d, pos1, len, nesting_level, member_cb_main);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x18, %r8d
jl 0x27404
leaq 0xed37d(%rip), %rsi     # 0x11476f
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe9df7
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xed37a(%rip), %rsi     # 0x114791
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
leaq 0xef(%rip), %r9         # 0x27524
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x27154
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe9585
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: member_cb_for_prescan
static void member_cb_for_prescan(deark *c, lctx *d, struct member_parser_data *mpd)
{
	if(mpd->magic!=d->sig_byte) return;
	if(mpd->cmpr_meth_masked==0x00) { // end of archive
		d->prescan_found_eoa = 1;
		d->prescan_pos_after_eoa = mpd->member_pos + mpd->member_len;
		de_dbg2(c, "end of member sequence at %"I64_FMT, d->prescan_pos_after_eoa);
		return;
	}
	if(mpd->cmpr_meth==20 || mpd->cmpr_meth==21 || mpd->cmpr_meth==30) {
		// Features we're pretty sure aren't used by PAK.
		d->has_arc_extensions = 1;
	}
	d->num_top_level_members++;
	de_dbg2(c, "member at %"I64_FMT, mpd->member_pos);
}

// Assembly:
movb 0x8(%rdx), %al
cmpb 0x24(%rsi), %al
jne 0x27494
cmpb $0x0, 0xa(%rdx)
je 0x27495
movzbl 0x9(%rdx), %eax
cmpl $0x1e, %eax
ja 0x27483
movl $0x40300000, %ecx       # imm = 0x40300000
btl %eax, %ecx
jae 0x27483
movb $0x1, 0x28(%rsi)
incq 0x38(%rsi)
movq 0x10(%rdx), %rdx
leaq 0x114351(%rip), %rsi    # 0x13b7e3
jmp 0x274af
retq
movb $0x1, 0x25(%rsi)
movq 0x18(%rdx), %rax
addq 0x10(%rdx), %rax
movq %rax, 0x30(%rsi)
leaq 0xed1c7(%rip), %rsi     # 0x114673
movq %rax, %rdx
xorl %eax, %eax
jmp 0xe93cf
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: is_pkcomment_sig_at
static int is_pkcomment_sig_at(deark *c, lctx *d, i64 pos)
{
	i64 comments_descr_pos;

	if(!d->prescan_found_eoa) return 0;
	if(pos < d->prescan_pos_after_eoa) return 0;
	if(pos > c->infile->len-8) return 0;
	if((UI)de_getu32be(pos) != 0x504baa55U) {
		return 0;
	}
	comments_descr_pos = de_getu32le(pos+4);
	if((comments_descr_pos < d->prescan_pos_after_eoa) ||
		(comments_descr_pos > pos-4))
	{
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpb $0x0, 0x25(%rsi)
je 0x27517
movq %rdx, %rbx
movq %rsi, %r14
cmpq %rdx, 0x30(%rsi)
jg 0x27517
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rax
addq $-0x8, %rax
cmpq %rbx, %rax
jl 0x27517
movq %rbx, %rsi
callq 0xef32a
cmpl $0x504baa55, %eax       # imm = 0x504BAA55
jne 0x27517
movq 0x18(%r15), %rdi
leaq 0x4(%rbx), %rsi
callq 0xef37e
cmpq 0x30(%r14), %rax
setge %cl
addq $-0x4, %rbx
cmpq %rbx, %rax
setle %al
andb %cl, %al
movzbl %al, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: decompressor_squeezed
static void decompressor_squeezed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dcmpr_two_layer_params tlp;

	de_zeromem(&tlp, sizeof(struct de_dcmpr_two_layer_params));
	tlp.codec1_type1 = fmtutil_huff_squeeze_codectype1;
	tlp.codec2 = dfilter_rle90_codec;
	tlp.dcmpri = dcmpri;
	tlp.dcmpro = dcmpro;
	tlp.dres = dres;
	de_dfilter_decompress_two_layer(c, &tlp);
}

// Assembly:
subq $0x58, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
leaq 0xd33de(%rip), %rax     # 0xfb871
movq %rax, (%rsi)
leaq 0xd2960(%rip), %rax     # 0xfadfd
movq %rax, 0x18(%rsi)
movq %rcx, 0x28(%rsi)
movq %r8, 0x30(%rsi)
movq %r9, 0x38(%rsi)
callq 0xfb662
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: decompressor_crunched6
static void decompressor_crunched6(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dcmpr_two_layer_params tlp;
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_ARC5;

	de_zeromem(&tlp, sizeof(struct de_dcmpr_two_layer_params));
	tlp.codec1_pushable = dfilter_lzw_codec;
	tlp.codec1_private_params = (void*)&delzwp;

	tlp.codec2 = dfilter_rle90_codec;

	tlp.dcmpri = dcmpri;
	tlp.dcmpro = dcmpro;
	tlp.dres = dres;

	de_dfilter_decompress_two_layer(c, &tlp);
}

// Assembly:
subq $0x78, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movl $0x7, (%rax)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
leaq 0xda7eb(%rip), %rdx     # 0x102d0b
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
leaq 0xd28ce(%rip), %rax     # 0xfadfd
movq %rax, 0x18(%rsi)
movq %rcx, 0x28(%rsi)
movq %r8, 0x30(%rsi)
movq %r9, 0x38(%rsi)
callq 0xfb662
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: decompressor_squashed
static void decompressor_squashed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_UNIXCOMPRESS;
	delzwp.max_code_size = 13;
	fmtutil_decompress_lzw(c, dcmpri, dcmpro, dres, &delzwp);
}

// Assembly:
subq $0x18, %rsp
movq %r8, %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x0, 0x10(%r8)
movl $0x1, (%r8)
movl $0xd, 0xc(%r8)
movq %rcx, %rsi
movq %r9, %rcx
callq 0x102cf0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: decompressor_trimmed
static void decompressor_trimmed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	struct de_dcmpr_two_layer_params tlp;
	struct de_lh1_params lh1p;

	de_zeromem(&lh1p, sizeof(struct de_lh1_params));
	lh1p.is_arc_trimmed = 1;
	lh1p.history_fill_val = 0x00;

	de_zeromem(&tlp, sizeof(struct de_dcmpr_two_layer_params));
	tlp.codec1_pushable = dfilter_lh1_codec;
	tlp.codec1_private_params = (void*)&lh1p;

	tlp.codec2 = dfilter_rle90_codec;

	tlp.dcmpri = dcmpri;
	tlp.dcmpro = dcmpro;
	tlp.dres = dres;

	de_dfilter_decompress_two_layer(c, &tlp);
}

// Assembly:
subq $0x68, %rsp
leaq 0x8(%rsp), %rax
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movb $0x1, 0x2(%rax)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
leaq 0xde655(%rip), %rdx     # 0x106c75
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
leaq 0xd27ce(%rip), %rax     # 0xfadfd
movq %rax, 0x18(%rsi)
movq %rcx, 0x28(%rsi)
movq %r8, 0x30(%rsi)
movq %r9, 0x38(%rsi)
callq 0xfb662
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/arc.c
// Function: decompressor_spark_compressed
static void decompressor_spark_compressed(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_UNIXCOMPRESS;
	delzwp.flags |= DE_LZWFLAG_HAS1BYTEHEADER;
	fmtutil_decompress_lzw(c, dcmpri, dcmpro, dres, &delzwp);
}

// Assembly:
subq $0x18, %rsp
movq %r8, %rdx
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x0, 0x10(%r8)
movl $0x1, (%r8)
orb $0x2, 0x4(%r8)
movq %rcx, %rsi
movq %r9, %rcx
callq 0x102cf0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: de_module_amiga_adf
void de_module_amiga_adf(deark *c, struct deark_module_info *mi)
{
	mi->id = "amiga_adf";
	mi->desc = "Amiga disk image";
	mi->run_fn = de_run_amiga_adf;
	mi->identify_fn = de_identify_amiga_adf;
}

// Assembly:
leaq 0xec3e9(%rip), %rax     # 0x114c60
movq %rax, (%rsi)
leaq 0xec3e9(%rip), %rax     # 0x114c6a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x2889c
movq %rax, 0x18(%rsi)
leaq 0x292(%rip), %rax       # 0x28b29
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: de_identify_amiga_adf
static int de_identify_amiga_adf(deark *c)
{
	int has_size;
	int has_ext;

	if(dbuf_memcmp(c->infile, 0, "DOS", 3)) return 0;
	if(de_getbyte(3)>0x05) return 0;
	has_ext = de_input_file_has_ext(c, "adf");
	has_size = (c->infile->len==901120 || c->infile->len==1802240);
	if(has_ext && has_size) return 100;
	if(has_size) return 90;
	if(has_ext) return 60;
	return 20;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x11a9f0(%rip), %rdx    # 0x14352b
xorl %ebx, %ebx
movl $0x3, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x28bbf
movq 0x18(%r14), %rdi
movl $0x3, %esi
callq 0xef0d5
cmpb $0x5, %al
ja 0x28bbf
leaq 0x121d3c(%rip), %rsi    # 0x14a8a2
movq %r14, %rdi
callq 0xea936
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
cmpq $0xdc000, %rcx          # imm = 0xDC000
sete %dl
cmpq $0x1b8000, %rcx         # imm = 0x1B8000
sete %sil
testl %eax, %eax
je 0x28b99
orb %sil, %dl
movl $0x64, %ebx
jne 0x28bbf
movl $0x5a, %ebx
cmpq $0xdc000, %rcx          # imm = 0xDC000
je 0x28bbf
cmpq $0x1b8000, %rcx         # imm = 0x1B8000
je 0x28bbf
testl %eax, %eax
movl $0x3c, %eax
movl $0x14, %ebx
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: test_root_block
static int test_root_block(deark *c, lctx *d, i64 blknum)
{
	i64 pos;

	pos = blocknum_to_offset(d, blknum);
	if(de_getu32be(pos) != ADF_T_HEADER) return 0;
	if(de_getu32be(pos+d->bsize-4) != ADF_ST_ROOT) return 0;
	d->root_block = blknum;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rsi), %r15
imulq %rdx, %r15
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xef32a
xorl %ebp, %ebp
cmpq $0x2, %rax
jne 0x29a4c
movq 0x18(%r12), %rdi
movq 0x8(%r14), %rax
leaq (%r15,%rax), %rsi
addq $-0x4, %rsi
callq 0xef32a
cmpq $0x1, %rax
jne 0x29a4c
movq %rbx, 0x10(%r14)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: claim_block
static int claim_block(deark *c, lctx *d, i64 blknum)
{
	if(blknum<0 || blknum>=d->num_blocks) {
		de_err(c, "Bad block number: %"I64_FMT, blknum);
		return 0;
	}
	if(!d->block_used_flags) {
		d->block_used_flags = de_malloc(c, d->num_blocks);
	}
	if(d->block_used_flags[blknum]) {
		de_err(c, "Attempt to reuse block #%"I64_FMT, blknum);
		return 0;
	}
	d->block_used_flags[blknum] = 1;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x29a9b
movq %rsi, %r15
movq 0x18(%rsi), %rsi
cmpq %rbx, %rsi
jle 0x29a9b
cmpq $0x0, 0x28(%r15)
jne 0x29a88
movq %r14, %rdi
callq 0xe969b
movq %rax, 0x28(%r15)
movq 0x28(%r15), %rax
cmpb $0x0, (%rax,%rbx)
je 0x29abe
leaq 0xeb306(%rip), %rsi     # 0x114d9f
jmp 0x29aa2
leaq 0xeb2e7(%rip), %rsi     # 0x114d89
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xe9df7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, (%rax,%rbx)
movl $0x1, %ebp
jmp 0x29ab1
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: read_protection_flags
static void read_protection_flags(deark *c, lctx *d, struct member_data *md, i64 pos)
{
	UI n;

	n = (UI)de_getu32be(pos);
	de_dbg(c, "protection flags: 0x%08x", n);
	if(md->fi && !md->is_dir) {
		// Some disks use the 0x2 bit to mean "non executable", but I don't think
		// there's a good way to tell *which* disks.
		if((n & 0x0000ff0f)!=0) { // If these flags seem to be used...
			if(n & 0x00000002) {
				md->fi->mode_flags |= DE_MODEFLAG_NONEXE;
			}
			else {
				md->fi->mode_flags |= DE_MODEFLAG_EXE;
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
callq 0xef32a
movq %rax, %r14
leaq 0xeb368(%rip), %rsi     # 0x114e52
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x29b1f
testl $0xff0f, %r14d          # imm = 0xFF0F
je 0x29b1f
cmpb $0x0, 0x10(%rbx)
jne 0x29b1f
andl $0x2, %r14d
xorl %ecx, %ecx
cmpl $0x1, %r14d
adcl $0x1, %ecx
orl %ecx, 0x14(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: read_ofs_timestamp
static void read_ofs_timestamp(deark *c, i64 pos1, struct de_timestamp *ts,
	const char *name)
{
	i64 pos = pos1;
	i64 days, mins, ticks;
	i64 ut;
	char timestamp_buf[64];

	ts->is_valid = 0;
	days = de_getu32be_p(&pos);
	mins = de_getu32be_p(&pos);
	ticks = de_getu32be_p(&pos);
	ut = (6*365 + 2*366) * 86400; // 1970-01-01 to 1978-01-01
	ut += days * 86400;
	ut += mins * 60;
	ut += ticks / 50;

	if(days!=0) {
		de_unix_time_to_timestamp(ut, ts, 0);
		de_timestamp_set_subsec(ts, (double)(ticks%50) / 50.0);
		de_timestamp_to_string(ts, timestamp_buf, sizeof(timestamp_buf), 0);
	}
	else {
		de_strlcpy(timestamp_buf, "none", sizeof(timestamp_buf));
	}

	de_dbg(c, "%s: [%"I64_FMT",%"I64_FMT",%"I64_FMT"] (%s)",
		name, days, mins, ticks, timestamp_buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %rbp
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %rsi, (%r13)
movb $0x0, (%rdx)
movq 0x18(%rdi), %rdi
movq %r13, %rsi
callq 0xef34e
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %r13, %rsi
callq 0xef34e
movq %rax, %r12
movq 0x18(%r14), %rdi
movq %r13, %rsi
callq 0xef34e
movq %rax, %r13
testq %r15, %r15
je 0x29c04
imulq $0x15180, %r15, %rcx    # imm = 0x15180
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0xA3D70A3D70A3D70B
movq %r13, %rax
imulq %rdx
movq %rbx, 0x10(%rsp)
movq %rdx, %rbx
imulq $0x3c, %r12, %rax
addq %rcx, %rax
addq %r13, %rbx
movq %rbx, %rcx
shrq $0x3f, %rcx
sarq $0x5, %rbx
addq %rcx, %rbx
leaq (%rax,%rbx), %rdi
addq $0xf0c3f00, %rdi        # imm = 0xF0C3F00
movq %rbp, %rsi
xorl %edx, %edx
callq 0xeace2
imulq $0x32, %rbx, %rax
movq 0x10(%rsp), %rbx
movq %r13, %rcx
subq %rax, %rcx
cvtsi2sd %rcx, %xmm0
divsd 0xeb072(%rip), %xmm0    # 0x114c58
movq %rbp, %rdi
callq 0xead3a
leaq 0x20(%rsp), %rsi
movl $0x40, %edx
movq %rbp, %rdi
xorl %ecx, %ecx
callq 0xeb4f8
jmp 0x29c1a
leaq 0xe6b1a(%rip), %rsi     # 0x110725
leaq 0x20(%rsp), %rdi
movl $0x40, %edx
callq 0xe8ded
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0xeb241(%rip), %rsi     # 0x114e6b
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0xe9226
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: read_blocks_table
static void read_blocks_table(deark *c, lctx *d, i64 pos, struct block_ptrs_tbl *bpt)
{
	i64 k;

	for(k=0; k<bpt->blocks_tbl_capacity; k++) {
		bpt->blocks_tbl[k] = de_getu32be(pos + 4*k);
		if(c->debug_level>=2 && bpt->blocks_tbl[k]!=0) {
			de_dbg2(c, "blktbl[%d]: %u", (int)k, (UI)bpt->blocks_tbl[k]);
		}
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdx)
jle 0x29cbf
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xeb32c(%rip), %r12     # 0x114f9b
xorl %r13d, %r13d
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xef32a
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
cmpl $0x2, (%r15)
setl %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x29ca9
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe93cf
incq %r13
addq $0x4, %r14
cmpq 0x8(%rbx), %r13
jl 0x29c72
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amiga-dsk.c
// Function: read_file_segment_from_blocks_tbl
static int read_file_segment_from_blocks_tbl(deark *c, lctx *d, struct member_data *md)
{
	i64 nbytes_left_to_copy;
	i64 k;
	int retval = 0;

	nbytes_left_to_copy = md->fsize - md->outf->len;

	for(k=0; k<md->tmpbpt.high_seq; k++) {
		i64 blknum;
		i64 blkpos;
		i64 nbytes_to_copy;

		if(nbytes_left_to_copy<1) break;

		blknum = md->tmpbpt.blocks_tbl[md->tmpbpt.blocks_tbl_capacity-1-k];
		if(!claim_block(c, d, blknum)) {
			goto done;
		}

		blkpos = blocknum_to_offset(d, blknum);
		nbytes_to_copy = d->bsize;
		if(!d->is_ffs) {
			// TODO: If we allow this, it might be better to call
			// do_file_ofs_data_block(), somehow.
			blkpos += 24;
			nbytes_to_copy -= 24;
		}

		if(nbytes_to_copy > nbytes_left_to_copy) {
			nbytes_to_copy = nbytes_left_to_copy;
		}
		dbuf_copy(c->infile, blkpos, nbytes_to_copy, md->outf);
		nbytes_left_to_copy -= nbytes_to_copy;
	}
	retval = 1;

done:
	return retval;
}

// Assembly:
movl $0x1, %eax
cmpq $0x0, 0x70(%rdx)
jle 0x29dbd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x18(%rdx), %rbp
movq 0x50(%rdx), %rax
subq 0x18(%rax), %rbp
movq $-0x8, %rbx
xorl %r12d, %r12d
movq 0x10(%rsp), %r15
testq %rbp, %rbp
jle 0x29d77
movq %rbp, (%rsp)
movq 0x78(%r14), %rax
shlq $0x3, %rax
addq 0x80(%r14), %rax
movq (%rbx,%rax), %r13
movq %r15, %rdi
movq 0x8(%rsp), %rbp
movq %rbp, %rsi
movq %r13, %rdx
callq 0x29a57
testl %eax, %eax
je 0x29d7e
movq 0x8(%rbp), %rax
imulq %rax, %r13
leaq 0x18(%r13), %rsi
cmpb $0x0, (%rbp)
cmovneq %r13, %rsi
leaq -0x18(%rax), %r13
cmovneq %rax, %r13
movq (%rsp), %rbp
cmpq %rbp, %r13
cmovgeq %rbp, %r13
movq 0x18(%r15), %rdi
movq 0x50(%r14), %rcx
movq %r13, %rdx
callq 0xefabc
subq %r13, %rbp
xorl %eax, %eax
jmp 0x29d87
movl $0x2, %eax
jmp 0x29d87
movl $0x5, %eax
movq (%rsp), %rbp
testl %eax, %eax
jne 0x29da3
incq %r12
addq $-0x8, %rbx
cmpq 0x70(%r14), %r12
jl 0x29d06
movl $0x1, %eax
jmp 0x29daf
cmpl $0x2, %eax
movl $0x1, %eax
je 0x29daf
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/binscii.c
// Function: de_module_binscii
void de_module_binscii(deark *c, struct deark_module_info *mi)
{
	mi->id = "binscii";
	mi->desc = "BinSCII";
	mi->run_fn = de_run_binscii;
	mi->identify_fn = de_identify_binscii;
}

// Assembly:
leaq 0xeb32d(%rip), %rax     # 0x1150f4
movq %rax, (%rsi)
leaq 0xeb32b(%rip), %rax     # 0x1150fc
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x29dec
movq %rax, 0x18(%rsi)
leaq 0x8e8(%rip), %rax       # 0x2a6cf
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/binscii.c
// Function: de_identify_binscii
static int de_identify_binscii(deark *c)
{
	int has_ext;
	int ret;
	i64 foundpos;

	has_ext = de_input_file_has_ext(c, "bsc") ||
		de_input_file_has_ext(c, "bsq");
	if(!dbuf_memcmp(c->infile, 0, g_binscii_seg_sig, 18)) {
		return has_ext?100:90;
	}

	if(!has_ext) return 0;

	ret = dbuf_search(c->infile, g_binscii_seg_sig, 18, 0, 4096, &foundpos);
	if(ret) {
		// TODO? We could do better, by making sure the string starts at the
		// beginning of a line, etc.
		return 35;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xeaba1(%rip), %rsi     # 0x115282
callq 0xea936
movb $0x1, %bpl
testl %eax, %eax
jne 0x2a702
leaq 0xeab92(%rip), %rsi     # 0x115286
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
setne %bpl
movq 0x18(%rbx), %rdi
leaq 0xeaa23(%rip), %rdx     # 0x115130
xorl %r14d, %r14d
movl $0x12, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
je 0x2a755
testb %bpl, %bpl
je 0x2a767
movq 0x18(%rbx), %rdi
leaq 0xeaa00(%rip), %rsi     # 0x115130
leaq 0x8(%rsp), %r9
movl $0x12, %edx
movl $0x1000, %r8d           # imm = 0x1000
xorl %ecx, %ecx
callq 0xf1a9c
testl %eax, %eax
movl $0x23, %r14d
cmovel %eax, %r14d
jmp 0x2a767
testb %bpl, %bpl
movl $0x64, %eax
movl $0x5a, %r14d
cmovnel %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/binscii.c
// Function: binscii_close_cur_file
static void binscii_close_cur_file(deark *c, struct binscii_ctx *d)
{
	struct binscii_md *md;

	md = d->cur_md;
	if(!d->cur_md) return;
	de_dbg(c, "closing file");
	if(d->cur_md->orig_len != d->cur_md->nbytes_written) {
		binscii_set_generic_error(c, d);
	}
	dbuf_close(md->outf);
	ucstring_destroy(md->fn);
	de_free(c, md);
	d->cur_md = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x2a7d1
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xeaae8(%rip), %rsi     # 0x115275
xorl %eax, %eax
callq 0xe9226
movq (%rbx), %rax
movq 0x8(%rax), %rcx
cmpq 0x10(%rax), %rcx
je 0x2a7ad
cmpb $0x0, 0xc(%rbx)
jne 0x2a7ad
movw $0x101, 0xc(%rbx)       # imm = 0x101
movq 0x20(%r14), %rdi
callq 0xf0b13
movq 0x18(%r14), %rdi
callq 0xf6bb0
movq %r15, %rdi
movq %r14, %rsi
callq 0xe9752
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/binscii.c
// Function: binscii_decode
static void binscii_decode(deark *c, struct binscii_ctx *d, const u8 *src,
	i64 num_units, dbuf *outf)
{
	i64 i;
	u8 ib[4];

	for(i=0; i<num_units; i++) {
		UI j;

		for(j=0; j<4; j++) {
			ib[j] = d->cur_seg.bmap[(UI)src[i*4+j]];
		}
		dbuf_writebyte(outf, (ib[3]<<2)|(ib[2]>>4));
		dbuf_writebyte(outf, ((ib[2]&0x0f)<<4)|(ib[1]>>2));
		dbuf_writebyte(outf, ((ib[1]&0x03)<<6)|ib[0]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
jle 0x2a879
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
movb 0x120(%r12,%rcx), %cl
movb %cl, 0xc(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x2a801
movb 0xe(%rsp), %bpl
movb 0xf(%rsp), %al
shlb $0x2, %al
movl %ebp, %ecx
shrb $0x4, %cl
orb %al, %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0xf11be
shlb $0x4, %bpl
movb 0xd(%rsp), %r14b
movl %r14d, %eax
shrb $0x2, %al
orb %bpl, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0xf11be
shlb $0x6, %r14b
orb 0xc(%rsp), %r14b
movzbl %r14b, %esi
movq %rbx, %rdi
callq 0xf11be
incq %r13
addq $0x4, %r15
cmpq 0x10(%rsp), %r13
jne 0x2a7ff
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/binscii.c
// Function: binscii_create_output_file
static void binscii_create_output_file(deark *c, struct binscii_ctx *d)
{
	de_finfo *fi = NULL;

	if(!d->cur_md) {
		binscii_set_generic_error(c, d);
		goto done;
	}
	if(d->cur_md->outf) {
		binscii_set_generic_error(c, d);
		goto done;
	}

	fi = de_finfo_create(c);
	if(d->cur_md->fn) {
		de_finfo_set_name_from_ucstring(c, fi, d->cur_md->fn, 0);
		fi->original_filename_flag = 1;
	}
	fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = d->cur_md->mod_time;
	fi->timestamp[DE_TIMESTAMPIDX_CREATE] = d->cur_md->create_time;

	d->cur_md->outf = dbuf_create_output_file(c, NULL, fi, 0);
	dbuf_enable_wbuffer(d->cur_md->outf);

done:
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x2a8a2
cmpq $0x0, 0x20(%rax)
je 0x2a8b5
cmpb $0x0, 0xc(%r15)
jne 0x2a8b0
movw $0x101, 0xc(%r15)       # imm = 0x101
xorl %r14d, %r14d
jmp 0x2a914
movq %rbx, %rdi
callq 0xea9a9
movq %rax, %r14
movq (%r15), %rax
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x2a8de
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xea9e4
movb $0x1, 0x8(%r14)
movq (%r15), %rax
movups 0x28(%rax), %xmm0
movups %xmm0, 0x18(%r14)
movq (%r15), %rax
movups 0x38(%rax), %xmm0
movups %xmm0, 0x28(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xf037a
movq (%r15), %rcx
movq %rax, 0x20(%rcx)
movq %rax, %rdi
callq 0xf0e3f
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xea9b3
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: de_module_jpeg2000
void de_module_jpeg2000(deark *c, struct deark_module_info *mi)
{
	mi->id = "jpeg2000";
	mi->desc = "JPEG 2000 image";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_bmff;
	mi->identify_fn = de_identify_jpeg2000;
}

// Assembly:
leaq 0xea99d(%rip), %rax     # 0x1152c8
movq %rax, (%rsi)
leaq 0xea99c(%rip), %rax     # 0x1152d1
movq %rax, 0x8(%rsi)
leaq 0xea9a1(%rip), %rax     # 0x1152e1
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x2a95b
movq %rax, 0x18(%rsi)
leaq 0x158(%rip), %rax       # 0x2aaae
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: de_run_bmff
static void de_run_bmff(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	struct de_boxesctx *bctx = NULL;
	int skip_autodetect = 0;
	const char *s;

	d = de_malloc(c, sizeof(lctx));
	bctx = de_malloc(c, sizeof(struct de_boxesctx));

	if(de_havemodcode(c, mparams, 'T')) {
		d->is_jumbf = 1;
		skip_autodetect = 1;
	}
	if(de_havemodcode(c, mparams, 'X')) {
		d->is_jpx = 1;
		d->is_jp2_jpx_jpm = 1;
		skip_autodetect = 1;
	}
	if(de_havemodcode(c, mparams, 'B')) {
		d->is_bmff = 1;
		skip_autodetect = 1;
	}

	if(!skip_autodetect) {
		u32 first_boxtype;
		// Try to detect old QuickTime files that don't have an ftyp box.
		first_boxtype = (u32)de_getu32be(4);
		if(first_boxtype==BOX_mdat || first_boxtype==BOX_moov ||
			first_boxtype==BOX_free || first_boxtype==BOX_wide ||
			first_boxtype==BOX_skip || first_boxtype==BOX_pnot)
		{
			d->is_bmff = 1;
		}
	}

	s = de_get_ext_option(c, "bmff:maxentries");
	if(s) {
		d->max_entries_to_print = de_atoi64(s);
	}
	else {
		d->max_entries_to_print = 32;
	}
	if(d->max_entries_to_print<0) {
		d->max_entries_to_print = 0;
	}

	bctx->userdata = (void*)d;
	bctx->f = c->infile;
	bctx->identify_box_fn = my_box_identify_fn;
	bctx->handle_box_fn = my_box_handler;

	fmtutil_read_boxes_format(c, bctx);

	de_free(c, bctx);
	de_free(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movl $0x30, %esi
callq 0xe969b
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
movl $0x54, %edx
callq 0xea97e
testl %eax, %eax
je 0x2a9a6
movb $0x1, 0xa(%r14)
movl $0x1, %ebp
jmp 0x2a9a8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x58, %edx
callq 0xea97e
testl %eax, %eax
je 0x2a9c8
movw $0x101, 0x5(%r14)       # imm = 0x101
movl $0x1, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x42, %edx
callq 0xea97e
testl %eax, %eax
je 0x2a9e6
movb $0x1, 0x4(%r14)
movl $0x1, %ebp
testl %ebp, %ebp
jne 0x2aa30
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef32a
cmpl $0x706e6f73, %eax       # imm = 0x706E6F73
jg 0x2aa16
cmpl $0x66726565, %eax       # imm = 0x66726565
je 0x2aa2b
cmpl $0x6d646174, %eax       # imm = 0x6D646174
je 0x2aa2b
cmpl $0x6d6f6f76, %eax       # imm = 0x6D6F6F76
je 0x2aa2b
jmp 0x2aa30
cmpl $0x706e6f74, %eax       # imm = 0x706E6F74
je 0x2aa2b
cmpl $0x77696465, %eax       # imm = 0x77696465
je 0x2aa2b
cmpl $0x736b6970, %eax       # imm = 0x736B6970
jne 0x2aa30
movb $0x1, 0x4(%r14)
leaq 0xea8f2(%rip), %rsi     # 0x115329
movq %rbx, %rdi
callq 0xea6cb
testq %rax, %rax
je 0x2aa4e
movq %rax, %rdi
callq 0xea786
jmp 0x2aa53
movl $0x20, %eax
movq %rax, 0x10(%r14)
testq %rax, %rax
jns 0x2aa64
movq $0x0, 0x10(%r14)
movq %r14, (%r15)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r15)
leaq 0x129(%rip), %rax       # 0x2ab9f
movq %rax, 0x18(%r15)
leaq 0x231(%rip), %rax       # 0x2acb2
movq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf87fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe9752
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe9752
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: de_module_bmff
void de_module_bmff(deark *c, struct deark_module_info *mi)
{
	mi->id = "bmff";
	mi->desc = "ISO Base Media File Format";
	mi->desc2 = "MP4, QuickTime, etc.";
	mi->id_alias[0] = "mp4";
	mi->run_fn = de_run_bmff;
	mi->identify_fn = de_identify_bmff;
	mi->help_fn = de_help_bmff;
}

// Assembly:
leaq 0xea815(%rip), %rax     # 0x1152f0
movq %rax, (%rsi)
leaq 0xea810(%rip), %rax     # 0x1152f5
movq %rax, 0x8(%rsi)
leaq 0xea820(%rip), %rax     # 0x115310
movq %rax, 0x10(%rsi)
leaq 0xea82a(%rip), %rax     # 0x115325
movq %rax, 0x38(%rsi)
leaq -0x1ab(%rip), %rax      # 0x2a95b
movq %rax, 0x18(%rsi)
leaq 0x10(%rip), %rax        # 0x2ab21
movq %rax, 0x20(%rsi)
leaq 0x75(%rip), %rax        # 0x2ab91
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: de_identify_bmff
static int de_identify_bmff(deark *c)
{
	u32 first_boxtype;

	first_boxtype = (u32)de_getu32be(4);
	if(first_boxtype==BOX_ftyp) return 80;
	if(first_boxtype==BOX_mdat) return 35;
	if(first_boxtype==BOX_moov) return 35;
	if(first_boxtype==BOX_skip) return 10;
	if(first_boxtype==BOX_wide) return 10;
	if(first_boxtype==BOX_pnot) return 10;
	if(first_boxtype==BOX_free) return 9;
	return 0;
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rdi
movl $0x4, %esi
callq 0xef32a
cmpl $0x6d6f6f75, %eax       # imm = 0x6D6F6F75
jle 0x2ab4e
cmpl $0x736b696f, %eax       # imm = 0x736B696F
jg 0x2ab6a
cmpl $0x6d6f6f76, %eax       # imm = 0x6D6F6F76
je 0x2ab63
cmpl $0x706e6f74, %eax       # imm = 0x706E6F74
je 0x2ab78
jmp 0x2ab86
cmpl $0x66726565, %eax       # imm = 0x66726565
je 0x2ab7f
cmpl $0x66747970, %eax       # imm = 0x66747970
je 0x2ab8a
cmpl $0x6d646174, %eax       # imm = 0x6D646174
jne 0x2ab86
movl $0x23, %eax
jmp 0x2ab8f
cmpl $0x736b6970, %eax       # imm = 0x736B6970
je 0x2ab78
cmpl $0x77696465, %eax       # imm = 0x77696465
jne 0x2ab86
movl $0xa, %eax
jmp 0x2ab8f
movl $0x9, %eax
jmp 0x2ab8f
xorl %eax, %eax
jmp 0x2ab8f
movl $0x50, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: my_box_identify_fn
static void my_box_identify_fn(deark *c, struct de_boxesctx *bctx)
{
	const struct box_type_info *bti;
	lctx *d = (lctx*)bctx->userdata;
	struct de_boxdata *curbox = bctx->curbox;
	struct de_boxdata *par = curbox->parent;
	struct de_boxdata *gpar = NULL;
	int is_ilst_child = 0;

	if(curbox->boxtype != BOX_uuid) {
		curbox->box_name = "?";
	}

	if(par) {
		gpar = par->parent;
	}

	if((par && (par->boxtype==BOX_ilst)) ||
		(gpar && (gpar->boxtype==BOX_ilst)) )
	{
		is_ilst_child = 1;
	}

	if(is_ilst_child) {
		bti = find_ilst_box_type_info(c, d, curbox->boxtype);
	}
	else {
		bti = find_box_type_info(c, d, curbox->boxtype, curbox->level);
	}

	if(bti) {
		// So that we don't have to run "find" again in my_box_handler(),
		// record it here.
		curbox->box_userdata = (void*)bti;

		if(bti->name) {
			curbox->box_name = bti->name;
		}
	}
	// TODO: Do we need special handling of 'data' boxes?
}

// Assembly:
movq (%rsi), %rdx
movq 0x28(%rsi), %rax
movq (%rax), %rsi
movl 0xc(%rax), %ecx
cmpl $0x75756964, %ecx       # imm = 0x75756964
je 0x2abbf
leaq 0x1012ae(%rip), %rdi    # 0x12be69
movq %rdi, 0x50(%rax)
testq %rsi, %rsi
je 0x2abc9
movq (%rsi), %rdi
jmp 0x2abcb
xorl %edi, %edi
testq %rsi, %rsi
je 0x2abd9
cmpl $0x696c7374, 0xc(%rsi)  # imm = 0x696C7374
je 0x2abe7
testq %rdi, %rdi
je 0x2ac0d
cmpl $0x696c7374, 0xc(%rdi)  # imm = 0x696C7374
jne 0x2ac0d
xorl %edx, %edx
leaq 0x153770(%rip), %rsi    # 0x17e360
xorl %edi, %edi
cmpl %ecx, (%rdi,%rsi)
je 0x2ac87
addq $0x20, %rdi
cmpq $0x140, %rdi            # imm = 0x140
jne 0x2abf2
jmp 0x2ac9b
xorl %esi, %esi
cmpb $0x0, 0x4(%rdx)
setne %sil
cmpb $0x0, 0x8(%rdx)
leal 0x8(%rsi), %edi
cmovel %esi, %edi
leal 0x10000(%rdi), %esi
cmpb $0x0, 0x5(%rdx)
cmovel %edi, %esi
leal 0x40000(%rsi), %edi
cmpb $0x0, 0xa(%rdx)
cmovel %esi, %edi
movl %edi, %esi
orl $0x80000, %esi          # imm = 0x80000
cmpb $0x0, 0x9(%rdx)
cmovel %edi, %esi
movl 0x8(%rax), %edi
leaq 0x15384c(%rip), %rdx    # 0x17e4a0
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpl %ecx, (%r9,%rdx)
jne 0x2ac73
testl %edi, %edi
jne 0x2ac6c
testb $0x2, 0x8(%r9,%rdx)
jne 0x2ac94
testl %esi, 0x4(%r9,%rdx)
jne 0x2ac8f
incq %r8
addq $0x20, %r9
cmpq $0xf00, %r9             # imm = 0xF00
jne 0x2ac5a
xorl %edx, %edx
jmp 0x2ac9b
addq %rdi, %rsi
movq %rsi, %rdx
jmp 0x2ac9b
addq %r9, %rdx
jmp 0x2ac9b
shlq $0x5, %r8
addq %r8, %rdx
testq %rdx, %rdx
je 0x2acb1
movq %rdx, 0x48(%rax)
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x2acb1
movq %rcx, 0x50(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: my_box_handler
static int my_box_handler(deark *c, struct de_boxesctx *bctx)
{
	const struct box_type_info *bti;
	lctx *d = (lctx*)bctx->userdata;
	struct de_boxdata *curbox = bctx->curbox;

	if(curbox->is_uuid) {
		if(!de_memcmp(curbox->uuid, g_uuid_cr3_85c0, 16)) {
			curbox->is_superbox = 1;
		}
		else if(!de_memcmp(curbox->uuid, g_uuid_cr3_eaf4, 16)) {
			curbox->is_superbox = 1;
			curbox->extra_bytes_before_children = 8;
		}
		else {
			return fmtutil_default_box_handler(c, bctx);
		}
		return 1;
	}

	bti = (const struct box_type_info *)curbox->box_userdata;

	if(bti && (bti->flags2 & 0x1)) {
		curbox->is_superbox = 1;
	}
	else if(d->is_bmff && curbox->parent && (curbox->parent->boxtype==BOX_ilst)) {
		curbox->is_superbox = 1;
	}

	if(bti && bti->hfn) {
		bti->hfn(c, d, bctx);
	}

	return 1;
}

// Assembly:
movq %rsi, %rdx
movq 0x28(%rsi), %rax
cmpl $0x0, 0x10(%rax)
je 0x2acf9
movdqu 0x14(%rax), %xmm0
pcmpeqb 0xea5c4(%rip), %xmm0    # 0x115290
pmovmskb %xmm0, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x2ad41
movdqu 0x14(%rax), %xmm0
pcmpeqb 0xea5bb(%rip), %xmm0    # 0x1152a0
pmovmskb %xmm0, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x2ad4a
movq %rdx, %rsi
jmp 0xf8650
movq (%rdx), %rsi
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x2ad0b
testb $0x1, 0x8(%rcx)
jne 0x2ad23
cmpb $0x0, 0x4(%rsi)
je 0x2ad2a
movq (%rax), %r8
testq %r8, %r8
je 0x2ad2a
cmpl $0x696c7374, 0xc(%r8)   # imm = 0x696C7374
jne 0x2ad2a
movl $0x1, 0x5c(%rax)
testq %rcx, %rcx
je 0x2ad59
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0x2ad59
pushq %rax
callq *%rax
addq $0x8, %rsp
jmp 0x2ad59
movl $0x1, 0x5c(%rax)
jmp 0x2ad59
movl $0x1, 0x5c(%rax)
movq $0x8, 0x70(%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: do_box_ftyp
static void do_box_ftyp(deark *c, lctx *d, struct de_boxesctx *bctx)
{
	i64 i;
	i64 mver;
	i64 num_compat_brands;
	struct de_fourcc brand4cc;
	struct de_boxdata *curbox = bctx->curbox;

	if(curbox->payload_len<4) goto done;
	dbuf_read_fourcc(bctx->f, curbox->payload_pos, &brand4cc, 4, 0x0);
	d->major_brand = brand4cc.id;
	de_dbg(c, "major brand: '%s'", brand4cc.id_dbgstr);
	if(curbox->level==0)
		apply_brand(c, d, d->major_brand);

	if(curbox->payload_len<8) goto done;
	mver = dbuf_getu32be(bctx->f, curbox->payload_pos+4);
	de_dbg(c, "minor version: %u", (unsigned int)mver);

	if(curbox->payload_len<12) goto done;
	num_compat_brands = (curbox->payload_len - 8)/4;

	for(i=0; i<num_compat_brands; i++) {
		dbuf_read_fourcc(bctx->f, curbox->payload_pos + 8 + i*4, &brand4cc, 4, 0x0);
		if(brand4cc.id==0) continue; // Placeholder. Ignore.
		de_dbg(c, "compatible brand: '%s'", brand4cc.id_dbgstr);
		if(curbox->level==0)
			apply_brand(c, d, brand4cc.id);
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x28(%rdx), %rbp
cmpq $0x4, 0x40(%rbp)
jl 0x2b076
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rdi
movq 0x38(%rbp), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
movl 0x4(%r12), %eax
movl %eax, (%r14)
leaq 0x18(%rsp), %rdx
leaq 0xeaa6a(%rip), %rsi     # 0x115a23
movq %r15, %rdi
xorl %eax, %eax
callq 0xe9226
cmpl $0x0, 0x8(%rbp)
jne 0x2afd4
movl (%r14), %esi
movq %r14, %rdi
callq 0x2d63a
cmpq $0x8, 0x40(%rbp)
jl 0x2b076
movq 0x10(%rbx), %rdi
movq 0x38(%rbp), %rsi
addq $0x4, %rsi
callq 0xef32a
leaq 0xeaa3e(%rip), %rsi     # 0x115a35
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x40(%rbp), %r12
cmpq $0xc, %r12
jl 0x2b076
addq $-0x8, %r12
cmpq $0x4, %r12
jb 0x2b076
shrq $0x2, %r12
movl $0x8, %r13d
movq 0x10(%rbx), %rdi
movq 0x38(%rbp), %rsi
addq %r13, %rsi
leaq 0x8(%rsp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
cmpl $0x0, 0xc(%rsp)
je 0x2b06d
movq %r15, %rdi
leaq 0xea9f8(%rip), %rsi     # 0x115a47
leaq 0x18(%rsp), %rdx
xorl %eax, %eax
callq 0xe9226
cmpl $0x0, 0x8(%rbp)
jne 0x2b06d
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x2d63a
addq $0x4, %r13
decq %r12
jne 0x2b021
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: do_box_jP
static void do_box_jP(deark *c, lctx *d, struct de_boxesctx *bctx)
{
	u32 n;
	struct de_boxdata *curbox = bctx->curbox;

	if(curbox->level!=0) return;
	if(curbox->payload_len<4) return;
	n = (u32)dbuf_getu32be(bctx->f, curbox->payload_pos);
	if(n==0x0d0a870a) {
		de_dbg(c, "found JPEG 2000 signature");
	}
}

// Assembly:
pushq %rbx
movq 0x28(%rdx), %rax
cmpl $0x0, 0x8(%rax)
jne 0x2b0c0
cmpq $0x4, 0x40(%rax)
jl 0x2b0c0
movq %rdi, %rbx
movq 0x10(%rdx), %rdi
movq 0x38(%rax), %rsi
callq 0xef32a
cmpl $0xd0a870a, %eax        # imm = 0xD0A870A
jne 0x2b0c0
leaq 0xea9a9(%rip), %rsi     # 0x115a5e
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0xe9226
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: do_box_stco
static void do_box_stco(deark *c, lctx *d, struct de_boxesctx *bctx)
{
	u8 version;
	u32 flags;
	struct de_boxdata *curbox = bctx->curbox;
	i64 pos = curbox->payload_pos;
	i64 e_count;
	i64 e_size;

	do_read_version_and_flags(c, d, bctx, &version, &flags, 1);
	pos += 4;
	if(version!=0 || flags!=0) return;

	e_size = (bctx->curbox->boxtype == BOX_co64) ? 8 : 4;
	e_count = dbuf_getu32be_p(bctx->f, &pos);
	de_dbg(c, "entry count: %u", (unsigned int)e_count);

	do_simple_int_table(c, d, bctx, pos, e_count, e_size, "entry", "chunk offset");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdx), %rax
movq 0x38(%rax), %rsi
movq %rsi, (%rsp)
movq 0x10(%rdx), %rdi
callq 0xef32a
movq %rax, %r12
movl %r12d, %edx
shrl $0x18, %edx
leaq 0xea98d(%rip), %rsi     # 0x115a88
movl %r12d, %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
setne %bpl
movq %r15, %rdi
xorl %eax, %eax
callq 0xe9226
addq $0x4, (%rsp)
shrq $0x18, %r12
testb %r12b, %r12b
setne %al
orb %bpl, %al
jne 0x2b190
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x636f3634, 0xc(%rax)  # imm = 0x636F3634
sete %cl
leaq 0x4(,%rcx,4), %r12
movq %rsp, %r13
movq %r13, %rsi
callq 0xef34e
movq %rax, %rbp
leaq 0xea921(%rip), %rsi     # 0x115a78
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
movq (%r13), %rcx
leaq 0xea2eb(%rip), %rax     # 0x115459
leaq 0x1196be(%rip), %r10    # 0x144833
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %r8
movq %r12, %r9
pushq %rax
pushq %r10
callq 0x2d6e5
addq $0x10, %rsp
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: do_box_colr_bmff
static void do_box_colr_bmff(deark *c, lctx *d, struct de_boxesctx *bctx)
{
	struct de_boxdata *curbox = bctx->curbox;
	i64 pos = curbox->payload_pos;
	struct de_fourcc ct4cc; // colour_type

	if(curbox->payload_len<4) goto done;

	dbuf_read_fourcc(bctx->f, pos, &ct4cc, 4, 0x0);
	de_dbg(c, "colour type: '%s'", ct4cc.id_dbgstr);
	pos += 4;

	if(ct4cc.id==CODE_rICC || ct4cc.id==CODE_prof) {
		dbuf_create_file_from_slice(bctx->f, pos,
			curbox->payload_pos+curbox->payload_len-pos,
			"icc", NULL, DE_CREATEFLAG_IS_AUX);
	}

done:
	;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq 0x28(%rdx), %r13
cmpq $0x4, 0x40(%r13)
jl 0x2b23b
movq %rdx, %r14
movq %rdi, %r15
movq 0x38(%r13), %rbx
movq 0x10(%rdx), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
leaq 0x10(%rsp), %r12
leaq 0xea8f3(%rip), %rsi     # 0x115adb
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xe9226
movl -0xc(%r12), %eax
cmpl $0x72494343, %eax       # imm = 0x72494343
je 0x2b208
cmpl $0x70726f66, %eax       # imm = 0x70726F66
jne 0x2b23b
movq 0x10(%r14), %rdi
movq 0x38(%r13), %rax
movq 0x40(%r13), %rcx
subq %rbx, %rax
addq $0x4, %rbx
leaq (%rax,%rcx), %rdx
addq $-0x4, %rdx
leaq 0xea8c3(%rip), %rcx     # 0x115aed
movq %rbx, %rsi
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xf0321
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: do_box_dref
static void do_box_dref(deark *c, lctx *d, struct de_boxesctx *bctx)
{
	i64 nitems;
	u8 version;
	struct de_boxdata *curbox = bctx->curbox;
	i64 pos = curbox->payload_pos;

	do_read_version_and_flags(c, d, bctx, &version, NULL, 1);
	pos += 4;

	nitems = dbuf_getu32be_p(bctx->f, &pos);
	de_dbg(c, "number of items: %u", (unsigned int)nitems);

	curbox->num_children_is_known = 1;
	curbox->num_children = nitems;
	curbox->extra_bytes_before_children = pos - curbox->payload_pos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movq 0x28(%rdx), %r12
movq 0x38(%r12), %rsi
movq %rsp, %rbx
movq %rsi, (%rbx)
movq 0x10(%rdx), %rdi
callq 0xef32a
movl %eax, %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
shrl $0x18, %eax
leaq 0xea807(%rip), %rsi     # 0x115a88
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
addq $0x4, (%rbx)
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0xef34e
movq %rax, %r15
leaq 0xea84a(%rip), %rsi     # 0x115af1
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
movl $0x1, 0x60(%r12)
movq %r15, 0x68(%r12)
movq (%rbx), %rax
subq 0x38(%r12), %rax
movq %rax, 0x70(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/bmff.c
// Function: do_box_hdlr
static void do_box_hdlr(deark *c, lctx *d, struct de_boxesctx *bctx)
{
	de_ucstring *s = NULL;
	struct de_boxdata *curbox = bctx->curbox;
	i64 pos = curbox->payload_pos;
	struct de_fourcc tmp4cc;

	if(curbox->payload_len<4) goto done;
	do_read_version_and_flags(c, d, bctx, NULL, NULL, 1);
	pos += 4;
	if(curbox->payload_len<24) goto done;
	pos += 4; // "Predefined"

	dbuf_read_fourcc(bctx->f, pos, &tmp4cc, 4, 0x0);
	de_dbg(c, "handler type: '%s'", tmp4cc.id_dbgstr);
	pos += 4;

	pos += 12; // reserved
	if(curbox->payload_len<25) goto done;
	if(dbuf_getbyte(bctx->f, pos) == 0x00) goto done;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(bctx->f, pos, curbox->payload_pos + curbox->payload_len - pos,
		DE_DBG_MAX_STRLEN, s, DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_UTF8);
	de_dbg(c, "metadata type name: \"%s\"", ucstring_getpsz_d(s));

done:
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x28(%rdx), %rbp
cmpq $0x4, 0x40(%rbp)
jge 0x2b2fc
xorl %r14d, %r14d
jmp 0x2b3ed
movq %rdx, %r15
movq %rdi, %rbx
movq 0x38(%rbp), %r12
movq 0x10(%rdx), %rdi
movq %r12, %rsi
callq 0xef32a
movl %eax, %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
shrl $0x18, %eax
leaq 0xea764(%rip), %rsi     # 0x115a88
xorl %r14d, %r14d
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
cmpq $0x18, 0x40(%rbp)
jl 0x2b3ed
leaq 0x8(%r12), %rsi
movq 0x10(%r15), %rdi
leaq 0x8(%rsp), %rdx
xorl %r14d, %r14d
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0xf1d74
leaq 0x18(%rsp), %rdx
leaq 0xea79d(%rip), %rsi     # 0x115b05
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
cmpq $0x19, 0x40(%rbp)
jl 0x2b3ed
leaq 0x18(%r12), %r13
movq 0x10(%r15), %rdi
movq %r13, %rsi
callq 0xef0d5
testb %al, %al
je 0x2b2f4
movq %rbx, %rdi
callq 0xf6870
movq %rax, %r14
movq 0x10(%r15), %rdi
movq 0x38(%rbp), %rax
movq 0x40(%rbp), %rcx
subq %r12, %rax
leaq (%rax,%rcx), %rdx
addq $-0x18, %rdx
movl $0x2, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r13, %rsi
movq %r14, %r8
movl $0x1, %r9d
callq 0xf0203
movq %r14, %rdi
callq 0xf7557
leaq 0xea738(%rip), %rsi     # 0x115b18
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
callq 0xf6bb0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq