LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: read_datetime17
static void read_datetime17(deark *c, lctx *d, i64 pos, int fieldlen,
	struct de_timestamp *ts)
{
	i64 yr, mo, da;
	i64 hr, mi, se, hs;
	i64 offs;

	de_zeromem(ts, sizeof(struct de_timestamp));
	yr = read_decimal_substr(c->infile, pos, 4);
	if(yr==0) return;
	mo = read_decimal_substr(c->infile, pos+4, 2);
	da = read_decimal_substr(c->infile, pos+6, 2);
	hr = read_decimal_substr(c->infile, pos+8, 2);
	mi = read_decimal_substr(c->infile, pos+10, 2);
	se = read_decimal_substr(c->infile, pos+12, 2);
	hs = read_decimal_substr(c->infile, pos+14, 2);
	if(fieldlen==16) {
		offs = 0;
	}
	else {
		offs = dbuf_geti8(c->infile, pos+16);
	}
	de_make_timestamp(ts, yr, mo, da, hr, mi, se);
	de_timestamp_set_subsec(ts, ((double)hs)/100.0);
	de_timestamp_cvt_to_utc(ts, -offs*60*15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0xce460
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xce2b1
jmp 0xce3e5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movl $0x2, %edx
callq 0xce460
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
movl $0x2, %edx
callq 0xce460
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movl $0x2, %edx
callq 0xce460
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0xa, %rsi
movl $0x2, %edx
callq 0xce460
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
movl $0x2, %edx
callq 0xce460
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0xe, %rsi
movl $0x2, %edx
callq 0xce460
movq %rax, -0x60(%rbp)
cmpl $0x10, -0x1c(%rbp)
jne 0xce375
movq $0x0, -0x68(%rbp)
jmp 0xce38e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x165140
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x50(%rbp), %r9
movq -0x58(%rbp), %rax
movq %rax, (%rsp)
callq 0x15d830
movq -0x28(%rbp), %rdi
cvtsi2sdq -0x60(%rbp), %xmm0
movsd 0xd7f03(%rip), %xmm1    # 0x1a62c8
divsd %xmm1, %xmm0
callq 0x15d5e0
movq -0x28(%rbp), %rdi
xorl %eax, %eax
subq -0x68(%rbp), %rax
imulq $0x3c, %rax, %rax
imulq $0xf, %rax, %rsi
callq 0x15de10
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: dbg_timestamp
static void dbg_timestamp(deark *c, struct de_timestamp *ts, const char *field_name)
{
	char timestamp_buf[64];

	if(ts->is_valid) {
		de_dbg_timestamp_to_string(c, ts, timestamp_buf, sizeof(timestamp_buf), 0);
		de_dbg(c, "%s: %s", field_name, timestamp_buf);
	}
	else {
		de_dbg(c, "%s: (not set)", field_name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xce442
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movl $0x40, %ecx
xorl %r8d, %r8d
callq 0x15e2d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rcx
leaq 0x106a8d(%rip), %rsi    # 0x1d4ec6
movb $0x0, %al
callq 0x15b0d0
jmp 0xce458
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xe974a(%rip), %rsi     # 0x1b7b9b
movb $0x0, %al
callq 0x15b0d0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: read_decimal_substr
static i64 read_decimal_substr(dbuf *f, i64 pos, i64 len)
{
	char buf[24];

	if(len<1 || len>23) return 0;
	dbuf_read(f, (u8*)buf, pos, len);
	buf[len] = '\0';
	return de_atoi64(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jl 0xce482
cmpq $0x17, -0x20(%rbp)
jle 0xce48c
movq $0x0, -0x8(%rbp)
jmp 0xce4b7
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x164d10
movq -0x20(%rbp), %rax
movb $0x0, -0x40(%rbp,%rax)
leaq -0x40(%rbp), %rdi
callq 0x15ccc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: free_dir_record
static void free_dir_record(deark *c, struct dir_record *dr)
{
	if(!dr) return;
	ucstring_destroy(dr->fname);
	ucstring_destroy(dr->rr_name);
	de_free(c, dr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xcecb9
jmp 0xcece0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: read_datetime7
static void read_datetime7(deark *c, lctx *d, i64 pos, int fieldlen,
	struct de_timestamp *ts)
{
	i64 yr, mo, da;
	i64 hr, mi, se;
	i64 offs;

	ts->is_valid = 0;

	yr = de_getbyte(pos);
	mo = de_getbyte(pos+1);
	if(mo==0) return;
	da = de_getbyte(pos+2);
	hr = de_getbyte(pos+3);
	mi = de_getbyte(pos+4);
	se = de_getbyte(pos+5);
	if(fieldlen==6) {
		offs = 0;
	}
	else {
		offs = dbuf_geti8(c->infile, pos+6);
	}

	de_make_timestamp(ts, 1900+yr, mo, da, hr, mi, se);
	de_timestamp_cvt_to_utc(ts, -offs*60*15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xced52
jmp 0xcee2e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x3, %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x5, %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x58(%rbp)
cmpl $0x6, -0x1c(%rbp)
jne 0xcedd2
movq $0x0, -0x60(%rbp)
jmp 0xcedeb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0x165140
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x76c, %rsi            # imm = 0x76C
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x50(%rbp), %r9
movq -0x58(%rbp), %rax
movq %rax, (%rsp)
callq 0x15d830
movq -0x28(%rbp), %rdi
xorl %eax, %eax
subq -0x60(%rbp), %rax
imulq $0x3c, %rax, %rax
imulq $0xf, %rax, %rsi
callq 0x15de10
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: name_to_lowercase
static void name_to_lowercase(de_ucstring *s)
{
	i64 i;

	if(!s) return;
	for(i=0; i<s->len; i++) {
		if(s->str[i]>='A' && s->str[i]<='Z') {
			s->str[i] += 32;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xcee51
jmp 0xceeb0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0xceeb0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $0x41, (%rax,%rcx,4)
jl 0xceea0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $0x5a, (%rax,%rcx,4)
jg 0xceea0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x20, %edx
movl %edx, (%rax,%rcx,4)
jmp 0xceea2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xcee59
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: is_SUSP_indicator
static int is_SUSP_indicator(deark *c, i64 pos, i64 len)
{
	u8 buf[6];

	if(len<6) return 0;
	de_read(buf, pos, 6);
	if(buf[0]=='S' && buf[1]=='P' && buf[4]==0xbe && buf[5]==0xef) {
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x6, -0x20(%rbp)
jge 0xcf574
movl $0x0, -0x4(%rbp)
jmp 0xcf5c6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x26(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %ecx
callq 0x164d10
movzbl -0x26(%rbp), %eax
cmpl $0x53, %eax
jne 0xcf5bf
movzbl -0x25(%rbp), %eax
cmpl $0x50, %eax
jne 0xcf5bf
movzbl -0x22(%rbp), %eax
cmpl $0xbe, %eax
jne 0xcf5bf
movzbl -0x21(%rbp), %eax
cmpl $0xef, %eax
jne 0xcf5bf
movl $0x1, -0x4(%rbp)
jmp 0xcf5c6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_CDXA_dirdata
static void do_CDXA_dirdata(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1)
{
	unsigned int attribs;

	de_dbg(c, "CD-ROM XA data at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	attribs = (unsigned int)de_getu16be(pos1+4);
	de_dbg(c, "attribs: 0x%04x", attribs);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xea8d3(%rip), %rsi     # 0x1b9eca
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0x1651d0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0xea7f7(%rip), %rsi     # 0x1b9e29
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_Apple_AA_HFS
static void do_Apple_AA_HFS(deark *c, lctx *d, struct dir_record *dr, i64 pos1, i64 len)
{
	unsigned int finder_flags;
	struct de_fourcc type4cc;
	struct de_fourcc creator4cc;
	i64 pos = pos1+4;

	de_dbg(c, "Apple AA/HFS extension at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	dbuf_read_fourcc(c->infile, pos, &type4cc, 4, 0x0);
	de_dbg(c, "type: '%s'", type4cc.id_dbgstr);
	pos += 4;
	dbuf_read_fourcc(c->infile, pos, &creator4cc, 4, 0x0);
	de_dbg(c, "creator: '%s'", creator4cc.id_dbgstr);
	pos += 4;
	finder_flags = (unsigned int)de_getu16be_p(&pos);
	de_dbg(c, "finder flags: 0x%04x", finder_flags);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xea853(%rip), %rsi     # 0x1b9ee0
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x98(%rbp), %rsi
leaq -0x5c(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x5c(%rbp), %rdx
addq $0x10, %rdx
leaq 0xde30a(%rip), %rsi     # 0x1ad9df
movb $0x0, %al
callq 0x15b0d0
movq -0x98(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x98(%rbp), %rsi
leaq -0x8c(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x8c(%rbp), %rdx
addq $0x10, %rdx
leaq 0xf060b(%rip), %rsi     # 0x1bfd32
movb $0x0, %al
callq 0x15b0d0
movq -0x98(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x98(%rbp), %rsi
callq 0x165210
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0xd0fb1(%rip), %rsi     # 0x1a0716
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_ARCHIMEDES
static void do_ARCHIMEDES(deark *c, lctx *d, struct dir_record *dr, i64 pos1, i64 len)
{
	i64 pos = pos1;
	struct de_riscos_file_attrs rfa;

	de_dbg(c, "ARCHIMEDES extension at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	if(len<10+12) goto done;
	pos += 10; // signature

	de_zeromem(&rfa, sizeof(struct de_riscos_file_attrs));
	fmtutil_riscos_read_load_exec(c, c->infile, &rfa, pos);
	dr->riscos_timestamp = rfa.mod_time;
	pos += 8;

	fmtutil_riscos_read_attribs_field(c, c->infile, &rfa, pos, 0);
	dr->has_riscos_data = 1;
	dr->rfa = rfa;

done:
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xea73b(%rip), %rsi     # 0x1b9efe
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
cmpq $0x16, -0x28(%rbp)
jge 0xcf7e4
jmp 0xcf876
movq -0x30(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19140
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rcx
leaq -0x60(%rbp), %rdx
callq 0x1755e0
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rcx
leaq -0x60(%rbp), %rdx
xorl %r8d, %r8d
callq 0x175740
movq -0x18(%rbp), %rax
movb $0x1, 0x78(%rax)
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x191e0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_dir_rec_SUSP
static void do_dir_rec_SUSP(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len1)
{
	i64 pos = pos1;
	i64 len = len1;

	while(1) {
		i64 ca_blk = 0;
		i64 ca_offs = 0;
		i64 ca_len = 0;

		do_dir_rec_SUSP_set(c, d, dr, pos, len, &ca_blk, &ca_offs, &ca_len);

		if(ca_blk==0) {
			break;
		}

		// Prepare to jump to a continuation area

		pos = sector_dpos(d, ca_blk) + ca_offs;

		// Prevent loops
		if(!de_inthashtable_add_item(c, d->dirs_seen, pos, NULL)) {
			break;
		}

		len = ca_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
leaq -0x48(%rbp), %r10
leaq -0x50(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xcf960
cmpq $0x0, -0x40(%rbp)
jne 0xcf90b
jmp 0xcf94d
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xcd1e0
addq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15e810
cmpl $0x0, %eax
jne 0xcf940
jmp 0xcf94d
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xcf8bc
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_SP
static void do_SUSP_SP(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len)
{
	if(!dr->is_root_dot) return;
	if(len<7) return;
	d->vol->SUSP_default_bytes_to_skip = (i64)de_getbyte(pos1+6);
	de_dbg(c, "bytes skipped: %d", (int)d->vol->SUSP_default_bytes_to_skip);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x4(%rax)
jne 0xcfd38
jmp 0xcfd87
cmpq $0x7, -0x28(%rbp)
jge 0xcfd41
jmp 0xcfd87
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x6, %rsi
callq 0x165060
movzbl %al, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x30(%rax), %rax
movl %eax, %edx
leaq 0xea1de(%rip), %rsi     # 0x1b9f5e
movb $0x0, %al
callq 0x15b0d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_CE
static void do_SUSP_CE(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len,
	i64 *ca_blk, i64 *ca_offs, i64 *ca_len)
{
	i64 pos = pos1 + 4;


	if(len<28) return;
	*ca_blk = getu32bbo_p(c->infile, &pos);
	de_dbg(c, "loc. of continuation area: block #%u", (unsigned int)*ca_blk);
	*ca_offs = getu32bbo_p(c->infile, &pos);
	de_dbg(c, "continuation area offset: %u bytes", (unsigned int)*ca_offs);
	*ca_len = getu32bbo_p(c->infile, &pos);
	de_dbg(c, "continuation area len: %u bytes", (unsigned int)*ca_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
cmpq $0x1c, -0x28(%rbp)
jge 0xcfdd0
jmp 0xcfe72
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xce0e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0xea171(%rip), %rsi     # 0x1b9f70
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xce0e0
movq %rax, %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0xea160(%rip), %rsi     # 0x1b9f95
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xce0e0
movq %rax, %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq 0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0xea14d(%rip), %rsi     # 0x1b9fb8
movb $0x0, %al
callq 0x15b0d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_ER
static void do_SUSP_ER(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len)
{
	i64 pos = pos1+4;
	i64 len_id, len_des, len_src;
	u8 ext_ver;
	de_ucstring *tmpstr = NULL;

	if(!dr->is_root_dot) goto done;
	if(len<8) goto done;
	len_id = (i64)de_getbyte_p(&pos);
	len_des = (i64)de_getbyte_p(&pos);
	len_src = (i64)de_getbyte_p(&pos);
	ext_ver = de_getbyte_p(&pos);
	de_dbg(c, "extension version: %u", (unsigned int)ext_ver);
	if(8+len_id+len_des+len_src > len) goto done;
	tmpstr = ucstring_create(c);
	handle_iso_string_p(c, d, NULL, "extension id", &pos, len_id, tmpstr);
	handle_iso_string_p(c, d, NULL, "extension descriptor", &pos, len_des, tmpstr);
	handle_iso_string_p(c, d, NULL, "extension source", &pos, len_src, tmpstr);

done:
	ucstring_destroy(tmpstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x4(%rax)
jne 0xcfebf
jmp 0xcffdd
cmpq $0x8, -0x28(%rbp)
jge 0xcfecb
jmp 0xcffdd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165170
movb %al, -0x49(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x49(%rbp), %edx
leaq 0xea0a2(%rip), %rsi     # 0x1b9fd8
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rax
addq $0x8, %rax
addq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0xcff58
jmp 0xcffdd
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %r9
movq -0x58(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0xea06e(%rip), %rcx     # 0x1b9fee
leaq -0x30(%rbp), %r8
movq %rax, (%rsp)
callq 0xcd5e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %r9
movq -0x58(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0xea053(%rip), %rcx     # 0x1b9ffb
leaq -0x30(%rbp), %r8
movq %rax, (%rsp)
callq 0xcd5e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %r9
movq -0x58(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0xea040(%rip), %rcx     # 0x1ba010
leaq -0x30(%rbp), %r8
movq %rax, (%rsp)
callq 0xcd5e0
movq -0x58(%rbp), %rdi
callq 0x171750
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_rockridge_NM
static void do_SUSP_rockridge_NM(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len)
{
	u8 flags;

	flags = de_getbyte(pos1+4);
	de_dbg(c, "flags: 0x%02x", (unsigned int)flags);
	if(len<6) return;
	if(!dr->rr_name)
		dr->rr_name = ucstring_create(c);
	// It is intentional that this may append to a name that started in a previous
	// NM item.
	dbuf_read_to_ucstring(c->infile, pos1+5, len-5, dr->rr_name, 0x0,
		d->rr_encoding);
	de_dbg(c, "Rock Ridge name: \"%s\"", ucstring_getpsz_d(dr->rr_name));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0x165060
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x29(%rbp), %edx
leaq 0xebae6(%rip), %rsi     # 0x1bbb19
movb $0x0, %al
callq 0x15b0d0
cmpq $0x6, -0x28(%rbp)
jge 0xd0043
jmp 0xd00bc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xd0062
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x5, %rsi
movq -0x28(%rbp), %rdx
subq $0x5, %rdx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r9d
xorl %r8d, %r8d
callq 0x1669f0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x172650
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xe9f6c(%rip), %rsi     # 0x1ba021
movb $0x0, %al
callq 0x15b0d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_rockridge_PX
static void do_SUSP_rockridge_PX(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len)
{
	i64 pos = pos1+4;
	u32 perms;
	u32 ftype;

	if(len<36) return; // 36 in v1r1.10; 44 in v1.12
	perms = (u32)getu32bbo_p(c->infile, &pos);
	de_dbg(c, "perms: octal(%06o)", (unsigned int)perms);
	ftype = (perms&0170000);
	if(ftype==0100000 || ftype==0) { // regular file
		if(perms&0111) {
			dr->rr_is_executable = 1;
		}
		else {
			dr->rr_is_nonexecutable = 1;
		}
	}
	else if(ftype==040000U) { // directory
		;
	}
	else if(ftype==0120000U) {
		dr->is_symlink = 1;
	}
	else {
		dr->is_specialfiletype = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
cmpq $0x24, -0x28(%rbp)
jge 0xd0104
jmp 0xd0190
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0xce0e0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq 0xe9f11(%rip), %rsi     # 0x1ba037
movb $0x0, %al
callq 0x15b0d0
movl -0x34(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
movl %eax, -0x38(%rbp)
cmpl $0x8000, -0x38(%rbp)    # imm = 0x8000
je 0xd0147
cmpl $0x0, -0x38(%rbp)
jne 0xd0166
movl -0x34(%rbp), %eax
andl $0x49, %eax
cmpl $0x0, %eax
je 0xd015c
movq -0x18(%rbp), %rax
movb $0x1, 0x5(%rax)
jmp 0xd0164
movq -0x18(%rbp), %rax
movb $0x1, 0x6(%rax)
jmp 0xd0190
cmpl $0x4000, -0x38(%rbp)    # imm = 0x4000
jne 0xd0171
jmp 0xd018e
cmpl $0xa000, -0x38(%rbp)    # imm = 0xA000
jne 0xd0184
movq -0x18(%rbp), %rax
movb $0x1, 0x7(%rax)
jmp 0xd018c
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0xd018e
jmp 0xd0190
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_rockridge_TF
static void do_SUSP_rockridge_TF(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len)
{
	i64 pos = pos1+4;
	unsigned int flags;
	unsigned int i;
	i64 bytes_per_field;
	static const char *names[7] = { "create", "mod", "access",
		"attrib-change", "backup", "expire", "effective" };

	if(len<5) return;
	flags = (unsigned int)de_getbyte_p(&pos);
	bytes_per_field = (flags&0x80) ? 17 : 7;

	for(i=0; i<=6; i++) {
		struct de_timestamp tmpts;
		char tmpsz[32];

		// Flag bits indicate which timestamps are present.
		if(flags & (1<<i)) {
			if(bytes_per_field==17) {
				read_datetime17(c, d, pos, 0, &tmpts);
			}
			else {
				read_datetime7(c, d, pos, 0, &tmpts);
			}
			de_snprintf(tmpsz, sizeof(tmpsz), "%s time", names[i]);
			dbg_timestamp(c, &tmpts, tmpsz);

			if(i==1 && tmpts.is_valid) { // Save the mod time
				dr->rr_modtime = tmpts;
			}
			pos += bytes_per_field;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
cmpq $0x5, -0x28(%rbp)
jge 0xd01d4
jmp 0xd02e3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
andl $0x80, %edx
movl $0x7, %eax
movl $0x11, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cltq
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x6, -0x38(%rbp)
ja 0xd02e3
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xd02d3
cmpq $0x11, -0x40(%rbp)
jne 0xd0255
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x50(%rbp), %r8
callq 0xce260
jmp 0xd026c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x50(%rbp), %r8
callq 0xcecf0
leaq -0x70(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %ecx
leaq 0x155534(%rip), %rax    # 0x2257b0
movq (%rax,%rcx,8), %rcx
movl $0x20, %esi
leaq 0xe9de4(%rip), %rdx     # 0x1ba070
movb $0x0, %al
callq 0x15a980
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0xce3f0
cmpl $0x1, -0x38(%rbp)
jne 0xd02c7
movzbl -0x50(%rbp), %eax
cmpl $0x0, %eax
je 0xd02c7
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xd02d5
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xd0211
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_SUSP_ZF
static void do_SUSP_ZF(deark *c, lctx *d, struct dir_record *dr,
	i64 pos1, i64 len)
{
	struct de_fourcc cmprtype;
	i64 n;
	i64 pos = pos1+4;

	dr->is_specialfileformat = 1;
	if(len<16) goto done;

	dbuf_read_fourcc(c->infile, pos, &cmprtype, 2, 0x0);
	de_dbg(c, "cmpr algorithm: '%s'", cmprtype.id_dbgstr);
	pos += 2;

	n = (i64)de_getbyte_p(&pos);
	de_dbg(c, "header size: %u (%u bytes)", (unsigned int)n,
		(unsigned int)(n*4));

	n = (i64)de_getbyte_p(&pos);
	de_dbg(c, "block size: 2^%u (%u bytes)", (unsigned int)n,
		(unsigned int)(1U<<(unsigned int)n));

	n = getu32bbo_p(c->infile, &pos);
	de_dbg(c, "uncmpr. size: %"I64_FMT" bytes", n);

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x9(%rax)
cmpq $0x10, -0x28(%rbp)
jge 0xd032c
jmp 0xd0413
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
addq $0x10, %rdx
leaq 0xe9d1c(%rip), %rsi     # 0x1ba078
movb $0x0, %al
callq 0x15b0d0
movq -0x68(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x68(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rax
movl %eax, %edx
movq -0x60(%rbp), %rax
shlq $0x2, %rax
movl %eax, %ecx
leaq 0xe9ceb(%rip), %rsi     # 0x1ba08d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x68(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rax
movl %eax, %edx
movq -0x60(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
leaq 0xe9cc7(%rip), %rsi     # 0x1ba0a8
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x68(%rbp), %rsi
callq 0xce0e0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xe9cb8(%rip), %rsi     # 0x1ba0c4
movb $0x0, %al
callq 0x15b0d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: fixup_filename
static void fixup_filename(deark *c, lctx *d, de_ucstring *fname)
{
	if(fname->len<3) return;
	if(fname->str[fname->len-2]==';' &&
		fname->str[fname->len-1]=='1')
	{
		ucstring_truncate(fname, fname->len-2);

		if(fname->len>1) {
			if(fname->str[fname->len-1]=='.') {
				ucstring_truncate(fname, fname->len-1);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x3, 0x10(%rax)
jge 0xd0444
jmp 0xd04cb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x2, %rcx
cmpl $0x3b, (%rax,%rcx,4)
jne 0xd04cb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpl $0x31, (%rax,%rcx,4)
jne 0xd04cb
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x2, %rsi
callq 0x171230
movq -0x18(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jle 0xd04c9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpl $0x2e, (%rax,%rcx,4)
jne 0xd04c7
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x1, %rsi
callq 0x171230
jmp 0xd04c9
jmp 0xd04cb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: cdsig_at
static int cdsig_at(dbuf *f, i64 pos)
{
	u8 buf[14];
	u8 ty;

	dbuf_read(f, buf, pos, sizeof(buf));
	if(!de_memcmp(&buf[1], g_sig_CD001, 5)) {
		ty = buf[0];
	}
	else if(!de_memcmp(&buf[1], g_sig_CD_I, 5)) {
		ty = buf[0];
	}
	else if(!de_memcmp(&buf[9], g_sig_CDROM, 5)) {
		ty = buf[8];
	}
	else {
		return 0;
	}
	if(ty>3 && ty<255) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x26(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0xe, %ecx
callq 0x164d10
leaq -0x26(%rbp), %rdi
addq $0x1, %rdi
movq 0x15521b(%rip), %rsi    # 0x225790
movl $0x5, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0xd058c
movb -0x26(%rbp), %al
movb %al, -0x27(%rbp)
jmp 0xd05e5
leaq -0x26(%rbp), %rdi
addq $0x1, %rdi
movq 0x1551fd(%rip), %rsi    # 0x225798
movl $0x5, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0xd05b2
movb -0x26(%rbp), %al
movb %al, -0x27(%rbp)
jmp 0xd05e3
leaq -0x26(%rbp), %rdi
addq $0x9, %rdi
movq 0x1551df(%rip), %rsi    # 0x2257a0
movl $0x5, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0xd05d8
movb -0x1e(%rbp), %al
movb %al, -0x27(%rbp)
jmp 0xd05e1
movl $0x0, -0x4(%rbp)
jmp 0xd0609
jmp 0xd05e3
jmp 0xd05e5
movzbl -0x27(%rbp), %eax
cmpl $0x3, %eax
jle 0xd0602
movzbl -0x27(%rbp), %eax
cmpl $0xff, %eax
jge 0xd0602
movl $0x0, -0x4(%rbp)
jmp 0xd0609
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: cdraw_setdefaults
static void cdraw_setdefaults(struct cdraw_params *cdrp)
{
	cdrp->ok = 0;
	cdrp->sector_total_len = 2048;
	cdrp->sector_dlen = 2048;
	cdrp->sector_data_offset = 0;
	cdrp->ext = "bin";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x800, 0x8(%rax)       # imm = 0x800
movq -0x8(%rbp), %rax
movq $0x800, 0x10(%rax)      # imm = 0x800
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0xf0ba6(%rip), %rcx     # 0x1c1207
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_cdraw_convert
static void do_cdraw_convert(deark *c, struct cdraw_params *cdrp)
{
	i64 pos;
	de_finfo *fi = NULL;
	dbuf *outf = NULL;

	fi = de_finfo_create(c);
	cdraw_set_name_from_vol_id(c, cdrp, fi);

	outf = dbuf_create_output_file(c, cdrp->ext, fi, 0x0);

	pos = cdrp->sector_data_offset;
	while(1) {
		if(pos >= c->infile->len) break;
		dbuf_copy(c->infile, pos, cdrp->sector_dlen, outf);
		pos += cdrp->sector_total_len;
	}

	dbuf_close(outf);
	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd09a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xd0909
jmp 0xd0938
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x166070
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd08f5
movq -0x28(%rbp), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15d260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: cdraw_set_name_from_vol_id
static void cdraw_set_name_from_vol_id(deark *c, struct cdraw_params *cdrp, de_finfo *fi)
{
	de_ucstring *vol_id = NULL;
	i64 pos;

	pos = 16*cdrp->sector_total_len + cdrp->sector_data_offset;
	if(dbuf_memcmp(c->infile, pos, "\x01" "CD001", 6)) goto done;

	vol_id = ucstring_create(c);
	dbuf_read_to_ucstring(c->infile, pos+40, 32, vol_id, DE_CONVFLAG_STOP_AT_NUL,
		DE_ENCODING_ASCII);
	ucstring_strip_trailing_spaces(vol_id);

	if(ucstring_isnonempty(vol_id)) {
		de_dbg(c, "iso9660 volume id: \"%s\"", ucstring_getpsz_d(vol_id));
		de_finfo_set_name_from_ucstring(c, fi, vol_id, 0);
	}

done:
	ucstring_destroy(vol_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x4, %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
leaq 0xe98ed(%rip), %rdx     # 0x1ba2d4
movl $0x6, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xd09fb
jmp 0xd0a81
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rcx
movl $0x20, %edx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x1669f0
movq -0x20(%rbp), %rdi
callq 0x171360
movq -0x20(%rbp), %rdi
callq 0x1717f0
cmpl $0x0, %eax
je 0xd0a7f
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x172650
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xe9876(%rip), %rsi     # 0x1ba2db
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x15d2c0
jmp 0xd0a81
movq -0x20(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: detect_nrg_internal
static int detect_nrg_internal(deark *c)
{
	if(!dbuf_memcmp(c->infile, c->infile->len-8, "NERO", 4)) {
		return 1;
	}
	if(!dbuf_memcmp(c->infile, c->infile->len-12, "NER5", 4)) {
		return 2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rsi
subq $0x8, %rsi
leaq 0xe9893(%rip), %rdx     # 0x1ba34e
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0xd0ad3
movl $0x1, -0x4(%rbp)
jmp 0xd0b11
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rsi
subq $0xc, %rsi
leaq 0xe9861(%rip), %rdx     # 0x1ba353
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0xd0b0a
movl $0x2, -0x4(%rbp)
jmp 0xd0b11
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_nrg_chunks
static void do_nrg_chunks(deark *c, struct nrg_ctx *nrg)
{
	struct de_iffctx *ictx = NULL;

	ictx = fmtutil_create_iff_decoder(c);
	ictx->userdata = (void*)nrg;
	ictx->preprocess_chunk_fn = my_preprocess_nrg_chunk_fn;
	ictx->handle_chunk_fn = my_nrg_chunk_handler;
	ictx->f = c->infile;
	ictx->is_le = 0;
	ictx->reversed_4cc = 0;

	fmtutil_read_iff_format(ictx, nrg->chunk_list_start, nrg->chunk_list_size);
	fmtutil_destroy_iff_decoder(ictx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18c8b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
leaq 0x64(%rip), %rcx        # 0xd0bc0
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
leaq 0x135(%rip), %rcx       # 0xd0ca0
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x5c(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x18c920
movq -0x18(%rbp), %rdi
callq 0x18c8f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: my_preprocess_nrg_chunk_fn
static int my_preprocess_nrg_chunk_fn(struct de_iffctx *ictx)
{
	const char *name = NULL;

	switch(ictx->chunkctx->chunk4cc.id) {
	case CODE_CDTX: name = "CD-text"; break;
	case CODE_CUES: case CODE_CUEX: name = "cue sheet"; break;
	case CODE_DAOI: case CODE_DAOX: name = "DAO info"; break;
	case CODE_ETNF: name = "extended track info"; break;
	case CODE_SINF: name = "session info"; break;
	}

	if(name) {
		ictx->chunkctx->chunk_name = name;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x43445458, %eax       # imm = 0x43445458
je 0xd0c32
jmp 0xd0bea
movl -0x14(%rbp), %eax
subl $0x43554553, %eax       # imm = 0x43554553
je 0xd0c3f
jmp 0xd0bf6
movl -0x14(%rbp), %eax
subl $0x43554558, %eax       # imm = 0x43554558
je 0xd0c3f
jmp 0xd0c02
movl -0x14(%rbp), %eax
subl $0x44414f49, %eax       # imm = 0x44414F49
je 0xd0c4c
jmp 0xd0c0e
movl -0x14(%rbp), %eax
subl $0x44414f58, %eax       # imm = 0x44414F58
je 0xd0c4c
jmp 0xd0c1a
movl -0x14(%rbp), %eax
subl $0x45544e46, %eax       # imm = 0x45544E46
je 0xd0c59
jmp 0xd0c26
movl -0x14(%rbp), %eax
subl $0x53494e46, %eax       # imm = 0x53494E46
je 0xd0c66
jmp 0xd0c71
leaq 0xe971f(%rip), %rax     # 0x1ba358
movq %rax, -0x10(%rbp)
jmp 0xd0c71
leaq 0xe971a(%rip), %rax     # 0x1ba360
movq %rax, -0x10(%rbp)
jmp 0xd0c71
leaq 0xe9717(%rip), %rax     # 0x1ba36a
movq %rax, -0x10(%rbp)
jmp 0xd0c71
leaq 0xe9713(%rip), %rax     # 0x1ba373
movq %rax, -0x10(%rbp)
jmp 0xd0c71
leaq 0xe971a(%rip), %rax     # 0x1ba387
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd0c8b
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rcx, 0x58(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: my_nrg_chunk_handler
static int my_nrg_chunk_handler(struct de_iffctx *ictx)
{
	deark *c = ictx->c;
	struct nrg_ctx *nrg = (struct nrg_ctx*)ictx->userdata;

	switch(ictx->chunkctx->chunk4cc.id) {
	case CODE_ETNF:
		do_nrg_ETNF(c, ictx, ictx->chunkctx);
		ictx->handled = 1;
		break;
	case CODE_DAOX:
		do_nrg_DAOX(c, ictx, nrg);
		ictx->handled = 1;
		break;
	case CODE_END_:
		return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x44414f58, %eax       # imm = 0x44414F58
je 0xd0d1d
jmp 0xd0cdd
movl -0x24(%rbp), %eax
subl $0x454e4421, %eax       # imm = 0x454E4421
je 0xd0d3e
jmp 0xd0ce9
movl -0x24(%rbp), %eax
subl $0x45544e46, %eax       # imm = 0x45544E46
jne 0xd0d47
jmp 0xd0cf5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rdx
callq 0xd0d60
movq -0x10(%rbp), %rax
movl $0x1, 0x130(%rax)
jmp 0xd0d47
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd0eb0
movq -0x10(%rbp), %rax
movl $0x1, 0x130(%rax)
jmp 0xd0d47
movl $0x0, -0x4(%rbp)
jmp 0xd0d4e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_nrg_ETNF
static void do_nrg_ETNF(deark *c, struct de_iffctx *ictx,
	const struct de_iffchunkctx *chunkctx)
{
	i64 pos = chunkctx->dpos;
	i64 t = 0;

	while(1) {
		i64 track_offs_bytes, track_len_bytes, start_lba;
		unsigned int mode;

		if(chunkctx->dpos + chunkctx->dlen - pos < 20) break;
		de_dbg(c, "track #%d", (int)t);
		de_dbg_indent(c, 1);
		track_offs_bytes = de_getu32be(pos);
		track_len_bytes = de_getu32be(pos+4);
		de_dbg(c, "offset: %"I64_FMT", len: %"I64_FMT, track_offs_bytes, track_len_bytes);
		mode = (unsigned int)de_getu32be(pos+8);
		de_dbg(c, "mode: %u", mode);
		start_lba = de_getu32be(pos+12);
		de_dbg(c, "start lba: %"I64_FMT, start_lba);
		de_dbg_indent(c, -1);
		pos += 20;
		t++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x48(%rcx), %rax
subq -0x20(%rbp), %rax
cmpq $0x14, %rax
jge 0xd0da7
jmp 0xd0e9c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
leaq 0xd8d92(%rip), %rsi     # 0x1a9b4a
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x165470
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0x165470
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0xe9586(%rip), %rsi     # 0x1ba394
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x165470
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %edx
leaq 0xe4605(%rip), %rsi     # 0x1b5440
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0xc, %rsi
callq 0x165470
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xe9540(%rip), %rsi     # 0x1ba3aa
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x20(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xd0d88
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_nrg_DAOX
static void do_nrg_DAOX(deark *c, struct de_iffctx *ictx, struct nrg_ctx *nrg)
{
	i64 pos1 = ictx->chunkctx->dpos;

	if(ictx->chunkctx->dpos<56) return;
	nrg->pre_gap = dbuf_geti64be(ictx->f, pos1+48);
	de_dbg(c, "pre-gap: %"I64_FMT, nrg->pre_gap);
	dbuf_constrain_offset(c->infile, &nrg->pre_gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
cmpq $0x38, 0x40(%rax)
jge 0xd0eeb
jmp 0xd0f3a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rsi
callq 0x165730
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0xe949b(%rip), %rsi     # 0x1ba3b9
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x164c60
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/macbinary.c
// Function: de_module_macbinary
void de_module_macbinary(deark *c, struct deark_module_info *mi)
{
	mi->id = "macbinary";
	mi->desc = "MacBinary";
	mi->run_fn = de_run_macbinary;
	mi->identify_fn = de_identify_macbinary;
	mi->flags = DE_MODFLAG_SHAREDDETECTION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xea549(%rip), %rcx     # 0x1bb4a0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xe9461(%rip), %rcx     # 0x1ba3c6
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xd0fa0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x18d(%rip), %rcx       # 0xd1110
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x10, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)