LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_pp1
void de_module_stos_pp1(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_pp1";
	mi->desc = "Picture Packer low res";
	mi->run_fn = de_run_stos_pp1;
	mi->identify_fn = de_identify_stos_pp1;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x930d7(%rip), %rax     # 0x122f30
movq %rax, (%rsi)
leaq 0x930d6(%rip), %rax     # 0x122f39
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x8fe89
movq %rax, 0x18(%rsi)
leaq 0x18(%rip), %rax        # 0x8fe91
movq %rax, 0x20(%rsi)
leaq -0x5e(%rip), %rax       # 0x8fe26
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_pp1
static int de_identify_stos_pp1(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "pp1");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && res==1) return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x93096(%rip), %rsi     # 0x122f35
callq 0xdfcd5
testl %eax, %eax
je 0x8fecb
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9153f
xorl %edx, %edx
cmpl $0x1, (%r14)
pushq $0x64
popq %rcx
cmovnel %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x8fecd
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_pp2
void de_module_stos_pp2(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_pp2";
	mi->desc = "Picture Packer med res";
	mi->run_fn = de_run_stos_pp2;
	mi->identify_fn = de_identify_stos_pp2;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x93072(%rip), %rax     # 0x122f50
movq %rax, (%rsi)
leaq 0x93071(%rip), %rax     # 0x122f59
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x8ff0e
movq %rax, 0x18(%rsi)
leaq 0x18(%rip), %rax        # 0x8ff16
movq %rax, 0x20(%rsi)
leaq -0xe3(%rip), %rax       # 0x8fe26
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_pp2
static int de_identify_stos_pp2(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "pp2");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && res==1) return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x93031(%rip), %rsi     # 0x122f55
callq 0xdfcd5
testl %eax, %eax
je 0x8ff50
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9153f
xorl %edx, %edx
cmpl $0x1, (%r14)
pushq $0x64
popq %rcx
cmovnel %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x8ff52
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_pp3
void de_module_stos_pp3(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_pp3";
	mi->desc = "Picture Packer high res";
	mi->run_fn = de_run_stos_pp3;
	mi->identify_fn = de_identify_stos_pp3;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x9300d(%rip), %rax     # 0x122f70
movq %rax, (%rsi)
leaq 0x9300c(%rip), %rax     # 0x122f79
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x8ff93
movq %rax, 0x18(%rsi)
leaq 0x18(%rip), %rax        # 0x8ff9b
movq %rax, 0x20(%rsi)
leaq -0x168(%rip), %rax      # 0x8fe26
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_pp3
static int de_identify_stos_pp3(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "pp3");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && res==1) return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x92fcc(%rip), %rsi     # 0x122f75
callq 0xdfcd5
testl %eax, %eax
je 0x8ffd5
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9153f
xorl %edx, %edx
cmpl $0x1, (%r14)
pushq $0x64
popq %rcx
cmovnel %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x8ffd7
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_module_stos_daj
void de_module_stos_daj(deark *c, struct deark_module_info *mi)
{
	mi->id = "stos_daj";
	mi->desc = "Picture Packer DAJ";
	mi->run_fn = de_run_stos_daj;
	mi->identify_fn = de_identify_stos_daj;
	mi->help_fn = de_help_mbk;
}

// Assembly:
leaq 0x92fa9(%rip), %rax     # 0x122f91
movq %rax, (%rsi)
leaq 0x92fa8(%rip), %rax     # 0x122f9a
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x90018
movq %rax, 0x18(%rsi)
leaq 0x15(%rip), %rax        # 0x9001d
movq %rax, 0x20(%rsi)
leaq -0x1ed(%rip), %rax      # 0x8fe26
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: de_identify_stos_daj
static int de_identify_stos_daj(deark *c)
{
	int has_ext;
	int is_pkscr;
	UI res;

	has_ext = de_input_file_has_ext(c, "daj");
	if(!has_ext) return 0;
	is_pkscr = is_stos_packedscreen(c, &res);
	if(is_pkscr && (res==0 || res==1)) return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x92f6b(%rip), %rsi     # 0x122f96
callq 0xdfcd5
testl %eax, %eax
je 0x90057
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9153f
xorl %edx, %edx
cmpl $0x2, (%r14)
pushq $0x64
popq %rcx
cmovael %edx, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x90059
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mbk.c
// Function: is_stos_packedscreen
static int is_stos_packedscreen(deark *c, UI *res)
{
	u8 buf[24];
	u8 is_mbk = 0;
	UI id = 0;
	UI field14;
	UI field18;
	i64 bpos = 0;

	*res = 0;
	de_read(buf, 0, sizeof(buf));

	if(!de_memcmp(buf, g_lion_sig, 10)) is_mbk = 1;
	if(is_mbk) {
		if((UI)de_getu32be_direct(&buf[10]) == 0) return 0; // screen out MBS
		if(buf[14] != 0x81) return 0; // must be type 'data'
		bpos = 18;
	}

	id = (UI)de_getu32be_direct(&buf[bpos]);
	if(id!=BANKID_PKSCREEN) return 0;
	*res = (UI)de_getu16be_direct(&buf[bpos+4]);
	if(*res > 2) return 0;

	field14 = (UI)de_getu16be_direct(&buf[bpos+14]);
	if(field14>=1 && field14<=6) {
		// It's likely that this is the AMOS format, not the STOS format.
		field18 = (UI)de_getu16be_direct(&buf[bpos+18]);
		// Expecting STOS flags to be small
		if(field18>=8) return 0;
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
andl $0x0, (%rsi)
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
movq %rsp, %r15
pushq $0x18
popq %rcx
movq %r15, %rsi
xorl %edx, %edx
callq 0xe3cb7
leaq 0x91abd(%rip), %rsi     # 0x12302a
pushq $0xa
popq %rdx
movq %r15, %rdi
callq 0x18230
movl $0x0, %r12d
testl %eax, %eax
jne 0x915a0
leaq 0xa(%rsp), %rdi
callq 0xe404a
testl %eax, %eax
je 0x915f2
cmpb $-0x7f, 0xe(%rsp)
jne 0x915f2
leaq 0x12(%rsp), %r15
pushq $0x12
popq %r12
movq %r15, %rdi
callq 0xe404a
cmpl $0x6071963, %eax        # imm = 0x6071963
jne 0x915f2
leaq (%rsp,%r12), %rdi
addq $0x4, %rdi
callq 0xe3f3b
movl %eax, (%r14)
cmpl $0x2, %eax
ja 0x915f2
movq %rsp, %r14
leaq (%r12,%r14), %rdi
addq $0xe, %rdi
callq 0xe3f3b
decl %eax
cmpl $0x5, %eax
ja 0x915ef
leaq (%r12,%r14), %rdi
addq $0x12, %rdi
callq 0xe3f3b
testl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
jne 0x915f2
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mmm.c
// Function: de_module_mmm
void de_module_mmm(deark *c, struct deark_module_info *mi)
{
	mi->id = "mmm";
	mi->desc = "RIFF Multimedia Movie";
	mi->run_fn = de_run_mmm;
	mi->identify_fn = de_identify_mmm;
	mi->help_fn = de_help_mmm;
}

// Assembly:
leaq 0x91e26(%rip), %rax     # 0x12342d
movq %rax, (%rsi)
leaq 0x91e20(%rip), %rax     # 0x123431
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x91637
movq %rax, 0x18(%rsi)
leaq 0x353(%rip), %rax       # 0x9197a
movq %rax, 0x20(%rsi)
leaq 0x386(%rip), %rax       # 0x919b8
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mmm.c
// Function: my_mmm_handle_nonchunk_data_fn
static int my_mmm_handle_nonchunk_data_fn(struct de_iffctx *ictx,
	i64 pos, i64 *plen)
{
	u8 buf[6];

	dbuf_read(ictx->f, buf, pos, sizeof(buf));

	if(buf[0]<65 || buf[1]<65) {
		if(looks_like_a_4cc_b(&buf[2])) {
			*plen = 2;
			de_dbg(ictx->c, "[%"I64_FMT" non-RIFF bytes at %"I64_FMT"]", *plen, pos);
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
leaq 0x2(%rsp), %r12
pushq $0x6
popq %rcx
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe3cb7
cmpb $0x41, (%r12)
jb 0x926d5
cmpb $0x40, 0x3(%rsp)
ja 0x926ec
xorl %eax, %eax
cmpq $0x4, %rax
je 0x926f0
movb 0x4(%rsp,%rax), %cl
addb $-0x7f, %cl
incq %rax
cmpb $-0x5f, %cl
jae 0x926d7
xorl %eax, %eax
jmp 0x92711
movq $0x2, (%r14)
movq (%r15), %rdi
leaq 0x90f29(%rip), %rsi     # 0x12362a
pushq $0x2
popq %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mmm.c
// Function: mmm_read_name_p
static void mmm_read_name_p(deark *c, struct mmm_ctx *d, struct de_iffctx *ictx,
	i64 *ppos, const char *name)
{
	i64 pos = *ppos;
	i64 namelen;

	ucstring_empty(d->tmp_namestr);
	namelen = (i64)dbuf_getbyte(ictx->f, pos);
	if(namelen) {
		dbuf_read_to_ucstring(ictx->f, pos+1, namelen, d->tmp_namestr, 0, d->input_encoding);
		de_dbg(c, "%s: \"%s\"", (name ? name : "name"), ucstring_getpsz_d(d->tmp_namestr));
	}
	*ppos += de_pad_to_2(1+namelen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, (%rsp)
movq (%rcx), %rbp
movq 0x28(%rsi), %rdi
callq 0xeac85
movq 0x18(%r14), %rdi
movq %rbp, %rsi
callq 0xe3eb4
movzbl %al, %r15d
testb %r15b, %r15b
je 0x92825
movq 0x18(%r14), %rdi
incq %rbp
movq 0x28(%r13), %rcx
movl 0xc(%r13), %r9d
movq %rbp, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xe4c9a
testq %r12, %r12
leaq 0x88e12(%rip), %r14     # 0x11b612
cmovneq %r12, %r14
movq 0x28(%r13), %rdi
callq 0xeb877
leaq 0x8c6a6(%rip), %rsi     # 0x11eeba
movq (%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xde896
leaq 0x1(%r15), %rdi
callq 0xdfb87
addq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mp3.c
// Function: de_module_apetag
void de_module_apetag(deark *c, struct deark_module_info *mi)
{
	mi->id = "apetag";
	mi->desc = "APE tag";
	mi->run_fn = de_run_apetag;
	mi->identify_fn = NULL;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
leaq 0x90fa7(%rip), %rax     # 0x1237ee
movq %rax, (%rsi)
leaq 0x90fa4(%rip), %rax     # 0x1237f5
movq %rax, 0x8(%rsi)
leaq 0xe(%rip), %rax         # 0x9286a
movq %rax, 0x18(%rsi)
andq $0x0, 0x20(%rsi)
orb $0x1, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mp3.c
// Function: de_module_mpegaudio
void de_module_mpegaudio(deark *c, struct deark_module_info *mi)
{
	mi->id = "mpegaudio";
	mi->id_alias[0] = "mp3";
	mi->desc = "MP3 / MPEG audio";
	mi->run_fn = de_run_mpegaudio;
	mi->identify_fn = de_identify_mpegaudio;
}

// Assembly:
leaq 0x90993(%rip), %rax     # 0x1237fd
movq %rax, (%rsi)
leaq 0x90993(%rip), %rax     # 0x123807
movq %rax, 0x38(%rsi)
leaq 0x9098c(%rip), %rax     # 0x12380b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x92e9a
movq %rax, 0x18(%rsi)
leaq 0x56c(%rip), %rax       # 0x93401
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mp3.c
// Function: de_module_monkeys_audio
void de_module_monkeys_audio(deark *c, struct deark_module_info *mi)
{
	mi->id = "monkeys_audio";
	mi->desc = "Monkey's Audio (.ape)";
	mi->run_fn = de_run_monkeys_audio;
	mi->identify_fn = de_identify_monkeys_audio;
}

// Assembly:
leaq 0x902b4(%rip), %rax     # 0x12381c
movq %rax, (%rsi)
leaq 0x902b8(%rip), %rax     # 0x12382a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x9358d
movq %rax, 0x18(%rsi)
leaq 0x75(%rip), %rax        # 0x935fd
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mp3.c
// Function: de_run_monkeys_audio
static void de_run_monkeys_audio(deark *c, de_module_params *mparams)
{
	i64 endpos = c->infile->len;

	if(is_apetag_sig_at(c->infile, endpos-32)) {
		de_dbg(c, "APE tag found, ending at %"I64_FMT, endpos);
		de_dbg_indent(c, 1);
		de_run_module_by_id_on_slice2(c, "apetag", NULL, c->infile, 0, endpos);
		de_dbg_indent(c, -1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %r14
leaq -0x20(%r14), %rsi
callq 0x93689
testl %eax, %eax
je 0x935f5
leaq 0x903f3(%rip), %rsi     # 0x1239a3
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
movq 0x18(%rbx), %rcx
leaq 0x9021b(%rip), %rsi     # 0x1237ee
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
movq %r14, %r9
callq 0xdfa28
pushq $-0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdeba7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mp3.c
// Function: de_identify_monkeys_audio
static int de_identify_monkeys_audio(deark *c)
{
	unsigned int n;

	if(dbuf_memcmp(c->infile, 0, "MAC ", 4)) return 0;
	n = (unsigned int)de_getu16le(6);
	if(ma_is_known_cmpr(n)) return 100;
	n = (unsigned int)de_getu16le(52);
	if(ma_is_known_cmpr(n)) return 100;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x9067a(%rip), %rdx     # 0x123c89
xorl %r14d, %r14d
pushq $0x4
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
jne 0x93681
movq 0x18(%rbx), %rdi
pushq $0x6
popq %rsi
callq 0xe3fa3
leal -0x3e8(%rax), %ecx
xorl %ebp, %ebp
movw $0x3e8, %r14w           # imm = 0x3E8
xorl %edx, %edx
divw %r14w
cmpl $0xfa0, %ecx            # imm = 0xFA0
ja 0x93652
testw %dx, %dx
jne 0x93652
pushq $0x64
popq %r14
jmp 0x93681
movq 0x18(%rbx), %rdi
pushq $0x34
popq %rsi
callq 0xe3fa3
movq %rax, %rcx
xorl %edx, %edx
divw %r14w
testw %dx, %dx
pushq $0x64
popq %r14
cmovnel %ebp, %r14d
leal -0x3e8(%rcx), %eax
cmpl $0xfa1, %eax            # imm = 0xFA1
cmovael %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: de_module_mscompress
void de_module_mscompress(deark *c, struct deark_module_info *mi)
{
	mi->id = "mscompress";
	mi->desc = "MS-DOS Installation Compression";
	mi->run_fn = de_run_mscompress;
	mi->identify_fn = de_identify_mscompress;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
leaq 0x9075e(%rip), %rax     # 0x123e09
movq %rax, (%rsi)
leaq 0x9075f(%rip), %rax     # 0x123e14
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x936d4
movq %rax, 0x18(%rsi)
leaq 0x10f4(%rip), %rax      # 0x947bf
movq %rax, 0x20(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: de_module_is_ibt
void de_module_is_ibt(deark *c, struct deark_module_info *mi)
{
	mi->id = "is_ibt";
	mi->desc = "InstallShield IBT archive";
	mi->run_fn = de_run_is_ibt;
	mi->identify_fn = de_identify_is_ibt;
}

// Assembly:
leaq 0x8f65e(%rip), %rax     # 0x123e34
movq %rax, (%rsi)
leaq 0x8f65b(%rip), %rax     # 0x123e3b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x947fb
movq %rax, 0x18(%rsi)
leaq 0x315(%rip), %rax       # 0x94b0b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: de_module_mrnz
void de_module_mrnz(deark *c, struct deark_module_info *mi)
{
	mi->id = "mrnz";
	mi->desc = "MRNZ obfuscated file";
	mi->run_fn = de_run_mrnz;
	mi->identify_fn = de_identify_mrnz;
}

// Assembly:
leaq 0x8f321(%rip), %rax     # 0x123e55
movq %rax, (%rsi)
leaq 0x8f31c(%rip), %rax     # 0x123e5a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x94b59
movq %rax, 0x18(%rsi)
leaq 0xc1(%rip), %rax        # 0x94c15
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: de_run_mrnz
static void de_run_mrnz(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;
	i64 ipos;
	i64 i;
	i64 ocount;
	u8 errflag = 0;

	ipos = 8;
	// Guessing that this is the number of obfuscated bytes
	ocount = de_getu32le_p(&ipos);
	if(ocount>0xff) {
		errflag = 1;
		goto done;
	}

	outf = dbuf_create_output_file(c, "bin", NULL, 0);
	for(i=0; i<ocount; i++) {
		u8 b;

		if(ipos >= c->infile->len) goto done;
		b = de_getbyte_p(&ipos);
		dbuf_writebyte(outf, b^0xae);
	}

	dbuf_copy(c->infile, ipos, c->infile->len-ipos, outf);

done:
	dbuf_close(outf);
	if(errflag) {
		de_err(c, "Failed to decode MRNZ file");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x8, (%rsi)
movq 0x18(%rdi), %rdi
callq 0xe40bf
cmpq $0xff, %rax
jg 0x94bd0
movq %rax, %r15
leaq 0x93954(%rip), %rsi     # 0x1284dd
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %r14
testq %r15, %r15
cmovleq %r12, %r15
movq %rsp, %r12
subq $0x1, %r15
jb 0x94bea
movq (%rsp), %rax
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jge 0x94c01
movq %r12, %rsi
callq 0xe3f2a
xorb $-0x52, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0xe5bc5
jmp 0x94ba5
xorl %edi, %edi
callq 0xe5591
leaq 0x8f585(%rip), %rsi     # 0x124163
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf2a5
jmp 0x94c09
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
movq 0x18(%rdi), %rdx
subq %rsi, %rdx
movq %r14, %rcx
callq 0xe45f4
movq %r14, %rdi
callq 0xe5591
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: detect_fmt_internal
static int detect_fmt_internal(deark *c)
{
	u8 buf[8];

	de_read(buf, 0, sizeof(buf));
	if(!de_memcmp(buf, "\x53\x5a\x44\x44\x88\xf0\x27\x33", 8))
		return FMT_SZDD;
	if(!de_memcmp(buf, "\x4b\x57\x41\x4a\x88\xf0\x27\xd1", 8))
		return FMT_KWAJ;
	if(!de_memcmp(buf, "SZ \x88\xf0\x27\x33", 7))
		return FMT_SZ;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x18(%rdi), %rdi
leaq 0x8(%rsp), %rbx
pushq $0x8
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe3cb7
movabsq $0x3327f08844445a53, %rax # imm = 0x3327F08844445A53
cmpq %rax, (%rbx)
je 0x94c92
movabsq $-0x2ed80f77b5bea8b5, %rax # imm = 0xD127F0884A41574B
cmpq %rax, 0x8(%rsp)
je 0x94c96
leaq 0x8f23d(%rip), %rsi     # 0x123eb6
leaq 0x8(%rsp), %rdi
pushq $0x7
popq %rdx
callq 0x18230
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x94c99
pushq $0x1
jmp 0x94c98
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: get_cmpr_meth_name
static const char *get_cmpr_meth_name(UI n)
{
	char *name = NULL;

	switch(n) {
	case CMPR_NONE: name="uncompressed"; break;
	case CMPR_XOR: name="XOR"; break;
	case CMPR_LZSS16: case CMPR_LZSS18: name="LZSS"; break;
	case CMPR_LZHUFF: name="LZ+Huffman"; break;
	case CMPR_MSZIP: name="MSZIP"; break;
	}
	return name?name:"?";
}

// Assembly:
cmpl $0x4, %edi
ja 0x94cbe
movl %edi, %eax
leaq 0x8f133(%rip), %rcx     # 0x123de0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa81fb(%rip), %rax     # 0x13ceb8
retq
cmpl $0x10000, %edi          # imm = 0x10000
jne 0x94cce
leaq 0x8429b(%rip), %rax     # 0x118f68
retq
leaq 0x8a20c(%rip), %rax     # 0x11eee1
retq
leaq 0x775f5(%rip), %rax     # 0x10c2d2
retq
leaq 0x86e00(%rip), %rax     # 0x11bae5
retq
leaq 0x8f260(%rip), %rax     # 0x123f4d
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: XOR_cbfn
static int XOR_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	i64 k;
	dbuf *f = (dbuf*)brctx->userdata;

	for(k=0; k<buf_len; k++) {
		dbuf_writebyte(f, buf[k] ^ (u8)0xff);
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r15
xorl %r12d, %r12d
testq %rdx, %rdx
cmovleq %r12, %rbx
cmpq %r12, %rbx
je 0x94d26
movzbl (%r14,%r12), %esi
xorl $0xff, %esi
movq %r15, %rdi
callq 0xe5bc5
incq %r12
jmp 0x94d09
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: mslzh_lz77buf_writebytecb
static void mslzh_lz77buf_writebytecb(struct de_lz77buffer *rb, u8 n)
{
	struct mslzh_context *lzhctx = (struct mslzh_context*)rb->userdata;

	if(mslzh_have_enough_output(lzhctx)) return;
	dbuf_writebyte(lzhctx->dcmpro->f, n);
	lzhctx->nbytes_written++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x94d64
testl %eax, %eax
jne 0x94d5d
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movzbl %bpl, %esi
callq 0xe5bc5
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: mslzh_getnextcode
static MSLZH_VALUE_TYPE mslzh_getnextcode(struct mslzh_context *lzhctx,
	struct mslzh_tree *htr)
{
	fmtutil_huffman_valtype val = 0;
	int ret;

	fmtutil_huffman_reset_cursor(htr->fmtuht->cursor); // Should be unnecessary

	ret = fmtutil_huffman_read_next_value(htr->fmtuht->bk, &lzhctx->bitrd, &val, NULL);
	if(!ret) return 0;
	return (MSLZH_VALUE_TYPE)val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rax
movq (%rax), %rdi
callq 0xf7e52
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
addq $0x20, %r15
movq %r15, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xf8071
testl %eax, %eax
je 0x94dc3
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mscompress.c
// Function: read_sz_p
static int read_sz_p(dbuf *f, i64 maxlen, de_ucstring *s, de_encoding enc, i64 *ppos)
{
	i64 startpos = *ppos;
	i64 foundpos;
	i64 len;
	int ret;

	ret = dbuf_search_byte(f, 0x00, startpos, maxlen, &foundpos);
	if(!ret) return 0;
	len = foundpos - startpos; // length w/o NUL
	dbuf_read_to_ucstring(f, startpos, len, s, 0, enc);
	*ppos = foundpos+1;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movq (%rcx), %r15
xorl %r13d, %r13d
pushq $0x50
popq %rcx
movq %rsp, %r8
xorl %esi, %esi
movq %r15, %rdx
callq 0xe4b21
testl %eax, %eax
je 0x94e26
movq (%rsp), %rdx
subq %r15, %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0xe4c9a
movq (%rsp), %rax
incq %rax
movq %rax, (%rbx)
pushq $0x1
popq %r13
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mac-arch.c
// Function: de_module_tome
void de_module_tome(deark *c, struct deark_module_info *mi)
{
	mi->id = "tome";
	mi->desc = "Tome";
	mi->run_fn = de_run_tome;
	mi->identify_fn = de_identify_tome;
	mi->flags |= DE_MODFLAG_NONWORKING;
}

// Assembly:
leaq 0x8f348(%rip), %rax     # 0x124187
movq %rax, (%rsi)
leaq 0x8f343(%rip), %rax     # 0x12418c
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x94e68
movq %rax, 0x18(%rsi)
leaq 0x63b(%rip), %rax       # 0x9549a
movq %rax, 0x20(%rsi)
orb $0x2, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mac-arch.c
// Function: destroy_tome_md
static void destroy_tome_md(deark *c, struct tome_md *md)
{
	if(!md) return;
	de_advfile_destroy(md->advf);
	de_destroy_stringreaderdata(c, md->fname);
	de_free(c, md);
}

// Assembly:
testq %rsi, %rsi
je 0x954eb
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rdi
callq 0xf0812
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xe4b94
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mac-arch.c
// Function: tome_read_timestamp
static void tome_read_timestamp(deark *c, struct tome_ctx *d, struct tome_md *md,
	i64 pos, UI tzi, const char *name)
{
	i64 n;
	struct de_timestamp ts;
	char timestamp_buf[64];

	n = dbuf_getu32be(c->infile, pos);
	de_mac_time_to_timestamp(n, &ts);
	de_timestamp_to_string(&ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s time: %"U64_FMT" (%s)", name, n, timestamp_buf);
	md->advf->mainfork.fi->timestamp[tzi] = ts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movl %ecx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %r13
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
callq 0xe404f
movq %rax, %rbp
leaq 0x10(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xe0102
leaq 0x20(%rsp), %rbx
pushq $0x40
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xe0644
leaq 0x8ed3f(%rip), %rsi     # 0x124281
movq %r13, %rdi
movq %r15, %rdx
movq %rbp, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0xde896
movq 0x30(%r14), %rax
movq 0x20(%rax), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
movups (%r12), %xmm0
movups %xmm0, 0x18(%rax,%rcx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mac-arch.c
// Function: tome_writelistener
static void tome_writelistener(dbuf *f, void *userdata, const u8 *buf, i64 buf_len)
{
	struct tome_fork_data *fdata = (struct tome_fork_data*)userdata;
	struct tome_md *md = fdata->md;
	i64 i;

	for(i=0; i<buf_len; i++) {
		md->frk[fdata->forknum].checksum_calc = (u32)buf[i] ^
			((u32)(md->frk[fdata->forknum].checksum_calc >> 0x18) +
				(u32)(md->frk[fdata->forknum].checksum_calc <<8));
	}
}

// Assembly:
movl $0xc0, %eax
addq (%rsi), %rax
xorl %edi, %edi
testq %rcx, %rcx
cmovleq %rdi, %rcx
cmpq %rdi, %rcx
je 0x955b7
movl 0x8(%rsi), %r8d
imulq $0x38, %r8, %r8
movl 0x14(%rax,%r8), %r9d
roll $0x8, %r9d
movzbl (%rdx,%rdi), %r10d
xorl %r10d, %r9d
movl %r9d, 0x14(%rax,%r8)
incq %rdi
jmp 0x9558f
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/mac-arch.c
// Function: tome_advfile_cbfn
static int tome_advfile_cbfn(deark *c, struct de_advfile *advf,
	struct de_advfile_cbparams *afp)
{
	UI forknum;
	struct tome_md *md = (struct tome_md*)advf->userdata;

	if(afp->whattodo == DE_ADVFILE_WRITEMAIN) {
		forknum = 0;
	}
	else if(afp->whattodo == DE_ADVFILE_WRITERSRC) {
		forknum = 1;
	}
	else {
		return 0;
	}

	if(md->frk[forknum].is_compressed) {
		tome_decompress_fork(md, forknum, afp->outf);
	}
	else {
		tome_copy_fork(md, forknum, afp->outf);
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x8(%rsi), %rbp
movl (%rdx), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x955e2
cmpl $0x2, %ecx
jne 0x95731
pushq $0x1
popq %rax
leaq 0xc0(%rbp), %r15
movl %eax, %r13d
imulq $0x38, %r13, %r12
cmpb $0x0, 0xcc(%rbp,%r12)
movq 0x8(%rdx), %r14
je 0x956c1
movq (%rbp), %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xdebae
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
callq 0xee7ee
imull $0x3e8, 0x10(%rbp), %eax # imm = 0x3E8
orl %r13d, %eax
leaq 0x28(%rsp), %rsi
movl %eax, 0x18(%rsi)
movq 0x18(%rbx), %rax
movq %rax, (%rsi)
leaq (%r15,%r12), %r13
movups 0x20(%r15,%r12), %xmm0
movups %xmm0, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x8(%rdx)
movq 0x18(%r15,%r12), %rax
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xf58f6
cmpl $0x0, (%r14)
je 0x9571d
movq 0x38(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xeb877
movq %rax, %r14
addq $0x30, %r13
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xee7bc
leaq 0x724e2(%rip), %rsi     # 0x107b8e
movq %rbx, %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdf2a5
jmp 0x95722
leaq (%r15,%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%r15,%r12), %rbx
movq 0x20(%r15,%r12), %r13
testq %rbx, %rbx
jle 0x95712
leaq 0x4(%r13), %r15
movl $0x10000, %esi          # imm = 0x10000
movq %rbx, %rdi
callq 0xdfb45
movq %rax, %r12
movq 0x30(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xe45f4
addq %r12, %r13
addq $0x4, %r13
subq %r12, %rbx
jmp 0x956d4
movq 0x8(%rsp), %rax
movb $0x1, 0xd(%rax)
jmp 0x9572e
movb $0x1, 0xd(%r13)
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xdebb7
pushq $0x1
popq %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/msp.c
// Function: de_module_msp
void de_module_msp(deark *c, struct deark_module_info *mi)
{
	mi->id = "msp";
	mi->desc = "Microsoft Paint image";
	mi->run_fn = de_run_msp;
	mi->identify_fn = de_identify_msp;
}

// Assembly:
leaq 0x8eb65(%rip), %rax     # 0x1242b0
movq %rax, (%rsi)
leaq 0x8eb5f(%rip), %rax     # 0x1242b4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x95770
movq %rax, 0x18(%rsi)
leaq 0x339(%rip), %rax       # 0x95aa4
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/msp.c
// Function: de_identify_msp
static int de_identify_msp(deark *c)
{
	u8 b[4];
	de_read(b, 0, 4);

	if(b[0]==0x44 && b[1]==0x61 && b[2]==0x6e && b[3]==0x4d)
		return 100;
	if(b[0]==0x4c && b[1]==0x69 && b[2]==0x6e && b[3]==0x53)
		return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
leaq 0x14(%rsp), %rbx
pushq $0x4
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe3cb7
movd (%rbx), %xmm0
movd %xmm0, %eax
cmpl $0x4d6e6144, %eax       # imm = 0x4D6E6144
je 0x95b1b
movdqa 0x8e7c5(%rip), %xmm1    # 0x1242a0
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x55, %xmm0, %xmm2     # xmm2 = xmm0[1,1,1,1,4,5,6,7]
pcmpeqb %xmm1, %xmm2
movdqa %xmm0, (%rsp)
movb (%rsp), %cl
movb 0x1(%rsp), %dl
xorb $0x4c, %cl
xorb $0x69, %dl
pextrw $0x2, %xmm2, %esi
cmpb $0x53, 0x3(%rsp)
pushq $0x64
popq %rax
cmovnel %r14d, %eax
testb $0x1, %sil
cmovel %r14d, %eax
orb %cl, %dl
cmovnel %r14d, %eax
jmp 0x95b1e
pushq $0x64
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_module_nol
void de_module_nol(deark *c, struct deark_module_info *mi)
{
	mi->id = "nol";
	mi->desc = "Nokia Operator Logo";
	mi->run_fn = de_run_nol;
	mi->identify_fn = de_identify_nol;
}

// Assembly:
leaq 0x8e807(%rip), %rax     # 0x124336
movq %rax, (%rsi)
leaq 0x8e801(%rip), %rax     # 0x12433a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x95b54
movq %rax, 0x18(%rsi)
leaq 0x77(%rip), %rax        # 0x95bc6
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_run_nol
static void de_run_nol(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	d->w = de_getu16le(10);
	d->h = de_getu16le(12);
	de_dbg_dimensions(c, d->w, d->h);
	if(!de_good_image_dimensions(c, d->w, d->h)) goto done;

	nol_ngg_read_bitmap(c, d, 20);
done:
	de_free(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rdi
pushq $0xa
popq %rsi
callq 0xe3fa3
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
pushq $0xc
popq %rsi
callq 0xe3fa3
movq %rax, 0x8(%r14)
movq (%r14), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdf038
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xe6be1
testl %eax, %eax
je 0x95bb4
pushq $0x14
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95fe2
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_module_ngg
void de_module_ngg(deark *c, struct deark_module_info *mi)
{
	mi->id = "ngg";
	mi->desc = "Nokia Group Graphic";
	mi->run_fn = de_run_ngg;
	mi->identify_fn = de_identify_ngg;
}

// Assembly:
leaq 0x8e75f(%rip), %rax     # 0x12434e
movq %rax, (%rsi)
leaq 0x8e759(%rip), %rax     # 0x124352
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x95c14
movq %rax, 0x18(%rsi)
leaq 0x77(%rip), %rax        # 0x95c86
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_run_ngg
static void de_run_ngg(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	d->w = de_getu16le(6);
	d->h = de_getu16le(8);
	de_dbg_dimensions(c, d->w, d->h);
	if(!de_good_image_dimensions(c, d->w, d->h)) goto done;

	nol_ngg_read_bitmap(c, d, 16);
done:
	de_free(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rdi
pushq $0x6
popq %rsi
callq 0xe3fa3
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0xe3fa3
movq %rax, 0x8(%r14)
movq (%r14), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdf038
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xe6be1
testl %eax, %eax
je 0x95c74
pushq $0x10
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95fe2
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_module_npm
void de_module_npm(deark *c, struct deark_module_info *mi)
{
	mi->id = "npm";
	mi->desc = "Nokia Picture Message";
	mi->run_fn = de_run_npm;
	mi->identify_fn = de_identify_npm;
}

// Assembly:
leaq 0x8e6b7(%rip), %rax     # 0x124366
movq %rax, (%rsi)
leaq 0x8e6b1(%rip), %rax     # 0x12436a
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x95cd4
movq %rax, 0x18(%rsi)
leaq 0x117(%rip), %rax       # 0x95de6
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_run_npm
static void de_run_npm(deark *c, de_module_params *mparams)
{
	i64 txt_len;
	i64 pos;
	lctx *d = NULL;
	de_ucstring *s = NULL;

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

	pos = 4;
	txt_len = (i64)de_getbyte_p(&pos);
	de_dbg(c, "text length: %d", (int)txt_len);
	if(txt_len>0) {
		s = ucstring_create(c);
		dbuf_read_to_ucstring(c->infile, pos, txt_len, s, 0, DE_ENCODING_ASCII);
		de_dbg(c, "text: \"%s\"", ucstring_getpsz_d(s));
		pos += txt_len;
	}
	pos += 1;

	d->w = (i64)de_getbyte_p(&pos);
	d->h = (i64)de_getbyte_p(&pos);
	de_dbg_dimensions(c, d->w, d->h);

	pos += 3;
	npm_nlm_read_bitmap(c, d, pos);

	ucstring_destroy(s);
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0xdecaf
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq $0x4, (%rsi)
movq 0x18(%rbx), %rdi
callq 0xe3f2a
movzbl %al, %r12d
leaq 0x7692f(%rip), %rsi     # 0x10c63e
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xde896
testb %r12b, %r12b
je 0x95d6a
movq %rbx, %rdi
callq 0xeac74
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
pushq $0x1
popq %r9
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0xe4c9a
movq %r15, %rdi
callq 0xeb877
leaq 0x9805e(%rip), %rsi     # 0x12ddb4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
addq 0x8(%rsp), %r12
jmp 0x95d72
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
incq %r12
leaq 0x8(%rsp), %r13
movq %r12, (%r13)
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0xe3f2a
movzbl %al, %eax
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0xe3f2a
movzbl %al, %edx
movq %rdx, 0x8(%r14)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xdf038
movq (%r13), %rdx
addq $0x3, %rdx
movq %rdx, (%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9606d
movq %r15, %rdi
callq 0xeaf3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xded32
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_module_nlm
void de_module_nlm(deark *c, struct deark_module_info *mi)
{
	mi->id = "nlm";
	mi->desc = "Nokia Logo Manager bitmap";
	mi->run_fn = de_run_nlm;
	mi->identify_fn = de_identify_nlm;
}

// Assembly:
leaq 0x8e571(%rip), %rax     # 0x124380
movq %rax, (%rsi)
leaq 0x8e56b(%rip), %rax     # 0x124384
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x95e34
movq %rax, 0x18(%rsi)
leaq 0xa2(%rip), %rax        # 0x95ed1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_run_nlm
static void de_run_nlm(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	u8 imgtype;
	const char *s;

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

	imgtype = de_getbyte(5);
	switch(imgtype) {
	case 0: s="Operator logo"; break;
	case 1: s="Caller logo"; break;
	case 2: s="Startup logo"; break;
	case 3: s="Picture image logo"; break;
	default: s="unknown";
	}
	de_dbg(c, "image type: %d (%s)", (int)imgtype, s);

	d->w = (i64)de_getbyte(7);
	d->h = (i64)de_getbyte(8);
	de_dbg_dimensions(c, d->w, d->h);

	npm_nlm_read_bitmap(c, d, 10);

	de_free(c, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq 0x18(%rbx), %rdi
pushq $0x5
popq %rsi
callq 0xe3eb4
movzbl %al, %edx
cmpb $0x3, %al
ja 0x95e69
leaq 0x8e5f4(%rip), %rax     # 0x124454
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmp 0x95e70
leaq 0x6f60c(%rip), %rcx     # 0x10547c
leaq 0x8e584(%rip), %rsi     # 0x1243fb
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde896
movq 0x18(%rbx), %rdi
pushq $0x7
popq %rsi
callq 0xe3eb4
movzbl %al, %eax
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0xe3eb4
movzbl %al, %edx
movq %rdx, 0x8(%r14)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xdf038
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9606d
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_module_nsl
void de_module_nsl(deark *c, struct deark_module_info *mi)
{
	mi->id = "nsl";
	mi->desc = "Nokia Startup Logo";
	mi->run_fn = de_run_nsl;
	mi->identify_fn = de_identify_nsl;
}

// Assembly:
leaq 0x8e4a4(%rip), %rax     # 0x12439e
movq %rax, (%rsi)
leaq 0x8e49e(%rip), %rax     # 0x1243a2
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x95f1f
movq %rax, 0x18(%rsi)
leaq 0x68(%rip), %rax        # 0x95f82
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_run_nsl
static void de_run_nsl(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	struct de_iffctx *ictx = NULL;

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

	ictx->userdata = (void*)d;
	ictx->handle_chunk_fn = my_nsl_chunk_handler;
	ictx->f = c->infile;
	ictx->sizeof_len = 2;

	fmtutil_read_iff_format(ictx, 0, c->infile->len);

	fmtutil_destroy_iff_decoder(ictx);
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0xdecaf
movq %rax, %r14
movq %rbx, %rdi
callq 0xfacc0
movq %rax, %r15
movq %r14, 0x10(%rax)
leaq 0x15a(%rip), %rax       # 0x960a2
movq %rax, 0x20(%r15)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r15)
movq $0x2, 0x50(%r15)
movq 0x18(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0xface4
movq %r15, %rdi
callq 0xfacd3
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: de_identify_nsl
static int de_identify_nsl(deark *c)
{
	i64 x;

	// NSL uses a variant of IFF, which is not so easy to identify.
	// (TODO: Write an IFF format detector.)

	if(dbuf_memcmp(c->infile, 0, "FORM", 4)) return 0;

	x = de_getu16be(4);
	if(x+6 != c->infile->len) return 0;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x7836f(%rip), %rdx     # 0x10e303
xorl %ebx, %ebx
pushq $0x4
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
jne 0x95fd8
movq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
callq 0xe3f46
addq $0x6, %rax
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rax
jne 0x95fd8
leaq 0x8e3d9(%rip), %rsi     # 0x12439e
movq %r14, %rdi
callq 0xdfcd5
testl %eax, %eax
pushq $0xa
popq %rax
pushq $0x64
popq %rbx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: nol_ngg_read_bitmap
static void nol_ngg_read_bitmap(deark *c, lctx *d, i64 pos)
{
	de_bitmap *img = NULL;
	i64 i, j;
	u8 n;

	img = de_bitmap_create(c, d->w, d->h, 1);

	for(j=0; j<d->h; j++) {
		for(i=0; i<d->w; i++) {
			n = de_getbyte(pos);
			pos++;
			de_bitmap_setpixel_gray(img, i, j, n=='0' ? 255 : 0);
		}
	}

	de_bitmap_write_to_file(img, NULL, DE_CREATEFLAG_IS_BWIMG);
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
pushq $0x1
popq %rcx
callq 0xe7437
movq %rax, %r15
xorl %r13d, %r13d
cmpq 0x8(%rbx), %r13
jge 0x9604a
xorl %ebp, %ebp
leaq (%r12,%rbp), %rsi
cmpq (%rbx), %rbp
jge 0x96042
movq 0x18(%r14), %rdi
callq 0xe3eb4
cmpb $0x30, %al
sete %al
negb %al
movzbl %al, %ecx
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xe71da
incq %rbp
jmp 0x96013
incq %r13
movq %rsi, %r12
jmp 0x9600b
pushq $0x8
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0xe70b7
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe7084
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/nokia.c
// Function: my_nsl_chunk_handler
static int my_nsl_chunk_handler(struct de_iffctx *ictx)
{
	deark *c = ictx->c;
	lctx *d = (lctx*)ictx->userdata;

	if(ictx->chunkctx->chunk4cc.id == CODE_FORM) {
		ictx->is_raw_container = 1;
		return 1;
	}

	switch(ictx->chunkctx->chunk4cc.id) {
	case CODE_NSLD:
		if(ictx->level==1 && !d->done_flag) {
			nsl_read_bitmap(c, d, ictx->chunkctx->dpos, ictx->chunkctx->dlen);
		}
		ictx->handled = 1;
		break;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x128(%rdi), %rax
movl 0x4(%rax), %ecx
cmpl $0x464f524d, %ecx       # imm = 0x464F524D
je 0x961b8
cmpl $0x4e534c44, %ecx       # imm = 0x4E534C44
jne 0x961c4
movl $0x130, %ecx            # imm = 0x130
cmpl $0x1, 0x64(%rdi)
jne 0x961bd
movq 0x10(%rdi), %rbx
cmpl $0x0, 0x10(%rbx)
jne 0x961bd
movq %rdi, 0x10(%rsp)
movq (%rdi), %r14
movq 0x40(%rax), %r15
movq 0x48(%rax), %r13
leaq 0x8e30e(%rip), %rsi     # 0x124414
movq %r14, %rdi
movl %r15d, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0xde896
movl $0x1, 0x10(%rbx)
cmpq $0x1f8, %r13            # imm = 0x1F8
jne 0x961d6
movq $0x54, (%rbx)
movq $0x30, 0x8(%rbx)
pushq $0x54
popq %rsi
pushq $0x30
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0xe7437
movq %rax, (%rsp)
xorl %eax, %eax
cmpq 0x8(%rbx), %rax
jge 0x961ee
movq %rax, %r13
shrq $0x3, %r13
movq %rax, 0x8(%rsp)
movl %eax, %ecx
andb $0x7, %cl
movb $0x1, %r12b
shlb %cl, %r12b
xorl %ebp, %ebp
movq (%rbx), %rsi
cmpq %rsi, %rbp
jge 0x961ae
movq 0x18(%r14), %rdi
imulq %r13, %rsi
addq %r15, %rsi
addq %rbp, %rsi
callq 0xe3eb4
testb %r12b, %al
jne 0x961a9
movq (%rsp), %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movl $0xff, %ecx
callq 0xe71da
incq %rbp
jmp 0x96173
movq 0x8(%rsp), %rax
incq %rax
jmp 0x96150
movl $0x138, %ecx            # imm = 0x138
movl $0x1, (%rdi,%rcx)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8e24c(%rip), %rsi     # 0x124429
xorl %ebx, %ebx
movq %r14, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0xdf2a5
jmp 0x961ff
pushq $0x8
popq %rdx
movq (%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe70b7
movq %rbx, %rdi
callq 0xe7084
movq 0x10(%rsp), %rdi
movl $0x130, %ecx            # imm = 0x130
jmp 0x961bd
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/os2bmp.c
// Function: de_module_os2bmp
void de_module_os2bmp(deark *c, struct deark_module_info *mi)
{
	mi->id = "os2bmp";
	mi->desc = "OS/2 icon (.ICO), cursor (.PTR), bitmap array";
	mi->run_fn = de_run_os2bmp;
	mi->identify_fn = de_identify_os2bmp;
}

// Assembly:
leaq 0x8e331(%rip), %rax     # 0x12454c
movq %rax, (%rsi)
leaq 0x8e32e(%rip), %rax     # 0x124553
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x96240
movq %rax, 0x18(%rsi)
leaq 0x677(%rip), %rax       # 0x968b2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/os2bmp.c
// Function: de_identify_os2bmp_internal
static enum fmtcode de_identify_os2bmp_internal(deark *c)
{
	enum fmtcode fmt;
	u8 b[16];

	de_read(b, 0, 16);

	fmt = bytes_to_fmtcode(b[0], b[1]);
	if(fmt==DE_OS2FMT_BA) {
		enum fmtcode ba_fmt;

		// A Bitmap Array file can contain a mixture of different image types,
		// but for the purposes of identifying the file type, we only look at
		// the first one. This is not ideal, but it really doesn't matter.
		ba_fmt = bytes_to_fmtcode(b[14], b[15]);
		if(ba_fmt==DE_OS2FMT_IC) return DE_OS2FMT_BA_IC;
		if(ba_fmt==DE_OS2FMT_PT) return DE_OS2FMT_BA_PT;
		if(ba_fmt==DE_OS2FMT_CI) return DE_OS2FMT_BA_CI;
		if(ba_fmt==DE_OS2FMT_CP) return DE_OS2FMT_BA_CP;
		if(ba_fmt==DE_OS2FMT_BM) return DE_OS2FMT_BA_BM;
		return DE_OS2FMT_BA;
	}
	if(fmt==DE_OS2FMT_IC) return DE_OS2FMT_IC;
	if(fmt==DE_OS2FMT_PT) return DE_OS2FMT_PT;
	if(fmt==DE_OS2FMT_CI) return DE_OS2FMT_CI;
	if(fmt==DE_OS2FMT_CP) return DE_OS2FMT_CP;
	return DE_OS2FMT_UNKNOWN;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x18(%rdi), %rdi
movq %rsp, %rbx
pushq $0x10
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe3cb7
movzbl (%rbx), %edi
movzbl 0x1(%rbx), %esi
callq 0x9693e
cmpl $0xa, %eax
ja 0x96935
movl $0x550, %ecx            # imm = 0x550
btl %eax, %ecx
jae 0x9690b
addq $0x10, %rsp
popq %rbx
retq
cmpl $0x1, %eax
jne 0x96935
movzbl 0xe(%rsp), %edi
movzbl 0xf(%rsp), %esi
callq 0x9693e
addl $-0x2, %eax
cmpl $0x9, %eax
jae 0x96939
movl %eax, %eax
leaq 0x8dbcc(%rip), %rcx     # 0x1244fc
movl (%rcx,%rax,4), %eax
jmp 0x96905
xorl %eax, %eax
jmp 0x96905
pushq $0x1
popq %rax
jmp 0x96905
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/os2bmp.c
// Function: bytes_to_fmtcode
static enum fmtcode bytes_to_fmtcode(u8 b0, u8 b1)
{
	if(b0=='C' && b1=='I') {
		return DE_OS2FMT_CI;
	}
	else if(b0=='C' && b1=='P') {
		return DE_OS2FMT_CP;
	}
	else if(b0=='I' && b1=='C') {
		return DE_OS2FMT_IC;
	}
	else if(b0=='P' && b1=='T') {
		return DE_OS2FMT_PT;
	}
	else if(b0=='B' && b1=='M') {
		return DE_OS2FMT_BM;
	}
	else if(b0=='B' && b1=='A') {
		return DE_OS2FMT_BA;
	}
	return DE_OS2FMT_UNKNOWN;
}

// Assembly:
movl %edi, %eax
xorb $0x43, %al
movl %esi, %ecx
xorb $0x49, %cl
orb %al, %cl
jne 0x9694f
pushq $0x8
jmp 0x9698d
movl %esi, %ecx
xorb $0x50, %cl
orb %cl, %al
jne 0x9695c
pushq $0xa
jmp 0x9698d
movl %edi, %eax
xorb $0x49, %al
movl %esi, %ecx
xorb $0x43, %cl
orb %al, %cl
jne 0x9696d
pushq $0x4
jmp 0x9698d
movl %edi, %eax
xorb $0x50, %al
movl %esi, %ecx
xorb $0x54, %cl
orb %al, %cl
jne 0x9697e
pushq $0x6
jmp 0x9698d
xorb $0x42, %dil
movl %esi, %eax
xorb $0x4d, %al
orb %dil, %al
jne 0x9698f
pushq $0x2
popq %rax
retq
xorb $0x41, %sil
xorl %eax, %eax
orb %sil, %dil
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/os2bmp.c
// Function: do_free_srcbmp
static void do_free_srcbmp(deark *c, struct srcbitmap *srcbmp)
{
	if(!srcbmp) return;
	if(srcbmp->img) {
		de_bitmap_destroy(srcbmp->img);
	}
	de_free(c, srcbmp);
}

// Assembly:
testq %rsi, %rsi
je 0x969ea
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x969d8
callq 0xe7084
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
retq