LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/lbr.c
// Function: de_module_crlzh
void de_module_crlzh(deark *c, struct deark_module_info *mi)
{
	mi->id = "crlzh";
	mi->desc = "CRLZH (CP/M)";
	mi->run_fn = de_run_crlzh;
	mi->identify_fn = de_identify_crlzh;
}

// Assembly:
leaq 0x92830(%rip), %rax     # 0x1320d7
movq %rax, (%rsi)
leaq 0x9282c(%rip), %rax     # 0x1320dd
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x9f8cc
movq %rax, 0x18(%rsi)
leaq 0x384(%rip), %rax       # 0x9fc4b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/lbr.c
// Function: de_module_zsq
void de_module_zsq(deark *c, struct deark_module_info *mi)
{
	mi->id = "zsq";
	mi->desc = "ZSQ (ZSQUSQ, LZW-compressed file)";
	mi->run_fn = de_run_zsq;
	mi->identify_fn = de_identify_zsq;
}

// Assembly:
leaq 0x9247a(%rip), %rax     # 0x1320ea
movq %rax, (%rsi)
leaq 0x92474(%rip), %rax     # 0x1320ee
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x9fc95
movq %rax, 0x18(%rsi)
leaq 0x2f3(%rip), %rax       # 0x9ff83
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/lbr.c
// Function: de_module_lzwcom
void de_module_lzwcom(deark *c, struct deark_module_info *mi)
{
	mi->id = "lzwcom";
	mi->desc = "LZWCOM compressed file";
	mi->run_fn = de_run_lzwcom;
	mi->identify_fn = NULL;
	mi->help_fn = de_help_lzwcom;
}

// Assembly:
leaq 0x92168(%rip), %rax     # 0x132110
movq %rax, (%rsi)
leaq 0x92165(%rip), %rax     # 0x132117
movq %rax, 0x8(%rsi)
leaq 0x18(%rip), %rax        # 0x9ffd5
movq %rax, 0x18(%rsi)
movq $0x0, 0x20(%rsi)
leaq 0x37e(%rip), %rax       # 0xa034e
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/lbr.c
// Function: handle_timestamp
static void handle_timestamp(deark *c, lctx *d, i64 date_raw, i64 time_raw,
	struct de_timestamp *ts, const char *name)
{
	i64 ut;
	char timestamp_buf[64];

	if(date_raw==0) {
		de_dbg(c, "%s: [not set]", name);
		return;
	}

	// Day 0 is Dec 31, 1977 (or it would be, if 0 weren't reserved).
	// Difference from Unix time (Jan 1, 1970) =
	//  365 days in 1970, 1971, 1973, 1974, 1975
	//  + 366 days in 1972, 1976
	//  + 364 days in 1977.
	ut = 86400 * (date_raw + (365*5 + 366*2 + 364));

