LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/gif.c
// Function: my_giflzw_write_cb
static void my_giflzw_write_cb(dbuf *f, void *userdata,
	const u8 *buf, i64 size)
{
	i64 i;
	struct my_giflzw_userdata *u = (struct my_giflzw_userdata*)userdata;

	for(i=0; i<(i64)size; i++) {
		do_record_pixel(u->c, u->d, u->gi,
			buf[i], i);
	}
	u->gi->pixels_set += (i64)size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
xorl %r12d, %r12d
testq %rcx, %rcx
movl $0x0, %r13d
cmovgq %rcx, %r13
cmpq %r12, %r13
je 0x50572
movq 0x10(%r14), %rsi
movq 0x28(%rsi), %rax
addq %r12, %rax
cqto
idivq 0x18(%rsi)
movq 0x50(%rsi), %rcx
testq %rcx, %rcx
je 0x50513
cmpq 0x20(%rsi), %rax
jge 0x50513
movzwl (%rcx,%rax,2), %eax
movq 0x8(%r14), %r8
movzbl (%r15,%r12), %edi
cmpl $0x0, 0x34(%rsi)
je 0x5052e
cmpq %rdi, 0x48(%rsi)
jle 0x5052e
leaq 0x58(%rsi), %rcx
jmp 0x50532
leaq 0x38(%r8), %rcx
movl (%rcx,%rdi,4), %ecx
movq 0x440(%r8), %r8
testq %r8, %r8
je 0x50556
cmpb $0x0, 0x1(%r8)
je 0x50556
cmpb %dil, 0x2(%r8)
jne 0x50556
andl $0xffffff, %ecx         # imm = 0xFFFFFF
jmp 0x5055c
orl $0xff000000, %ecx       # imm = 0xFF000000
movq (%rsi), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xe7287
incq %r12
jmp 0x504e6
movq 0x10(%r14), %rax
addq %rbx, 0x28(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/gif.c
// Function: callback_for_image_subblock
static void callback_for_image_subblock(deark *c, lctx *d, struct subblock_reader_data *sbrd)
{
	struct gif_image_data *gi = (struct gif_image_data*)sbrd->userdata;

	if(sbrd->reported_dlen==0) {
		de_dbg(c, "block terminator at %"I64_FMT, sbrd->subblkpos);
		return;
	}
	de_dbg2(c, "sub-block at %"I64_FMT", size=%"I64_FMT, sbrd->subblkpos, sbrd->reported_dlen);

	if(!gi->failure_flag && !gi->dfctx->finished_flag) {
		de_dfilter_addslice(gi->dfctx, sbrd->inf, sbrd->dpos, sbrd->dlen);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x18(%rdx), %rdx
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x505c2
movq (%rbx), %r14
leaq 0xc2a7a(%rip), %rsi     # 0x11301c
xorl %eax, %eax
callq 0xde9f1
cmpl $0x0, 0x38(%r14)
jne 0x505ba
movq 0x40(%r14), %rdi
cmpb $0x0, 0x20(%rdi)
je 0x505d7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc2a3b(%rip), %rsi     # 0x113004
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde896
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeea0d
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grasp.c
// Function: de_module_graspgl
void de_module_graspgl(deark *c, struct deark_module_info *mi)
{
	mi->id = "graspgl";
	mi->desc = "GRASP GL animation";
	mi->run_fn = de_run_graspgl;
	mi->identify_fn = de_identify_graspgl;
}

// Assembly:
leaq 0xc2b57(%rip), %rax     # 0x11314e
movq %rax, (%rsi)
leaq 0xc2b55(%rip), %rax     # 0x113156
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x5061c
movq %rax, 0x18(%rsi)
leaq 0x321(%rip), %rax       # 0x50938
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grasp.c
// Function: de_identify_graspgl
static int de_identify_graspgl(deark *c)
{
	i64 index_size;
	i64 index_pos;
	i64 first_offset;
	int is_le = 1;
	int gl_ext;

	index_size = de_getu16le(0);
	if(index_size==0x4741) {
		if((UI)de_getu16be(2)==0x0100U) {
			is_le = 0; // Amiga GL?
			index_size = de_getu16be(4);
		}
	}

	// Header should be a nonzero multiple of 17 bytes.
	if(index_size==0 || (index_size%17 != 0)) return 0;
	index_pos = is_le ? 2 : 6;
	if(index_pos+index_size>c->infile->len) return 0;

	gl_ext = de_input_file_has_ext(c, "gl");

	// Most likely, the first embedded file immediately follows
	// the header. If so, it's pretty good evidence this is a
	// grasp_gl file.
	first_offset = dbuf_getu32x(c->infile, index_pos, is_le);

	if(first_offset>c->infile->len || first_offset<index_pos+index_size) return 0;
	if(first_offset == index_pos+index_size)
		return gl_ext ? 100 : 70;

	if(gl_ext) return 5;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3fa3
pushq $0x1
popq %rbp
cmpq $0x4741, %rax           # imm = 0x4741
jne 0x50990
movq 0x18(%r14), %rdi
pushq $0x2
popq %r12
movq %r12, %rsi
callq 0xe3f46
movl $0x4741, %r15d          # imm = 0x4741
cmpl $0x100, %eax            # imm = 0x100
jne 0x50997
movq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
callq 0xe3f46
movq %rax, %r15
xorl %ebp, %ebp
pushq $0x6
jmp 0x50995
movq %rax, %r15
pushq $0x2
popq %r12
pushq $0x11
popq %rcx
movq %r15, %rax
cqto
idivq %rcx
testq %r15, %r15
je 0x509b9
testq %rdx, %rdx
jne 0x509b9
addq %r12, %r15
movq 0x18(%r14), %rax
cmpq 0x18(%rax), %r15
jle 0x509ca
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2782(%rip), %rsi     # 0x113153
movq %r14, %rdi
callq 0xdfcd5
movl %eax, %r13d
movq 0x18(%r14), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xe41cb
cmpq %r15, %rax
jl 0x509b9
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rax
jg 0x509b9
cmpq %r15, %rax
jne 0x50a0c
testl %r13d, %r13d
pushq $0x46
popq %rax
pushq $0x64
popq %rbx
cmovel %eax, %ebx
jmp 0x509b9
xorl %eax, %eax
testl %r13d, %r13d
setne %al
leal (%rax,%rax,4), %ebx
jmp 0x509b9
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grasp.c
// Function: de_module_graspfont
void de_module_graspfont(deark *c, struct deark_module_info *mi)
{
	mi->id = "graspfont";
	mi->desc = "GRASP font";
	mi->run_fn = de_run_graspfont;
	mi->identify_fn = de_identify_graspfont;
}

// Assembly:
leaq 0xc2749(%rip), %rax     # 0x113169
movq %rax, (%rsi)
leaq 0xc2749(%rip), %rax     # 0x113173
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x50a45
movq %rax, 0x18(%rsi)
leaq 0x50a(%rip), %rax       # 0x50f4a
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grasp.c
// Function: de_identify_graspfont
static int de_identify_graspfont(deark *c)
{
	i64 reported_filesize;
	i64 num_chars;
	i64 bytes_per_glyph;

	if(!de_input_file_has_ext(c, "set") && !de_input_file_has_ext(c, "fnt"))
		return 0;

	if(gfont_is_new_format(c)) {
		return 30;
	}

	reported_filesize = de_getu16le(0);
	if(reported_filesize != c->infile->len) return 0;
	num_chars = (i64)de_getbyte(2);
	if(num_chars==0) num_chars=256;
	bytes_per_glyph = (i64)de_getbyte(6);
	if(7+num_chars*bytes_per_glyph == reported_filesize)
		return 100;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc0bb8(%rip), %rsi     # 0x111b11
callq 0xdfcd5
testl %eax, %eax
jne 0x50f75
leaq 0xbf374(%rip), %rsi     # 0x1102dd
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
je 0x50fdf
movq %rbx, %rdi
callq 0x50feb
testl %eax, %eax
je 0x50f87
pushq $0x1e
popq %r15
jmp 0x50fe2
movq 0x18(%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0xe3fa3
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jne 0x50fe2
movq %rax, %r14
pushq $0x2
popq %rsi
callq 0xe3eb4
movzbl %al, %eax
testb %al, %al
movl $0x100, %r15d           # imm = 0x100
cmovneq %rax, %r15
movq 0x18(%rbx), %rdi
pushq $0x6
popq %rsi
callq 0xe3eb4
movzbl %al, %eax
imulq %r15, %rax
addq $0x7, %rax
xorl %ecx, %ecx
cmpq %r14, %rax
pushq $0x64
popq %r15
cmovnel %ecx, %r15d
jmp 0x50fe2
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grob.c
// Function: de_module_grob
void de_module_grob(deark *c, struct deark_module_info *mi)
{
	mi->id = "grob";
	mi->desc = "GROB - HP48/49 calculator image";
	mi->run_fn = de_run_grob;
	mi->identify_fn = de_identify_grob;
	mi->help_fn = de_help_grob;
}

// Assembly:
leaq 0xc2327(%rip), %rax     # 0x113356
movq %rax, (%rsi)
leaq 0xc2322(%rip), %rax     # 0x11335b
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x5105f
movq %rax, 0x18(%rsi)
leaq 0x43b(%rip), %rax       # 0x5148a
movq %rax, 0x20(%rsi)
leaq 0x4ba(%rip), %rax       # 0x51514
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grob.c
// Function: de_identify_grob
static int de_identify_grob(deark *c)
{
	u8 buf[10];
	de_read(buf, 0, 10);

	if(buf[0]=='H' && buf[1]=='P' && buf[2]=='H' && buf[3]=='P' &&
		buf[4]=='4' && (buf[5]=='8' || buf[5]=='9') &&
		buf[8]==0x1e && buf[9]==0x2b)
	{
			return 100;
	}

	if(buf[0]=='G' && buf[1]=='R' && buf[2]=='O' && buf[3]=='B') {
		return 90;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0xe(%rsp), %r14
pushq $0xa
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xe3cb7
movb (%r14), %cl
cmpb $0x48, %cl
setne %dl
movd 0x1(%r14), %xmm0
movd %xmm0, %eax
cmpl $0x34504850, %eax       # imm = 0x34504850
setne %sil
orb %dl, %sil
jne 0x514e9
movb 0x13(%rsp), %dl
andb $-0x2, %dl
cmpb $0x38, %dl
jne 0x514e9
cmpb $0x1e, 0x16(%rsp)
jne 0x514e9
cmpb $0x2b, 0x17(%rsp)
jne 0x514e9
pushq $0x64
popq %rbx
jmp 0x5150a
xorb $0x47, %cl
movl %eax, %edx
xorb $0x52, %dl
orb %cl, %dl
movl %eax, %ecx
shrl $0x8, %ecx
xorb $0x4f, %cl
orb %dl, %cl
shrl $0x10, %eax
xorb $0x42, %al
orb %cl, %al
pushq $0x5a
popq %rax
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/grob.c
// Function: grob_read_binary_bitmap
static void grob_read_binary_bitmap(deark *c, lctx *d, dbuf *inf, i64 pos)
{
	i64 h_logical;
	i64 rowspan;
	i64 pdwidth;
	de_bitmap *img = NULL;
	de_color pal[256];

	if(d->num_planes<=1) {
		de_convert_and_write_image_bilevel2(inf, pos, d->w, d->h_phys, (d->w+7)/8,
			DE_CVTF_WHITEISZERO|DE_CVTF_LSBFIRST, NULL, 0);
		return;
	}
	if(d->num_planes>8) goto done;

	if((d->h_phys % d->num_planes) != 0) {
		de_warn(c, "Number of rows is not divisible by number of planes. The grob:planes "
			"setting is probably not correct.");
	}
	h_logical = d->h_phys/d->num_planes;

	if(!de_good_image_dimensions(c, d->w, h_logical))
		goto done;

	de_dbg(c, "logical dimensions: %d"DE_CHAR_TIMES"%d", (int)d->w, (int)h_logical);

	rowspan = (d->w+7)/8;
	pdwidth = rowspan * 8;
	img = de_bitmap_create2(c, d->w, pdwidth, h_logical, 1);

	de_zeromem(pal, sizeof(pal));
	de_make_grayscale_palette(pal, 1ULL<<d->num_planes, 0x1);

	de_convert_image_paletted_planar(inf, pos, d->num_planes,
		rowspan, h_logical*rowspan, pal, img, 0x1 | (d->grayscale_lsb?0x02:0));

	de_bitmap_write_to_file_finfo(img, NULL, 0);
done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x18(%rsi), %rsi
cmpq $0x1, %rsi
jg 0x51594
movq (%r15), %r8
movq 0x8(%r15), %rcx
leaq 0x7(%r8), %rax
pushq $0x8
popq %rsi
cqto
idivq %rsi
pushq $0x3
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r8, %rdx
movq %rax, %r8
pushq $0x0
pushq $0x0
callq 0xe78af
addq $0x418, %rsp            # imm = 0x418
jmp 0x516a2
cmpq $0x8, %rsi
ja 0x51690
movq %rdi, %r13
movq 0x8(%r15), %rcx
movq %rcx, %rax
cqto
idivq %rsi
testq %rdx, %rdx
je 0x515cb
leaq 0xc1ea0(%rip), %rsi     # 0x113459
movq %r13, %rdi
xorl %eax, %eax
callq 0xdf05a
movq 0x8(%r15), %rcx
movq 0x18(%r15), %rsi
movq %rcx, %rax
cqto
idivq %rsi
movq %rax, %r12
movq (%r15), %rsi
movq %r13, %rdi
movq %rax, %rdx
callq 0xe6be1
testl %eax, %eax
je 0x51690
movl (%r15), %edx
leaq 0xc1ec9(%rip), %rsi     # 0x1134bf
movq %r13, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0xde896
movq (%r15), %rsi
leaq 0x7(%rsi), %rax
pushq $0x8
popq %rcx
cqto
idivq %rcx
movq %rax, %rbp
leaq (,%rax,8), %rdx
pushq $0x1
popq %r8
movq %r13, %rdi
movq %r12, %rcx
callq 0xe746f
movq %rax, %r13
movq %rsp, %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x18140
movb 0x18(%r15), %cl
pushq $0x1
popq %rsi
shlq %cl, %rsi
movq %rsp, %rdi
pushq $0x1
popq %rdx
callq 0xe87a8
movq 0x18(%r15), %rdx
imulq %rbp, %r12
xorl %eax, %eax
cmpl $0x0, 0x20(%r15)
setne %al
leal 0x1(%rax,%rax), %eax
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r12, %r8
movq %rsp, %r9
pushq %rax
pushq %r13
callq 0xe7de1
popq %rax
popq %rcx
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe70ab
jmp 0x51693
xorl %r13d, %r13d
movq %r13, %rdi
callq 0xe7084
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/gzip.c
// Function: de_module_gzip
void de_module_gzip(deark *c, struct deark_module_info *mi)
{
	mi->id = "gzip";
	mi->desc = "gzip compressed file";
	mi->run_fn = de_run_gzip;
	mi->identify_fn = de_identify_gzip;
}

// Assembly:
leaq 0xc1ee6(%rip), %rax     # 0x11359d
movq %rax, (%rsi)
leaq 0xc1ee1(%rip), %rax     # 0x1135a2
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x516dc
movq %rax, 0x18(%rsi)
leaq 0x591(%rip), %rax       # 0x51c68
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: de_module_cdr_wl
void de_module_cdr_wl(deark *c, struct deark_module_info *mi)
{
	mi->id = "cdr_wl";
	mi->desc = "CorelDRAW (old WL format)";
	mi->desc2 = "extract preview image";
	mi->run_fn = de_run_cdr_wl;
	mi->identify_fn = de_identify_cdr_wl;
	mi->help_fn = de_help_cdr_wl;
}

// Assembly:
leaq 0xc1af5(%rip), %rax     # 0x1137a8
movq %rax, (%rsi)
leaq 0xc1af2(%rip), %rax     # 0x1137af
movq %rax, 0x8(%rsi)
leaq 0xbd74a(%rip), %rax     # 0x10f412
movq %rax, 0x10(%rsi)
leaq 0x1b(%rip), %rax        # 0x51cee
movq %rax, 0x18(%rsi)
leaq 0x140(%rip), %rax       # 0x51e1e
movq %rax, 0x20(%rsi)
leaq 0x17f(%rip), %rax       # 0x51e68
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: de_module_corel_clb
void de_module_corel_clb(deark *c, struct deark_module_info *mi)
{
	mi->id = "corel_clb";
	mi->desc = "CorelMOSAIC .CLB library";
	mi->run_fn = de_run_corel_clb;
	mi->identify_fn = de_identify_corel_clb;
	mi->help_fn = de_help_corel_clb;
}

// Assembly:
leaq 0xc1955(%rip), %rax     # 0x1137c9
movq %rax, (%rsi)
leaq 0xc1955(%rip), %rax     # 0x1137d3
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x51ea4
movq %rax, 0x18(%rsi)
leaq 0x3d3(%rip), %rax       # 0x52267
movq %rax, 0x20(%rsi)
leaq 0x44c(%rip), %rax       # 0x522eb
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: de_identify_corel_clb
static int de_identify_corel_clb(deark *c)
{
	i64 nlen, n;

	// This might be too strict. Need more samples.
	if(!de_input_file_has_ext(c, "clb")) return 0;
	nlen = de_getu16le(0);
	if(nlen<1 || nlen>63) return 0;
	if(de_getbyte(2+nlen-1)!=0x00) return 0;
	n = de_getu32le(2+nlen+4);
	if(n!=0x00000001) return 0;
	n = de_getu32le(2+nlen+16);
	if(n!=2+nlen+20 && n!=0) return 0;
	return 100;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xc1559(%rip), %rsi     # 0x1137cf
callq 0xdfcd5
testl %eax, %eax
je 0x522e1
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe3fa3
movq %rax, %r15
addq $-0x40, %rax
cmpq $-0x3f, %rax
jb 0x522e3
movq 0x18(%r14), %rdi
leaq 0x1(%r15), %rsi
callq 0xe3eb4
testb %al, %al
jne 0x522e3
movq 0x18(%r14), %rdi
leaq 0x6(%r15), %rsi
callq 0xe409f
cmpq $0x1, %rax
jne 0x522e3
movq 0x18(%r14), %rdi
leaq 0x12(%r15), %rsi
callq 0xe409f
addq $0x16, %r15
xorl %ebx, %ebx
testq %rax, %rax
pushq $0x64
popq %rcx
cmovel %ecx, %ebx
cmpq %r15, %rax
cmovel %ecx, %ebx
jmp 0x522e3
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: de_module_corel_bmf
void de_module_corel_bmf(deark *c, struct deark_module_info *mi)
{
	mi->id = "corel_bmf";
	mi->desc = "Corel Gallery BMF";
	mi->run_fn = de_run_corel_bmf;
	mi->identify_fn = de_identify_corel_bmf;
}

// Assembly:
leaq 0xc14f5(%rip), %rax     # 0x1137ec
movq %rax, (%rsi)
leaq 0xc14f5(%rip), %rax     # 0x1137f6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x5231c
movq %rax, 0x18(%rsi)
leaq 0xfe(%rip), %rax        # 0x52415
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: de_run_corel_bmf
static void de_run_corel_bmf(deark *c, de_module_params *mparams1)
{
	de_module_params *mparams2 = NULL;
	int saved_indent_level;
	i64 pos;
	i64 n;
	i64 seg_size;

	de_dbg_indent_save(c, &saved_indent_level);
	pos = 65;
	seg_size = de_getu32le_p(&pos);
	de_dbg(c, "preview image segment at %"I64_FMT", len=%"I64_FMT, pos, seg_size);
	de_dbg_indent(c, 1);

	if(pos + seg_size > c->infile->len) {
		seg_size = c->infile->len - pos;
	}

	n = de_getu32le(pos);
	if(n!=40) {
		de_err(c, "Unsupported Corel BMF version");
		goto done;
	}

	mparams2 = de_malloc(c, sizeof(de_module_params));
	mparams2->in_params.codes = "X";
	mparams2->in_params.flags = 0x81;
	de_run_module_by_id_on_slice(c, "dib", mparams2, c->infile, pos, seg_size);

done:
	de_free(c, mparams2);
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
callq 0xdebae
leaq 0x8(%rsp), %r15
movq $0x41, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xe40bf
movq %rax, %r14
movq (%r15), %rdx
leaq 0xc15f9(%rip), %rsi     # 0x113954
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq (%r15), %r15
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %r13
movq %r15, %rsi
callq 0xe409f
cmpq $0x28, %rax
jne 0x523dc
movq %r13, %r12
subq %r15, %r12
addq %r14, %r15
cmpq %r13, %r15
cmovleq %r14, %r12
pushq $0x70
popq %rsi
movq %rbx, %rdi
callq 0xdecaf
movq %rax, %r14
leaq 0xe423b(%rip), %rax     # 0x1365ec
movq %rax, (%r14)
movl $0x81, 0x8(%r14)
movq 0x18(%rbx), %rcx
movq 0x8(%rsp), %r8
leaq 0xc3e83(%rip), %rsi     # 0x11624f
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %r9
callq 0xdf9b8
jmp 0x523f0
leaq 0xc1597(%rip), %rsi     # 0x11397a
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0xded32
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xdebb7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: de_module_corel_ccx
void de_module_corel_ccx(deark *c, struct deark_module_info *mi)
{
	mi->id = "corel_ccx";
	mi->desc = "Corel CCX";
	mi->desc2 = "Decompress to CMX";
	mi->run_fn = de_run_corel_ccx;
	mi->identify_fn = de_identify_corel_ccx;
}

// Assembly:
leaq 0xc13ca(%rip), %rax     # 0x113808
movq %rax, (%rsi)
leaq 0xc13ca(%rip), %rax     # 0x113812
movq %rax, 0x8(%rsi)
leaq 0xc13c9(%rip), %rax     # 0x11381c
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x5246e
movq %rax, 0x18(%rsi)
leaq 0x31d(%rip), %rax       # 0x52786
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/corel.c
// Function: my_ccx_chunk_handler
static int my_ccx_chunk_handler(struct de_iffctx *ictx)
{
	lctx *d = (lctx*)ictx->userdata;

	switch(ictx->chunkctx->chunk4cc.id) {
	case CODE_RIFF:
		ictx->is_std_container = 1;
		return 1;
	case CODE_pack:
		d->pack_pos = ictx->chunkctx->pos;
		d->pack_dpos = ictx->chunkctx->dpos;
		d->pack_dlen = ictx->chunkctx->dlen;
		// We have what we need; tell the RIFF parser to stop.
		return 0;
	}

	ictx->handled = 1; // We're just scanning the file, so suppress default chunk handling
	return 1;
}

// Assembly:
movq 0x128(%rdi), %rax
movl 0x4(%rax), %ecx
cmpl $0x7061636b, %ecx       # imm = 0x7061636B
je 0x527f7
cmpl $0x52494646, %ecx       # imm = 0x52494646
jne 0x5280d
movl $0x1, 0x134(%rdi)
jmp 0x52817
movq 0x10(%rdi), %rcx
movq 0x30(%rax), %rdx
movq %rdx, (%rcx)
movups 0x40(%rax), %xmm0
movups %xmm0, 0x8(%rcx)
xorl %eax, %eax
retq
movl $0x1, 0x130(%rdi)
pushq $0x1
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: de_module_hfs
void de_module_hfs(deark *c, struct deark_module_info *mi)
{
	mi->id = "hfs";
	mi->desc = "HFS filesystem image";
	mi->run_fn = de_run_hfs;
	mi->identify_fn = de_identify_hfs;
}

// Assembly:
leaq 0xb4bc0(%rip), %rax     # 0x1073e3
movq %rax, (%rsi)
leaq 0xc1246(%rip), %rax     # 0x113a73
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x52848
movq %rax, 0x18(%rsi)
leaq 0x3ff(%rip), %rax       # 0x52c42
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: de_identify_hfs
static int de_identify_hfs(deark *c)
{
	i64 drAlBlkSiz;
	int has_ext;

	if(dbuf_memcmp(c->infile, 1024, "BD", 2)) return 0;

	// Allocation block size must be a nonzero multiple of 512.
	drAlBlkSiz = de_getu32be(1024+20);
	if(drAlBlkSiz==0 || (drAlBlkSiz%512)!=0) return 0;

	has_ext = de_input_file_has_ext(c, "hfs");
	return has_ext?90:15;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xc12fc(%rip), %rdx     # 0x113f4f
pushq $0x2
popq %rcx
movl $0x400, %esi            # imm = 0x400
callq 0xe4d48
xorl %ebp, %ebp
testl %eax, %eax
jne 0x52c9f
movq 0x18(%rbx), %rdi
movl $0x414, %esi            # imm = 0x414
callq 0xe404f
testq %rax, %rax
sete %cl
testw $0x1ff, %ax             # imm = 0x1FF
setne %al
orb %cl, %al
jne 0x52c9f
leaq 0xb4757(%rip), %rsi     # 0x1073e3
movq %rbx, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0xf
popq %rax
pushq $0x5a
popq %rbp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: read_one_timestamp
static void read_one_timestamp(deark *c, lctx *d, i64 pos, struct de_timestamp *returned_ts,
	const char *name)
{
	i64 ts_raw;
	struct de_timestamp ts;
	char timestamp_buf[64];

	de_zeromem(&ts, sizeof(struct de_timestamp));
	ts.is_valid = 0;
	ts_raw = de_getu32be(pos);
	if(ts_raw!=0) {
		de_mac_time_to_timestamp(ts_raw, &ts);
	}

	if(returned_ts) {
		*returned_ts = ts;
	}

	if(ts.is_valid) {
		de_timestamp_to_string(&ts, timestamp_buf, sizeof(timestamp_buf), 0);
	}
	else {
		de_strlcpy(timestamp_buf, "unknown", sizeof(timestamp_buf));
	}
	de_dbg(c, "%s: %"I64_FMT" (%s)", name, ts_raw, timestamp_buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq 0x18(%rdi), %rdi
callq 0xe404f
movq %rax, %r15
testq %rax, %rax
je 0x52cdf
movq %rsp, %rsi
movq %r15, %rdi
callq 0xe0102
testq %r12, %r12
je 0x52ced
movaps (%rsp), %xmm0
movups %xmm0, (%r12)
cmpb $0x0, (%rsp)
je 0x52d07
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
pushq $0x40
popq %rdx
xorl %ecx, %ecx
callq 0xe0644
jmp 0x52d1b
leaq 0xb276e(%rip), %rsi     # 0x10547c
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rdx
callq 0xde492
leaq 0xb6e7f(%rip), %rsi     # 0x109ba1
leaq 0x10(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xde896
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: read_ExtDataRecs
static void read_ExtDataRecs(deark *c, lctx *d, i64 pos1,
	struct ExtDescriptor *eds, size_t num_eds, const char *name)
{
	size_t i;
	i64 pos = pos1;

	for(i=0; i<num_eds; i++) {
		eds[i].first_alloc_blk = de_getu16be_p(&pos);
		eds[i].num_alloc_blks = de_getu16be_p(&pos);
		de_dbg(c, "%s[%u]: first_blk=%u, num_blks=%u", name, (unsigned int)i,
			(unsigned int)eds[i].first_alloc_blk, (unsigned int)eds[i].num_alloc_blks);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %rsi, (%r12)
leaq 0xc0e3e(%rip), %r13     # 0x113ba3
xorl %ebp, %ebp
cmpq $0x3, %rbp
je 0x52dad
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xe3f6e
movq %rax, (%r14)
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xe3f6e
movq %rax, 0x8(%r14)
movl (%r14), %r8d
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
movl %eax, %r9d
xorl %eax, %eax
callq 0xde896
incq %rbp
addq $0x10, %r14
jmp 0x52d67
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: do_all_leaf_nodes
static int do_all_leaf_nodes(deark *c, lctx *d, struct nodedata *hdr_node, int pass)
{
	i64 curr_nodenum;
	struct nodedata *nd = NULL;
	int retval = 0;

	de_dbg(c, "reading leaf nodes, pass %d", pass);
	de_dbg_indent(c, 1);

	// Read all leaf nodes, using the leaf-to-leaf links
	curr_nodenum = hdr_node->bthFNode;

	while(curr_nodenum!=0) {
		nd = de_malloc(c, sizeof(struct nodedata));
		nd->nodenum = curr_nodenum;

		if(!do_node(c, d, nd, pass)) goto done;

		curr_nodenum = nd->f_link;
		destroy_nodedata(c, nd);
		nd = NULL;
	}
	retval = 1;

done:
	destroy_nodedata(c, nd);
	de_dbg_indent(c, -1);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc09d7(%rip), %rsi     # 0x113f33
movl %ecx, %edx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq 0x38(%r12), %rbp
pushq $0x50
popq %r12
testq %rbp, %rbp
je 0x535b6
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdecaf
movq %rax, %r13
movq %rbp, 0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movl %r14d, %ecx
callq 0x52dbc
testl %eax, %eax
je 0x535be
movq 0x18(%r13), %rbp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x535e7
jmp 0x53579
xorl %r13d, %r13d
pushq $0x1
popq %rbp
jmp 0x535c0
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x535e7
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: squash_slashes
static void squash_slashes(de_ucstring *s, i64 pos1)
{
	i64 i;

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

// Assembly:
movq 0x10(%rdi), %rax
cmpq %rax, %rsi
jge 0x53ac0
movq 0x8(%rdi), %rcx
cmpl $0x2f, (%rcx,%rsi,4)
jne 0x53abb
movl $0x5f, (%rcx,%rsi,4)
incq %rsi
jmp 0x53aa5
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: get_full_path_from_dirid
static void get_full_path_from_dirid(deark *c, lctx *d, u32 dirid, de_ucstring *s,
	int depth)
{
	void *item;
	int ret;
	struct dirid_item_struct *dirid_item;

	if(depth>20) goto done;
	if(dirid==0) goto done;
	ret = de_inthashtable_get_item(c, d->dirid_hash, (i64)dirid, &item);
	if(!ret && dirid>1) {
		de_warn(c, "Unknown parent directory (ID %u)", (unsigned int)dirid);
	}
	if(!ret) goto done;
	dirid_item = (struct dirid_item_struct*)item;

	if(dirid_item->ParID!=0 && dirid_item->ParID!=dirid) {
		get_full_path_from_dirid(c, d, dirid_item->ParID, s, depth+1);
	}

	if(!ucstring_isnonempty(dirid_item->name)) goto done;
	ucstring_append_ucstring(s, dirid_item->name);
	ucstring_append_sz(s, "/", DE_ENCODING_LATIN1);
done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
cmpl $0x15, %r8d
setge %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x53b7f
movl %r8d, %ebp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movq 0xb0(%rsi), %rsi
movl %edx, %edx
movq %rsp, %rcx
callq 0xe09a8
testl %eax, %eax
setne %cl
cmpl $0x2, %r12d
setb %dl
orb %cl, %dl
jne 0x53b26
leaq 0xc020f(%rip), %rsi     # 0x113d26
movq %r14, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xdf05a
jmp 0x53b7f
testl %eax, %eax
je 0x53b7f
movq (%rsp), %r13
movl (%r13), %edx
testl %edx, %edx
sete %al
cmpl %r12d, %edx
sete %cl
orb %al, %cl
jne 0x53b54
incl %ebp
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x53ac1
movq 0x8(%r13), %rdi
callq 0xeaf8a
testl %eax, %eax
je 0x53b7f
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0xead71
leaq 0xb14ea(%rip), %rsi     # 0x10505e
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0xeae42
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: read_timestamp_fields
static void read_timestamp_fields(deark *c, lctx *d, i64 pos1,
	de_finfo *fi1)
{
	i64 pos = pos1;

	read_one_timestamp(c, d, pos, &fi1->timestamp[DE_TIMESTAMPIDX_CREATE], "create date");
	pos += 4;
	read_one_timestamp(c, d, pos, &fi1->timestamp[DE_TIMESTAMPIDX_MODIFY], "mod date");
	pos += 4;
	read_one_timestamp(c, d, pos, &fi1->timestamp[DE_TIMESTAMPIDX_BACKUP], "backup date");
	//pos += 4;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdx), %r12
addq $0x28, %rdx
leaq 0xbff0a(%rip), %rcx     # 0x113ab8
callq 0x52ca8
leaq 0x4(%r14), %rsi
leaq 0xbff10(%rip), %rcx     # 0x113ace
movq %r15, %rdi
movq %r12, %rdx
callq 0x52ca8
addq $0x8, %r14
addq $0x58, %rbx
leaq 0xb5fb1(%rip), %rcx     # 0x109b89
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x52ca8
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: do_extract_fork_init
static void do_extract_fork_init(deark *c, lctx *d, struct recorddata *rd,
	struct fork_info *fki)
{
	i64 len_avail;

	len_avail = d->drAlBlkSiz * (fki->ExtRec[0].num_alloc_blks +
		fki->ExtRec[1].num_alloc_blks + fki->ExtRec[2].num_alloc_blks);
	if(fki->logical_eof > len_avail) {
		// TODO: Need to be able to read the Extents Overflow tree.
		de_err(c, "%s: Files with more than 3 fragments are not supported",
			rd->name_srd?ucstring_getpsz(rd->name_srd->str):"");
		fki->extract_error_flag = 1;
		goto done;
	}

done:
	;
}

// Assembly:
movq 0x38(%rcx), %rax
addq 0x28(%rcx), %rax
addq 0x48(%rcx), %rax
imulq 0x20(%rsi), %rax
cmpq %rax, 0x10(%rcx)
jle 0x53c4c
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x18(%rdx), %rax
testq %rax, %rax
je 0x53c29
movq 0x18(%rax), %rdi
callq 0xeb7e4
movq %rax, %rdx
jmp 0x53c30
leaq 0xe4030(%rip), %rdx     # 0x137c60
leaq 0xc01f2(%rip), %rsi     # 0x113e29
movq %r14, %rdi
xorl %eax, %eax
callq 0xdf2a5
movb $0x1, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hfs.c
// Function: do_extract_fork_run
static void do_extract_fork_run(deark *c, lctx *d, struct recorddata *rd,
	struct fork_info *fki, dbuf *outf)
{
	i64 nbytes_still_to_write;
	size_t k;

	nbytes_still_to_write = fki->logical_eof;

	for(k=0; k<3; k++) {
		i64 fragment_dpos;
		i64 nbytes_to_write_this_time;

		if(nbytes_still_to_write<=0) break;

		fragment_dpos = allocation_blk_dpos(d, fki->ExtRec[k].first_alloc_blk);
		nbytes_to_write_this_time = d->drAlBlkSiz * fki->ExtRec[k].num_alloc_blks;
		if(nbytes_to_write_this_time > nbytes_still_to_write) {
			nbytes_to_write_this_time = nbytes_still_to_write;
		}

		if(fragment_dpos + nbytes_to_write_this_time > c->infile->len) {
			de_err(c, "Member file data goes beyond end of file");
			goto done;
		}

		dbuf_copy(c->infile, fragment_dpos, nbytes_to_write_this_time, outf);

		nbytes_still_to_write -= nbytes_to_write_this_time;
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdx), %rbp
addq $0x28, %r15
xorl %r14d, %r14d
cmpq $0x2, %r14
ja 0x53cfa
testq %rbp, %rbp
jle 0x53cfa
movq 0x20(%r12), %r13
movq 0x30(%r12), %rax
imulq 0x8(%r12), %rax
movq -0x8(%r15), %rsi
imulq %r13, %rsi
imulq (%r15), %r13
addq %rax, %rsi
cmpq %rbp, %r13
cmovgeq %rbp, %r13
leaq (%rsi,%r13), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jg 0x53d09
movq %r13, %rdx
movq (%rsp), %rcx
callq 0xe45f4
subq %r13, %rbp
incq %r14
addq $0x10, %r15
jmp 0x53ca3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0150(%rip), %rsi     # 0x113e60
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf2a5
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: de_module_hlp
void de_module_hlp(deark *c, struct deark_module_info *mi)
{
	mi->id = "hlp";
	mi->desc = "HLP";
	mi->run_fn = de_run_hlp;
	mi->identify_fn = de_identify_hlp;
	mi->help_fn = de_help_hlp;
}

// Assembly:
leaq 0xc02a1(%rip), %rax     # 0x113fd0
movq %rax, (%rsi)
leaq 0xc029b(%rip), %rax     # 0x113fd4
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x53d5f
movq %rax, 0x18(%rsi)
leaq 0x294(%rip), %rax       # 0x53fe3
movq %rax, 0x20(%rsi)
leaq 0x2ab(%rip), %rax       # 0x54005
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: do_extract_raw_file
static void do_extract_raw_file(deark *c, lctx *d, i64 pos1, i64 used_space,
	struct de_stringreaderdata *fn)
{
	de_finfo *fi = NULL;
	const char *ext = NULL;

	fi = de_finfo_create(c);
	fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = d->gendate;
	if(fn && ucstring_isnonempty(fn->str)) {
		de_finfo_set_name_from_ucstring(c, fi, fn->str, 0);
		fi->original_filename_flag = 1;
	}
	else {
		ext = "bin";
	}
	dbuf_create_file_from_slice(c->infile, pos1, used_space, ext, fi, 0);

	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0xdfd1a
movq %rax, %r15
movups 0x120(%r13), %xmm0
movups %xmm0, 0x18(%rax)
leaq 0xd21e9(%rip), %r13     # 0x1284dd
testq %rbp, %rbp
je 0x5631f
movq 0x18(%rbp), %rdi
callq 0xeaf8a
testl %eax, %eax
je 0x5631f
movq 0x18(%rbp), %rdx
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0xdfd55
movb $0x1, 0x8(%r15)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0xe4e0b
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdfd24
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: format_topiclink
static void format_topiclink(deark *c, lctx *d, u32 n, char *buf, size_t buf_len)
{
	if(d->ver_minor<=16) {
		de_snprintf(buf, buf_len, "%u", (UI)n);
	}
	else {
		if(n==INVALIDPOS) {
			de_strlcpy(buf, "-1", buf_len);
		}
		else {
			de_snprintf(buf, buf_len, "Blk%u:%u", (UI)(n/16384),
				(UI)(n%16384));
		}
	}
}

// Assembly:
movq %rdx, %rax
movl %esi, %r8d
cmpl $0x10, 0x8c(%rdi)
jg 0x56376
leaq 0xb207e(%rip), %rdx     # 0x1083e4
pushq $0x18
popq %rsi
movq %rax, %rdi
movl %r8d, %ecx
xorl %eax, %eax
jmp 0xde40c
cmpl $-0x1, %r8d
je 0x5639d
movl %r8d, %ecx
shrl $0xe, %ecx
andl $0x3fff, %r8d           # imm = 0x3FFF
leaq 0xbe0c6(%rip), %rdx     # 0x114456
pushq $0x18
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
jmp 0xde40c
leaq 0xb2ea6(%rip), %rsi     # 0x10924a
pushq $0x18
popq %rdx
movq %rax, %rdi
jmp 0xde492
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: ensure_text_output_file_open
static void ensure_text_output_file_open(deark *c, lctx *d)
{
	if(d->outf_text) return;
	d->outf_text = dbuf_create_output_file(c, "dump.txt", NULL, 0);
	if(d->output_is_utf8 && c->write_bom) {
		dbuf_write_uchar_as_utf8(d->outf_text, 0xfeff);
	}
	if(ucstring_isnonempty(d->help_file_title)) {
		dbuf_puts(d->outf_text, "Title: ");
		// TODO: This doesn't do the right thing if !d->output_is_utf8.
		ucstring_write_as_utf8(c, d->help_file_title, d->outf_text, 0);
		dbuf_puts(d->outf_text, "\n");
	}
	if(ucstring_isnonempty(d->help_file_copyright)) {
		dbuf_puts(d->outf_text, "Copyright: ");
		ucstring_write_as_utf8(c, d->help_file_copyright, d->outf_text, 0);
		dbuf_puts(d->outf_text, "\n");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xc0(%rsi)
je 0x563f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xbe26f(%rip), %rsi     # 0x11466c
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, 0xc0(%rbx)
cmpl $0x0, 0x4(%rbx)
je 0x5642a
cmpb $0x0, 0xcc(%r14)
je 0x5642a
movq %rax, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
callq 0xe1790
movq 0x110(%rbx), %rdi
callq 0xeaf8a
testl %eax, %eax
je 0x56478
movq 0xc0(%rbx), %rdi
leaq 0xbe22d(%rip), %rsi     # 0x114675
callq 0xe5fe4
movq 0xc0(%rbx), %rdx
movq 0x110(%rbx), %rsi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xeb576
movq 0xc0(%rbx), %rdi
leaq 0xacd14(%rip), %rsi     # 0x103187
callq 0xe5fe4
movq 0x118(%rbx), %rdi
callq 0xeaf8a
testl %eax, %eax
je 0x563e8
movq 0xc0(%rbx), %rdi
leaq 0xbe1e3(%rip), %rsi     # 0x11467d
callq 0xe5fe4
movq 0xc0(%rbx), %rdx
movq 0x118(%rbx), %rsi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xeb576
movq 0xc0(%rbx), %rdi
leaq 0xaccc2(%rip), %rsi     # 0x103187
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe5fe4
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: emit_slice
static void emit_slice(deark *c, lctx *d, dbuf *inf, i64 pos, i64 len)
{
	if(!d->outf_text) return;

	if(!d->output_is_utf8) {
		dbuf_copy(inf, pos, len, d->outf_text);
		return;
	}

	ucstring_empty(d->tmpucstring1);
	dbuf_read_to_ucstring(inf, pos, len, d->tmpucstring1, 0, d->input_encoding);
	ucstring_write_as_utf8(c, d->tmpucstring1, d->outf_text, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0xc0(%rsi), %rcx
testq %rcx, %rcx
je 0x56540
movq %rdx, %r12
movq %rsi, %r15
cmpl $0x0, 0x4(%rsi)
je 0x5654c
movq %rdi, %r14
movq 0x108(%r15), %rdi
callq 0xeac85
movq 0x108(%r15), %rcx
movl (%r15), %r9d
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xe4c9a
movq 0xc0(%r15), %rdx
movq 0x108(%r15), %rsi
movq %r14, %rdi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xeb576
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe45f4
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: dump_phrase_offset_table
static void dump_phrase_offset_table(deark *c, lctx *d)
{
	UI k;

	for(k=0; k<d->num_phrases; k++) {
		de_dbg2(c, "phrase[%u]: offs=%u, len=%u", k, d->phrase_info[k].pos,
			d->phrase_info[k].len);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xbe2c0(%rip), %r15     # 0x11484a
xorl %r12d, %r12d
movl 0xf8(%rbx), %eax
cmpq %rax, %r12
jae 0x565bd
movq 0x100(%rbx), %rax
movl (%rax,%r12,8), %ecx
movl 0x4(%rax,%r12,8), %r8d
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0xde9f1
incq %r12
jmp 0x5658d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: decompress_Phrases
static void decompress_Phrases(deark *c, lctx *d, i64 pos, i64 cmpr_len, i64 uncmpr_len)
{
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = pos;
	dcmpri.len = cmpr_len;
	dcmpro.f = d->phrases_data;
	dcmpro.len_known = 1;
	dcmpro.expected_len = uncmpr_len;
	fmtutil_hlp_lz77_codectype1(c, &dcmpri, &dcmpro, &dres, NULL);
	if(dres.errcode || (d->phrases_data->len!=uncmpr_len)) {
		de_warn(c, "Phrases decompression may have failed");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rbp
leaq 0x10(%rsp), %r14
leaq 0x48(%rsp), %rcx
movq %rbp, %rsi
movq %r14, %rdx
callq 0xee7ee
movq 0x18(%rbx), %rax
movq %rax, (%rbp)
movq %r13, 0x8(%rbp)
movq %r12, 0x10(%rbp)
movq %r15, %r12
movq 0x8(%rsp), %r15
movq 0xf0(%r12), %rax
movq %rax, (%r14)
movb $0x1, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
leaq 0x48(%rsp), %r14
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xef3d3
cmpl $0x0, (%r14)
jne 0x5665e
movq 0xf0(%r12), %rax
cmpq %r15, 0x18(%rax)
je 0x5666f
leaq 0xbe201(%rip), %rsi     # 0x114866
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf05a
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/hlp.c
// Function: do_display_and_store_STRINGZ
static void do_display_and_store_STRINGZ(deark *c, lctx *d, i64 pos1, i64 len,
	const char *name, de_ucstring *s1)
{
	de_ucstring *s_tmp = NULL;
	de_ucstring *s;

	if(s1) {
		s = s1;
	}
	else {
		s_tmp = ucstring_create(c);
		s = s_tmp;
	}

	ucstring_empty(s);
	if(len<1) return;

	dbuf_read_to_ucstring_n(c->infile,
		pos1, len, DE_DBG_MAX_STRLEN,
		s, DE_CONVFLAG_STOP_AT_NUL, d->input_encoding);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));

	if(s_tmp) ucstring_destroy(s_tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
testq %r9, %r9
je 0x566ad
movq %r9, %r13
xorl %r14d, %r14d
jmp 0x566bb
movq %r15, %rdi
callq 0xeac74
movq %rax, %r14
movq %rax, %r13
movq %r13, %rdi
callq 0xeac85
testq %r12, %r12
jle 0x56724
movq 0x18(%r15), %rdi
movl (%rbx), %eax
movl %eax, (%rsp)
pushq $0x1
popq %r9
movl $0x1f4, %ecx            # imm = 0x1F4
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0xe4ced
movq %r13, %rdi
callq 0xeb7e4
leaq 0xc87c3(%rip), %rsi     # 0x11eeba
movq %r15, %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
testq %r14, %r14
je 0x56724
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/dsstore.c
// Function: de_module_dsstore
void de_module_dsstore(deark *c, struct deark_module_info *mi)
{
	mi->id = "dsstore";
	mi->desc = "Mac Finder .DS_Store format";
	mi->run_fn = de_run_dsstore;
	mi->identify_fn = de_identify_dsstore;
	mi->help_fn = de_help_dsstore;
}

// Assembly:
leaq 0xbe425(%rip), %rax     # 0x114b60
movq %rax, (%rsi)
leaq 0xbe423(%rip), %rax     # 0x114b68
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x5676b
movq %rax, 0x18(%rsi)
leaq 0x407(%rip), %rax       # 0x56b62
movq %rax, 0x20(%rsi)
leaq 0x41e(%rip), %rax       # 0x56b84
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/dsstore.c
// Function: block_id_to_offset_and_size
static int block_id_to_offset_and_size(deark *c, lctx *d, u32 blk_id,
	i64 *poffs, i64 *psize)
{
	int retval = 0;
	u32 addr_code;
	unsigned int size_indicator;

	if((i64)blk_id>=d->blkcount) {
		goto done;
	}

	addr_code = d->block_addr_table[blk_id].addr_code;
	size_indicator = addr_code&0x1f;
	*psize = de_pow2((i64)size_indicator);
	*poffs = HDRSIZE+(i64)(addr_code-size_indicator);

	retval = 1;
done:
	if(!retval) {
		*poffs = c->infile->len;
		*psize = 0;
	}
	return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %eax
cmpq %rax, 0x20(%rsi)
jle 0x57211
movq 0x28(%rsi), %rcx
movl (%rcx,%rax,8), %r15d
movl %r15d, %edi
andl $0x1f, %edi
callq 0xdfba1
movq %rax, (%r14)
andl $-0x20, %r15d
orq $0x4, %r15
movq %r15, (%rbx)
pushq $0x1
popq %rax
jmp 0x57222
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rax
movq %rax, (%rbx)
andq $0x0, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/fli.c
// Function: de_module_fli
void de_module_fli(deark *c, struct deark_module_info *mi)
{
	mi->id = "fli";
	mi->desc = "FLI/FLC animation";
	mi->run_fn = de_run_fli;
	mi->identify_fn = de_identify_fli;
}

// Assembly:
leaq 0xbdc39(%rip), %rax     # 0x114e90
movq %rax, (%rsi)
leaq 0xbdc33(%rip), %rax     # 0x114e94
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x5727c
movq %rax, 0x18(%rsi)
leaq 0x5c(%rip), %rax        # 0x572d3
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/fli.c
// Function: de_run_fli
static void de_run_fli(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 bytes_consumed = 0;

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

	(void)do_chunk(c, d, NULL, 0, c->infile->len, 0, &bytes_consumed);

	if(d) {
		de_free(c, d);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x50
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r8
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x5734a
testq %r14, %r14
je 0x572cb
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xded32
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/fli.c
// Function: de_identify_fli
static int de_identify_fli(deark *c)
{
	UI ct;
	int has_ext;

	ct = (UI)de_getu16le(4);
	if((ct>>8) != 0xaf) return 0;
	has_ext = de_input_file_has_ext(c, "fli") ||
		de_input_file_has_ext(c, "flc");
	if(ct==CHUNKTYPE_FLI || ct==CHUNKTYPE_FLC) {
		if(has_ext) return 100;
		return 20;
	}
	if(has_ext) return 9;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
pushq $0x4
popq %rsi
callq 0xe3fa3
movq %rax, %rbx
movl %ebx, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
xorl %eax, %eax
cmpl $0xaf00, %ecx           # imm = 0xAF00
jne 0x57342
leaq 0xbdb8e(%rip), %rsi     # 0x114e90
movq %r14, %rdi
callq 0xdfcd5
movb $0x1, %cl
testl %eax, %eax
jne 0x57324
leaq 0xbdee2(%rip), %rsi     # 0x1151f9
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
setne %cl
addl $0xffff50ef, %ebx       # imm = 0xFFFF50EF
cmpl $0x1, %ebx
ja 0x5733c
testb %cl, %cl
pushq $0x64
popq %rcx
pushq $0x14
popq %rax
cmovnel %ecx, %eax
jmp 0x57342
movzbl %cl, %eax
leal (%rax,%rax,8), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/fli.c
// Function: do_chunk_frame
static void do_chunk_frame(deark *c, lctx *d, struct chunk_info_type *ci)
{
	i64 num_subchunks;
	i64 frame_idx;
	i64 prev_use_count = 0;
	de_finfo *fi = NULL;

	frame_idx = d->frame_count;
	d->frame_count++;
	de_dbg(c, "frame number: %d", (int)frame_idx);

	num_subchunks = de_getu16le(ci->dpos);
	de_dbg(c, "num subchunks: %"I64_FMT, num_subchunks);

	if(ci->ictx) {
		prev_use_count = ci->ictx->use_count;
	}

	do_sequence_of_chunks(c, d, ci, ci->dpos+10, num_subchunks);

	if(ci->ictx) {
		if(ci->ictx->use_count > prev_use_count && !ci->ictx->error_flag) {
			if(d->num_frames>0 && frame_idx==d->num_frames && c->extract_level<2) {
				de_dbg(c, "[not extracting ring frame]");
				goto done;
			}

			fi = de_finfo_create(c);
			fi->density = ci->ictx->density;
			fi->internal_mod_time = d->mod_timestamp;
			de_bitmap_write_to_file_finfo(ci->ictx->img, fi, 0);
		}
	}

done:
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x10(%rsi)
leaq 0xbd602(%rip), %rsi     # 0x115130
xorl %ebp, %ebp
movl %r12d, %edx
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
movq 0x20(%r14), %rsi
callq 0xe3fa3
movq %rax, %r13
leaq 0xbd5f0(%rip), %rsi     # 0x115141
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x57b6b
movslq 0x10(%rax), %rbp
movq 0x20(%r14), %rcx
addq $0xa, %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %r8
callq 0x5866f
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x57b9c
movslq 0x10(%rax), %rcx
cmpq %rcx, %rbp
jge 0x57b9c
cmpl $0x0, 0x14(%rax)
je 0x57bb8
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdfd24
movq 0x8(%r15), %rax
testq %rax, %rax
setle %cl
cmpq %rax, %r12
setne %al
orb %cl, %al
jne 0x57beb
cmpl $0x1, 0x90(%rbx)
jg 0x57beb
leaq 0xbd578(%rip), %rsi     # 0x115154
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
jmp 0x57b9f
movq %rbx, %rdi
callq 0xdfd1a
movq %rax, %r12
movq 0x48(%r14), %rax
movq 0x28(%rax), %rcx
movq %rcx, 0x88(%r12)
movups 0x18(%rax), %xmm0
movups %xmm0, 0x78(%r12)
movups 0x28(%r15), %xmm0
movups %xmm0, 0x68(%r12)
movq 0x48(%r14), %rax
movq 0x30(%rax), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xe70ab
jmp 0x57b9f