LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_identify_bmp
static int de_identify_bmp(deark *c)
{
	i64 fsize;
	i64 bits_offset;
	i64 infohdrsize;
	u32 compression_field = 0;
	int bmp_ext;
	u8 buf[6];

	de_read(buf, 0, sizeof(buf));
	if(de_memcmp(buf, "BM", 2)) {
		return 0;
	}

	bmp_ext = de_input_file_has_ext(c, "bmp");
	fsize = de_getu32le_direct(&buf[2]);
	bits_offset = de_getu32le(10);
	infohdrsize = de_getu32le(14);
	if(infohdrsize>=20) {
		compression_field = (u32)de_getu32le(14+16);
		// Don't detect KQP format as BMP
		if(infohdrsize==68 && compression_field==0x4745504aU) return 0;
	}

	if(infohdrsize<12) return 0;
	if(infohdrsize>256) return 0;
	if(bits_offset>=c->infile->len) return 0;
	if(bits_offset<14+infohdrsize) return 0;
	if(fsize==c->infile->len && bmp_ext) return 100;
	if(buf[2]==0xcb) {
		// Possible VBM file.
		// Windows BMP files are highly unlikely to start with 'B' 'M' \xcb,
		// because that would imply the file is an odd number of bytes in size,
		// which is legal but silly.
		if(bmp_ext) return 90;
		return 5;
	}

	if(bmp_ext) return 100;
	if(infohdrsize==12 || infohdrsize==40 || infohdrsize==108 ||
		infohdrsize==124)
	{
		return 100;
	}
	return 90;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0x2(%rsp), %r15
movl $0x6, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
cmpw $0x4d42, (%r15)         # imm = 0x4D42
je 0x341e1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xecf7a(%rip), %rsi     # 0x121162
movq %r14, %rdi
callq 0xea491
movl %eax, %ebp
leaq 0x4(%rsp), %rdi
callq 0xeed5e
movq %rax, %r12
movq 0x18(%r14), %rdi
movl $0xa, %esi
callq 0xeed61
movq %rax, %r13
movq 0x18(%r14), %rdi
movl $0xe, %esi
callq 0xeed61
movq %rax, %r15
cmpq $0x14, %rax
jl 0x34260
movq 0x18(%r14), %rdi
movl $0x1e, %esi
callq 0xeed61
movq %r15, %rcx
xorq $0x44, %rcx
movl %eax, %eax
xorq $0x4745504a, %rax       # imm = 0x4745504A
orq %rcx, %rax
sete %al
cmpq $0x100, %r15            # imm = 0x100
ja 0x341d0
testb %al, %al
je 0x3426a
jmp 0x341d0
cmpq $0xc, %r15
jl 0x341d0
movq 0x18(%r14), %rax
movq 0x18(%rax), %rax
cmpq %rax, %r13
setge %cl
leaq 0xe(%r15), %rdx
cmpq %rdx, %r13
setl %dl
orb %cl, %dl
jne 0x341d0
cmpq %rax, %r12
sete %al
testl %ebp, %ebp
setne %cl
movl $0x64, %ebx
testb %cl, %al
jne 0x341d0
cmpb $-0x35, 0x4(%rsp)
jne 0x342bd
testl %ebp, %ebp
movl $0x5a, %eax
movl $0x5, %ebx
cmovnel %eax, %ebx
jmp 0x341d0
testl %ebp, %ebp
jne 0x341d0
movabsq $0x7fffffffffffffef, %rax # imm = 0x7FFFFFFFFFFFFFEF
andq %r15, %rax
cmpq $0x6c, %rax
je 0x341d0
cmpq $0xc, %r15
movl $0x64, %eax
movl $0x5a, %ebx
cmovel %eax, %ebx
cmpq $0x28, %r15
cmovel %eax, %ebx
jmp 0x341d0
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_module_picjpeg
void de_module_picjpeg(deark *c, struct deark_module_info *mi)
{
	mi->id = "picjpeg";
	mi->desc = "Pegasus JPEG, and KQP";
	mi->run_fn = de_run_picjpeg;
	mi->identify_fn = de_identify_picjpeg;
	mi->id_alias[0] = "kqp";
}

// Assembly:
leaq 0xe366d(%rip), %rax     # 0x11796d
movq %rax, (%rsi)
leaq 0xe366b(%rip), %rax     # 0x117975
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x34330
movq %rax, 0x18(%rsi)
leaq 0x8f5(%rip), %rax       # 0x34c15
movq %rax, 0x20(%rsi)
leaq 0xe3660(%rip), %rax     # 0x11798b
movq %rax, 0x38(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_identify_picjpeg
static int de_identify_picjpeg(deark *c)
{
	if(dbuf_memcmp(c->infile, 0, (const void*)"BM", 2)) return 0;
	if(de_getu32le(14) != 68) return 0;
	if((UI)de_getu32le(30) != 0x4745504aU) return 0;
	return 100;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xe74e7(%rip), %rdx     # 0x11c10e
xorl %ebx, %ebx
movl $0x2, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x34c6a
movq 0x18(%r14), %rdi
movl $0xe, %esi
callq 0xeed61
cmpq $0x44, %rax
jne 0x34c6a
movq 0x18(%r14), %rdi
movl $0x1e, %esi
callq 0xeed61
xorl %ecx, %ecx
cmpl $0x4745504a, %eax       # imm = 0x4745504A
movl $0x64, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_module_dib
void de_module_dib(deark *c, struct deark_module_info *mi)
{
	mi->id = "dib";
	mi->desc = "DIB (raw Windows bitmap)";
	mi->run_fn = de_run_dib;
	mi->identify_fn = de_identify_dib;
}

// Assembly:
leaq 0xee794(%rip), %rax     # 0x12340f
movq %rax, (%rsi)
leaq 0xe2d0a(%rip), %rax     # 0x11798f
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x34ca0
movq %rax, 0x18(%rsi)
leaq 0x135(%rip), %rax       # 0x34dd0
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_run_dib
static void de_run_dib(deark *c, de_module_params *mparams)
{
	struct de_bmpinfo bi;
	UI createflags = 0;
	dbuf *outf = NULL;
	int implicit_size = 0;
	i64 dib_len;
	const char *ext = "bmp";
	de_finfo *fi_to_use = NULL;

	if(mparams) {
		// If flags&0x01, try to calculate the proper file size, instead of trusting
		// the length of the input file.
		if(mparams->in_params.flags & 0x01) implicit_size = 1;

		if(mparams->in_params.flags & 0x80) ext = "preview.bmp";

		fi_to_use = mparams->in_params.fi;
	}

	if(de_havemodcode(c, mparams, 'X')) {
		createflags |= DE_CREATEFLAG_IS_AUX;
	}

	if(!fmtutil_get_bmpinfo(c, c->infile, &bi, 0, c->infile->len, 0)) {
		de_err(c, "Invalid DIB, or not a DIB file");
		goto done;
	}

	if(implicit_size) {
		dib_len = bi.total_size;
		if(dib_len > c->infile->len) {
			dib_len = c->infile->len;
		}
	}
	else {
		dib_len = c->infile->len;
	}

	outf = dbuf_create_output_file(c, ext, fi_to_use, createflags);

	de_dbg(c, "writing a BMP FILEHEADER");
	fmtutil_generate_bmpfileheader(c, outf, &bi, 14+dib_len);

	de_dbg(c, "copying DIB file");
	dbuf_copy(c->infile, 0, dib_len, outf);

done:
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x34cdc
movl 0x8(%rsi), %eax
testb $0x1, %al
sete %r12b
testb %al, %al
leaq 0xec497(%rip), %rax     # 0x121162
leaq 0xe3181(%rip), %r14     # 0x117e53
cmovnsq %rax, %r14
movq 0x28(%rsi), %r15
jmp 0x34ce9
leaq 0xec47f(%rip), %r14     # 0x121162
movb $0x1, %r12b
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x58, %edx
callq 0xea4d9
xorl %ebp, %ebp
testl %eax, %eax
setne %r13b
movq 0x18(%rbx), %rsi
movq 0x18(%rsi), %r8
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0xf7425
testl %eax, %eax
je 0x34d2e
movb %r13b, %bpl
testb %r12b, %r12b
je 0x34d44
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r12
jmp 0x34d5b
leaq 0xe312a(%rip), %rsi     # 0x117e5f
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
jmp 0x34db6
movq 0x98(%rsp), %rax
movq 0x18(%rbx), %rcx
movq 0x18(%rcx), %r12
cmpq %r12, %rax
cmovlq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xefda1
movq %rax, %r14
leaq 0xe3109(%rip), %rsi     # 0x117e7e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
leaq 0xe(%r12), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf78fa
leaq 0xe30fc(%rip), %rsi     # 0x117e97
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0xef481
movq %r14, %rdi
callq 0xf052b
addq $0xa8, %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/bmp.c
// Function: de_identify_dib
static int de_identify_dib(deark *c)
{
	i64 n;

	n = de_getu32le(0); // biSize
	if(n!=40) return 0;
	n = de_getu16le(12); // biPlanes
	if(n!=1) return 0;
	n = de_getu16le(14); // biBitCount
	if(n==1 || n==4 || n==8 || n==16 || n==24 || n==32) return 15;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeed61
cmpq $0x28, %rax
jne 0x34e27
movq 0x18(%r14), %rdi
movl $0xc, %esi
callq 0xeebc8
cmpq $0x1, %rax
jne 0x34e27
movq 0x18(%r14), %rdi
movl $0xe, %esi
callq 0xeebc8
cmpq $0x20, %rax
ja 0x34e31
movl $0xf, %ebx
movabsq $0x101010112, %rcx      # imm = 0x101010112
btq %rax, %rcx
jae 0x34e31
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
jmp 0x34e27
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_module_ddb
void de_module_ddb(deark *c, struct deark_module_info *mi)
{
	mi->id = "ddb";
	mi->desc = "Windows DDB bitmap";
	mi->run_fn = de_run_ddb;
	mi->identify_fn = NULL;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
leaq 0xee591(%rip), %rax     # 0x1233cd
movq %rax, (%rsi)
leaq 0xe2b62(%rip), %rax     # 0x1179a8
movq %rax, 0x8(%rsi)
leaq 0x11(%rip), %rax        # 0x34e62
movq %rax, 0x18(%rsi)
movq $0x0, 0x20(%rsi)
orb $0x1, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_module_winzle
void de_module_winzle(deark *c, struct deark_module_info *mi)
{
	mi->id = "winzle";
	mi->desc = "Winzle! puzzle image";
	mi->run_fn = de_run_winzle;
	mi->identify_fn = de_identify_winzle;
}

// Assembly:
leaq 0xe2612(%rip), %rax     # 0x1179bb
movq %rax, (%rsi)
leaq 0xe260f(%rip), %rax     # 0x1179c2
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x353ce
movq %rax, 0x18(%rsi)
leaq 0xa7(%rip), %rax        # 0x35470
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_run_winzle
static void de_run_winzle(deark *c, de_module_params *mparams)
{
	u8 buf[256];
	i64 xorsize;
	i64 i;
	dbuf *f = NULL;

	xorsize = c->infile->len >= 256 ? 256 : c->infile->len;
	de_read(buf, 0, xorsize);
	for(i=0; i<xorsize; i++) {
		buf[i] ^= 0x0d;
	}

	f = dbuf_create_output_file(c, "bmp", NULL, 0);
	dbuf_write(f, buf, xorsize);
	if(c->infile->len > 256) {
		dbuf_copy(c->infile, 256, c->infile->len - 256, f);
	}
	dbuf_close(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %r15
movl $0x100, %r14d           # imm = 0x100
cmpq %r14, %r15
cmovlq %r15, %r14
movq %rsp, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xee8d4
testq %r15, %r15
jle 0x35412
xorl %eax, %eax
xorb $0xd, (%rsp,%rax)
incq %rax
cmpq %rax, %r14
jne 0x35406
leaq 0xebd49(%rip), %rsi     # 0x121162
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r15
movq %rsp, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0xef547
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
cmpq $0x101, %rdx            # imm = 0x101
jl 0x3545b
addq $-0x100, %rdx
movl $0x100, %esi            # imm = 0x100
movq %r15, %rcx
callq 0xef481
movq %r15, %rdi
callq 0xf052b
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_module_jigsaw_wk
void de_module_jigsaw_wk(deark *c, struct deark_module_info *mi)
{
	mi->id = "jigsaw_wk";
	mi->desc = "Jigsaw .jig";
	mi->run_fn = de_run_jigsaw_wk;
	mi->identify_fn = de_identify_jigsaw_wk;
}

// Assembly:
leaq 0xe2513(%rip), %rax     # 0x1179d7
movq %rax, (%rsi)
leaq 0xe2513(%rip), %rax     # 0x1179e1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x354e9
movq %rax, 0x18(%rsi)
leaq 0x7c(%rip), %rax        # 0x35560
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_run_jigsaw_wk
static void de_run_jigsaw_wk(deark *c, de_module_params *mparams)
{
	i64 fsize;
	dbuf *outf = NULL;

	fsize = de_getu32le(2);
	if(fsize>c->infile->len) goto done;

	outf = dbuf_create_output_file(c, "bmp", NULL, 0);
	dbuf_write(outf, (const u8*)"BM", 2);
	dbuf_copy(c->infile, 2, fsize-2, outf);

done:
	dbuf_close(outf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x2, %esi
callq 0xeed61
movq %rax, %r14
movq 0x18(%rbx), %rax
cmpq 0x18(%rax), %r14
jle 0x35511
xorl %r15d, %r15d
jmp 0x35553
leaq 0xebc4a(%rip), %rsi     # 0x121162
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r15
leaq 0xe6be0(%rip), %rsi     # 0x11c10e
movl $0x2, %edx
movq %rax, %rdi
callq 0xef547
movq 0x18(%rbx), %rdi
addq $-0x2, %r14
movl $0x2, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0xef481
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf052b
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: de_identify_jigsaw_wk
static int de_identify_jigsaw_wk(deark *c)
{
	i64 fsize;
	int ret;
	u8 buf[32];

	if(dbuf_memcmp(c->infile, 0, "JG", 2)) {
		return 0;
	}

	fsize = de_getu32le(2);
	if(fsize>c->infile->len) return 0;

	de_read(buf, 0, sizeof(buf));
	buf[0] = 'B';
	buf[1] = 'M';
	ret = looks_like_bmp_bytes(buf, sizeof(buf), 0);
	if(ret) {
		return 95;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xe29cf(%rip), %rdx     # 0x117f44
xorl %ebx, %ebx
movl $0x2, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x355dc
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xeed61
movq 0x18(%r14), %rdi
cmpq 0x18(%rdi), %rax
jg 0x355dc
movq %rsp, %rbx
movl $0x20, %ecx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xee8d4
movw $0x4d42, (%rbx)         # imm = 0x4D42
leaq 0xe2357(%rip), %rsi     # 0x117914
movl $0x1e, %edx
movq %rbx, %rdi
movl $0x3f, %ecx
xorl %r8d, %r8d
callq 0xeba3e
testl %eax, %eax
movl $0x5f, %ebx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: do_read_bitfields
static void do_read_bitfields(deark *c, lctx *d, i64 pos, i64 len)
{
	i64 k;

	if(len>16) len=16;
	for(k=0; 4*k<len; k++) {
		d->bitfield[k].mask = (u32)de_getu32le(pos+4*k);
		de_dbg(c, "mask[%d]: 0x%08x", (int)k, (UI)d->bitfield[k].mask);
	}
	update_bitfields_info(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rcx, %rcx
jle 0x3566a
movq %rdx, %r14
movq %rdi, %r15
cmpq $0x10, %rcx
movl $0x10, %eax
cmovbq %rcx, %rax
movq (%rsp), %rcx
leaq 0x100(%rcx), %rbp
cmpq $0x5, %rax
movl $0x4, %ebx
cmovaeq %rax, %rbx
decq %rbx
shrq $0x2, %rbx
incq %rbx
leaq 0xe2607(%rip), %r12     # 0x117c3d
xorl %r13d, %r13d
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xeed61
movl %eax, (%rbp)
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xe8617
incq %r13
addq $0x4, %r14
addq $0x10, %rbp
cmpq %r13, %rbx
jne 0x35639
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3567e
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: update_bitfields_info
static void update_bitfields_info(deark *c, lctx *d)
{
	i64 k;
	u32 tmpmask;

	for(k=0; k<4; k++) {
		tmpmask = d->bitfield[k].mask;
		if(tmpmask==0) continue;
		while((tmpmask & 0x1) == 0) {
			d->bitfield[k].shift++;
			tmpmask >>= 1;
		}
		d->bitfield[k].scale = 255.0 / (double)tmpmask;
	}
}

// Assembly:
addq $0x100, %rdi            # imm = 0x100
xorl %eax, %eax
movsd 0xe21a9(%rip), %xmm0    # 0x117838
movq %rax, %rcx
shlq $0x4, %rcx
movl (%rdi,%rcx), %edx
testl %edx, %edx
je 0x356cf
addq %rdi, %rcx
testb $0x1, %dl
jne 0x356b8
movl 0x4(%rcx), %esi
movl %edx, %r8d
incl %esi
shrl %edx
testb $0x2, %r8b
je 0x356a8
movl %esi, 0x4(%rcx)
movl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rcx)
incq %rax
cmpq $0x4, %rax
jne 0x3568f
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: do_image_paletted
static void do_image_paletted(deark *c, lctx *d, dbuf *bits, i64 bits_offset, u8 want_trns)
{
	int bypp;

	if(d->pal_is_grayscale) bypp = 1;
	else bypp = 3;
	if(want_trns) bypp++;

	d->img = bmp_bitmap_create(c, d, bypp);
	de_convert_image_paletted(bits, bits_offset,
		d->bitcount, d->rowspan, d->pal, d->img, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
xorl %eax, %eax
cmpl $0x0, 0x88(%rsi)
sete %al
xorl %ecx, %ecx
testl %r8d, %r8d
setne %cl
leal (%rcx,%rax,2), %r8d
incl %r8d
movq 0x50(%rsi), %rsi
movq 0x58(%rbx), %rdx
movq 0x60(%rbx), %rcx
callq 0xf26a5
movq %rax, 0x10(%rbx)
movq 0x38(%rbx), %rdx
movq 0xf8(%rbx), %rcx
addq $0x140, %rbx            # imm = 0x140
movl $0x0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
movq %rax, %r9
callq 0xf2f79
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: do_image_24bit
static void do_image_24bit(deark *c, lctx *d, dbuf *bits, i64 bits_offset, u8 want_trns)
{
	i64 i, j;
	u32 clr;
	int bypp;

	if(want_trns) bypp = 4;
	else bypp = 3;

	d->img = bmp_bitmap_create(c, d, bypp);
	for(j=0; j<d->height; j++) {
		i64 rowpos = bits_offset + j*d->rowspan;
		i64 pos_in_this_row = 0;
		u8 cbuf[3];

		for(i=0; i<d->pdwidth; i++) {
			dbuf_read(bits, cbuf, rowpos + pos_in_this_row, 3);
			if(pos_in_this_row+3 > d->rowspan) {
				// If -padpix was used, a partial pixel at the end of the row is
				// possible. Happens when width == 1 or 2 (mod 4).
				// To handle that, zero out the byte(s) that we shouldn't have read.
				cbuf[2] = 0;
				if(pos_in_this_row+2 > d->rowspan) {
					cbuf[1] = 0;
				}
			}
			clr = DE_MAKE_RGB(cbuf[2], cbuf[1], cbuf[0]);
			de_bitmap_setpixel_rgb(d->img, i, j, clr);
			pos_in_this_row += 3;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq 0x50(%rsi), %rsi
movq 0x58(%r15), %rdx
movq 0x60(%r15), %rcx
cmpl $0x1, %r8d
movl $0x4, %r8d
sbbl $0x0, %r8d
callq 0xf26a5
movq %rax, 0x10(%r15)
movq 0x60(%r15), %rcx
testq %rcx, %rcx
jle 0x3583c
movq 0x58(%r15), %rax
xorl %r12d, %r12d
testq %rax, %rax
jle 0x35830
movq 0xf8(%r15), %rbp
imulq %r12, %rbp
addq 0x10(%rsp), %rbp
movl $0x3, %r13d
xorl %ebx, %ebx
movl $0x3, %ecx
movq %r14, %rdi
leaq 0xd(%rsp), %rsi
movq %rbp, %rdx
callq 0xee8d4
movq 0xf8(%r15), %rax
cmpq %rax, %r13
jle 0x357f4
movb $0x0, 0xf(%rsp)
leaq -0x1(%r13), %rcx
cmpq %rax, %rcx
jle 0x357f4
movb $0x0, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
shll $0x8, %eax
movzbl 0xd(%rsp), %ecx
orl %eax, %ecx
orl $0xff000000, %ecx       # imm = 0xFF000000
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xf24ba
incq %rbx
movq 0x58(%r15), %rax
addq $0x3, %rbp
addq $0x3, %r13
cmpq %rax, %rbx
jl 0x357c0
movq 0x60(%r15), %rcx
incq %r12
cmpq %rcx, %r12
jl 0x3579f
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/bmp.c
// Function: do_image_huffman1d
static void do_image_huffman1d(deark *c, lctx *d)
{
	dbuf *unc_pixels = NULL;
	struct de_dfilter_in_params dcmpri;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	struct de_fax34_params fax34params;

	// Caution: These settings might be wrong. I need more information about this format.
	de_zeromem(&fax34params, sizeof(struct de_fax34_params));
	fax34params.image_width = d->width;
	fax34params.image_height = d->height;
	fax34params.out_rowspan = d->rowspan;
	fax34params.tiff_cmpr_meth = 3;
	fax34params.t4options = 0;
	fax34params.is_lsb = (u8)de_get_ext_option_bool(c, "bmp:huffmanlsb", 0);

	unc_pixels = dbuf_create_membuf(c, d->rowspan*d->height, 0x1);

	de_dfilter_init_objects(c, &dcmpri, &dcmpro, &dres);
	dcmpri.f = c->infile;
	dcmpri.pos = d->bits_offset;
	dcmpri.len = get_bits_size(c, d);
	dcmpro.f = unc_pixels;
	dcmpro.len_known = 1;
	dcmpro.expected_len = d->rowspan*d->height;

	fmtutil_fax34_codectype1(c, &dcmpri, &dcmpro, &dres,
		 (void*)&fax34params);

	do_image_paletted(c, d, unc_pixels, 0, 0);

	dbuf_close(unc_pixels);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movq 0x50(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0xf8(%rsi), %rax
movq %rax, 0x18(%rsp)
movl $0x3, 0x20(%rsp)
leaq 0xe24e1(%rip), %rsi     # 0x117d75
xorl %edx, %edx
callq 0xe9bd0
movb %al, 0x24(%rsp)
movq 0x60(%rbx), %rsi
imulq 0xf8(%rbx), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xf09c5
movq %rax, %r15
leaq 0x48(%rsp), %r12
leaq 0x30(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0xfa1dc
movq 0x18(%r14), %rdx
movq %rdx, (%r12)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%r12)
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
jle 0x358fe
leaq (%rcx,%rax), %rsi
movq 0x18(%rdx), %rdx
cmpq %rdx, %rsi
jg 0x35902
jmp 0x35908
movq 0x18(%rdx), %rdx
subq %rax, %rdx
movq %rdx, %rcx
leaq 0x48(%rsp), %rsi
movq %rcx, 0x10(%rsi)
leaq 0x30(%rsp), %rdx
movq %r15, (%rdx)
movb $0x1, 0x8(%rdx)
movq 0x60(%rbx), %rax
imulq 0xf8(%rbx), %rax
movq %rax, 0x10(%rdx)
leaq 0x68(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rdi
callq 0xfe128
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x356d9
movq %r15, %rdi
callq 0xf052b
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: extract_embedded_image
static void extract_embedded_image(deark *c, lctx *d, const char *ext)
{
	i64 nbytes;

	if(d->want_returned_img) return;

	nbytes = get_bits_size(c, d);
	if(nbytes<1) return;

	dbuf_create_file_from_slice(c->infile, d->bits_offset, nbytes, ext, NULL, 0);
}

// Assembly:
cmpb $0x0, 0x4(%rsi)
je 0x35970
retq
movq %rdx, %rcx
movq 0x48(%rsi), %rdx
testq %rdx, %rdx
jle 0x35993
movq 0x28(%rsi), %rsi
leaq (%rsi,%rdx), %r8
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rax
cmpq %rax, %r8
jg 0x3599f
jmp 0x359a7
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rax
movq 0x28(%rsi), %rsi
subq %rsi, %rax
movq %rax, %rdx
jle 0x3596f
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0xefd48
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: rle_to_bytes_append_unit4
static void rle_to_bytes_append_unit4(deark *c, struct rle_dcmpr_ctx *rc, u8 n, u8 mflag)
{
	if(rc->num_pending_bits) { // presumably = 4
		rc->pending_bits |= n;
		rc->num_pending_bits += 4;
		rle_to_bytes_flush(c, rc);
	}
	else { // presumably num_pending_bits = 0
		rc->pending_bits = n<<4;
		rc->num_pending_bits += 4;
	}

	if(mflag && rc->mask) {
		de_bitmap_setpixel_gray(rc->mask, rc->xpos, rc->ypos, 0xff);
	}
	rc->xpos++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl 0x60(%rdi), %eax
testl %eax, %eax
je 0x35a29
orb 0x64(%rbx), %sil
movb %sil, 0x64(%rbx)
addl $0x4, %eax
movl %eax, 0x60(%rbx)
je 0x35a21
movq 0x40(%rbx), %rdi
movzbl %sil, %esi
callq 0xf0bd6
movb $0x0, 0x64(%rbx)
xorl %eax, %eax
jmp 0x35a36
shlb $0x4, %sil
movb %sil, 0x64(%rbx)
movl $0x4, %eax
movl %eax, 0x60(%rbx)
testb %bpl, %bpl
je 0x35a59
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x35a59
movq 0x50(%rbx), %rsi
movq 0x58(%rbx), %rdx
movl $0xff, %ecx
callq 0xf2405
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: rle_to_bytes_append_unit24
static void rle_to_bytes_append_unit24(deark *c, struct rle_dcmpr_ctx *rc,
	u8 cr, u8 cg, u8 cb, u8 mflag)
{
	dbuf_writebyte(rc->unc_pixels, cb);
	dbuf_writebyte(rc->unc_pixels, cg);
	dbuf_writebyte(rc->unc_pixels, cr);
	if(mflag && rc->mask) {
		de_bitmap_setpixel_gray(rc->mask, rc->xpos, rc->ypos, 0xff);
	}
	rc->xpos++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movl %ecx, %esi
callq 0xf0bd6
movq 0x40(%rbx), %rdi
movl %r14d, %esi
callq 0xf0bd6
movq 0x40(%rbx), %rdi
movl %r15d, %esi
callq 0xf0bd6
testl %ebp, %ebp
je 0x35ab9
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x35ab9
movq 0x50(%rbx), %rsi
movq 0x58(%rbx), %rdx
movl $0xff, %ecx
callq 0xf2405
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: rle_to_bytes_append_unit8
static void rle_to_bytes_append_unit8(deark *c, struct rle_dcmpr_ctx *rc, u8 n, u8 mflag)
{
	dbuf_writebyte(rc->unc_pixels, n);
	if(mflag && rc->mask) {
		de_bitmap_setpixel_gray(rc->mask, rc->xpos, rc->ypos, 0xff);
	}
	rc->xpos++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0xf0bd6
testl %ebp, %ebp
je 0x35af8
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x35af8
movq 0x50(%rbx), %rsi
movq 0x58(%rbx), %rdx
movl $0xff, %ecx
callq 0xf2405
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: do_read_linked_profile
static void do_read_linked_profile(deark *c, lctx *d)
{
	de_ucstring *fname = NULL;

	de_dbg(c, "linked profile filename at %"I64_FMT, d->profile_offset);
	fname = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, d->profile_offset,
		d->profile_size, DE_DBG_MAX_STRLEN, fname,
		DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_WINDOWS1252);
	de_dbg_indent(c, 1);
	de_dbg(c, "profile filename: \"%s\"", ucstring_getpsz(fname));
	de_dbg_indent(c, -1);
	ucstring_destroy(fname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0xe8(%rsi), %rdx
leaq 0xe2264(%rip), %rsi     # 0x117d84
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
callq 0xf6410
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq 0xe8(%r15), %rsi
movq 0xf0(%r15), %rdx
movl $0x9, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %rax, %r8
movl $0x1, %r9d
callq 0xefc2a
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq %r14, %rdi
callq 0xf705c
leaq 0xe2229(%rip), %rsi     # 0x117da3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf6753
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bmp.c
// Function: do_read_embedded_profile
static void do_read_embedded_profile(deark *c, lctx *d)
{
	de_dbg(c, "embedded profile at %"I64_FMT", size=%"I64_FMT, d->profile_offset,
		d->profile_size);
	de_dbg_indent(c, 1);
	dbuf_create_file_from_slice(c->infile, d->profile_offset, d->profile_size, "icc",
		NULL, DE_CREATEFLAG_IS_AUX);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe8(%rsi), %rdx
movq 0xf0(%rsi), %rcx
leaq 0xe21f6(%rip), %rsi     # 0x117dba
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%rbx), %rdi
movq 0xe8(%r14), %rsi
movq 0xf0(%r14), %rdx
leaq 0xdffac(%rip), %rcx     # 0x115b9d
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xefd48
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8a15
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arj.c
// Function: de_module_arj
void de_module_arj(deark *c, struct deark_module_info *mi)
{
	mi->id = "arj";
	mi->desc = "ARJ";
	mi->run_fn = de_run_arj;
	mi->identify_fn = de_identify_arj;
	mi->help_fn = de_help_arj;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
leaq 0xe232c(%rip), %rax     # 0x117f47
movq %rax, (%rsi)
leaq 0xe2326(%rip), %rax     # 0x117f4b
movq %rax, 0x8(%rsi)
leaq 0x1f(%rip), %rax        # 0x35c4f
movq %rax, 0x18(%rsi)
leaq 0x495(%rip), %rax       # 0x360d0
movq %rax, 0x20(%rsi)
leaq 0x4f2(%rip), %rax       # 0x36138
movq %rax, 0x28(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arj.c
// Function: de_identify_arj
static int de_identify_arj(deark *c)
{
	i64 basic_hdr_size;

	if(dbuf_memcmp(c->infile, 0, g_arj_hdr_id, 2)) return 0;
	basic_hdr_size = de_getu16le(2);
	if(basic_hdr_size>ARJ_MAX_BASIC_HEADER_SIZE || basic_hdr_size<ARJ_MIN_BASIC_HEADER_SIZE) return 0;
	if(de_input_file_has_ext(c, "arj")) return 100;
	return 75;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0xe1ee2(%rip), %rdx     # 0x117fc4
xorl %ebx, %ebx
movl $0x2, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x3612e
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xeebc8
addq $-0xa29, %rax           # imm = 0xF5D7
cmpq $-0xa0b, %rax           # imm = 0xF5F5
jb 0x3612e
leaq 0xe1e30(%rip), %rsi     # 0x117f47
movq %r14, %rdi
callq 0xea491
testl %eax, %eax
movl $0x4b, %eax
movl $0x64, %ebx
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/arj.c
// Function: do_arj_volume
static void do_arj_volume(deark *c, lctx *d, struct arjvol_struct *v)
{
	i64 pos;
	i64 bytes_consumed = 0;

	d->cv = v;
	d->inf = v->inf;
	pos = v->archive_start;
	if(do_header_or_member(c, d, pos, 1, &bytes_consumed) != 1) goto done;
	pos += bytes_consumed;
	if(d->cv->is_secured) {
		do_security_envelope(c, d);
	}

	do_member_sequence(c, d, pos);

done:
	;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r8
movq $0x0, (%r8)
movq %rdx, 0x8(%rsi)
movq (%rdx), %rax
movq %rax, (%rsi)
movq 0x10(%rdx), %r14
movq %r14, %rdx
movl $0x1, %ecx
callq 0x3662f
cmpl $0x1, %eax
jne 0x36583
movq 0x8(%r15), %rax
addq 0x10(%rsp), %r14
cmpb $0x0, 0x19(%rax)
je 0x364d1
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x364d1
movq 0x20(%rax), %rdx
leaq 0xe2297(%rip), %rsi     # 0x11871d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq (%r15), %rsi
movq 0x8(%r15), %rax
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
movl $0x0, (%rsp)
movl $0x100, %r8d            # imm = 0x100
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0xe8bea
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq $0x0, 0x8(%rsp)
leaq 0x2(%r14), %rax
movq (%r15), %rcx
cmpq 0x18(%rcx), %rax
jg 0x36583
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x3662f
testl %eax, %eax
je 0x36583
movq 0x8(%rsp), %rcx
cmpq $0x2, %rcx
jl 0x36583
addq %rcx, %r14
cmpl $0x2, %eax
je 0x36532
movq $0x0, 0x8(%rsp)
leaq 0x2(%r14), %rax
movq (%r15), %rcx
cmpq 0x18(%rcx), %rax
jle 0x364f0
jmp 0x36583
movq 0x8(%r15), %rax
cmpb $0x0, 0x1b(%rax)
jne 0x36583
movq 0x28(%rax), %rsi
testq %rsi, %rsi
jle 0x36554
addq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0xe9c46
movq %rax, %r14
movq (%r15), %rax
movq 0x18(%rax), %rdx
subq %r14, %rdx
cmpq $0x2, %rdx
jl 0x36583
leaq 0xe21d4(%rip), %rsi     # 0x11873f
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8617
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arj.c
// Function: arj_logical_member_finish_and_free
static void arj_logical_member_finish_and_free(deark *c, lctx *d, u8 errflag)
{
	if(!d->clm) return;

	if(errflag) {
		if(d->mp_opt_used) {
			de_err(c, "%s: Incomplete file; not all fragments were found",
				ucstring_getpsz_d(d->clm->filename));
		}
		else {
			if(!d->clm->warned_incomplete) {
				de_warn(c, "%s: Incomplete file; use \"-mp\" for multi-volume support",
					ucstring_getpsz_d(d->clm->filename));
				d->clm->warned_incomplete = 1;
			}
		}
	}
	dbuf_close(d->clm->outf);
	ucstring_destroy(d->clm->filename);
	de_free(c, d->clm);
	d->clm = NULL;
}

// Assembly:
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x3662e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testb %dl, %dl
je 0x365fe
cmpb $0x0, 0x14(%rbx)
je 0x365d3
movq 0x8(%rax), %rdi
callq 0xf70f6
leaq 0xe21a9(%rip), %rsi     # 0x118769
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9295
movq 0x28(%rbx), %rax
jmp 0x365fe
cmpb $0x0, 0x10(%rax)
jne 0x365fe
movq 0x8(%rax), %rdi
callq 0xf70f6
leaq 0xe20a6(%rip), %rsi     # 0x11868f
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8faa
movq 0x28(%rbx), %rax
movb $0x1, 0x10(%rax)
movq (%rax), %rdi
callq 0xf052b
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xf6753
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arj.c
// Function: read_arj_datetime
static void read_arj_datetime(deark *c, lctx *d, struct member_data *md,
	i64 pos, struct de_timestamp *ts1, const char *name)
{
	i64 dosdt, dostm;
	char timestamp_buf[64];

	dostm = dbuf_getu16le(d->inf, pos);
	dosdt = dbuf_getu16le(d->inf, pos+2);
	if(dostm==0 && dosdt==0) {
		de_snprintf(timestamp_buf, sizeof(timestamp_buf), "[not set]");
	}
	else if(md->unix_timestamp_format) {
		i64 ut;

		// Unix time is usually signed, but it seems that Open Source ARJ makes
		// it unsigned, so the valid dates are from 1970-2106.
		ut = (dosdt<<16) | dostm;
		de_unix_time_to_timestamp(ut, ts1, 0x1);
		de_timestamp_to_string(ts1, timestamp_buf, sizeof(timestamp_buf), 0);
	}
	else {
		de_dos_datetime_to_timestamp(ts1, dosdt, dostm);
		ts1->tzcode = DE_TZCODE_LOCAL;
		de_timestamp_to_string(ts1, timestamp_buf, sizeof(timestamp_buf), 0);
	}
	de_dbg(c, "%s time: %s", name, timestamp_buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq %rcx, %rsi
callq 0xeebc8
movq %rax, %r12
movq (%rbx), %rdi
addq $0x2, %rbp
movq %rbp, %rsi
callq 0xeebc8
movq %r12, %rcx
orq %rax, %rcx
jne 0x37cd7
leaq 0xfa528(%rip), %rdx     # 0x1321ec
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
xorl %eax, %eax
callq 0xe8193
jmp 0x37d1e
cmpb $0x0, 0x10(%r13)
je 0x37cf7
shlq $0x10, %rax
orq %r12, %rax
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xea7f5
jmp 0x37d0a
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xea92a
movb $0x2, 0x1(%r15)
leaq 0x10(%rsp), %rsi
movl $0x40, %edx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xeaf46
leaq 0xe0801(%rip), %rsi     # 0x118526
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0xe8617
addq $0x58, %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/arj.c
// Function: decompress_method_1
static void decompress_method_1(deark *c, lctx *d, struct member_data *md,
	struct de_dfilter_in_params *dcmpri, struct de_dfilter_out_params *dcmpro,
	struct de_dfilter_results *dres)
{
	struct de_lh5x_params lzhparams;

	de_zeromem(&lzhparams, sizeof(struct de_lh5x_params));
	if(md->min_ver_to_extract==51) {
		lzhparams.fmt = DE_LH5X_FMT_LH7; // For ARJZ
	}
	else {
		lzhparams.fmt = DE_LH5X_FMT_LH6;
	}

	// ARJ does not appear to allow LZ77 offsets that point to data before
	// the beginning of the file, so it doesn't matter what we initialize the
	// history buffer to.
	lzhparams.history_fill_val = 0x00;

	lzhparams.zero_codes_block_behavior = DE_LH5X_ZCB_65536;
	lzhparams.warn_about_zero_codes_block = 1;
	fmtutil_decompress_lh5x(c, dcmpri, dcmpro, dres, &lzhparams);

	de_dbg3(c, "max dist: %"I64_FMT, lzhparams.max_offset_used);
	if(!dres->errcode) {
		if(lzhparams.max_offset_used>26624 && md->min_ver_to_extract<=11) {
			// Open-source ARJ can make files like this, with "-hdd32750" option.
			de_warn(c, "%s: Non-portable compression detected (max dist=%"I64_FMT", "
				"expected "DE_CHAR_LEQ"26624)",
				ucstring_getpsz_d(md->name_srd->str), lzhparams.max_offset_used);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
xorl %eax, %eax
cmpb $0x33, 0xe(%rsi)
sete %al
orl $0x6, %eax
movl %eax, (%r12)
movw $0x103, 0x4(%r12)       # imm = 0x103
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r12, %r8
callq 0xfec18
movq 0x8(%r12), %rdx
leaq 0xe092b(%rip), %rsi     # 0x1186c7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe889f
cmpl $0x0, (%r15)
jne 0x37de7
cmpq $0x6801, 0x8(%rsp)      # imm = 0x6801
jl 0x37de7
cmpb $0xb, 0xe(%r14)
ja 0x37de7
movq 0x98(%r14), %rax
movq 0x18(%rax), %rdi
callq 0xf70f6
movq 0x8(%rsp), %rcx
leaq 0xe08fb(%rip), %rsi     # 0x1186d5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8faa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/arj.c
// Function: method4_lz77buf_writebytecb
static void method4_lz77buf_writebytecb(struct de_lz77buffer *rb, const u8 n)
{
	struct method4_ctx *cctx = (struct method4_ctx*)rb->userdata;

	if(cctx->stop_flag) return;
	if(cctx->dcmpro->len_known) {
		if(cctx->nbytes_written >= cctx->dcmpro->expected_len) {
			cctx->stop_flag = 1;
			return;
		}
	}

	dbuf_writebyte(cctx->dcmpro->f, n);
	cctx->nbytes_written++;
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
cmpl $0x0, 0x8(%rbx)
jne 0x38051
movq 0x10(%rbx), %rax
cmpb $0x0, 0x8(%rax)
je 0x38039
movq (%rbx), %rcx
cmpq 0x10(%rax), %rcx
jge 0x3804a
movq (%rax), %rdi
movzbl %sil, %esi
callq 0xf0bd6
incq (%rbx)
jmp 0x38051
movl $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bpg.c
// Function: de_module_bpg
void de_module_bpg(deark *c, struct deark_module_info *mi)
{
	mi->id = "bpg";
	mi->desc = "BPG (Better Portable Graphics)";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_bpg;
	mi->identify_fn = de_identify_bpg;
}

// Assembly:
leaq 0xe0954(%rip), %rax     # 0x1189af
movq %rax, (%rsi)
leaq 0xe0857(%rip), %rax     # 0x1188bc
movq %rax, 0x8(%rsi)
leaq 0xdd321(%rip), %rax     # 0x115391
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x3808b
movq %rax, 0x18(%rsi)
leaq 0x361(%rip), %rax       # 0x383e7
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bpg.c
// Function: get_ue7
static i64 get_ue7(deark *c, i64 *pos)
{
	u8 b;
	i64 val = 0;
	int bytecount = 0;

	// TODO: Better error handling
	while(1) {
		b = de_getbyte(*pos);
		(*pos)++;
		bytecount++;

		// A quick hack to prevent 64-bit integer overflow.
		// 5 bytes are enough for 35 bits, and none of the fields in
		// BPG v0.9.4.1 require more than 32.
		if(bytecount<=5)
			val = (val<<7)|(b&0x7f);

		if(b<0x80) {
			break;
		}
	}
	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
xorl %eax, %eax
xorl %r15d, %r15d
movq %rax, %r12
movq 0x18(%r14), %rdi
callq 0xeead3
movl %eax, %ecx
movq (%rbx), %rsi
incq %rsi
movq %rsi, (%rbx)
movq %r12, %rdx
shlq $0x7, %rdx
andb $0x7f, %al
movzbl %al, %eax
orq %rdx, %rax
cmpl $0x5, %r15d
leal 0x1(%r15), %edx
cmovaeq %r12, %rax
movl %edx, %r15d
testb %cl, %cl
js 0x38423
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bsave.c
// Function: de_module_bsave
void de_module_bsave(deark *c, struct deark_module_info *mi)
{
	mi->id = "bsave";
	mi->desc = "BSAVE/BLOAD image";
	mi->run_fn = de_run_bsave;
	mi->identify_fn = de_identify_bsave;
	mi->help_fn = de_help_bsave;
}

// Assembly:
leaq 0xe059e(%rip), %rax     # 0x118a0d
movq %rax, (%rsi)
leaq 0xe059a(%rip), %rax     # 0x118a13
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x3849f
movq %rax, 0x18(%rsi)
leaq 0x8ec(%rip), %rax       # 0x38d7b
movq %rax, 0x20(%rsi)
leaq 0x917(%rip), %rax       # 0x38db1
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bsave.c
// Function: de_help_bsave
static void de_help_bsave(deark *c)
{
	size_t k;

	de_msg(c, "-opt bsave:fmt=...");
	for(k=0; k<DE_ARRAYCOUNT(bsave_fmt_arr); k++) {
		const struct bsave_fmt_arr_item *item;

		item = &bsave_fmt_arr[k];
		if(item->flags & FMTFLAG_UNLISTED) continue;
		de_msg(c, " %-5s : %s", item->name, item->descr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe00e7(%rip), %rsi     # 0x118eaa
xorl %eax, %eax
callq 0xe9461
movl $0x18, %r15d
leaq 0x1467b9(%rip), %r12    # 0x17f590
leaq 0xe00df(%rip), %r14     # 0x118ebd
testb $-0x80, -0x14(%r15,%r12)
jne 0x38dfc
movq -0x8(%r15,%r12), %rdx
movq (%r15,%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xe9461
addq $0x20, %r15
cmpq $0x1b8, %r15            # imm = 0x1B8
jne 0x38dde
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bsave.c
// Function: identify_bsave_internal
static void identify_bsave_internal(deark *c, struct bsave_id_info *idi)
{
	u32 load_segment;
	i64 data_size;
	// Known signatures: "PCPaint V1.0", "PCPaint V1.5".
	static const u8 *pcpaintsig = (const u8*)"PCPaint V1.";

	de_zeromem(idi, sizeof(struct bsave_id_info));
	if(c->infile->len<12) return;
	if(de_getbyte(0)!=0xfd) return;
	idi->might_be_bsave = 1;

	load_segment = (u32)de_getu16le(1);
	data_size = de_getu16le(5);
	if(data_size > c->infile->len) {
		// Mas data_size *should* be filesize-7, but there are a few bad files
		// that set it to filesize.
		idi->probably_not_bsave = 1;
		return;
	}
	if(data_size==0) {
		idi->probably_not_bsave = 1;
		return;
	}

	if(load_segment==0xb800 && (c->infile->len>=8007+14)) {
		i64 pos;

		pos = 8007;
		if(!dbuf_memcmp(c->infile, pos, pcpaintsig, 11)) {
			idi->pcpaint_sig_found = 1;
			idi->pcpaint_sig_pos = pos;
			return;
		}
	}

	if(data_size > c->infile->len) {
		idi->probably_not_bsave = 1;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq 0x18(%rdi), %rdi
cmpq $0xc, 0x18(%rdi)
jl 0x38ebc
movq %rsi, %rbx
xorl %esi, %esi
callq 0xeead3
cmpb $-0x3, %al
jne 0x38ebc
movb $0x1, (%rbx)
movq 0x18(%r14), %rdi
movl $0x1, %esi
callq 0xeebc8
movq %rax, %r12
movq 0x18(%r14), %rdi
movl $0x5, %esi
callq 0xeebc8
movq %rax, %r15
movq 0x18(%r14), %rdi
movq 0x18(%rdi), %rax
cmpq %rax, %r15
jg 0x38eb8
testq %r15, %r15
je 0x38eb8
cmpl $0xb800, %r12d          # imm = 0xB800
setne %cl
cmpq $0x1f55, %rax           # imm = 0x1F55
setl %dl
orb %cl, %dl
jne 0x38eb3
leaq 0xdfd38(%rip), %rdx     # 0x118bd0
movl $0x1f47, %esi           # imm = 0x1F47
movl $0xb, %ecx
callq 0xefc85
testl %eax, %eax
je 0x38ec8
movq 0x18(%r14), %rax
movq 0x18(%rax), %rax
cmpq %rax, %r15
jle 0x38ebc
movb $0x1, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, 0x2(%rbx)
movq $0x1f47, 0x8(%rbx)      # imm = 0x1F47
jmp 0x38ebc
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bsave.c
// Function: use_fmt_by_id
static void use_fmt_by_id(deark *c, lctx *d, UI fmt_id)
{
	if(fmt_id==FMT_UNKNOWN) return;
	d->fmt_info = get_fmt_info_by_id(fmt_id);
	if(d->fmt_info) {
		d->decoder_fn = d->fmt_info->decoder_fn;
		d->has_dimension_fields = (d->fmt_info->flags & FMTFLAG_HAS_DIMENSION_FIELDS)?1:0;
		d->interlaced = (d->fmt_info->flags & FMTFLAG_INTERLACED)?1:0;
	}
}

// Assembly:
testl %esi, %esi
je 0x38f21
xorl %eax, %eax
leaq 0x1466ad(%rip), %rcx    # 0x17f590
cmpl %esi, (%rax,%rcx)
je 0x38efd
addq $0x20, %rax
cmpq $0x1a0, %rax            # imm = 0x1A0
jne 0x38ee3
movq $0x0, 0x20(%rdi)
retq
leaq (%rcx,%rax), %rdx
movq %rdx, 0x20(%rdi)
movq 0x8(%rax,%rcx), %rdx
movq %rdx, 0x30(%rdi)
movb 0x4(%rax,%rcx), %al
movl %eax, %ecx
andb $0x1, %cl
movb %cl, 0x2d(%rdi)
shrb %al
andb $0x1, %al
movb %al, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bsave.c
// Function: do_2color
static void do_2color(deark *c, lctx *d)
{
	i64 w, h;
	i64 j;
	i64 src_rowspan;
	i64 pos;
	de_bitmap *img = NULL;

	pos = BSAVE_HDRSIZE;

	if(d->has_dimension_fields) {
		// 11-byte header that includes width & height
		w = d->metrics.maybe_bitsperrow;
		h = d->metrics.maybe_nrows;
		pos+=4;
	}
	else if(!d->interlaced) {
		w = get_width(c, d, 640);
		src_rowspan = (w+7)/8;
		h = d->data_size / src_rowspan;
		h = get_height(c, d, h);
	}
	else {
		w = get_width(c, d, 640);
		h = get_height(c, d, 200);
	}

	de_dbg_dimensions(c, w, h);
	src_rowspan = (w+7)/8;

	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 1);

	for(j=0; j<h; j++) {
		if(d->interlaced) {
			de_convert_row_bilevel(c->infile, pos + (j%2)*8192 + (j/2)*src_rowspan,
				img, j, 0);
		}
		else {
			de_convert_row_bilevel(c->infile, pos + j*src_rowspan, img, j, 0);
		}
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r13
cmpb $0x0, 0x2d(%rsi)
je 0x39282
movq 0x440(%r14), %r12
movq 0x448(%r14), %rbx
movl $0xb, %eax
jmp 0x392d7
movb 0x2c(%r14), %bl
movl $0x280, %esi            # imm = 0x280
movq %r13, %rdi
callq 0x39b51
movq %rax, %r12
testb %bl, %bl
je 0x392a4
movl $0xc8, %esi
movq %r13, %rdi
jmp 0x392ca
leaq 0x7(%r12), %rax
movq %r12, %rcx
addq $0xe, %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x3, %rcx
movq 0x10(%r14), %rax
cqto
idivq %rcx
movq %r13, %rdi
movq %rax, %rsi
callq 0x39b9a
movq %rax, %rbx
movl $0x7, %eax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe8f88
leaq 0x7(%r12), %rax
leaq 0xe(%r12), %rbp
testq %rax, %rax
cmovnsq %rax, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xf1db1
testl %eax, %eax
je 0x393a2
movq %r14, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xf266a
movq %rax, %r12
testq %rbx, %rbx
jle 0x39394
movq %rbx, %r15
sarq $0x3, %rbp
xorl %ebx, %ebx
movq (%rsp), %r14
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
cmpb $0x0, 0x2c(%rax)
movq %r14, %rsi
je 0x3936b
movl %ebx, %eax
andl $0x2000, %eax           # imm = 0x2000
addq (%rsp), %rax
movq %r13, %rsi
shrq %rsi
imulq %rbp, %rsi
addq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0xf2a28
incq %r13
addq %rbp, %r14
addq $0x2000, %rbx           # imm = 0x2000
cmpq %r13, %r15
jne 0x39345
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf22dc
jmp 0x393a5
xorl %r12d, %r12d
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf228d
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/bsave.c
// Function: do_256color
static void do_256color(deark *c, lctx *d)
{
	i64 w, h;
	i64 pos = BSAVE_HDRSIZE;
	de_bitmap *img = NULL;

	if(d->has_dimension_fields) {
		w = d->metrics.maybe_bytesperrow;
		h = d->metrics.maybe_nrows;
		pos += 4;
	}
	else {
		w = get_width(c, d, 320);
		h = d->data_size / w;
		h = get_height(c, d, h);
	}
	de_dbg_dimensions(c, w, h);

	if(!d->pal_valid) {
		de_copy_std_palette(DE_PALID_VGA256, 0, 0, d->pal, 256, 0);
	}

	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 3);
	de_convert_image_paletted(c->infile, pos, 8, w, d->pal, img, 0);
	de_bitmap_write_to_file(img, NULL, 0);
done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x2d(%rsi)
je 0x39860
movq 0x448(%rbx), %r13
movq 0x450(%rbx), %r15
movl $0xb, %r12d
jmp 0x3988d
movl $0x140, %esi            # imm = 0x140
movq %r14, %rdi
callq 0x39b51
movq %rax, %r15
movq 0x10(%rbx), %rax
cqto
idivq %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x39b9a
movq %rax, %r13
movl $0x7, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe8f88
cmpl $0x0, 0x38(%rbx)
jne 0x398bc
leaq 0x3c(%rbx), %rcx
movl $0x100, %r8d            # imm = 0x100
movl $0x28, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0xec55a
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xf1db1
testl %eax, %eax
je 0x39917
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x3, %ecx
callq 0xf266a
movq %rax, %r13
movq 0x18(%r14), %rdi
addq $0x3c, %rbx
movl $0x0, (%rsp)
movl $0x8, %edx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %rax, %r9
callq 0xf2f79
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf22dc
jmp 0x3991a
xorl %r13d, %r13d
movq %r13, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf228d