	// Time of day is in DOS format.
	ut += 3600*(time_raw>>11); // hours
	ut += 60*(time_raw&0x07e0)>>5; // minutes
	ut += 2*(time_raw&0x001f); // seconds
	de_unix_time_to_timestamp(ut, ts, 0);
	de_timestamp_to_string(ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %s", name, timestamp_buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xa08c4
movq %rcx, %r15
imulq $0x15180, %rsi, %rax    # imm = 0x15180
movq %rdx, %rcx
sarq $0xb, %rcx
imulq $0xe10, %rcx, %rcx      # imm = 0xE10
addq %rax, %rcx
movl %edx, %eax
andl $0x1f, %eax
leaq (%rcx,%rax,2), %rax
andl $0x7e0, %edx            # imm = 0x7E0
imull $0x3c, %edx, %ecx
shrl $0x5, %ecx
leaq (%rcx,%rax), %rdi
addq $0xf0aed80, %rdi        # imm = 0xF0AED80
movq %r15, %rsi
xorl %edx, %edx
callq 0xea7f5
movq %rsp, %r12
movl $0x40, %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xeaf46
leaq 0xa8ada(%rip), %rsi     # 0x149382
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xe8617
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9191d(%rip), %rsi     # 0x1321e8
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8617
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/megapaint.c
// Function: de_module_bld
void de_module_bld(deark *c, struct deark_module_info *mi)
{
	mi->id = "bld";
	mi->desc = "MegaPaint BLD";
	mi->run_fn = de_run_bld;
	mi->identify_fn = de_identify_bld;
}

// Assembly:
leaq 0x919c4(%rip), %rax     # 0x1324d7
movq %rax, (%rsi)
leaq 0x919be(%rip), %rax     # 0x1324db
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa0b38
movq %rax, 0x18(%rsi)
leaq 0x1aa(%rip), %rax       # 0xa0cdd
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/megapaint.c
// Function: de_module_megapaint_pat
void de_module_megapaint_pat(deark *c, struct deark_module_info *mi)
{
	mi->id = "megapaint_pat";
	mi->desc = "MegaPaint Patterns";
	mi->run_fn = de_run_megapaint_pat;
	mi->identify_fn = de_identify_megapaint_pat;
}

// Assembly:
leaq 0x917ce(%rip), %rax     # 0x1324e9
movq %rax, (%rsi)
leaq 0x917d2(%rip), %rax     # 0x1324f7
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa0d40
movq %rax, 0x18(%rsi)
leaq 0x117(%rip), %rax       # 0xa0e52
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/megapaint.c
// Function: de_run_megapaint_pat
static void de_run_megapaint_pat(deark *c, de_module_params *mparams)
{
	// Note: This module is based on guesswork, and may be incomplete.
	de_bitmap *mainimg = NULL;
	i64 main_w, main_h;
	i64 pos = 0;
	i64 k;

	pos += 8;
	main_w = 1+(32+1)*16;
	main_h = 1+(32+1)*2;

	mainimg = de_bitmap_create(c, main_w, main_h, 1);
	de_bitmap_rect(mainimg, 0, 0, main_w, main_h, DE_MAKE_GRAY(128), 0);

	for(k=0; k<32; k++) {
		de_bitmap *img = NULL;
		i64 imgpos_x, imgpos_y;

		img = de_bitmap_create(c, 32, 32, 1);
		img->is_internal = 1;
		de_convert_image_bilevel(c->infile, pos, 4, img, DE_CVTF_WHITEISZERO);
		pos += 4*32;

		imgpos_x = 1+(32+1)*(k%16);
		imgpos_y = 1+(32+1)*(k/16);
		de_bitmap_copy_rect(img, mainimg, 0, 0, 32, 32, imgpos_x, imgpos_y, 0);
		de_bitmap_destroy(img);
	}

	de_bitmap_write_to_file(mainimg, NULL, 0);
	de_bitmap_destroy(mainimg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x211, %esi            # imm = 0x211
movl $0x43, %edx
movl $0x1, %ecx
callq 0xf266a
movq %rax, %r14
subq $0x8, %rsp
xorl %r13d, %r13d
movl $0x211, %ecx            # imm = 0x211
movl $0x43, %r8d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0xff808080, %r9d       # imm = 0xFF808080
pushq $0x0
callq 0xf3654
addq $0x10, %rsp
movl $0x8, %r15d
movl $0x20, %esi
movl $0x20, %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0xf266a
movq %rax, %r12
movb $0x1, 0x38(%rax)
movq 0x18(%rbx), %rdi
movl $0x4, %edx
movq %r15, %rsi
movq %rax, %rcx
movl $0x1, %r8d
callq 0xf2a40
subq $-0x80, %r15
movl %r13d, %eax
andl $0xf, %eax
movl %eax, %ecx
shll $0x5, %ecx
addq %rcx, %rax
incq %rax
movq %r13, %rcx
shrq $0x4, %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
leaq (%rcx,%rdx), %r10
incq %r10
subq $0x8, %rsp
movl $0x20, %r8d
movl $0x20, %r9d
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
pushq $0x0
pushq %r10
pushq %rax
callq 0xf36d0
addq $0x20, %rsp
movq %r12, %rdi
callq 0xf228d
incq %r13
cmpq $0x1008, %r15           # imm = 0x1008
jne 0xa0d93
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf22dc
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf228d
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/megapaint.c
// Function: de_module_megapaint_lib
void de_module_megapaint_lib(deark *c, struct deark_module_info *mi)
{
	mi->id = "megapaint_lib";
	mi->desc = "MegaPaint Symbol Library";
	mi->run_fn = de_run_megapaint_lib;
	mi->identify_fn = de_identify_megapaint_lib;
}

// Assembly:
leaq 0x9166a(%rip), %rax     # 0x13250a
movq %rax, (%rsi)
leaq 0x9166e(%rip), %rax     # 0x132518
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa0ec5
movq %rax, 0x18(%rsi)
leaq 0x146(%rip), %rax       # 0xa1006
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/megapaint.c
// Function: de_run_megapaint_lib
static void de_run_megapaint_lib(deark *c, de_module_params *mparams)
{
	// Note: This module is based on guesswork, and may be incomplete.
	const i64 idxpos = 14;
	i64 k;
	i64 nsyms;

	nsyms = 1+de_getu16be(12);
	de_dbg(c, "number of symbols: %d", (int)nsyms);

	for(k=0; k<nsyms; k++) {
		i64 sym_offs;
		i64 w, h, rowspan;

		sym_offs = de_getu32be(idxpos+4*k);
		de_dbg(c, "symbol #%d", (int)(1+k));
		de_dbg_indent(c, 1);
		de_dbg(c, "offset: %u", (unsigned int)sym_offs);

		w = 1+de_getu16be(sym_offs);
		h = 1+de_getu16be(sym_offs+2);
		de_dbg_dimensions(c, w, h);
		rowspan = ((w+15)/16)*2;
		de_convert_and_write_image_bilevel(c->infile, sym_offs+4, w, h, rowspan,
			DE_CVTF_WHITEISZERO, NULL, 0);
		de_dbg_indent(c, -1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0xc, %esi
callq 0xeeb67
movq %rax, %r14
leal 0x1(%rax), %edx
leaq 0x91693(%rip), %rsi     # 0x132584
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
testq %r14, %r14
js 0xa0ff7
movq $-0x1, %r13
movl $0xe, %eax
movq %r14, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0xeed0d
movq %rax, %rbp
leal 0x2(%r13), %edx
movq %rbx, %rdi
leaq 0x91661(%rip), %rsi     # 0x13259a
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq %rbx, %rdi
leaq 0x7e1ea(%rip), %rsi     # 0x11f141
movl %ebp, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
callq 0xeeb67
movq %rax, %r12
leaq 0x1(%rax), %r15
movq 0x18(%rbx), %rdi
leaq 0x2(%rbp), %rsi
callq 0xeeb67
leaq 0x1(%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe8f88
leaq 0x10(%r12), %rax
addq $0x1f, %r12
testq %rax, %rax
cmovnsq %rax, %r12
sarq $0x4, %r12
addq %r12, %r12
movq 0x18(%rbx), %rdi
addq $0x4, %rbp
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x10(%rsp), %r14
movq %r12, %r8
movl $0x1, %r9d
pushq $0x0
pushq $0x0
callq 0xf2a98
addq $0x10, %rsp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq 0x8(%rsp), %rax
incq %r13
addq $0x4, %rax
cmpq %r13, %r14
jne 0xa0f15
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/nie.c
// Function: de_module_nie
void de_module_nie(deark *c, struct deark_module_info *mi)
{
	mi->id = "nie";
	mi->desc = "NIE/NII/NIA (Naive Image Formats)";
	mi->run_fn = de_run_nie;
	mi->identify_fn = de_identify_nie;
}

// Assembly:
leaq 0x91569(%rip), %rax     # 0x1325c8
movq %rax, (%rsi)
leaq 0x91563(%rip), %rax     # 0x1325cc
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa1084
movq %rax, 0x18(%rsi)
leaq 0x413(%rip), %rax       # 0xa1492
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/nie.c
// Function: do_header
static int do_header(deark *c, lctx *d, i64 pos)
{
	u8 b;

	b = de_getbyte_p(&pos);
	if(b!=0xff) {
		de_err(c, "Unknown %s version", d->fmtname);
		return 0;
	}

	if(d->sig==SIG_NII) {
		pos += 3; // padding
	}
	else {
		b = de_getbyte_p(&pos);
		if(b=='b') {
			d->is_bgra = 1;
		}
		else if(b!='r') {
			d->bad_image_flag = 1;
		}
		de_dbg(c, "sample order: %sA", (d->is_bgra?"BGR":"RGB"));

		b = de_getbyte_p(&pos);
		if(b=='p') {
			d->premultiplied_alpha = 1;
		}
		else if(b!='n') {
			d->bad_image_flag = 1;
		}
		de_dbg(c, "premultiplied alpha: %d", d->premultiplied_alpha);

		b = de_getbyte_p(&pos);
		if(b=='8') {
			d->bytes_per_pixel = 8;
		}
		else if(b=='4') {
			d->bytes_per_pixel = 4;
		}
		else {
			d->bad_image_flag = 1;
		}
		de_dbg(c, "bytes/pixel: %d", (int)d->bytes_per_pixel);
	}

	d->width = de_getu32le_p(&pos);
	d->height = de_getu32le_p(&pos);
	de_dbg_dimensions(c, d->width, d->height);

	if(d->sig==SIG_NIE) return 1;

	read_NIIpayload(c, d, pos, 0);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
movq $0x4, (%rsi)
movq 0x18(%rdi), %rdi
callq 0xeeb4b
cmpb $-0x1, %al
je 0xa14fd
movq 0x8(%rbx), %rdx
leaq 0x9114b(%rip), %rsi     # 0x132637
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0xa1645
cmpl $0x6ec3af49, (%rbx)     # imm = 0x6EC3AF49
jne 0xa150f
addq $0x3, (%rsp)
jmp 0xa15ee
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xeeb4b
cmpb $0x62, %al
je 0xa152e
movzbl %al, %eax
cmpl $0x72, %eax
je 0xa153a
movl $0x30, %eax
jmp 0xa1533
movl $0x10, %eax
movl $0x1, (%rbx,%rax)
cmpl $0x0, 0x10(%rbx)
leaq 0x9e45b(%rip), %rax     # 0x13f9a0
leaq 0x935fe(%rip), %rdx     # 0x134b4a
cmoveq %rax, %rdx
leaq 0x910f3(%rip), %rsi     # 0x13264a
movq %r14, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xeeb4b
cmpb $0x6e, %al
je 0xa1589
movzbl %al, %eax
cmpl $0x70, %eax
jne 0xa1582
movl $0x1, 0x14(%rbx)
jmp 0xa1589
movl $0x1, 0x30(%rbx)
movl 0x14(%rbx), %edx
leaq 0x910c9(%rip), %rsi     # 0x13265c
movq %r14, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0xeeb4b
cmpb $0x34, %al
je 0xa15c4
movzbl %al, %eax
cmpl $0x38, %eax
jne 0xa15d3
movq $0x8, 0x18(%rbx)
movl $0x8, %edx
jmp 0xa15dd
movq $0x4, 0x18(%rbx)
movl $0x4, %edx
jmp 0xa15dd
movl $0x1, 0x30(%rbx)
movl 0x18(%rbx), %edx
leaq 0x9f1a8(%rip), %rsi     # 0x14078c
movq %r14, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0xeed83
movq %rax, 0x20(%rbx)
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xeed83
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0xe8f88
movl $0x1, %ebp
cmpl $0x6ec3af45, (%rbx)     # imm = 0x6EC3AF45
je 0xa1645
movq (%rsp), %rsi
movq 0x18(%r14), %rdi
callq 0xef0af
testb $0x1, %al
je 0xa1645
movl $0x1, 0x34(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/nie.c
// Function: read_NIIpayload
static void read_NIIpayload(deark *c, lctx *d, i64 pos, int printCCD)
{
	u64 ccd_code;
	i64 ccd;

	ccd_code = dbuf_getu64le(c->infile, pos);
	if(ccd_code & 0x1) {
		d->found_last_frame_flag = 1;
	}
	if(printCCD) {
		ccd = (i64)(ccd_code>>2);
		de_dbg(c, "CCD: %"I64_FMT" (%f seconds)", ccd,
			(double)ccd/705600000.0);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
callq 0xef0af
testb $0x1, %al
je 0xa1676
movl $0x1, 0x34(%r14)
testl %ebp, %ebp
je 0xa16a3
shrq $0x2, %rax
cvtsi2sd %rax, %xmm0
divsd 0x90f35(%rip), %xmm0    # 0x1325c0
leaq 0x90fe2(%rip), %rsi     # 0x132674
movq %rbx, %rdi
movq %rax, %rdx
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
jmp 0xe8617
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/installshld.c
// Function: de_module_is_z
void de_module_is_z(deark *c, struct deark_module_info *mi)
{
	mi->id = "is_z";
	mi->desc = "InstallShield Z";
	mi->run_fn = de_run_is_z;
	mi->identify_fn = de_identify_is_z;
}

// Assembly:
leaq 0x91003(%rip), %rax     # 0x1326b2
movq %rax, (%rsi)
leaq 0x90ffe(%rip), %rax     # 0x1326b7
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa16d4
movq %rax, 0x18(%rsi)
leaq 0x897(%rip), %rax       # 0xa1f66
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/installshld.c
// Function: de_module_is_instarch
void de_module_is_instarch(deark *c, struct deark_module_info *mi)
{
	mi->id = "is_instarch";
	mi->id_alias[0] = "is_inst32i";
	mi->desc = "InstallShield installer archive (_inst32i.ex_)";
	mi->run_fn = de_run_is_instarch;
	mi->identify_fn = de_identify_is_instarch;
}

// Assembly:
leaq 0x9073a(%rip), %rax     # 0x1326c7
movq %rax, (%rsi)
leaq 0x9073c(%rip), %rax     # 0x1326d3
movq %rax, 0x38(%rsi)
leaq 0x9073c(%rip), %rax     # 0x1326de
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa1fbd
movq %rax, 0x18(%rsi)
leaq 0x26f(%rip), %rax       # 0xa2227
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/installshld.c
// Function: de_module_tscomp
void de_module_tscomp(deark *c, struct deark_module_info *mi)
{
	mi->id = "tscomp";
	mi->desc = "The Stirling Compressor";
	mi->run_fn = de_run_tscomp;
	mi->identify_fn = de_identify_tscomp;
}

// Assembly:
leaq 0x904b9(%rip), %rax     # 0x13270d
movq %rax, (%rsi)
leaq 0x904b6(%rip), %rax     # 0x132714
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa2279
movq %rax, 0x18(%rsi)
leaq 0x2f2(%rip), %rax       # 0xa2566
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/installshld.c
// Function: de_module_is_sfx
void de_module_is_sfx(deark *c, struct deark_module_info *mi)
{
	mi->id = "is_sfx";
	mi->desc = "InstallShield SFX EXE";
	mi->run_fn = de_run_is_sfx;
	mi->flags |= DE_MODFLAG_HIDDEN | DE_MODFLAG_INTERNALONLY;
}

// Assembly:
leaq 0x7b428(%rip), %rax     # 0x11d9b3
movq %rax, (%rsi)
leaq 0x90197(%rip), %rax     # 0x13272c
movq %rax, 0x8(%rsi)
leaq 0x9(%rip), %rax         # 0xa25a9
movq %rax, 0x18(%rsi)
orb $-0x7f, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/os2ea.c
// Function: de_module_ea_data
void de_module_ea_data(deark *c, struct deark_module_info *mi)
{
	mi->id = "ea_data";
	mi->desc = "EA DATA (OS/2 extended attributes)";
	mi->run_fn = de_run_eadata;
	mi->identify_fn = de_identify_eadata;
	mi->help_fn = de_help_eadata;
}

// Assembly:
leaq 0x800ae(%rip), %rax     # 0x1229a5
movq %rax, (%rsi)
leaq 0x901e7(%rip), %rax     # 0x132ae8
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0xa2927
movq %rax, 0x18(%rsi)
leaq 0x2d7(%rip), %rax       # 0xa2bee
movq %rax, 0x20(%rsi)
leaq 0x32c(%rip), %rax       # 0xa2c4e
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/os2ea.c
// Function: de_identify_eadata
static int de_identify_eadata(deark *c)
{
	if(de_getu16be(0)!=0x4544) return 0;
	if(de_input_file_has_ext(c, " sf")) return 100;
	if(dbuf_is_all_zeroes(c->infile, 2, 30)) {
		return 20;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xeeb67
cmpq $0x4544, %rax           # imm = 0x4544
jne 0xa2c43
leaq 0x90040(%rip), %rsi     # 0x132c52
movq %rbx, %rdi
callq 0xea491
movl $0x64, %r14d
testl %eax, %eax
jne 0xa2c43
movq 0x18(%rbx), %rdi
movl $0x2, %esi
movl $0x1e, %edx
callq 0xf1856
testl %eax, %eax
movl $0x14, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/os2ea.c
// Function: eadata_do_raw_list
static void eadata_do_raw_list(deark *c, struct eadata_ctx *d, i64 pos1, i64 len)
{
	i64 pos = pos1;
	i64 endpos;
	de_ucstring *tmps = NULL;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);
	tmps = ucstring_create(c);

	endpos = pos1 + len;

	while(1) {
		int ret;
		i64 bytes_consumed = 0;
		i64 offset_to_next_attr;
		i64 attr_pos;

		if(pos >= endpos) goto done;

		attr_pos = pos;
		de_dbg(c, "attribute at %"I64_FMT, attr_pos);
		de_dbg_indent(c, 1);
		offset_to_next_attr = de_getu32le_p(&pos);
		de_dbg(c, "offset to next attr: %"I64_FMT, offset_to_next_attr);

		ret = eadata_do_attribute(c, d, pos, endpos-pos, tmps, &bytes_consumed);
		if(!ret || bytes_consumed<1) goto done;
		if(offset_to_next_attr==0) goto done;
		pos = attr_pos + offset_to_next_attr;
		de_dbg_indent(c, -1);
	}

done:
	ucstring_destroy(tmps);
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, (%rsp)
leaq 0x14(%rsp), %rsi
callq 0xe8a1c
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r13
movq $0x0, 0x8(%rsp)
testq %r14, %r14
jle 0xa2d40
addq %r12, %r14
movq %rbx, %rdi
leaq 0x8fea8(%rip), %rsi     # 0x132b56
movq %r12, %rdx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%rbx), %rdi
movq %rsp, %rsi
callq 0xeed83
movq %rax, %rbp
movq %rbx, %rdi
leaq 0x8fe89(%rip), %rsi     # 0x132b67
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq (%rsp), %rdx
movq %r14, %rcx
subq %rdx, %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %r8
leaq 0x8(%rsp), %r9
callq 0xa300a
testq %rbp, %rbp
je 0xa2d40
testl %eax, %eax
je 0xa2d40
cmpq $0x0, 0x8(%rsp)
jle 0xa2d40
addq %r12, %rbp
movq %rbp, (%rsp)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq $0x0, 0x8(%rsp)
movq (%rsp), %r12
cmpq %r14, %r12
jl 0xa2ca4
movq %r13, %rdi
callq 0xf6753
movl 0x14(%rsp), %esi
movq %rbx, %rdi
callq 0xe8a25
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/os2bootlogo.c
// Function: de_module_os2bootlogo
void de_module_os2bootlogo(deark *c, struct deark_module_info *mi)
{
	mi->id = "os2bootlogo";
	mi->desc = "OS/2 boot logo";
	mi->run_fn = de_run_os2bootlogo;
	mi->identify_fn = de_identify_os2bootlogo;
}

// Assembly:
leaq 0x8f73b(%rip), %rax     # 0x132c92
movq %rax, (%rsi)
leaq 0x8f73d(%rip), %rax     # 0x132c9e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa357c
movq %rax, 0x18(%rsi)
leaq 0x61f(%rip), %rax       # 0xa3b96
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/os2bootlogo.c
// Function: de_identify_os2bootlogo
static int de_identify_os2bootlogo(deark *c)
{
	UI offs;
	UI len;
	UI i;
	UI next_expected_offs = 32;
	i64 pos = 0;

	for(i=0; i<4; i++) {
		offs = (UI)de_getu32le_p(&pos);
		if(offs!=next_expected_offs) return 0;
		len = (UI)de_getu32le_p(&pos);
		if(len<2) return 0;
		next_expected_offs = offs+len;
	}
	if(next_expected_offs!=c->infile->len) return 0;
	return 55;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x20, %r15d
movl $0x4, %r12d
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xeed83
cmpl %eax, %r15d
jne 0xa3bfe
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xeed83
cmpl $0x2, %eax
jb 0xa3bfe
addl %eax, %r15d
decl %r12d
jne 0xa3bbf
movl %r15d, %eax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
cmpq %rax, 0x18(%rcx)
movl $0x37, %ebp
cmovnel %edx, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_psd
void de_module_psd(deark *c, struct deark_module_info *mi)
{
	mi->id = "psd";
	mi->desc = "Photoshop PSD";
	mi->run_fn = de_run_psd;
	mi->identify_fn = de_identify_psd;
}

// Assembly:
leaq 0x8f1ed(%rip), %rax     # 0x132e18
movq %rax, (%rsi)
leaq 0x8f1e7(%rip), %rax     # 0x132e1c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa3c50
movq %rax, 0x18(%rsi)
leaq 0xa19(%rip), %rax       # 0xa4664
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_identify_psd
static int de_identify_psd(deark *c)
{
	u8 buf[4];

	de_read(buf, 0, 4);
	if(!de_memcmp(buf, "8BPS", 4)) return 100;
	if(!de_memcmp(buf, "8BIM", 4)) {
		// We sometimes write .8bim files, so we want to identify them.
		// This is not necessarily a standard file format.
		if(de_input_file_has_ext(c, "8bim")) return 100;
		return 75;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
movl $0x4, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
cmpl $0x53504238, (%r15)     # imm = 0x53504238
je 0xa46bd
cmpl $0x4d494238, 0xc(%rsp)  # imm = 0x4D494238
jne 0xa46c2
leaq 0x8e895(%rip), %rsi     # 0x132f39
movq %r14, %rdi
callq 0xea491
testl %eax, %eax
movl $0x4b, %eax
movl $0x64, %ebx
cmovel %eax, %ebx
jmp 0xa46c2
movl $0x64, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_ps_action
void de_module_ps_action(deark *c, struct deark_module_info *mi)
{
	mi->id = "ps_action";
	mi->desc = "Photoshop Action";
	mi->run_fn = de_run_ps_action;
	mi->identify_fn = de_identify_ps_action;
}

// Assembly:
leaq 0x8e755(%rip), %rax     # 0x132e2a
movq %rax, (%rsi)
leaq 0x8e755(%rip), %rax     # 0x132e34
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa46fa
movq %rax, 0x18(%rsi)
leaq 0x5f5(%rip), %rax       # 0xa4cea
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_identify_ps_action
static int de_identify_ps_action(deark *c)
{
	int ver=0;

	if(!dbuf_memcmp(c->infile, 0, "\x00\x00\x00\x10\x00\x00", 6)) {
		ver = 16;
	}
	else if(!dbuf_memcmp(c->infile, 0, "\x00\x00\x00\x0c", 4)) {
		ver = 12;
	}
	if(ver==0) return 0;
	if(!de_input_file_has_ext(c, "atn")) return 0;
	if(ver==16) return 100;
	return 5; // A version we don't support
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x8e0ff(%rip), %rdx     # 0x132dfb
xorl %ebx, %ebx
movl $0x6, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
je 0xa4d30
movq 0x18(%r14), %rdi
leaq 0x8e0e9(%rip), %rdx     # 0x132e02
movl $0x4, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0xa4d49
movl $0x5, %ebx
jmp 0xa4d35
movl $0x64, %ebx
leaq 0x8fdd9(%rip), %rsi     # 0x134b15
movq %r14, %rdi
callq 0xea491
testl %eax, %eax
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_ps_gradient
void de_module_ps_gradient(deark *c, struct deark_module_info *mi)
{
	mi->id = "ps_gradient";
	mi->desc = "Photoshop Gradient";
	mi->run_fn = de_run_ps_gradient;
	mi->identify_fn = de_identify_ps_gradient;
}

// Assembly:
leaq 0x8e0eb(%rip), %rax     # 0x132e45
movq %rax, (%rsi)
leaq 0x8e0ed(%rip), %rax     # 0x132e51
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa4d7f
movq %rax, 0x18(%rsi)
leaq 0x103(%rip), %rax       # 0xa4e7d
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_run_ps_gradient
static void de_run_ps_gradient(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	zztype *zz = NULL;
	i64 grd_ver;

	de_declare_fmt(c, "Photoshop Gradient");

	d = de_malloc(c, sizeof(lctx));
	d->version = 1;
	init_version_specific_info(c, d);

	zz = de_malloc(c, sizeof(zztype));
	zz_init_absolute(zz, 0, c->infile->len);

	zz->pos += 4; // 8BGR signature
	grd_ver = psd_getu16zz(zz);
	de_dbg(c, "file version: %d", (int)grd_ver);

	if(grd_ver==5) {
		read_descriptor(c, d, zz, 1, "");
	}
	else {
		de_err(c, "Unsupported Photoshop Gradient file version: %d", (int)grd_ver);
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8e0c0(%rip), %rsi     # 0x132e51
callq 0xeb125
movl $0x58, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r14
movl $0x1, (%rax)
movq $0x2, 0x18(%rax)
movl $0x4, %r12d
movq %r12, 0x20(%rax)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0xeb220
movl %eax, 0x8(%r14)
movb $0x1, 0x14(%r14)
movl $0x18, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rax
movq $0x0, 0x8(%r15)
movq %rax, 0x10(%r15)
movq %r12, (%r15)
movl 0x4(%r14), %edx
movl $0x4, %esi
callq 0xeef43
movq %rax, %r12
addq $0x2, (%r15)
leaq 0x8fd56(%rip), %rsi     # 0x134b6f
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
cmpq $0x5, %r12
jne 0xa4e48
leaq 0xa027d(%rip), %r8      # 0x1450b0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0xa7748
jmp 0xa4e5c
leaq 0x8fcca(%rip), %rsi     # 0x134b19
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_ps_styles
void de_module_ps_styles(deark *c, struct deark_module_info *mi)
{
	mi->id = "ps_styles";
	mi->desc = "Photoshop Styles";
	mi->run_fn = de_run_ps_styles;
	mi->identify_fn = de_identify_ps_styles;
}

// Assembly:
leaq 0x8df90(%rip), %rax     # 0x132e64
movq %rax, (%rsi)
leaq 0x8df90(%rip), %rax     # 0x132e6e
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa4ef9
movq %rax, 0x18(%rsi)
leaq 0x361(%rip), %rax       # 0xa5255
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_ps_brush
void de_module_ps_brush(deark *c, struct deark_module_info *mi)
{
	mi->id = "ps_brush";
	mi->desc = "Photoshop Brush";
	mi->run_fn = de_run_ps_brush;
	mi->identify_fn = de_identify_ps_brush;
}

// Assembly:
leaq 0x8dbdd(%rip), %rax     # 0x132e7f
movq %rax, (%rsi)
leaq 0x8dbdc(%rip), %rax     # 0x132e88
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa52c7
movq %rax, 0x18(%rsi)
leaq 0x26a(%rip), %rax       # 0xa552c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_ps_csh
void de_module_ps_csh(deark *c, struct deark_module_info *mi)
{
	mi->id = "ps_csh";
	mi->desc = "Photoshop Custom Shape";
	mi->run_fn = de_run_ps_csh;
	mi->identify_fn = de_identify_ps_csh;
}

// Assembly:
leaq 0x8d927(%rip), %rax     # 0x132e98
movq %rax, (%rsi)
leaq 0x8d924(%rip), %rax     # 0x132e9f
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa5596
movq %rax, 0x18(%rsi)
leaq 0x350(%rip), %rax       # 0xa58e1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_module_ps_pattern
void de_module_ps_pattern(deark *c, struct deark_module_info *mi)
{
	mi->id = "ps_pattern";
	mi->desc = "Photoshop Pattern";
	mi->run_fn = de_run_ps_pattern;
	mi->identify_fn = de_identify_ps_pattern;
}

// Assembly:
leaq 0x8d57e(%rip), %rax     # 0x132eb6
movq %rax, (%rsi)
leaq 0x8d57f(%rip), %rax     # 0x132ec1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0xa595d
movq %rax, 0x18(%rsi)
leaq 0x1cf(%rip), %rax       # 0xa5b27
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: de_run_ps_pattern
static void de_run_ps_pattern(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	zztype *zz = NULL;
	i64 pat_ver;
	i64 num_patterns;
	i64 i;
	zztype czz;

	d = de_malloc(c, sizeof(lctx));
	d->version = 1;
	init_version_specific_info(c, d);

	zz = de_malloc(c, sizeof(zztype));
	zz_init_absolute(zz, 0, c->infile->len);

	zz->pos += 4; // Skip over '8BPT' signature

	pat_ver = psd_getu16zz(zz);
	de_dbg(c, "file version: %d", (int)pat_ver);

	if(pat_ver!=1) {
		de_warn(c, "PAT v%d format might not be supported correctly", (int)pat_ver);
	}

	num_patterns = psd_getu32zz(zz);
	de_dbg(c, "number of patterns: %d", (int)num_patterns);

	for(i=0; i<num_patterns; i++) {
		if(zz_avail(zz)<4) break;
		de_dbg(c, "pattern[%d] at %d", (int)i, (int)zz->pos);
		zz_init(&czz, zz);
		de_dbg_indent(c, 1);
		if(!do_pattern_internal(c, d, &czz)) break;
		de_dbg_indent(c, -1);
		zz->pos += zz_used(&czz);
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x58, %esi
callq 0xe8b2b
movq %rax, %r14
movl $0x1, (%rax)
movq $0x2, 0x18(%rax)
movl $0x4, %r12d
movq %r12, 0x20(%rax)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0xeb220
movl %eax, 0x8(%r14)
movb $0x1, 0x14(%r14)
movl $0x18, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rax
movq $0x0, 0x8(%r15)
movq %rax, 0x10(%r15)
movq %r12, (%r15)
movl 0x4(%r14), %edx
movl $0x4, %esi
callq 0xeef43
movq %rax, %r12
addq $0x2, (%r15)
leaq 0x8f181(%rip), %rsi     # 0x134b6f
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
cmpq $0x1, %r12
je 0xa5a15
leaq 0x8f3b9(%rip), %rsi     # 0x134dc1
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8faa
movq 0x18(%rbx), %rdi
movl 0x4(%r14), %edx
movq (%r15), %rsi
callq 0xeeff3
movq %rax, %r12
addq $0x4, (%r15)
leaq 0x8f3be(%rip), %rsi     # 0x134df1
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
testq %r12, %r12
jle 0xa5b03
movq (%r15), %rcx
movq %rsp, %rbp
xorl %r13d, %r13d
movq 0x10(%r15), %rax
cmpq %rax, %rcx
jge 0xa5b03
movq 0x8(%r15), %rdx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
subq %rdx, %rax
cmpq $0x4, %rax
jl 0xa5b03
movq %rbx, %rdi
leaq 0x8e90a(%rip), %rsi     # 0x13438b
movl %r13d, %edx
xorl %eax, %eax
callq 0xe8617
movq (%r15), %rax
movq 0x10(%r15), %rcx
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movq %rcx, 0x10(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xab290
testl %eax, %eax
je 0xa5b03
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rsi
movq %rsi, %rcx
subq %rax, %rcx
jle 0xa5aef
movq (%rsp), %rdx
cmpq %rsi, %rdx
jg 0xa5af1
subq %rax, %rdx
movq %rdx, %rcx
jmp 0xa5af1
xorl %ecx, %ecx
addq (%r15), %rcx
movq %rcx, (%r15)
incq %r13
cmpq %r13, %r12
jne 0xa5a52
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8be2
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe8be2
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: do_external_tagged_blocks
static void do_external_tagged_blocks(deark *c, lctx *d, zztype *zz)
{
	u32 code;

	d->tagged_blocks_only = 1;
	if(zz_avail(zz)<4) return;

	// Evidently, it is possible for this to use little-endian byte order. Weird.

	// Peek at the first 4 bytes
	code = (u32)de_getu32le(0);
	if(code==CODE_8BIM || code==CODE_8B64) {
		d->is_le = 1;
	}

	do_tagged_blocks(c, d, zz, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, 0xc(%rsi)
movq (%rdx), %rcx
movq 0x10(%rdx), %rax
cmpq %rax, %rcx
jge 0xa5fa1
movq %rdx, %rbx
movq 0x8(%rdx), %rdx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
subq %rdx, %rax
cmpq $0x4, %rax
jge 0xa5fa7
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0xeed61
cmpl $0x3842494d, %eax       # imm = 0x3842494D
je 0xa5fc6
cmpl $0x38423634, %eax       # imm = 0x38423634
jne 0xa5fce
movl $0x1, 0x4(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xa8d66
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: read_pascal_string_to_ucstring
static void read_pascal_string_to_ucstring(deark *c, lctx *d, de_ucstring *s, zztype *zz)
{
	i64 dlen;

	if(zz_avail(zz)<1) return;

	// First byte is the string length
	dlen = (i64)psd_getbytezz(zz);

	if(zz->pos + dlen > zz->endpos) { // error
		zz->pos = zz->endpos;
		return;
	}

	dbuf_read_to_ucstring(c->infile, zz->pos, dlen, s, 0, d->input_encoding);
	zz->pos += dlen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq (%rcx), %rsi
movq 0x10(%rcx), %rax
cmpq %rax, %rsi
jge 0xa6051
movq %rcx, %rbx
cmpq %rax, 0x8(%rcx)
jge 0xa6051
movq %rdx, %r14
movq %rdi, %r12
movq 0x18(%rdi), %rdi
callq 0xeead3
movq (%rbx), %rdx
movq 0x10(%rbx), %rcx
leaq 0x1(%rdx), %rsi
movq %rsi, (%rbx)
movzbl %al, %r13d
leaq (%rdx,%r13), %rax
incq %rax
cmpq %rcx, %rax
jg 0xa604e
movq 0x18(%r12), %rdi
movl 0x8(%r15), %r9d
movq %r13, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xefbd7
addq (%rbx), %r13
movq %r13, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_resolutioninfo
static void hrsrc_resolutioninfo(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	i64 xres_int, yres_int;
	double xres, yres;
	i64 xres_unit, yres_unit;

	if(zz_avail(zz)!=16) return;
	xres_int = psd_getu32(zz->pos);
	xres = ((double)xres_int)/65536.0;
	de_dbg(c, "xres=%.2f dpi", xres);
	xres_unit = psd_getu16(zz->pos+4);
	de_dbg(c, "xres display unit: %d (%s)", (int)xres_unit, units_name(xres_unit));
	//width_unit = psd_getu16(pos+6);

	yres_int = psd_getu32(zz->pos+8);
	yres = ((double)yres_int)/65536.0;
	de_dbg(c, "yres=%.2f dpi", yres);
	yres_unit = psd_getu16(zz->pos+12);
	de_dbg(c, "yres display unit: %d (%s)", (int)yres_unit, units_name(yres_unit));
	//height_unit = psd_getu16(pos+14);

	d->density.code = DE_DENSITY_DPI;
	d->density.xdens = xres;
	d->density.ydens = yres;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdx), %rsi
movq 0x10(%rdx), %rax
cmpq %rax, %rsi
jge 0xa65dc
movq %rdx, %r15
movq 0x8(%rdx), %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jne 0xa65dc
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movl 0x4(%rbx), %edx
callq 0xeeff3
cvtsi2sd %rax, %xmm0
mulsd 0x802a1(%rip), %xmm0    # 0x126788
movsd %xmm0, 0x10(%rsp)
leaq 0x8d22c(%rip), %rsi     # 0x133720
movq %r14, %rdi
movb $0x1, %al
callq 0xe8617
movq 0x18(%r14), %rdi
movq (%r15), %rsi
addq $0x4, %rsi
movl 0x4(%rbx), %edx
callq 0xeef43
cmpq $0x2, %rax
leaq 0x8d262(%rip), %r13     # 0x13377e
leaq 0x85c2e(%rip), %r12     # 0x12c151
movq %r12, %rcx
cmoveq %r13, %rcx
cmpq $0x1, %rax
leaq 0x8d23d(%rip), %rbp     # 0x133772
cmoveq %rbp, %rcx
leaq 0x8d1ee(%rip), %rsi     # 0x13372e
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe8617
movq 0x18(%r14), %rdi
movq (%r15), %rsi
addq $0x8, %rsi
movl 0x4(%rbx), %edx
callq 0xeeff3
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x80219(%rip), %xmm0    # 0x126788
movsd %xmm0, 0x8(%rsp)
leaq 0x8d1cd(%rip), %rsi     # 0x133749
movq %r14, %rdi
movb $0x1, %al
callq 0xe8617
movq 0x18(%r14), %rdi
movq (%r15), %rsi
addq $0xc, %rsi
movl 0x4(%rbx), %edx
callq 0xeef43
cmpq $0x2, %rax
cmoveq %r13, %r12
cmpq $0x1, %rax
cmoveq %rbp, %r12
leaq 0x8d1a7(%rip), %rsi     # 0x133757
movq %r14, %rdi
movl %eax, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0xe8617
movl $0x2, 0x38(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x48(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_namesofalphachannels
static void hrsrc_namesofalphachannels(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	de_ucstring *s = NULL;
	int idx = 0;

	// This is a "series of Pascal strings", whatever that is.

	s = ucstring_create(c);
	while(zz->pos < (zz->endpos-1)) {
		ucstring_empty(s);
		read_pascal_string_to_ucstring(c, d, s, zz);
		de_dbg(c, "%s[%d]: \"%s\"", ri->idname, idx, ucstring_getpsz_d(s));
		idx++;
	}
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xf6410
movq %rax, %r13
movq 0x10(%r14), %rax
decq %rax
cmpq %rax, (%r14)
jge 0xa666c
xorl %ebp, %ebp
movq %r15, (%rsp)
movq %r13, %rdi
callq 0xf6423
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xa5fe3
movq 0x8(%rbx), %r15
movq %r13, %rdi
callq 0xf70f6
movq %r12, %rdi
leaq 0x8d13d(%rip), %rsi     # 0x133788
movq %r15, %rdx
movq (%rsp), %r15
movl %ebp, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0xe8617
incl %ebp
movq 0x10(%r14), %rax
decq %rax
cmpq %rax, (%r14)
jl 0xa661c
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_printflags
static void hrsrc_printflags(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	u8 fl[9];
	if(zz_avail(zz)!=9) return;
	de_read(fl, zz->pos, 9);
	de_dbg(c, "%s: labels=%d, crop marks=%d, color bars=%d, registration marks=%d, "
		"negative=%d, flip=%d, interpolate=%d, caption=%d, print flags=%d",
		ri->idname, (int)fl[0], (int)fl[1], (int)fl[2], (int)fl[3],
		(int)fl[4], (int)fl[5], (int)fl[6], (int)fl[7], (int)fl[8]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rax
movq (%rdx), %rdx
movq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jge 0xa671f
movq 0x8(%rax), %rax
cmpq %rax, %rdx
cmovgq %rdx, %rax
subq %rax, %rcx
cmpq $0x9, %rcx
jne 0xa671f
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x7(%rsp), %r15
movl $0x9, %ecx
movq %r15, %rsi
callq 0xee8d4
movq 0x8(%r14), %rdx
movzbl (%r15), %ecx
movzbl 0x1(%r15), %r8d
movzbl 0x2(%r15), %r9d
movzbl 0x3(%r15), %r10d
movzbl 0x4(%r15), %r11d
movzbl 0x5(%r15), %r14d
movzbl 0x6(%r15), %r12d
movzbl 0x7(%r15), %r13d
movzbl 0x8(%r15), %r15d
leaq 0x8d090(%rip), %rsi     # 0x133795
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r13
pushq %r12
pushq %r14
pushq %r11
pushq %r10
callq 0xe8617
addq $0x30, %rsp
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_uint16
static void hrsrc_uint16(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	i64 n;
	if(zz_avail(zz)!=2) return;
	n = psd_getu16zz(zz);
	de_dbg(c, "%s: %d", ri->idname, (int)n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %rax
movq (%rdx), %rsi
movq 0x10(%rdx), %rcx
cmpq %rcx, %rsi
jge 0xa678a
movq %rdx, %r15
movq 0x8(%rdx), %rdx
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
subq %rdx, %rcx
cmpq $0x2, %rcx
jne 0xa678a
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x4(%rax), %edx
callq 0xeef43
addq $0x2, (%r15)
movq 0x8(%r14), %rdx
leaq 0x9896a(%rip), %rsi     # 0x13f0e3
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe8617
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_byte
static void hrsrc_byte(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	u8 b;
	if(zz_avail(zz)!=1) return;
	b = psd_getbytezz(zz);
	de_dbg(c, "%s: %d", ri->idname, (int)b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %rsi
movq 0x10(%rdx), %rax
cmpq %rax, %rsi
jge 0xa698e
movq %rcx, %r14
movq %rdx, %r15
movq 0x8(%rdx), %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jne 0xa698e
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xeead3
incq (%r15)
movq 0x8(%r14), %rdx
movzbl %al, %ecx
leaq 0x98764(%rip), %rsi     # 0x13f0e3
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe8617
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_plaintext
static void hrsrc_plaintext(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, zz->pos, zz_avail(zz), DE_DBG_MAX_STRLEN,
		s, 0, d->input_encoding);
	de_dbg(c, "%s: \"%s\"", ri->idname, ucstring_getpsz(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
callq 0xf6410
movq %rax, %rbx
movq 0x18(%r14), %rdi
movq (%r13), %rsi
movq 0x10(%r13), %rax
movq %rax, %rdx
subq %rsi, %rdx
jle 0xa69da
movq 0x8(%r13), %rcx
cmpq %rcx, %rsi
jge 0xa69dc
subq %rcx, %rax
movq %rax, %rdx
jmp 0xa69dc
xorl %edx, %edx
movl 0x8(%r12), %eax
movl %eax, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %rbx, %r8
xorl %r9d, %r9d
callq 0xefc2a
movq 0x8(%r15), %r15
movq %rbx, %rdi
callq 0xf705c
leaq 0x85723(%rip), %rsi     # 0x12c12a
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_uint32
static void hrsrc_uint32(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	i64 n;
	if(zz_avail(zz)!=4) return;
	n = psd_getu32zz(zz);
	de_dbg(c, "%s: %d", ri->idname, (int)n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %rax
movq (%rdx), %rsi
movq 0x10(%rdx), %rcx
cmpq %rcx, %rsi
jge 0xa6a89
movq %rdx, %r15
movq 0x8(%rdx), %rdx
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
subq %rdx, %rcx
cmpq $0x4, %rcx
jne 0xa6a89
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x4(%rax), %edx
callq 0xeeff3
addq $0x4, (%r15)
movq 0x8(%r14), %rdx
leaq 0x9866b(%rip), %rsi     # 0x13f0e3
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe8617
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_unicodestring_multi
static void hrsrc_unicodestring_multi(deark *c, lctx *d, zztype *zz,
	const struct rsrc_info *ri)
{
	de_ucstring *s = NULL;
	int idx = 0;

	s = ucstring_create(c);
	while(zz_avail(zz)>=4) {
		ucstring_empty(s);
		read_unicode_string(c, d, s, zz);
		de_dbg(c, "%s[%d]: \"%s\"", ri->idname, idx, ucstring_getpsz_d(s));
		idx++;
	}
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xf6410
movq %rax, %r13
movq (%r14), %rcx
movq 0x10(%r14), %rax
cmpq %rax, %rcx
jge 0xa6b5f
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
subq %rdx, %rax
cmpq $0x4, %rax
jl 0xa6b5f
movq %r13, %rdi
callq 0xf6423
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xa7614
movq (%rsp), %rax
movq 0x8(%rax), %rbx
movq %r13, %rdi
callq 0xf70f6
movq %r12, %rdi
leaq 0x8cc46(%rip), %rsi     # 0x133788
movq %rbx, %rdx
movl %ebp, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0xe8617
incl %ebp
movq (%r14), %rcx
movq 0x10(%r14), %rax
cmpq %rax, %rcx
jl 0xa6afb
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_unicodestring
static void hrsrc_unicodestring(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	read_unicode_string(c, d, s, zz);
	de_dbg(c, "%s: \"%s\"", ri->idname, ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xf6410
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0xa7614
movq 0x8(%rbx), %rbx
movq %r13, %rdi
callq 0xf70f6
leaq 0x85125(%rip), %rsi     # 0x12c12a
movq %r12, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe8617
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/psd.c
// Function: hrsrc_urllist
static void hrsrc_urllist(deark *c, lctx *d, zztype *zz, const struct rsrc_info *ri)
{
	de_ucstring *s = NULL;
	i64 count;
	i64 i;

	count = psd_getu32zz(zz);
	de_dbg(c, "URL count: %d", (int)count);

	s = ucstring_create(c);

	for(i=0; i<count; i++) {
		struct de_fourcc url4cc;
		i64 id;

		// undocumented field, seems to be a fourcc
		psd_read_fourcc_zz(c, d, zz, &url4cc);

		id = psd_getu32zz(zz);

		read_unicode_string(c, d, s, zz);
		de_dbg(c, "URL[%d]: '%s', id=%d, value=\"%s\"", (int)i,
			url4cc.id_dbgstr, (int)id, ucstring_getpsz(s));
		ucstring_empty(s);
	}

	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movl 0x4(%rsi), %edx
movq (%rbx), %rsi
callq 0xeeff3
movq %rax, %r12
addq $0x4, (%rbx)
leaq 0x8cc0d(%rip), %rsi     # 0x133c67
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe8617
movq %r15, %rdi
callq 0xf6410
movq %rax, %r13
testq %r12, %r12
jle 0xa7110
xorl %ebp, %ebp
movq %r12, (%rsp)
movq 0x18(%r15), %rdi
movq (%rbx), %rsi
xorl %r8d, %r8d
cmpl $0x0, 0x4(%r14)
setne %r8b
leaq 0x8(%rsp), %rdx
movl $0x4, %ecx
callq 0xf1762
movq (%rbx), %rsi
addq $0x4, %rsi
movq %rsi, (%rbx)
movq 0x18(%r15), %rdi
movl 0x4(%r14), %edx
callq 0xeeff3
movq %rax, %r12
addq $0x4, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xa7614
movq %r13, %rdi
callq 0xf705c
movq %r15, %rdi
leaq 0x8cb91(%rip), %rsi     # 0x133c75
movl %ebp, %edx
leaq 0x18(%rsp), %rcx
movl %r12d, %r8d
movq (%rsp), %r12
movq %rax, %r9
xorl %eax, %eax
callq 0xe8617
movq %r13, %rdi
callq 0xf6423
incq %rbp
cmpq %rbp, %r12
jne 0xa7081
movq %r13, %rdi
callq 0xf6753
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq