LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: de_run_spectrum512u
static void de_run_spectrum512u(deark *c, de_module_params *mparams)
{
	int is_enhanced = 0;

	if(!dbuf_memcmp(c->infile, 0, (const void*)"5BIT", 4)) {
		is_enhanced = 1;
	}
	de_declare_fmtf(c, "Spectrum 512 Uncompressed%s", (is_enhanced?" Enhanced":""));

	do_spu_internal(c, c->infile, is_enhanced);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xa08ed(%rip), %rdx     # 0x1c6ee7
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x126610
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0xaa5b2(%rip), %rdx     # 0x1d0bd0
leaq 0xa08e3(%rip), %rax     # 0x1c6f08
cmpl $0x0, %ecx
cmovneq %rax, %rdx
leaq 0xa08b9(%rip), %rsi     # 0x1c6eec
movb $0x0, %al
callq 0x15e3d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x126960
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: de_identify_spectrum512u
static int de_identify_spectrum512u(deark *c)
{
	if(c->infile->len!=51104 && c->infile->len!=51200)
		return 0;

	if(de_input_file_has_ext(c, "spu")) {
		return (c->infile->len==51104) ? 90 : 10;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0xc7a0, 0x18(%rax)     # imm = 0xC7A0
je 0x126699
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0xc800, 0x18(%rax)     # imm = 0xC800
je 0x126699
movl $0x0, -0x4(%rbp)
jmp 0x1266da
movq -0x10(%rbp), %rdi
leaq 0xa088c(%rip), %rsi     # 0x1c6f30
callq 0x15d180
cmpl $0x0, %eax
je 0x1266d3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
movl $0xa, %eax
movl $0x5a, %ecx
cmpq $0xc7a0, %rdx           # imm = 0xC7A0
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1266da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: de_module_spectrum512c
void de_module_spectrum512c(deark *c, struct deark_module_info *mi)
{
	mi->id = "spectrum512c";
	mi->desc = "Spectrum 512 Compressed";
	mi->run_fn = de_run_spectrum512c;
	mi->identify_fn = de_identify_spectrum512c;
	mi->help_fn = de_help_spectrum512cs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xa0778(%rip), %rcx     # 0x1c6e9f
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xa0777(%rip), %rcx     # 0x1c6eac
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x126770
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4d(%rip), %rcx        # 0x1267a0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0xce(%rip), %rcx        # 0x126830
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: de_identify_spectrum512c
static int de_identify_spectrum512c(deark *c)
{
	if(dbuf_memcmp(c->infile, 0, "\x53\x50\x00\x00", 4))
		return 0;

	if(de_input_file_has_ext(c, "spc")) {
		return 100;
	}

	if(de_input_file_has_ext(c, "sps")) {
		return 0;
	}

	return 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xa0841(%rip), %rdx     # 0x1c7000
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x1267d7
movl $0x0, -0x4(%rbp)
jmp 0x12681a
movq -0x10(%rbp), %rdi
leaq 0xa07ca(%rip), %rsi     # 0x1c6fac
callq 0x15d180
cmpl $0x0, %eax
je 0x1267f5
movl $0x64, -0x4(%rbp)
jmp 0x12681a
movq -0x10(%rbp), %rdi
leaq 0xa07b0(%rip), %rsi     # 0x1c6fb0
callq 0x15d180
cmpl $0x0, %eax
je 0x126813
movl $0x0, -0x4(%rbp)
jmp 0x12681a
movl $0xa, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: de_module_spectrum512s
void de_module_spectrum512s(deark *c, struct deark_module_info *mi)
{
	mi->id = "spectrum512s";
	mi->desc = "Spectrum 512 Smooshed";
	mi->run_fn = de_run_spectrum512s;
	mi->identify_fn = de_identify_spectrum512s;
	mi->help_fn = de_help_spectrum512cs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xa064d(%rip), %rcx     # 0x1c6ec4
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xa064c(%rip), %rcx     # 0x1c6ed1
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x1268c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4d(%rip), %rcx        # 0x1268f0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq -0x82(%rip), %rcx       # 0x126830
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: de_identify_spectrum512s
static int de_identify_spectrum512s(deark *c)
{
	if(dbuf_memcmp(c->infile, 0, "\x53\x50\x00\x00", 4))
		return 0;

	if(de_input_file_has_ext(c, "sps")) {
		return 100;
	}

	// No reason to return anything but 0. The file will be identified as SPC.
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xa06f1(%rip), %rdx     # 0x1c7000
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0x126927
movl $0x0, -0x4(%rbp)
jmp 0x12694c
movq -0x10(%rbp), %rdi
leaq 0xa067e(%rip), %rsi     # 0x1c6fb0
callq 0x15d180
cmpl $0x0, %eax
je 0x126945
movl $0x64, -0x4(%rbp)
jmp 0x12694c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: do_spu_internal
static void do_spu_internal(deark *c, dbuf *inf, int is_enhanced)
{
	struct atari_img_decode_data *adata = NULL;
	de_finfo *fi = NULL;
	static const i64 num_colors = 199*48;

	adata = de_malloc(c, sizeof(struct atari_img_decode_data));
	adata->is_spectrum512 = 1;
	adata->pal = de_mallocarray(c, num_colors, sizeof(u32));
	adata->bpp = 4;
	adata->w = 320;
	adata->h = 199;
	adata->ncolors = num_colors;

	fmtutil_read_atari_palette(c, inf, 32000, adata->pal, num_colors, num_colors,
		is_enhanced?DE_FLAG_ATARI_15BIT_PAL:0);

	adata->unc_pixels = dbuf_open_input_subfile(inf, 160, inf->len-160);
	adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
	fi = de_finfo_create(c);
	fmtutil_atari_set_standard_density(c, adata, fi);
	fmtutil_atari_decode_image(c, adata);
	de_bitmap_write_to_file_finfo(adata->img, fi, 0);

	if(adata) {
		de_bitmap_destroy(adata->img);
		de_free(c, adata->pal);
		dbuf_close(adata->unc_pixels);
		de_free(c, adata);
	}
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rdi
movl $0x2550, %esi           # imm = 0x2550
movl $0x4, %edx
callq 0x15c450
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x4, (%rax)
movq -0x20(%rbp), %rax
movq $0x140, 0x10(%rax)      # imm = 0x140
movq -0x20(%rbp), %rax
movq $0xc7, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x2550, 0x8(%rax)      # imm = 0x2550
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movl -0x14(%rbp), %r8d
xorl %eax, %eax
movl $0x2, %edx
cmpl $0x0, %r8d
cmovnel %edx, %eax
movl $0x7d00, %edx           # imm = 0x7D00
movl $0x2550, %r9d           # imm = 0x2550
movq %r9, %r8
movl %eax, (%rsp)
callq 0x174460
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
subq $0xa0, %rdx
movl $0xa0, %esi
callq 0x1691b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x3, %ecx
callq 0x16b750
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x174df0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x174910
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x16afa0
cmpq $0x0, -0x20(%rbp)
je 0x126af3
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x16af60
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x15b820
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: decompress_spc_or_sps
static void decompress_spc_or_sps(deark *c, struct spc_sps_ctx *d, dbuf *unc_pixels_planar)
{
	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 = d->pixels_pos;
	dcmpri.len = d->pixels_cmpr_len;
	dcmpro.f = unc_pixels_planar;
	dcmpro.len_known = 1;
	dcmpro.expected_len = 32000;

	if(d->is_sps) {
		sps_decompress_pixels(c, &dcmpri, &dcmpro, &dres);
	}
	else {
		spc_decompress_pixels(c, &dcmpri, &dcmpro, &dres);
	}

	if(dres.bytes_consumed_valid) {
		de_dbg(c, "decompressed %"I64_FMT" bytes to %"I64_FMT,
			dres.bytes_consumed, unc_pixels_planar->len);
	}

	// We expect exactly 31840.
	if(unc_pixels_planar->len<31840 || unc_pixels_planar->len>31970) {
		de_warn(c, "Decompression may have failed");
	}

	if(unc_pixels_planar->len > 31840) {
		dbuf_truncate(unc_pixels_planar, 31840);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x1773f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x48(%rbp)
movq $0x7d00, -0x40(%rbp)    # imm = 0x7D00
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x126f1a
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x127370
jmp 0x126f32
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x1274f0
cmpb $0x0, -0xac(%rbp)
je 0x126f5c
movq -0x8(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x77dee(%rip), %rsi     # 0x19ed43
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
cmpq $0x7c60, 0x18(%rax)     # imm = 0x7C60
jl 0x126f78
movq -0x18(%rbp), %rax
cmpq $0x7ce2, 0x18(%rax)     # imm = 0x7CE2
jle 0x126f8a
movq -0x8(%rbp), %rdi
leaq 0xa000b(%rip), %rsi     # 0x1c6f8e
movb $0x0, %al
callq 0x15bc10
movq -0x18(%rbp), %rax
cmpq $0x7c60, 0x18(%rax)     # imm = 0x7C60
jle 0x126fa6
movq -0x18(%rbp), %rdi
movl $0x7c60, %esi           # imm = 0x7C60
callq 0x168900
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: reorder_img_bytes
static void reorder_img_bytes(deark *c, dbuf *src, dbuf *dst, reorder_fn rfn)
{
	i64 i;
	u8 b;

	for(i=0; i<src->len; i++) {
		b = dbuf_getbyte(src, i);
		dbuf_writebyte_at(dst, rfn(i), b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x12701e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x165060
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movzbl -0x29(%rbp), %edx
callq 0x168790
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x126fd0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: reorderfn_spc
static i64 reorderfn_spc(i64 a)
{
	i64 b;

	if(a%2)
		b = 160 + (a-1)*4 + 1; // if odd
	else
		b = 160 + a*4; // if even

	while(b>=32000) {
		b -= (32000-(160+2));
	}
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x127118
movq -0x8(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
addq $0xa0, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12712a
movq -0x8(%rbp), %rax
shlq $0x2, %rax
addq $0xa0, %rax
movq %rax, -0x10(%rbp)
jmp 0x12712c
cmpq $0x7d00, -0x10(%rbp)    # imm = 0x7D00
jl 0x127146
movq -0x10(%rbp), %rax
subq $0x7c5e, %rax           # imm = 0x7C5E
movq %rax, -0x10(%rbp)
jmp 0x12712c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: sps_decompress_pal
static void sps_decompress_pal(deark *c, i64 pos1, dbuf *uncmpr_pal)
{
	static const i64 num_pals = 199*3;
	i64 i;
	UI k;
	UI code;
	struct de_bitreader bitrd;

	de_zeromem(&bitrd, sizeof(struct de_bitreader));
	bitrd.f = c->infile;
	bitrd.curpos = pos1;
	bitrd.endpos = c->infile->len;

	for(i=0; i<num_pals; i++) {
		code = (UI)de_bitreader_getbits(&bitrd, 14);

		for(k=0; k<16; k++) {
			// Palette entries 0 and 15 are always black
			if(k>=1 && k<=14 && (code&(1<<(14-k)))) {
				UI cr, cg, cb;
				UI palcode;

				cr = (UI)de_bitreader_getbits(&bitrd, 3);
				cg = (UI)de_bitreader_getbits(&bitrd, 3);
				cb = (UI)de_bitreader_getbits(&bitrd, 3);
				palcode = (cr<<8)|(cg<<4)|cb;
				dbuf_writeu16be(uncmpr_pal, palcode);
			}
			else {
				dbuf_write_zeroes(uncmpr_pal, 2);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x255, -0x20(%rbp)     # imm = 0x255
jge 0x12727f
leaq -0x58(%rbp), %rdi
movl $0xe, %esi
callq 0x16a390
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x24(%rbp)
jae 0x12726c
cmpl $0x1, -0x24(%rbp)
jb 0x12724e
cmpl $0xe, -0x24(%rbp)
ja 0x12724e
movl -0x28(%rbp), %eax
movl $0xe, %ecx
subl -0x24(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x12724e
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x16a390
movl %eax, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x16a390
movl %eax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x16a390
movl %eax, -0x64(%rbp)
movl -0x5c(%rbp), %eax
shll $0x8, %eax
movl -0x60(%rbp), %ecx
shll $0x4, %ecx
orl %ecx, %eax
orl -0x64(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movl -0x68(%rbp), %eax
movl %eax, %esi
callq 0x168a50
jmp 0x12725c
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1685f0
jmp 0x12725e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1271c6
jmp 0x12726e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1271a0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: spc_decompress_pal
static void spc_decompress_pal(deark *c, i64 pos1, dbuf *uncmpr_pal)
{
	static const i64 num_pals = 199*3;
	i64 pos = pos1;
	i64 i, k;
	UI code;

	for(i=0; i<num_pals; i++) {
		code = (UI)de_getu16be(pos);
		pos += 2;
		for(k=0; k<16; k++) {
			// Bit 15 is ignored. The corresponding pal entry will always be black.
			if(k<=14 && (code&0x1)) {
				dbuf_copy(c->infile, pos, 2, uncmpr_pal);
				pos += 2;
			}
			else {
				dbuf_write_zeroes(uncmpr_pal, 2);
			}
			code >>= 1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x255, -0x28(%rbp)     # imm = 0x255
jge 0x127362
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1651d0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jge 0x12734f
cmpq $0xe, -0x30(%rbp)
jg 0x12732b
movl -0x34(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12732b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x2, %edx
callq 0x166070
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x127339
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1685f0
movl -0x34(%rbp), %eax
shrl %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1272ea
jmp 0x127351
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1272b4
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/spectrum512.c
// Function: sps_decompress_pixels
static void sps_decompress_pixels(deark *c, struct de_dfilter_in_params *dcmpri,
	struct de_dfilter_out_params *dcmpro, struct de_dfilter_results *dres)
{
	i64 pos;
	u8 b, b2;
	i64 count;
	i64 endpos;
	i64 nbytes_written = 0;

	pos = dcmpri->pos;
	endpos = dcmpri->pos + dcmpri->len;

	while(1) {
		if(dcmpro->len_known && nbytes_written >= dcmpro->expected_len) {
			break; // Decompressed the requested amount of dst data.
		}

		if(pos+2 > endpos) { // Min item size is 2 bytes
			break; // Reached the end of source data
		}
		b = dbuf_getbyte(dcmpri->f, pos++);

		if(b<=127) { // A compressed run
			count = (i64)b +3;
			b2 = dbuf_getbyte(dcmpri->f, pos++);
			dbuf_write_run(dcmpro->f, b2, count);
			nbytes_written += count;
		}
		else { // An uncompressed run
			count = (i64)b - 127;
			if(pos+count > endpos) {
				pos--;
				break;
			}
			dbuf_copy(dcmpri->f, pos, count, dcmpro->f);
			pos += count;
			nbytes_written += count;
		}
	}

	dbuf_flush(dcmpro->f);
	dres->bytes_consumed = pos - dcmpri->pos;
	dres->bytes_consumed_valid = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x1273d0
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jl 0x1273d0
jmp 0x1274b8
movq -0x28(%rbp), %rax
addq $0x2, %rax
cmpq -0x40(%rbp), %rax
jle 0x1273e3
jmp 0x1274b8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x165060
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x7f, %eax
jg 0x127458
movzbl -0x29(%rbp), %eax
addq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x165060
movb %al, -0x2a(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movb -0x2a(%rbp), %al
movq -0x38(%rbp), %rdx
movzbl %al, %esi
callq 0x168800
movq -0x38(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1274b3
movzbl -0x29(%rbp), %eax
subq $0x7f, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x127480
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1274b8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
callq 0x166070
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1273b0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x167c30
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: de_module_sunras
void de_module_sunras(deark *c, struct deark_module_info *mi)
{
	mi->id = "sunras";
	mi->desc = "Sun Raster";
	mi->run_fn = de_run_sunras;
	mi->identify_fn = de_identify_sunras;
	mi->help_fn = de_help_sunras;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x9f97e(%rip), %rcx     # 0x1c7005
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x9f977(%rip), %rcx     # 0x1c700c
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x1276d0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x38d(%rip), %rcx       # 0x127a40
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x3ce(%rip), %rcx       # 0x127a90
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: handle_options
static void handle_options(deark *c, lctx *d)
{
	const char *fmt32;
	// Table of user-configurable color "descriptors" for 32-bit images.
	static const struct color32desc_type color32desc_arr[] = {
		{ { 0,  8, 16, 24 }, 0, "bgrx" },
		{ { 0,  8, 16, 24 }, 1, "bgra" },
		{ {16,  8,  0, 24 }, 0, "rgbx" },
		{ {16,  8,  0, 24 }, 1, "rgba" },
		{ {24,  0,  8, 16 }, 0, "xbgr" },
		{ {24,  0,  8, 16 }, 1, "abgr" },
		{ {24, 16,  8,  0 }, 0, "xrgb" },
		{ {24, 16,  8,  0 }, 1, "argb" }
	};

	fmt32 = de_get_ext_option(c, "sunras:fmt32");
	if(fmt32) {
		size_t k;
		for(k=0; k<DE_ARRAYCOUNT(color32desc_arr); k++) {
			if(!de_strcmp(fmt32, color32desc_arr[k].name)) {
				d->color32desc = color32desc_arr[k]; // struct copy
				d->user_set_fmt32 = 1;
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9f5f9(%rip), %rsi     # 0x1c70d4
callq 0x15cb30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x127b5f
movq $0x0, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x127b5d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq 0xf58b7(%rip), %rax     # 0x21d3c0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x191a0
cmpl $0x0, %eax
jne 0x127b4d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rdx
leaq 0xf5893(%rip), %rcx     # 0x21d3c0
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x22(%rax)
jmp 0x127b5d
jmp 0x127b4f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x127af3
jmp 0x127b5f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: do_read_palette
static void do_read_palette(deark *c, lctx *d, i64 pos)
{
	i64 num_entries;
	i64 num_entries_to_read;
	i64 k;
	u8 r, g, b;

	num_entries = d->maplen/3;
	num_entries_to_read = num_entries;
	if(num_entries_to_read>256) num_entries_to_read = 256;

	for(k=0; k<num_entries_to_read; k++) {
		r = de_getbyte(pos + k);
		g = de_getbyte(pos+num_entries + k);
		b = de_getbyte(pos+num_entries*2 + k);
		d->pal[k] = DE_MAKE_RGB(r, g, b);
		de_dbg_pal_entry(c, k, d->pal[k]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl $0x3, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x100, -0x28(%rbp)     # imm = 0x100
jle 0x127db4
movq $0x100, -0x28(%rbp)     # imm = 0x100
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x127e72
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x165060
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x165060
movb %al, -0x32(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
shlq %rax
addq %rax, %rsi
addq -0x30(%rbp), %rsi
callq 0x165060
movb %al, -0x33(%rbp)
movzbl -0x31(%rbp), %edx
shll $0x10, %edx
orl $0xff000000, %edx       # imm = 0xFF000000
movzbl -0x32(%rbp), %eax
shll $0x8, %eax
orl %eax, %edx
movzbl -0x33(%rbp), %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %edx, 0x64(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x64(%rax,%rcx,4), %edx
callq 0x15bf00
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x127dbc
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: do_decompress_image
static void do_decompress_image(deark *c, lctx *d, i64 pos1, i64 len, dbuf *unc_pixels)
{
	i64 pos = pos1;

	while(1) {
		u8 b0, b1, b2;

		// Stop if we reach the end of the input file.
		if(pos >= c->infile->len) break;

		b0 = de_getbyte(pos++);
		if(b0==0x80) {
			b1 = de_getbyte(pos++);
			if(b1==0x00) { // An escaped 0x80 byte
				dbuf_writebyte(unc_pixels, 0x80);
			}
			else { // A compressed run
				b2 = de_getbyte(pos++);
				dbuf_write_run(unc_pixels, b2, (i64)b1+1);
			}
		}
		else { // An uncompressed byte
			dbuf_writebyte(unc_pixels, b0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x127ebb
jmp 0x127f69
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x165060
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x80, %eax
jne 0x127f57
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x165060
movb %al, -0x32(%rbp)
movzbl -0x32(%rbp), %eax
cmpl $0x0, %eax
jne 0x127f1d
movq -0x28(%rbp), %rdi
movl $0x80, %esi
callq 0x168380
jmp 0x127f55
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x165060
movb %al, -0x33(%rbp)
movq -0x28(%rbp), %rdi
movb -0x33(%rbp), %al
movzbl -0x32(%rbp), %ecx
movl %ecx, %edx
addq $0x1, %rdx
movzbl %al, %esi
callq 0x168800
jmp 0x127f64
movq -0x28(%rbp), %rdi
movzbl -0x31(%rbp), %esi
callq 0x168380
jmp 0x127ea4
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: get_image_type_name
static const char *get_image_type_name(UI t)
{
	const char *name;

	switch(t) {
	case RT_OLD: name="old"; break;
	case RT_STANDARD: name="standard"; break;
	case RT_BYTE_ENCODED: name="RLE"; break;
	case RT_FORMAT_RGB: name="RGB"; break;
	case RT_FORMAT_TIFF: name="TIFF"; break;
	case RT_FORMAT_IFF: name="IFF"; break;
	case 0xffff: name="experimental"; break;
	default: name="?";
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x128291
jmp 0x128253
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x12829e
jmp 0x12825d
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x1282ab
jmp 0x128267
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x1282b8
jmp 0x128271
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0x1282c5
jmp 0x12827b
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x1282d2
jmp 0x128285
movl -0x14(%rbp), %eax
subl $0xffff, %eax           # imm = 0xFFFF
je 0x1282df
jmp 0x1282ec
leaq 0x9de34(%rip), %rax     # 0x1c60cc
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0x9878c(%rip), %rax     # 0x1c0a31
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0x88460(%rip), %rax     # 0x1b0712
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0xa3356(%rip), %rax     # 0x1cb615
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0xadf22(%rip), %rax     # 0x1d61ee
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0x8bdc3(%rip), %rax     # 0x1b409c
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0x9ee31(%rip), %rax     # 0x1c7117
movq %rax, -0x10(%rbp)
jmp 0x1282f7
leaq 0x8f93a(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: get_map_type_name
static const char *get_map_type_name(UI t)
{
	const char *name;

	switch(t) {
	case RMT_NONE: name="NONE"; break;
	case RMT_EQUAL_RGB: name="EQUAL_RGB"; break;
	case RMT_RAW: name="RAW"; break;
	default: name="?";
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x128327
jmp 0x128313
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x128334
jmp 0x12831d
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x128341
jmp 0x12834e
leaq 0x9edf6(%rip), %rax     # 0x1c7124
movq %rax, -0x10(%rbp)
jmp 0x128359
leaq 0x9edee(%rip), %rax     # 0x1c7129
movq %rax, -0x10(%rbp)
jmp 0x128359
leaq 0x87985(%rip), %rax     # 0x1afccd
movq %rax, -0x10(%rbp)
jmp 0x128359
leaq 0x8f8d8(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: decode_image_16
static void decode_image_16(deark *c, lctx *d, dbuf *unc_pixels, de_bitmap *img)
{
	i64 i, j;

	for(j=0; j<d->height; j++) {
		for(i=0; i<d->pdwidth; i++) {
			u32 x;
			de_color clr;

			// The 16-bit files I have all come from a Windows game named
			// Sub Culture, and this works for those files. But it's almost
			// certainly not standard.
			x = (u32)dbuf_getu16le(unc_pixels, d->rowspan*j+i*d->src_bypp);
			clr = de_rgb565_to_888(x);
			de_bitmap_setpixel_rgba(img, i, j, clr);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x128414
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x128401
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
imulq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x468(%rcx), %rax
addq %rax, %rsi
callq 0x165280
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x1618a0
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x38(%rbp), %ecx
callq 0x16b350
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12839a
jmp 0x128403
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x128380
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/sunras.c
// Function: decode_image_24_32
static void decode_image_24_32(deark *c, lctx *d, dbuf *unc_pixels, de_bitmap *img)
{
	de_color clr;
	i64 i, j;

	for(j=0; j<d->height; j++) {
		for(i=0; i<d->pdwidth; i++) {
			if(d->depth==24) {
				clr = dbuf_getRGB(unc_pixels, d->rowspan*j+i*d->src_bypp, d->getrgbflags);
				de_bitmap_setpixel_rgb(img, i, j, clr);
			}
			else if(d->depth==32) {
				u8 pixbuf[4];
				dbuf_read(unc_pixels, pixbuf, d->rowspan*j+i*d->src_bypp, 4);
				clr =
					((UI)pixbuf[0] << d->color32desc.channel_shift[0]) |
					((UI)pixbuf[1] << d->color32desc.channel_shift[1]) |
					((UI)pixbuf[2] << d->color32desc.channel_shift[2]) |
					((UI)pixbuf[3] << d->color32desc.channel_shift[3]);
				de_bitmap_setpixel_rgba(img, i, j, clr);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x128588
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x128575
movq -0x10(%rbp), %rax
cmpl $0x18, 0x18(%rax)
jne 0x1284c5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
imulq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x468(%rcx), %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x470(%rax), %edx
callq 0x165ff0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x16b310
jmp 0x128562
movq -0x10(%rbp), %rax
cmpl $0x20, 0x18(%rax)
jne 0x128560
movq -0x18(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdx
imulq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x468(%rcx), %rax
addq %rax, %rdx
movl $0x4, %ecx
callq 0x164d10
movzbl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x28(%rcx), %ecx
shll %cl, %eax
movzbl -0x3b(%rbp), %edx
movq -0x10(%rbp), %rcx
movzbl 0x29(%rcx), %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movzbl -0x3a(%rbp), %edx
movq -0x10(%rbp), %rcx
movzbl 0x2a(%rcx), %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movzbl -0x39(%rbp), %edx
movq -0x10(%rbp), %rcx
movzbl 0x2b(%rcx), %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x16b350
jmp 0x128562
jmp 0x128564
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x12845a
jmp 0x128577
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x128440
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/t64.c
// Function: de_module_t64
void de_module_t64(deark *c, struct deark_module_info *mi)
{
	mi->id = "t64";
	mi->desc = "T64 (C64 tape format)";
	mi->run_fn = de_run_t64;
	mi->identify_fn = de_identify_t64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x78d5d(%rip), %rcx     # 0x1a1304
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x9ec7e(%rip), %rcx     # 0x1c7233
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x1285e0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x16d(%rip), %rcx       # 0x128740
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/t64.c
// Function: de_run_t64
static void de_run_t64(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;
	i64 i;

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

	pos = 32;
	d->version = de_getu16le(pos);
	de_dbg(c, "version: 0x%04x", (int)d->version);
	if(d->version!=0x100 && d->version!=0x101) {
		de_warn(c, "Unexpected version number. This might not be a T64 file.");
	}

	d->max_dir_entries = de_getu16le(pos+2);
	d->used_dir_entries = de_getu16le(pos+4);
	de_dbg(c, "max dir entries = %d, files = %d", (int)d->max_dir_entries, (int)d->used_dir_entries);

	pos += 32;
	for(i=0; i<d->max_dir_entries; i++) {
		do_dir_entry(c, d, i, pos+32*i);
	}

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq $0x20, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0x98802(%rip), %rsi     # 0x1c0e43
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
cmpq $0x100, (%rax)          # imm = 0x100
je 0x128674
movq -0x18(%rbp), %rax
cmpq $0x101, (%rax)          # imm = 0x101
je 0x128674
movq -0x8(%rbp), %rdi
leaq 0x9ebdc(%rip), %rsi     # 0x1c7249
movb $0x0, %al
callq 0x15bc10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x2, %rsi
callq 0x165280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0x165280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
leaq 0x9ebaf(%rip), %rsi     # 0x1c7282
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x12872a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
callq 0x128790
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1286ee
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/t64.c
// Function: do_dir_entry
static void do_dir_entry(deark *c, lctx *d, i64 entry_num, i64 pos)
{
	u8 filetype_c64s;
	u8 filetype;

	filetype_c64s = de_getbyte(pos);
	if(filetype_c64s==0) {
		de_dbg2(c, "unused entry #%d at %d", (int)entry_num, (int)pos);
		return;
	}
	de_dbg(c, "entry #%d at %d", (int)entry_num, (int)pos);

	de_dbg_indent(c, 1);

	filetype = de_getbyte(pos+1);
	de_dbg(c, "c64s filetype=%d, filetype=0x%02x", (int)filetype_c64s, (int)filetype);

	if(filetype==0x00) {
		de_err(c, "Unsupported file type (0x%02x)", (int)filetype);
	}
	else {
		do_extract_file(c, d, pos, filetype_c64s, filetype);
	}

	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165060
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x1287e8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq 0x9eac7(%rip), %rsi     # 0x1c72a3
movb $0x0, %al
callq 0x15b350
jmp 0x128891
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq 0x9eaab(%rip), %rsi     # 0x1c72aa
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x165060
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x21(%rbp), %edx
movzbl -0x22(%rbp), %ecx
leaq 0x9ea7b(%rip), %rsi     # 0x1c72ba
movb $0x0, %al
callq 0x15b0d0
movzbl -0x22(%rbp), %eax
cmpl $0x0, %eax
jne 0x128867
movq -0x8(%rbp), %rdi
movzbl -0x22(%rbp), %edx
leaq 0x9ea7e(%rip), %rsi     # 0x1c72dc
movb $0x0, %al
callq 0x15bfb0
jmp 0x128883
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
movzbl %al, %ecx
movzbl -0x22(%rbp), %r8d
callq 0x1288a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/tar.c
// Function: de_module_tar
void de_module_tar(deark *c, struct deark_module_info *mi)
{
	mi->id = "tar";
	mi->desc = "tar archive";
	mi->run_fn = de_run_tar;
	mi->identify_fn = de_identify_tar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xac15a(%rip), %rcx     # 0x1d4c61
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x9e83a(%rip), %rcx     # 0x1c734f
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x128b40
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x14d(%rip), %rcx       # 0x128c80
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/tar.c
// Function: de_run_tar
static void de_run_tar(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;
	i64 item_len;
	int ret;

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

	d->global_ea = de_malloc(c, sizeof(struct extattr_data));

	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_UTF8);

	pos = 0;
	while(1) {
		if(d->found_trailer) break;
		if(pos >= c->infile->len) break;
		if(pos+512 > c->infile->len) {
			de_warn(c, "Ignoring %d extra bytes at end of file", (int)(c->infile->len - pos));
			break;
		}

		ret = read_member(c, d, pos, &item_len);
		if(!ret || item_len<1) break;
		pos += item_len;
	}

	if(d) {
		de_crcobj_destroy(d->crco_cksum);
		destroy_extattr_data(c, d->global_ea);
		de_free(c, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x128bb4
jmp 0x128c3e
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x128bc8
jmp 0x128c3e
movq -0x20(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x128c06
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
subq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x9e75e(%rip), %rsi     # 0x1c735b
movb $0x0, %al
callq 0x15bc10
jmp 0x128c3e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x128e10
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x128c2b
cmpq $0x1, -0x28(%rbp)
jge 0x128c2d
jmp 0x128c3e
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x128ba5
cmpq $0x0, -0x18(%rbp)
je 0x128c70
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15f2e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x129580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/tar.c
// Function: de_identify_tar
static int de_identify_tar(deark *c)
{
	int has_ext;
	u8 buf[8];
	i64 k;
	i64 digit_count;

	has_ext = de_input_file_has_ext(c, "tar");;
	if(!dbuf_memcmp(c->infile, 257, "ustar", 5)) {
		return has_ext ? 100 : 90;
	}

	if(has_ext) {
		if(!dbuf_memcmp(c->infile, 508, "tar\0", 4)) {
			return 90;
		}
	}

	// Try to detect tar formats that don't have the "ustar" identifier.
	if(!has_ext) return 0;

	// The 'checksum' field has a fairly distinctive format.
	// "This field should be stored as six octal digits followed by a null and
	// a space character."

	de_read(buf, 148, 8);
	digit_count = 0;
	for(k=0; k<6; k++) {
		if(buf[k]>='0' && buf[k]<='7') {
			digit_count++;
		}
		else if(buf[k]!=' ') {
			return 0;
		}
	}
	if(digit_count<1) return 0;
	if(buf[6]==0x00 && buf[7]==' ') return 60;
	if(buf[6]==' ' && buf[7]==0x00) return 15;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xabfca(%rip), %rsi     # 0x1d4c61
callq 0x15d180
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x101, %esi            # imm = 0x101
leaq 0x9e9af(%rip), %rdx     # 0x1c7662
movl $0x5, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x128cdd
movl -0x14(%rbp), %edx
movl $0x5a, %eax
movl $0x64, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x128df8
cmpl $0x0, -0x14(%rbp)
je 0x128d14
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1fc, %esi            # imm = 0x1FC
leaq 0x9e981(%rip), %rdx     # 0x1c7678
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0x128d12
movl $0x5a, -0x4(%rbp)
jmp 0x128df8
jmp 0x128d14
cmpl $0x0, -0x14(%rbp)
jne 0x128d26
movl $0x0, -0x4(%rbp)
jmp 0x128df8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x94, %edx
movl $0x8, %ecx
callq 0x164d10
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x6, -0x28(%rbp)
jge 0x128dab
movq -0x28(%rbp), %rax
movzbl -0x1c(%rbp,%rax), %eax
cmpl $0x30, %eax
jl 0x128d82
movq -0x28(%rbp), %rax
movzbl -0x1c(%rbp,%rax), %eax
cmpl $0x37, %eax
jg 0x128d82
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x128d9b
movq -0x28(%rbp), %rax
movzbl -0x1c(%rbp,%rax), %eax
cmpl $0x20, %eax
je 0x128d99
movl $0x0, -0x4(%rbp)
jmp 0x128df8
jmp 0x128d9b
jmp 0x128d9d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x128d51
cmpq $0x1, -0x30(%rbp)
jge 0x128dbb
movl $0x0, -0x4(%rbp)
jmp 0x128df8
movzbl -0x16(%rbp), %eax
cmpl $0x0, %eax
jne 0x128dd6
movzbl -0x15(%rbp), %eax
cmpl $0x20, %eax
jne 0x128dd6
movl $0x3c, -0x4(%rbp)
jmp 0x128df8
movzbl -0x16(%rbp), %eax
cmpl $0x20, %eax
jne 0x128df1
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x128df1
movl $0xf, -0x4(%rbp)
jmp 0x128df8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/tar.c
// Function: destroy_pmd
static void destroy_pmd(deark *c, struct phys_member_data *pmd)
{
	if(!pmd) return;
	ucstring_destroy(pmd->name);
	de_destroy_stringreaderdata(c, pmd->linkname);
	ucstring_destroy(pmd->prefix);
	de_free(c, pmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1295d9
jmp 0x129611
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x166830
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)