LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_run_cazip
static void de_run_cazip(deark *c, de_module_params *mparams)
{
	de_arch_lctx *d = NULL;
	struct de_arch_member_data *md = NULL;
	i64 pos;
	UI verfield, field10, field12, field18;

	d = de_arch_create_lctx(c);
	d->is_le = 1;
	d->crco = de_crcobj_create(c, DE_CRCOBJ_CRC32_IEEE);

	md = de_arch_create_md(c, d);
	//d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_CP437);

	pos = 8;
	verfield = (UI)de_getu16be_p(&pos);
	field10 = (UI)de_getu16le_p(&pos);
	field12 = (UI)de_getu16le_p(&pos);

	md->crc_reported = (u32)de_getu32le_p(&pos);
	de_dbg(c, "crc (reported): 0x%08x", (UI)md->crc_reported);

	field18 = (UI)de_getu16le_p(&pos);

	if(verfield!=0x3333 || field10!=1 || field12!=1 || field18!=0) {
		de_warn(c, "This version of CAZIP file might not be handled correctly");
	}

	md->cmpr_pos = pos;
	md->cmpr_len = c->infile->len - md->cmpr_pos;
	if(!de_arch_good_cmpr_data_pos(md)) {
		goto done;
	}

	md->dfn = dclimplode_decompressor_fn;
	md->validate_crc = 1;
	de_arch_extract_member_file(md);

done:
	if(md) {
		de_arch_destroy_md(c, md);
		md = NULL;
	}
	if(d) {
		de_arch_destroy_lctx(c, d);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xfdb0a
movq %rax, %r14
movl $0x1, 0x10(%rax)
movq %rbx, %rdi
movl $0x10, %esi
callq 0xeba56
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfda6c
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq $0x8, (%r12)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef193
movq %rax, %r13
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef1ed
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef1ed
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef3a0
movl %eax, 0x48(%r15)
leaq 0xd4dc5(%rip), %rsi     # 0x143d85
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xef1ed
cmpl $0x3333, %r13d          # imm = 0x3333
jne 0x6eff8
movl %ebp, %ecx
cmpl $0x1, %ecx
jne 0x6eff8
movl 0x8(%rsp), %ecx
cmpl $0x1, %ecx
jne 0x6eff8
movl %eax, %eax
testq %rax, %rax
je 0x6f009
leaq 0xb7021(%rip), %rsi     # 0x126020
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9b27
movq 0x10(%rsp), %rax
movq %rax, 0x40(%r15)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x30(%r15)
movq %r15, %rdi
callq 0xfde12
testl %eax, %eax
je 0x6f04b
leaq 0x2863(%rip), %rax      # 0x71897
movq %rax, 0xa8(%r15)
movb $0x1, 0xa1(%r15)
movq %r15, %rdi
callq 0xfdec1
testq %r15, %r15
je 0x6f05b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfdab8
testq %r14, %r14
je 0x6f06b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfdb25
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_cmz
void de_module_cmz(deark *c, struct deark_module_info *mi)
{
	mi->id = "cmz";
	mi->desc = "CMZ installer archive";
	mi->run_fn = de_run_cmz;
	mi->identify_fn = de_identify_cmz;
}

// Assembly:
leaq 0xb6958(%rip), %rax     # 0x1259ff
movq %rax, (%rsi)
leaq 0xb6952(%rip), %rax     # 0x125a03
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6f0cc
movq %rax, 0x18(%rsi)
leaq 0x27a(%rip), %rax       # 0x6f341
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_identify_cmz
static int de_identify_cmz(deark *c)
{
	i64 name_len;
	i64 cmpr_len;

	if(!cmz_sig_at(c, 0)) {
		return 0;
	}

	cmpr_len = de_getu32le(4);
	name_len = de_getu16le(16);
	if(cmpr_len==0 && name_len>0) {
		return 60;
	}
	if(dclimplode_header_at(c, 20+name_len)) {
		return 100;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xb6d51(%rip), %rdx     # 0x1260a4
xorl %r14d, %r14d
movl $0x4, %ecx
xorl %esi, %esi
callq 0xf025e
testl %eax, %eax
jne 0x6f3b6
movq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0xef37e
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x10, %esi
callq 0xef1ca
testq %r14, %r14
sete %cl
testq %rax, %rax
setg %dl
movl $0x3c, %r14d
testb %dl, %cl
jne 0x6f3b6
addq $0x14, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x71d2e
testl %eax, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_pcshrink
void de_module_pcshrink(deark *c, struct deark_module_info *mi)
{
	mi->id = "pcshrink";
	mi->desc = "PC-Install compressed archive";
	mi->run_fn = de_run_pcshrink;
	mi->identify_fn = de_identify_pcshrink;
}

// Assembly:
leaq 0xb6651(%rip), %rax     # 0x125a19
movq %rax, (%rsi)
leaq 0xb6650(%rip), %rax     # 0x125a22
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6f3ed
movq %rax, 0x18(%rsi)
leaq 0x2f9(%rip), %rax       # 0x6f6e1
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_identify_pcshrink
static int de_identify_pcshrink(deark *c)
{
	u8 multipart_flag;
	int ver;

	ver = detect_pcshrink_internal(c, &multipart_flag);
	if(ver==1) {
		return 60;
	}
	else if(ver==2) {
		if(multipart_flag) return 40;
		return 80;
	}

	return 0;
}

// Assembly:
pushq %rax
leaq 0x7(%rsp), %rsi
callq 0x71d6e
cmpl $0x1, %eax
je 0x6f70a
cmpl $0x2, %eax
jne 0x6f711
cmpb $0x0, 0x7(%rsp)
movl $0x50, %ecx
movl $0x28, %eax
cmovel %ecx, %eax
jmp 0x6f713
movl $0x3c, %eax
jmp 0x6f713
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_arcv
void de_module_arcv(deark *c, struct deark_module_info *mi)
{
	mi->id = "arcv";
	mi->desc = "ARCV installer archive";
	mi->run_fn = de_run_arcv;
	mi->identify_fn = de_identify_arcv;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xb6324(%rip), %rax     # 0x125a40
movq %rax, (%rsi)
leaq 0xb631f(%rip), %rax     # 0x125a45
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6f745
movq %rax, 0x18(%rsi)
leaq 0x38d(%rip), %rax       # 0x6fac9
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_identify_arcv
static int de_identify_arcv(deark *c)
{
	u8 ver;

	if((UI)de_getu32be(0) != CODE_ARCV) return 0;
	ver = de_getbyte(5);
	if(ver==1 || ver==2) {
		return 100;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef32a
cmpl $0x41524356, %eax       # imm = 0x41524356
jne 0x6fb00
movq 0x18(%r14), %rdi
movl $0x5, %esi
callq 0xef0d5
decb %al
xorl %ecx, %ecx
cmpb $0x2, %al
movl $0x64, %ebx
cmovael %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_red
void de_module_red(deark *c, struct deark_module_info *mi)
{
	mi->id = "red";
	mi->desc = "RED installer archive (Knowledge Dynamics Corp)";
	mi->run_fn = de_run_red;
	mi->identify_fn = de_identify_red;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xcdba1(%rip), %rax     # 0x13d6b2
movq %rax, (%rsi)
leaq 0xb5f41(%rip), %rax     # 0x125a5c
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x6fb3a
movq %rax, 0x18(%rsi)
leaq 0x243(%rip), %rax       # 0x6fd74
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_lif_kdc
void de_module_lif_kdc(deark *c, struct deark_module_info *mi)
{
	mi->id = "lif_kdc";
	mi->desc = "LIF installer archive (Knowledge Dynamics Corp)";
	mi->run_fn = de_run_lif_kdc;
	mi->identify_fn = de_identify_lif_kdc;
}

// Assembly:
leaq 0xb5cf4(%rip), %rax     # 0x125a8c
movq %rax, (%rsi)
leaq 0xb5cf2(%rip), %rax     # 0x125a94
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x6fdbd
movq %rax, 0x18(%rsi)
leaq 0x360(%rip), %rax       # 0x70118
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_identify_lif_kdc
static int de_identify_lif_kdc(deark *c)
{
	i64 cmprmeth;
	int errflag = 0;
	int has_ext;
	u8 b;
	i64 i;
	i64 n[4];

	cmprmeth = lif_read_field(c->infile, 32, 2, &errflag);
	if(errflag) return 0;
	if(cmprmeth<1 || cmprmeth>3) return 0;

	b = de_getbyte(34); // 1st char of filename
	if(b<32) return 0;
	b = de_getbyte(53); // last char of NUL-padded filename field??
	if(b!=0) return 0;

	for(i=0; i<4; i++) {
		n[i] = lif_read_field(c->infile, 8*i, 8, &errflag);
		if(errflag) return 0;
	}
	if(54+n[1] > c->infile->len) return 0; // File too short

	has_ext = de_input_file_has_ext(c, "lif");
	return has_ext ? 45 : 15;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
movq 0x18(%rdi), %rdi
movl $0x20, %esi
movl $0x2, %edx
movq %r15, %rcx
callq 0x7203b
xorl %ebx, %ebx
cmpl $0x0, (%r15)
jne 0x7017e
addq $-0x4, %rax
cmpq $-0x3, %rax
jb 0x7017e
movq 0x18(%r14), %rdi
movl $0x22, %esi
callq 0xef0d5
cmpb $0x20, %al
jb 0x7017e
movq 0x18(%r14), %rdi
movl $0x35, %esi
callq 0xef0d5
testb %al, %al
je 0x7018c
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
xorl %r12d, %r12d
movq 0x18(%r14), %rdi
movl $0x8, %edx
movq %r12, %rsi
movq %r15, %rcx
callq 0x7203b
movq %rax, 0x10(%rsp,%r12)
cmpl $0x0, 0xc(%rsp)
jne 0x7017e
addq $0x8, %r12
cmpq $0x20, %r12
jne 0x70196
movq 0x18(%rsp), %rax
addq $0x36, %rax
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rax
jg 0x7017e
leaq 0xae9c7(%rip), %rsi     # 0x11eba1
movq %r14, %rdi
callq 0xea936
testl %eax, %eax
movl $0xf, %eax
movl $0x2d, %ebx
cmovel %eax, %ebx
jmp 0x7017e
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_ain
void de_module_ain(deark *c, struct deark_module_info *mi)
{
	mi->id = "ain";
	mi->desc = "AIN archive";
	mi->run_fn = de_run_ain;
	mi->flags |= DE_MODFLAG_HIDDEN;
	mi->identify_fn = de_identify_ain;
}

// Assembly:
leaq 0xcdebd(%rip), %rax     # 0x13e0b7
movq %rax, (%rsi)
leaq 0xb58c0(%rip), %rax     # 0x125ac4
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x70223
movq %rax, 0x18(%rsi)
orb $0x1, 0x30(%rsi)
leaq 0x229(%rip), %rax       # 0x70447
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_run_ain
static void de_run_ain(deark *c, de_module_params *mparams)
{
	de_arch_lctx *d = NULL;

	d = de_arch_create_lctx(c);
	d->is_le = 1;
	do_ain_main(c, d);
	de_arch_destroy_lctx(c, d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xfdb0a
movq %rax, %r14
movl $0x1, 0x10(%rax)
leaq 0xb587a(%rip), %rsi     # 0x125ac4
movq %rbx, %rdi
callq 0xeb6d6
cmpl $0x1, 0x24(%rbx)
jne 0x70269
leaq 0xb5ff5(%rip), %rsi     # 0x126254
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9ef5
movq %rsp, %r15
movq $0x1, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef14d
movzbl %al, %ebp
movl %ebp, %edx
shrl $0x4, %edx
leaq 0xb5ffa(%rip), %rsi     # 0x126288
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
andl $0xf, %ebp
leaq 0xb5ff9(%rip), %rsi     # 0x12629b
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
incq (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef14d
movzbl %al, %edx
leaq 0xbfaa3(%rip), %rsi     # 0x12fd6a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef1ed
leaq 0xc2286(%rip), %rsi     # 0x13256e
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq $0x8, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef1ed
movq %rax, 0x20(%r14)
leaq 0xa434a(%rip), %rsi     # 0x11465c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
leaq 0xa69cd(%rip), %rdx     # 0x116cf3
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x4, %ecx
movq %r15, %r8
callq 0xfdc9b
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef3a0
movq %rax, %r12
leaq 0xb5f5d(%rip), %rsi     # 0x1262ae
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %r13
subq %r12, %r13
movq %r15, %rsi
callq 0xef1ed
leaq 0xb5f4b(%rip), %rsi     # 0x1262c3
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x30, %ecx
callq 0xebf42
movzwl %ax, %edx
leaq 0xb5f49(%rip), %rsi     # 0x1262eb
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
addq $0x2, (%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xef1ed
leaq 0xb5f52(%rip), %rsi     # 0x126315
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
movl $0x16, %edx
xorl %esi, %esi
movl $0x30, %ecx
callq 0xebf42
xorl $0x5555, %eax           # imm = 0x5555
leaq 0xb5f4d(%rip), %rsi     # 0x12633d
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq (%r15), %rdx
movq %r12, %rcx
subq %rdx, %rcx
leaq 0xc72e7(%rip), %rsi     # 0x1376f3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
leaq 0xb5f4a(%rip), %rsi     # 0x126367
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0xe9226
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfdb25
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_identify_ain
static int de_identify_ain(deark *c)
{
	UI hdr_checksum_reported;
	UI hdr_checksum_calc;
	int has_ext;
	i64 member_hdrs_pos;

	if(de_getbyte(0)!=0x21) return 0;
	if(de_getbyte(2)!=0x00) return 0;
	member_hdrs_pos = de_getu32le(14);
	if(member_hdrs_pos<24 || member_hdrs_pos>=c->infile->len) return 0;
	hdr_checksum_reported = (UI)de_getu16le(22);
	ain_calc_hdr_checksum(c, &hdr_checksum_calc);
	if(hdr_checksum_calc != hdr_checksum_reported) return 0;
	has_ext = de_input_file_has_ext(c, "ain");
	return has_ext?100:50;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef0d5
cmpb $0x21, %al
jne 0x704e0
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0xef0d5
testb %al, %al
jne 0x704e0
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xef37e
cmpq $0x18, %rax
jl 0x704e0
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rax
jge 0x704e0
movl $0x16, %esi
callq 0xef1ca
movq %rax, %r15
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
movl $0x16, %edx
xorl %esi, %esi
movl $0x30, %ecx
callq 0xebf42
xorl %r15d, %eax
cmpl $0x5555, %eax           # imm = 0x5555
jne 0x704e0
leaq 0xcdbf0(%rip), %rsi     # 0x13e0b7
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0x32, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_hta
void de_module_hta(deark *c, struct deark_module_info *mi)
{
	mi->id = "hta";
	mi->desc = "Hemera thumbnails";
	mi->run_fn = de_run_hta;
	mi->identify_fn = de_identify_hta;
}

// Assembly:
leaq 0xb55e0(%rip), %rax     # 0x125ad0
movq %rax, (%rsi)
leaq 0xb55da(%rip), %rax     # 0x125ad4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x70515
movq %rax, 0x18(%rsi)
leaq 0x2a7(%rip), %rax       # 0x707b7
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_hit
void de_module_hit(deark *c, struct deark_module_info *mi)
{
	mi->id = "hit";
	mi->desc = "HIT archive";
	mi->run_fn = de_run_hit;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
	mi->identify_fn = de_identify_hit;
}

// Assembly:
leaq 0xb5302(%rip), %rax     # 0x125ae6
movq %rax, (%rsi)
leaq 0xb52fc(%rip), %rax     # 0x125aea
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x7080d
movq %rax, 0x18(%rsi)
orb $0x20, 0x30(%rsi)
leaq 0x30b(%rip), %rax       # 0x70b13
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_binary_ii
void de_module_binary_ii(deark *c, struct deark_module_info *mi)
{
	mi->id = "binary_ii";
	mi->desc = "Binary II";
	mi->run_fn = de_run_binary_ii;
	mi->identify_fn = de_identify_binary_ii;
}

// Assembly:
leaq 0xb4fa8(%rip), %rax     # 0x125af6
movq %rax, (%rsi)
leaq 0xb4fa8(%rip), %rax     # 0x125b00
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x70b73
movq %rax, 0x18(%rsi)
leaq 0x598(%rip), %rax       # 0x71106
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_module_tc_trs80
void de_module_tc_trs80(deark *c, struct deark_module_info *mi)
{
	mi->id = "tc_trs80";
	mi->desc = "The Compressor (TRS-80 archive)";
	mi->run_fn = de_run_tc_trs80;
	mi->identify_fn = de_identify_tc_trs80;
}

// Assembly:
leaq 0xb49e1(%rip), %rax     # 0x125b0a
movq %rax, (%rsi)
leaq 0xb49e0(%rip), %rax     # 0x125b13
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x7114e
movq %rax, 0x18(%rsi)
leaq 0x389(%rip), %rax       # 0x714d2
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: de_identify_tc_trs80
static int de_identify_tc_trs80(deark *c)
{
	int has_ext = 0;
	u8 b;
	i64 n;
	i64 i;

	if(de_getbyte(0)!=1) return 0; // seq num #1
	if(de_getbyte(14)!=1) return 0; // format ver
	if(de_getbyte(18) >= 2) return 0; // cmpr meth

	for(i=0; i<11; i++) { // filename
		b = de_getbyte(1+i);
		if(b<32) return 0;
		if(i==0 && b==32) return 0;
	}

	b = de_getbyte(13); // ascii flag
	if(b!=0 && b!=255) return 0;

	n = (de_getu32be(14) & 0xffffff) + 19; // offset of member #2
	if(n >= c->infile->len) return 0;
	b = de_getbyte(n); // seq num #2
	if(b!=0 && b!=2) return 0;
	if(b!=0) {
		if(n+1+18+1 > c->infile->len) return 0;
	}

	if(de_input_file_has_ext(c, "arc")) has_ext = 1;
	else if(de_input_file_has_ext(c, "tc")) has_ext = 1;
	if(has_ext) return 75;
	else return 15;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef0d5
cmpb $0x1, %al
jne 0x715f2
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xef0d5
cmpb $0x1, %al
jne 0x715f2
movq 0x18(%rbx), %rdi
movl $0x12, %esi
callq 0xef0d5
cmpb $0x1, %al
ja 0x715f2
movl $0xb, %r12d
xorl %r13d, %r13d
movq 0x18(%rbx), %rdi
subq $0x1, %r12
jb 0x71561
leaq 0x1(%r13), %r15
movq %r15, %rsi
callq 0xef0d5
xorl %r14d, %r14d
cmpb $0x20, %al
jb 0x715f2
testq %r13, %r13
sete %cl
cmpb $0x20, %al
sete %al
movq %r15, %r13
testb %al, %cl
je 0x71529
jmp 0x715f2
movl $0xd, %esi
callq 0xef0d5
decb %al
xorl %r14d, %r14d
cmpb $-0x2, %al
jb 0x715f2
movq 0x18(%rbx), %rdi
movl $0xe, %esi
callq 0xef32a
movq %rax, %r15
andl $0xffffff, %r15d        # imm = 0xFFFFFF
leaq 0x13(%r15), %rsi
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %rsi
jge 0x715f2
callq 0xef0d5
testb %al, %al
je 0x715b9
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x715f2
addq $0x27, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%rax), %r15
jg 0x715f2
leaq 0xade9a(%rip), %rsi     # 0x11f45a
movq %rbx, %rdi
callq 0xea936
movl $0x4b, %r14d
testl %eax, %eax
jne 0x715f2
leaq 0xd013f(%rip), %rsi     # 0x141718
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0xf, %eax
movl $0x4b, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: cpshrink_decompressor_fn
static void cpshrink_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	switch(md->cmpr_meth) {
	case 0:
	case 1:
		fmtutil_dclimplode_codectype1(c, md->dcmpri, md->dcmpro, md->dres, NULL);
		break;
	case 2:
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
		break;
	default:
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
cmpl $0x2, 0x90(%rax)
jae 0x7162b
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0x10117f
jne 0x7164a
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xfaa08
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xfa815
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: dwc_decompressor_fn
static void dwc_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	if(md->cmpr_meth==1) {
		struct de_lzw_params delzwp;

		de_zeromem(&delzwp, sizeof(struct de_lzw_params));
		delzwp.fmt = DE_LZWFMT_DWC;
		fmtutil_decompress_lzw(c, md->dcmpri, md->dcmpro, md->dres, &delzwp);
	}
	else if(md->cmpr_meth==2) {
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
	}
	else {
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x90(%rax), %ecx
cmpl $0x2, %ecx
je 0x716aa
cmpl $0x1, %ecx
jne 0x716c7
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x0, 0x10(%r8)
movl $0x8, (%r8)
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
callq 0x102cf0
addq $0x18, %rsp
retq
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xfaa08
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xfa815
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: mdcd_decompressor_fn
static void mdcd_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	if(md->cmpr_meth==1) {
		struct de_lzw_params delzwp;

		de_zeromem(&delzwp, sizeof(struct de_lzw_params));
		delzwp.fmt = DE_LZWFMT_ZOOLZD;
		fmtutil_decompress_lzw(c, md->dcmpri, md->dcmpro, md->dres, &delzwp);
	}
	else if(md->cmpr_meth==0) {
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
	}
	else {
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x90(%rax), %ecx
testl %ecx, %ecx
je 0x71d03
cmpl $0x1, %ecx
jne 0x71d20
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x0, 0x10(%r8)
movl $0x4, (%r8)
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
callq 0x102cf0
addq $0x18, %rsp
retq
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movq 0xc0(%rax), %rcx
xorl %r8d, %r8d
jmp 0xfaa08
movq 0xc0(%rax), %rsi
xorl %edx, %edx
jmp 0xfa815
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: dclimplode_header_at
static int dclimplode_header_at(deark *c, i64 pos)
{
	u8 b;

	b = de_getbyte(pos);
	if(b>1) return 0;
	b = de_getbyte(pos+1);
	if(b<4 || b>6) return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0xef0d5
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x1, %cl
ja 0x71d66
movq 0x18(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0xef0d5
movl %eax, %ecx
addb $-0x4, %cl
xorl %eax, %eax
cmpb $0x3, %cl
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: detect_pcshrink_internal
static int detect_pcshrink_internal(deark *c, u8 *pmultipart_flag)
{
	u8 b;
	UI n;
	i64 cmpr_len;

	*pmultipart_flag = 0;
	b = de_getbyte(13);
	if(b==0x74) { // maybe old format
		if(de_getbyte(0)!=0) return 0;
		if(de_getbyte(16)!=0x74) return 0;
		if(de_getbyte(56)==0) return 0; // 1st byte of filename
		cmpr_len = de_getu32le(76);
		if(cmpr_len!=0) {
			if(!dclimplode_header_at(c, 104)) return 0;
		}
		return 1;
	}
	else if(b==0) { // maybe new format
		if(de_getu16le(14)!=0x74) return 0;
		n = (UI)de_getu16le(18);
		if(n==0x75) {
			*pmultipart_flag = 1;
		}
		else if(n!=0x74) {
			return 0;
		}
		if(n==0x74) {
			if(de_getbyte(58)==0) return 0; // 1st byte of filename
			cmpr_len = de_getu32le(194);
			if(cmpr_len!=0) {
				if(!dclimplode_header_at(c, 226)) return 0;
			}
		}
		if(de_getbyte(0)!=0) {
			*pmultipart_flag = 1;
		}
		return 2;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movb $0x0, (%rsi)
movq 0x18(%rdi), %rdi
movl $0xd, %esi
callq 0xef0d5
xorl %ebx, %ebx
testb %al, %al
je 0x71e0f
movzbl %al, %eax
cmpl $0x74, %eax
jne 0x71e8f
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xef0d5
testb %al, %al
jne 0x71e8f
movq 0x18(%r14), %rdi
movl $0x10, %esi
callq 0xef0d5
cmpb $0x74, %al
jne 0x71e8f
movq 0x18(%r14), %rdi
movl $0x38, %esi
callq 0xef0d5
testb %al, %al
je 0x71e8f
movq 0x18(%r14), %rdi
movl $0x4c, %esi
callq 0xef37e
testq %rax, %rax
je 0x71e05
movl $0x68, %esi
movq %r14, %rdi
callq 0x71d2e
testl %eax, %eax
je 0x71e8f
movl $0x1, %ebx
jmp 0x71e8f
movq 0x18(%r14), %rdi
movl $0xe, %esi
callq 0xef1ca
cmpq $0x74, %rax
jne 0x71e8f
movq 0x18(%r14), %rdi
movl $0x12, %esi
callq 0xef1ca
cmpl $0x74, %eax
je 0x71e59
cmpl $0x75, %eax
jne 0x71e8f
movb $0x1, (%r15)
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xef0d5
movl $0x2, %ebx
testb %al, %al
je 0x71e8f
movb $0x1, (%r15)
jmp 0x71e8f
movq 0x18(%r14), %rdi
movl $0x3a, %esi
callq 0xef0d5
testb %al, %al
je 0x71e8f
movq 0x18(%r14), %rdi
movl $0xc2, %esi
callq 0xef37e
testq %rax, %rax
je 0x71e3f
movl $0xe2, %esi
movq %r14, %rdi
callq 0x71d2e
testl %eax, %eax
jne 0x71e3f
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: do_arcv_common_fields
static void do_arcv_common_fields(deark *c, de_arch_lctx *d,
	struct de_arch_member_data *md, i64 pos1, i64 *nbytes_consumed)
{
	i64 fnlen;
	UI fver_maj1, fver_min1;
	UI fver_maj2, fver_min2;
	i64 pos = pos1;
	UI attr;

	fnlen = (i64)de_getbyte_p(&pos);
	dbuf_read_to_ucstring(c->infile, pos, fnlen, md->filename, 0,
		d->input_encoding);
	de_dbg(c, "filename: \"%s\"", ucstring_getpsz_d(md->filename));
	pos += fnlen;

	de_arch_read_field_orig_len_p(md, &pos);
	de_arch_read_field_cmpr_len_p(md, &pos);

	attr = (UI)de_getu32le_p(&pos); // TODO: How big is this field
	de_arch_handle_field_dos_attr(md, attr);

	de_arch_read_field_dttm_p(d, &md->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], "mod",
		DE_ARCH_TSTYPE_DOS_TD, &pos);

	fver_min1 = (UI)de_getu16le_p(&pos);
	fver_maj1 = (UI)de_getu16le_p(&pos);
	de_dbg(c, "file ver (1): %u.%u", fver_maj1, fver_min1);
	fver_min2 = (UI)de_getu16le_p(&pos);
	fver_maj2 = (UI)de_getu16le_p(&pos);
	de_dbg(c, "file ver (2): %u.%u", fver_maj2, fver_min2);

	// Algorithm seems to be "CRC-32/JAMCRC".
	// Same as the usual CRC-32, except it doesn't invert the bits as a final step.
	md->crc_reported = (u32)de_getu32le_p(&pos);
	de_dbg(c, "crc (reported): 0x%08x", (UI)md->crc_reported);

	*nbytes_consumed = pos - pos1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
leaq 0x10(%rsp), %r15
movq %rcx, (%r15)
movq 0x18(%rdi), %rdi
movq %r15, %rsi
callq 0xef14d
movzbl %al, %ebx
movq 0x18(%r12), %rdi
movq (%r15), %rsi
movq 0x58(%r13), %rcx
movl 0x18(%rbp), %r9d
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xf01b0
movq 0x58(%r13), %rdi
callq 0xf7557
leaq 0xc9adc(%rip), %rsi     # 0x13b9d4
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
addq %rbx, (%r15)
movq %r13, %rdi
movq %r15, %rsi
callq 0xfdb9b
movq %r13, %rdi
movq %r15, %rsi
callq 0xfdbe0
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xef3a0
movq %r13, %rdi
movl %eax, %esi
callq 0xfdc20
movq 0x50(%r13), %rsi
addq $0x18, %rsi
leaq 0xa615a(%rip), %rdx     # 0x11809e
movq %rbp, %rdi
movl $0x4, %ecx
movq %r15, %r8
callq 0xfdc9b
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xef1ed
movq %rax, %rbx
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xef1ed
leaq 0xb41e0(%rip), %rsi     # 0x126158
movq %r12, %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xef1ed
movq %rax, %rbx
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xef1ed
leaq 0xb41c2(%rip), %rsi     # 0x12616c
movq %r12, %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0xef3a0
movl %eax, 0x48(%r13)
leaq 0xd1db5(%rip), %rsi     # 0x143d85
movq %r12, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq (%r15), %rax
subq %r14, %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: lif_method2_decompressor_fn
static void lif_method2_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;
	struct de_lzw_params delzwp;

	de_zeromem(&delzwp, sizeof(struct de_lzw_params));
	delzwp.fmt = DE_LZWFMT_ZOOLZD;
	fmtutil_decompress_lzw(c, md->dcmpri, md->dcmpro, md->dres, &delzwp);
}

// Assembly:
subq $0x18, %rsp
movq (%rdi), %rax
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movl $0x0, 0x10(%r8)
movl $0x4, (%r8)
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rcx
movq %rax, %rdi
callq 0x102cf0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: lif_read_field
static i64 lif_read_field(dbuf *f, i64 pos1, i64 len, int *perrflag)
{
	i64 val = 0;
	i64 i;
	i64 pos = pos1;

	for(i=0; i<len; i++) {
		u8 b;
		i64 nv;

		b = dbuf_getbyte_p(f, &pos);
		if(b>='0' && b<='9') {
			nv = b - 48;
		}
		else if(b>='a' && b<='f') {
			nv = b - 87;
		}
		else {
			*perrflag = 1;
			return 0;
		}

		val = (val<<4) | nv;
	}
	return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdx, %rdx
jle 0x720af
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl $0xffffffa9, %eax       # imm = 0xFFFFFFA9
movq %rsp, %r13
leaq 0x27(%rax), %rbp
xorl %r12d, %r12d
movq %r15, %rdi
movq %r13, %rsi
callq 0xef14d
movzbl %al, %eax
movl %eax, %edx
addb $-0x30, %dl
movq %rbp, %rcx
cmpb $0xa, %dl
jb 0x7208f
leal -0x61(%rax), %edx
movl $0xffffffa9, %ecx       # imm = 0xFFFFFFA9
cmpb $0x6, %dl
jae 0x7209c
addl %eax, %ecx
shlq $0x4, %r12
orq %rcx, %r12
movb $0x1, %al
jmp 0x720a4
movl $0x1, (%rbx)
xorl %eax, %eax
testb %al, %al
je 0x720af
decq %r14
jne 0x72067
jmp 0x720b2
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: binary_ii_is_member_at
static int binary_ii_is_member_at(dbuf *f, i64 pos, u8 check_nr, int nr_expected)
{
	if(dbuf_memcmp(f, pos, (const void*)"\x0a\x47\x4c", 3)) return 0;
	if(dbuf_getbyte(f, pos+18) != 0x02) return 0;
	if(check_nr) {
		int nr;

		nr = (int)dbuf_getbyte(f, pos+127);
		if(nr != nr_expected) return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb4353(%rip), %rdx     # 0x126431
movl $0x3, %ecx
callq 0xf025e
xorl %ebp, %ebp
testl %eax, %eax
jne 0x7211e
leaq 0x12(%r14), %rsi
movq %r15, %rdi
callq 0xef0d5
cmpb $0x2, %al
jne 0x7211e
testb %r12b, %r12b
je 0x72119
addq $0x7f, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xef0d5
movzbl %al, %eax
cmpl %ebx, %eax
jne 0x7211e
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/misc3.c
// Function: tc_decompressor_fn
static void tc_decompressor_fn(struct de_arch_member_data *md)
{
	deark *c = md->c;

	if(md->cmpr_meth==0) {
		fmtutil_decompress_uncompressed(c, md->dcmpri, md->dcmpro, md->dres, 0);
	}
	else if(md->cmpr_meth==1) {
		tc_decompress_rle(md);
	}
	else {
		de_dfilter_set_generic_error(c, md->dres, NULL);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x90(%rdi), %eax
cmpl $0x1, %eax
je 0x7217b
movq (%rbx), %rdi
testl %eax, %eax
jne 0x722f6
movq 0xb0(%rbx), %rsi
movq 0xb8(%rbx), %rdx
movq 0xc0(%rbx), %rcx
xorl %r8d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfaa08
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %r12
leaq 0x10(%rsp), %r13
movq %r12, (%r13)
addq 0x10(%rax), %r12
movq (%rax), %rdi
movq %r13, %rsi
callq 0xef14d
movb %al, 0xf(%rsp)
xorl %r14d, %r14d
movb $0x1, %r15b
cmpq %r12, 0x10(%rsp)
jge 0x72294
movq 0xb0(%rbx), %rax
movq (%rax), %rdi
movq %r13, %rsi
callq 0xef14d
cmpb 0xf(%rsp), %al
jne 0x72216
movq 0xb0(%rbx), %rax
movq (%rax), %rdi
movq %r13, %rbp
movq %r13, %rsi
callq 0xef14d
testb %al, %al
je 0x72251
movzbl %al, %r13d
cmpl $0x2, %r13d
je 0x72230
cmpl $0x1, %r13d
jne 0x7225d
movq 0xb0(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %r15
movq %rbp, %rsi
callq 0xef14d
movzbl %al, %r13d
orq $0x100, %r13            # imm = 0x100
jmp 0x72264
movq 0xb8(%rbx), %rcx
movq (%rcx), %rdi
movzbl %al, %esi
callq 0xf11be
incq %r14
xorl %r15d, %r15d
jmp 0x72294
movq 0xb0(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %r15
movq %rbp, %rsi
callq 0xef193
movq %rax, %r13
addq $0x200, %r13            # imm = 0x200
jmp 0x72264
movl $0x1, %r13d
movb 0xf(%rsp), %al
jmp 0x72276
cmpb $0x4, %al
jb 0x7229f
movq %rbp, %r15
movq 0xb0(%rbx), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0xef14d
movq 0xb8(%rbx), %rcx
movq (%rcx), %rdi
movzbl %al, %esi
movq %r13, %rdx
callq 0xf14bd
addq %r13, %r14
xorl %r15d, %r15d
movq %rbp, %r13
testb %r15b, %r15b
je 0x721a5
jmp 0x722b7
movq (%rbx), %rdi
movq 0xc0(%rbx), %rsi
leaq 0xb4295(%rip), %rdx     # 0x126545
callq 0xfa815
jmp 0x72291
movq 0xc0(%rbx), %rax
cmpl $0x0, (%rax)
jne 0x722e7
movq 0x10(%rsp), %rdx
movq (%rbx), %rdi
movq 0xb0(%rbx), %rax
subq 0x8(%rax), %rdx
leaq 0xaf166(%rip), %rsi     # 0x121443
movq %r14, %rcx
xorl %eax, %eax
callq 0xe9226
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc0(%rbx), %rsi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfa815
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: de_module_iccprofile
void de_module_iccprofile(deark *c, struct deark_module_info *mi)
{
	mi->id = "iccprofile";
	mi->desc = "ICC profile";
	mi->run_fn = de_run_iccprofile;
	mi->identify_fn = de_identify_iccprofile;
}

// Assembly:
leaq 0xb4245(%rip), %rax     # 0x126560
movq %rax, (%rsi)
leaq 0xbaf85(%rip), %rax     # 0x12d2aa
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x72340
movq %rax, 0x18(%rsi)
leaq 0x762(%rip), %rax       # 0x72a9d
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: format_4cc_dbgstr
static const char *format_4cc_dbgstr(const struct de_fourcc *tmp4cc,
	char *buf, size_t buflen, UI flags)
{
	char str[40];

	if((tmp4cc->id==0) && (flags&0x2))
		de_strlcpy(str, "(none)", sizeof(str));
	else
		de_snprintf(str, sizeof(str), "'%s'", tmp4cc->id_dbgstr);

	if(flags&0x1)
		de_snprintf(buf, buflen, "0x%08x=%s", (UI)tmp4cc->id, str);
	else
		de_strlcpy(buf, str, buflen);

	return buf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testb $0x2, %bpl
je 0x72af9
cmpl $0x0, 0x4(%r14)
jne 0x72af9
leaq 0xce9ab(%rip), %rsi     # 0x141495
movq %rsp, %rdi
movl $0x28, %edx
callq 0xe8ded
jmp 0x72b13
leaq 0x10(%r14), %rcx
leaq 0xc770f(%rip), %rdx     # 0x13a213
movq %rsp, %rdi
movl $0x28, %esi
xorl %eax, %eax
callq 0xe8d67
testb $0x1, %bpl
jne 0x72b2b
movq %rsp, %rsi
movl $0x50, %edx
movq %rbx, %rdi
callq 0xe8ded
jmp 0x72b48
movl 0x4(%r14), %ecx
leaq 0xb3ba5(%rip), %rdx     # 0x1266db
movq %rsp, %r8
movl $0x50, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe8d67
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: typedec_hexdump
static void typedec_hexdump(deark *c, struct typedec_params *p)
{
	UI rsvd;

	if(p->len<8) return;
	rsvd = (UI)de_getu32be(p->pos1+4);
	de_dbg(c, "reserved/etc.: 0x%08x", rsvd);
	de_dbg_hexdump(c, c->infile, p->pos1+8, p->len-8, 256, NULL, 0x1);
}

// Assembly:
cmpq $0x8, 0x18(%rsi)
jl 0x72ea9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x10(%rsi), %rsi
addq $0x4, %rsi
callq 0xef32a
leaq 0xb4016(%rip), %rsi     # 0x126e80
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rsi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
addq $0x8, %rdx
addq $-0x8, %rcx
movl $0x1, (%rsp)
movl $0x100, %r8d            # imm = 0x100
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0xe975a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: typedec_XYZ
static void typedec_XYZ(deark *c, struct typedec_params *p)
{
	i64 xyz_count;
	i64 k;

	if(p->len<8) return;
	xyz_count = (p->len-8)/12;
	for(k=0; k<xyz_count; k++) {
		struct XYZ_type xyz;

		read_XYZ(c, p->pos1+8+12*k, &xyz);
		de_dbg(c, "XYZ[%d]: %.5f, %.5f, %.5f", (int)k,
			xyz.v[0], xyz.v[1], xyz.v[2]);
	}
}

// Assembly:
movq 0x18(%rsi), %rax
cmpq $0x8, %rax
jl 0x72f53
addq $-0x8, %rax
cmpq $0xc, %rax
jb 0x72f53
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r15
shrq $0x3, %r15
cmpq $0x1, %r15
adcq $0x0, %r15
movl $0x8, %r13d
xorl %r12d, %r12d
leaq 0xb3dcc(%rip), %rbp     # 0x126cd2
movq 0x10(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %rsp, %rdx
callq 0x72b54
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq %r14, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movb $0x3, %al
callq 0xe9226
incq %r12
addq $0xc, %r13
cmpq %r12, %r15
jne 0x72f06
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: typedec_dict
static void typedec_dict(deark *c, struct typedec_params *p)
{
	i64 pos = p->pos1 + 8;
	i64 nrec;
	i64 reclen;
	i64 i;

	if(p->len<16) goto done;

	nrec = de_getu32be_p(&pos);
	de_dbg(c, "num records: %u", (UI)nrec);
	reclen = de_getu32be_p(&pos);
	de_dbg(c, "rec len: %u", (UI)reclen);
	if(reclen!=16 && reclen!=24 && reclen!=32) goto done;
	if(pos+nrec*reclen > p->pos1 + p->len) goto done;
	if(nrec>MAX_TAGS_PER_TAGSET) goto done;

	for(i=0; i<nrec; i++) {
		do_dict_string(c, p, pos, "name");
		pos += 8;
		do_dict_string(c, p, pos, "value");
		pos += 8;
		if(reclen>=24) {
			do_dict_string(c, p, pos, "display name");
			pos += 8;
		}
		if(reclen>=32) {
			do_dict_string(c, p, pos, "display value");
			pos += 8;
		}
	}

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
addq $0x8, %rax
movq %rax, (%rsp)
cmpq $0x10, 0x18(%rsi)
jl 0x73229
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0xef34e
movq %rax, %r15
leaq 0xb3c06(%rip), %rsi     # 0x126d2c
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0xef34e
movq %rax, %r12
leaq 0xbae0b(%rip), %rsi     # 0x12df54
movq %r14, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
cmpq $0x20, %r12
ja 0x73229
movabsq $0x101010000, %rax      # imm = 0x101010000
btq %r12, %rax
jae 0x73229
leaq -0x1(%r15), %rax
cmpq $0x1f3, %rax            # imm = 0x1F3
ja 0x73229
movq %r12, %rax
imulq %r15, %rax
addq (%rsp), %rax
movq 0x18(%rbx), %rcx
addq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jg 0x73229
leaq 0xb547b(%rip), %r13     # 0x128622
leaq 0xc056b(%rip), %rbp     # 0x133719
movq (%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x73942
movq (%rsp), %rdx
addq $0x8, %rdx
movq %rdx, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x73942
movq (%rsp), %rdx
addq $0x8, %rdx
movq %rdx, (%rsp)
cmpq $0x18, %r12
jl 0x73203
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xb3b43(%rip), %rcx     # 0x126d3c
callq 0x73942
addq $0x8, (%rsp)
cmpq $0x20, %r12
jl 0x73224
movq (%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xb3b2f(%rip), %rcx     # 0x126d49
callq 0x73942
addq $0x8, (%rsp)
decq %r15
jne 0x731ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: typedec_sf32
static void typedec_sf32(deark *c, struct typedec_params *p)
{
	i64 count;
	i64 i;
	i64 pos = p->pos1 + 8;
	double val;

	if(p->len<8) return;
	count = (p->len-8)/4;
	for(i=0; i<count && i<64; i++) {
		val = read_s15Fixed16Number(c->infile, pos);
		pos += 4;
		de_dbg(c, "arr[%d] = %.5f", (int)i, val);
	}
}

// Assembly:
movq 0x18(%rsi), %rax
cmpq $0x8, %rax
jl 0x73512
addq $-0x8, %rax
cmpq $0x4, %rax
jb 0x73512
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
shrq $0x2, %rax
cmpq $0x40, %rax
movl $0x40, %r12d
cmovbq %rax, %r12
movq 0x10(%rsi), %r14
addq $0x8, %r14
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r15d, %r15d
movq 0x18(%rbx), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xef219
movq %rax, %rbp
leaq 0x2(%r14), %rsi
movq %r13, %rdi
callq 0xef169
xorps %xmm1, %xmm1
cvtsi2sd %rbp, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0xb3078(%rip), %xmm0    # 0x126558
addsd %xmm1, %xmm0
movq %rbx, %rdi
leaq 0xb38fb(%rip), %rsi     # 0x126de9
movl %r15d, %edx
movb $0x1, %al
callq 0xe9226
incq %r15
addq $0x4, %r14
cmpq %r15, %r12
jne 0x734aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: typedec_text
static void typedec_text(deark *c, struct typedec_params *p)
{
	de_ucstring *s = NULL;
	i64 textlen = p->len-8;
	de_ext_encoding enc;

	if(textlen<0) goto done;

	if(p->type_id==0x75746638U) {
		enc = DE_ENCODING_UTF8;
	}
	else {
		enc = DE_ENCODING_ASCII;
	}

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, p->pos1+8, textlen, DE_DBG_MAX_STRLEN,
		s, 0, enc);
	ucstring_truncate_at_NUL(s);
	de_dbg(c, "text: \"%s\"", ucstring_getpsz(s));

done:
	ucstring_destroy(s);
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x18(%rsi), %r15
cmpq $0x8, %r15
jge 0x738c6
xorl %r14d, %r14d
jmp 0x7392e
movq %rsi, %r12
movq %rdi, %rbx
addq $-0x8, %r15
xorl %ebp, %ebp
cmpl $0x75746638, 0x20(%rsi) # imm = 0x75746638
sete %bpl
incl %ebp
callq 0xf6870
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq 0x10(%r12), %rsi
addq $0x8, %rsi
movl %ebp, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r15, %rdx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %r14, %rdi
callq 0xf68c1
movq %r14, %rdi
callq 0xf74bd
leaq 0xc73eb(%rip), %rsi     # 0x13ad0c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf6bb0
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/iccprofile.c
// Function: do_dict_string
static void do_dict_string(deark *c, struct typedec_params *p, i64 itempos, const char *itemname)
{
	de_ucstring *s = NULL;
	i64 dpos_rel, dpos_abs, dlen;

	dpos_rel = de_getu32be(itempos);
	dpos_abs = p->pos1 + dpos_rel;
	dlen = de_getu32be(itempos+4);
	if(dpos_abs + dlen > p->pos1 + p->len) goto done;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, dpos_abs, dlen, DE_DBG_MAX_STRLEN, s, 0, DE_ENCODING_UTF16BE);
	de_dbg(c, "%s: dpos=%"I64_FMT", dlen=%"I64_FMT", string=\"%s\"", itemname, dpos_abs, dlen,
		ucstring_getpsz_d(s));

done:
	ucstring_destroy(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
callq 0xef32a
movq %rax, %r15
addq 0x10(%r13), %r15
movq 0x18(%r14), %rdi
addq $0x4, %r12
movq %r12, %rsi
callq 0xef32a
movq %rax, %r12
addq %r15, %rax
movq 0x18(%r13), %rcx
addq 0x10(%r13), %rcx
cmpq %rcx, %rax
jle 0x73996
xorl %r13d, %r13d
jmp 0x739e7
movq %r14, %rdi
callq 0xf6870
movq %rax, %r13
movq 0x18(%r14), %rdi
movl $0x4, (%rsp)
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %r13, %rdi
callq 0xf7557
leaq 0xb3386(%rip), %rsi     # 0x126d57
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xe9226
movq %r13, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6bb0
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/icns.c
// Function: de_module_icns
void de_module_icns(deark *c, struct deark_module_info *mi)
{
	mi->id = "icns";
	mi->desc = "Macintosh icon";
	mi->run_fn = de_run_icns;
	mi->identify_fn = de_identify_icns;
	mi->help_fn = de_help_icns;
}

// Assembly:
leaq 0xb3965(%rip), %rax     # 0x127368
movq %rax, (%rsi)
leaq 0xb3960(%rip), %rax     # 0x12736d
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x73a33
movq %rax, 0x18(%rsi)
leaq 0x26a(%rip), %rax       # 0x73c8d
movq %rax, 0x20(%rsi)
leaq 0x2b4(%rip), %rax       # 0x73ce2
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/icns.c
// Function: do_read_mask
static void do_read_mask(deark *c, lctx *d, struct page_ctx *pg, int masktype_id,
	int depth, i64 w, i64 h)
{
	de_bitmap *img;
	i64 rowspan;
	i64 mask_offset;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);

	if(depth==1) {
		rowspan = (w+7)/8;
		mask_offset = rowspan*h;
	}
	else {
		rowspan = w;
		mask_offset = 0;
	}

	de_dbg(c, "mask(%d"DE_CHAR_TIMES"%d,%d) segment at %"I64_FMT", mask at %"I64_FMT"+%"I64_FMT,
		(int)w, (int)h, depth, pg->segment_pos, pg->image_pos, mask_offset);
	de_dbg_indent(c, 1);

	if(d->mask[masktype_id].img) {
		de_dbg(c, "duplicate mask type %u", (UI)masktype_id);
		de_bitmap_destroy(d->mask[masktype_id].img);
	}
	d->mask[masktype_id].img = de_bitmap_create(c, w, h, 1);
	d->mask[masktype_id].segment_pos = pg->segment_pos;
	img = d->mask[masktype_id].img;

	if(depth==1) {
		de_convert_image_bilevel(c->infile, pg->image_pos+mask_offset, rowspan, img, 0);
	}
	else {
		convert_image_gray8(c->infile, pg->image_pos+mask_offset, rowspan, img);
	}

	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movl %r8d, %ebx
movl %ecx, 0xc(%rsp)
movq %rdx, %r12
movq %rsi, (%rsp)
movq %rdi, %rbp
leaq 0x14(%rsp), %rsi
callq 0xe958c
leaq 0x7(%r13), %r14
shrq $0x3, %r14
movq %r14, %r15
movq 0x50(%rsp), %rcx
imulq %rcx, %r15
xorl %eax, %eax
cmpl $0x1, %ebx
cmovneq %r13, %r14
cmovneq %rax, %r15
movq 0x8(%r12), %r9
leaq 0xb2acc(%rip), %rsi     # 0x127492
movq %rbp, %rdi
movl %r13d, %edx
movl %ebx, 0x10(%rsp)
movl %ebx, %r8d
xorl %eax, %eax
pushq %r15
pushq 0x10(%r12)
callq 0xe9226
addq $0x10, %rsp
movq %rbp, %rdi
movl $0x1, %esi
callq 0xe9585
movl 0xc(%rsp), %edx
movl %edx, %eax
shlq $0x5, %rax
movq (%rsp), %rcx
leaq (%rcx,%rax), %rbx
addq $0x10, %rbx
cmpq $0x0, 0x18(%rbx)
je 0x74a29
leaq 0xb2aac(%rip), %rsi     # 0x1274c2
movq %rbp, %rdi
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
callq 0xf28d4
movq %rbp, %rdi
movq %r13, %rsi
movq 0x50(%rsp), %rdx
movl $0x1, %ecx
callq 0xf2cab
movq %rax, %r13
movq %rax, 0x18(%rbx)
movq 0x8(%r12), %rax
movq %rax, (%rbx)
addq 0x10(%r12), %r15
movq %rbp, (%rsp)
movq 0x18(%rbp), %r12
cmpl $0x1, 0x10(%rsp)
jne 0x74a77
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0xf3081
jmp 0x74abb
cmpq $0x0, 0x10(%r13)
jle 0x74abb
xorl %ebp, %ebp
cmpq $0x0, 0x8(%r13)
jle 0x74aaf
xorl %ebx, %ebx
leaq (%r15,%rbx), %rsi
movq %r12, %rdi
callq 0xef0d5
movzbl %al, %ecx
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf2a4a
incq %rbx
cmpq 0x8(%r13), %rbx
jl 0x74a89
incq %rbp
addq %r14, %r15
cmpq 0x10(%r13), %rbp
jl 0x74a80
movl 0x14(%rsp), %esi
movq (%rsp), %rdi
callq 0xe9595
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq