LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: get_hdrtype_descr
static char *get_hdrtype_descr(deark *c, char *buf, size_t buflen, u8 hdr_type)
{
	if(hdr_type==0) {
		de_strlcpy(buf, "", buflen);
	}
	else {
		de_ucstring *s = NULL;
		s = ucstring_create(c);
		if(hdr_type&0x01) ucstring_append_flags_item(s, "continuation page");
		if(hdr_type&0x02) ucstring_append_flags_item(s, "first page");
		if(hdr_type&0x04) ucstring_append_flags_item(s, "last page");
		de_snprintf(buf, buflen, " (%s)", ucstring_getpsz(s));
		ucstring_destroy(s);
	}
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xc9bfb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x106fdf(%rip), %rsi    # 0x1d0bd0
callq 0x15aa30
jmp 0xc9c9f
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x28(%rbp)
movzbl -0x19(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc9c2c
movq -0x28(%rbp), %rdi
leaq 0xeee76(%rip), %rsi     # 0x1b8a9d
callq 0x172680
movzbl -0x19(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc9c48
movq -0x28(%rbp), %rdi
leaq 0x103968(%rip), %rsi    # 0x1cd5ab
callq 0x172680
movzbl -0x19(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc9c64
movq -0x28(%rbp), %rdi
leaq 0xeee50(%rip), %rsi     # 0x1b8aaf
callq 0x172680
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x172500
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rcx
leaq 0xedc5b(%rip), %rdx     # 0x1b78ea
movb $0x0, %al
callq 0x15a980
movq -0x28(%rbp), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ogg.c
// Function: destroy_bitstream
static void destroy_bitstream(deark *c, lctx *d, struct stream_info *si)
{
	if(!si) return;

	if((si->stream_type==STREAMTYPE_VORBIS || si->stream_type==STREAMTYPE_THEORA)
		&& si->stream_state==0)
	{
		do_theora_vorbis_after_headers(c, d, si);
	}

	if(si->header_stream) {
		dbuf_close(si->header_stream);
	}

	de_free(c, si);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc9fed
jmp 0xca03f
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0xc9fff
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xca01a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xca01a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc8dc0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xca032
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: de_module_olepropset
void de_module_olepropset(deark *c, struct deark_module_info *mi)
{
	mi->id = "olepropset";
	mi->desc = "OLE Property Set";
	mi->run_fn = de_run_olepropset;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xdbb5e(%rip), %rcx     # 0x1a5bc5
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xeec27(%rip), %rcx     # 0x1b8c9c
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xca0a0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: de_run_olepropset
static void de_run_olepropset(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = de_malloc(c, sizeof(lctx));
	d->f = c->infile;

	if(de_get_ext_option(c, "olepropset:asciipropnames")) {
		d->asciipropnames = 1;
	}

	do_decode_PropertySetStream(c, d);

	de_free(c, d);
}

// 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
movl $0x10, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0xeebc9(%rip), %rsi     # 0x1b8cad
callq 0x15cb30
cmpq $0x0, %rax
je 0xca0fa
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xca120
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: find_fmtid_info
static const struct fmtid_info_entry *find_fmtid_info(const u8 *b)
{
	size_t k;
	for(k=0; k<DE_ARRAYCOUNT(fmtid_info_arr); k++) {
		if(!de_memcmp(fmtid_info_arr[k].guid, b, 16)) {
			return &fmtid_info_arr[k];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0xa, -0x18(%rbp)
jae 0xca523
movq -0x18(%rbp), %rcx
leaq 0x1502fe(%rip), %rax    # 0x21a7d0
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xca513
movq -0x18(%rbp), %rcx
leaq 0x1502ca(%rip), %rax    # 0x21a7d0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xca52b
jmp 0xca515
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xca4c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: destroy_propset_struct
static void destroy_propset_struct(deark *c, struct propset_struct *si)
{
	if(!si) return;
	if(si->dictionary) {
		size_t k;
		for(k=0; k<si->num_dict_entries; k++) {
			ucstring_destroy(si->dictionary[k].str);
		}
		de_free(c, si->dictionary);
	}
	de_free(c, si);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xca8f9
jmp 0xca962
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xca955
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xca944
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x171750
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xca90c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: set_prop_name
static void set_prop_name(deark *c, struct propset_struct *si, struct prop_info_struct *pinfo)
{
	size_t k;

	// Check the dictionary
	if(si->dictionary) {
		for(k=0; k<si->num_dict_entries; k++) {
			if(si->dictionary[k].prop_id == pinfo->prop_id) {
				pinfo->name_disposition = 2;
				ucstring_to_sz(si->dictionary[k].str, pinfo->name, sizeof(pinfo->name),
					0, DE_ENCODING_UTF8);
				return;
			}
		}
	}

	// Check our table of known types
	for(k=0; k<DE_ARRAYCOUNT(prop_info_arr); k++) {
		if((prop_info_arr[k].sfmtid != si->sfmtid) &&
			(prop_info_arr[k].sfmtid != SFMTID_COMMON))
		{
			continue;
		}
		if((prop_info_arr[k].prop_id) != (pinfo->prop_id & prop_info_arr[k].prop_id_mask))
			continue;

		pinfo->name_disposition = 1;
		de_strlcpy(pinfo->name, prop_info_arr[k].name, sizeof(pinfo->name));
		return;
	}

	// Not found
	pinfo->name_disposition = 0;
	de_strlcpy(pinfo->name, "???", sizeof(pinfo->name));
}

// 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
cmpq $0x0, 0x20(%rax)
je 0xcaa19
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xcaa17
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xcaa07
movq -0x18(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x1c, %rsi
movl $0x50, %edx
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0x172200
jmp 0xcab02
jmp 0xcaa09
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xca99b
jmp 0xcaa19
movq $0x0, -0x20(%rbp)
cmpq $0x5c, -0x20(%rbp)
jae 0xcaade
movq -0x20(%rbp), %rcx
leaq 0x14fed9(%rip), %rax    # 0x21a910
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xcaa62
movq -0x20(%rbp), %rcx
leaq 0x14febc(%rip), %rax    # 0x21a910
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
je 0xcaa62
jmp 0xcaacd
movq -0x20(%rbp), %rcx
leaq 0x14fea3(%rip), %rax    # 0x21a910
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movq -0x20(%rbp), %rsi
leaq 0x14fe88(%rip), %rdx    # 0x21a910
shlq $0x5, %rsi
addq %rsi, %rdx
andl 0x8(%rdx), %ecx
cmpl %ecx, %eax
je 0xcaa98
jmp 0xcaacd
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rbp), %rdi
addq $0x1c, %rdi
movq -0x20(%rbp), %rcx
leaq 0x14fe5a(%rip), %rax    # 0x21a910
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movl $0x50, %edx
callq 0x15aa30
jmp 0xcab02
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcaa21
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
addq $0x1c, %rdi
leaq 0xeba78(%rip), %rsi     # 0x1b6570
movl $0x50, %edx
callq 0x15aa30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: get_prop_data_type_name
static char *get_prop_data_type_name(char *buf, size_t buf_len, u32 dt)
{
	const char *name = NULL;
	const char *prefix = "";
	size_t k;

	if(dt>=0x1000 && dt<0x2000) {
		prefix = "vector of ";
		dt -= 0x1000;
	}
	else if(dt>=0x2000 && dt<0x3000) {
		prefix = "array of ";
		dt -= 0x2000;
	}

	for(k=0; k<DE_ARRAYCOUNT(prop_data_type_info_arr); k++) {
		if(prop_data_type_info_arr[k].dt == dt) {
			name = prop_data_type_info_arr[k].name;
			break;
		}
	}

	if(name) {
		de_snprintf(buf, buf_len, "%s%s", prefix, name);
	}
	else {
		de_strlcpy(buf, "?", buf_len);
	}

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x105aee(%rip), %rax    # 0x1d0bd0
movq %rax, -0x28(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jb 0xcb110
cmpl $0x2000, -0x14(%rbp)    # imm = 0x2000
jae 0xcb110
leaq 0xee2e1(%rip), %rax     # 0x1b93e0
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x14(%rbp)
jmp 0xcb13a
cmpl $0x2000, -0x14(%rbp)    # imm = 0x2000
jb 0xcb138
cmpl $0x3000, -0x14(%rbp)    # imm = 0x3000
jae 0xcb138
leaq 0xee2c2(%rip), %rax     # 0x1b93eb
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x14(%rbp)
jmp 0xcb13a
movq $0x0, -0x30(%rbp)
cmpq $0x15, -0x30(%rbp)
jae 0xcb18e
movq -0x30(%rbp), %rcx
leaq 0x15033c(%rip), %rax    # 0x21b490
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xcb17e
movq -0x30(%rbp), %rcx
leaq 0x150323(%rip), %rax    # 0x21b490
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcb18e
jmp 0xcb180
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcb142
cmpq $0x0, -0x20(%rbp)
je 0xcb1b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x106ea9(%rip), %rdx    # 0x1d2055
movb $0x0, %al
callq 0x15a980
jmp 0xcb1c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xeca69(%rip), %rsi     # 0x1b7c2d
callq 0x15aa30
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_vector_of_scalar
static int do_prop_vector_of_scalar(deark *c, lctx *d, struct propset_struct *si,
	struct prop_info_struct *pinfo, u32 scalar_type)
{
	i64 k;
	i64 nitems;
	i64 pos = pinfo->dpos;

	read_vectorheader(c, d, si, pinfo, &nitems);
	pos += 4;

	// Note: These are the valid types:
	//  2,3,4,5,6,7,8,0xa,0xb,
	//  0x10,0x11,0x12,0x13,0x14,0x15,0x1e,0x1f,
	//  0x40,0x47,0x48
	//  (0xc is also a valid vector type, but is not handled here)

	for(k=0; k<nitems; k++) {
		i64 bytes_consumed = 0;
		int ret;
		char name[80];

		if(pos >= d->f->len) break;
		if(k>500) break;

		de_snprintf(name, sizeof(name), "%s[%u]",
			(pinfo->name_disposition==1)?pinfo->name:"value", (unsigned int)k);
		ret = do_prop_simple_type(c, d, si, pinfo, scalar_type, name, pos, &bytes_consumed);
		if(!ret || (bytes_consumed<1)) return 0;
		pos += bytes_consumed;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0xcc160
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0xcb8eb
movq $0x0, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xcb814
jmp 0xcb8eb
cmpq $0x1f4, -0x38(%rbp)     # imm = 0x1F4
jle 0xcb823
jmp 0xcb8eb
leaq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xcb84c
movq -0x28(%rbp), %rax
addq $0x1c, %rax
movq %rax, -0xc0(%rbp)
jmp 0xcb85c
leaq 0xf3d05(%rip), %rax     # 0x1bf558
movq %rax, -0xc0(%rbp)
jmp 0xcb85c
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movq -0x38(%rbp), %rax
movl %eax, %r8d
movl $0x50, %esi
leaq 0xedc85(%rip), %rdx     # 0x1b9502
movb $0x0, %al
callq 0x15a980
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0xb0(%rbp), %r9
movq -0x48(%rbp), %r10
leaq -0x50(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xcb1e0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xcb8c5
cmpq $0x1, -0x50(%rbp)
jge 0xcb8ce
movl $0x0, -0x4(%rbp)
jmp 0xcb8f2
movq -0x50(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xcb7e8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_any_int
static void do_prop_any_int(deark *c, lctx *d, struct propset_struct *si,
	struct prop_info_struct *pinfo, const char *name, i64 pos,
	unsigned int nbytes, int is_signed)
{
	i64 n;
	char descr[200];

	// FIXME: This doesn't really support uint64.
	n = dbuf_getint_ext(d->f, pos, nbytes, 1, is_signed);

	descr[0] = '\0';

	if(pinfo->prop_id==0x00000001U) { // code page
		// Code page is usually a *signed* 16-bit int, which means the maximum
		// value is 32767, even though code pages can go up to 65535.
		// Apparently, code pages over 32767 are stored as negative numbers.
		if(de_int_in_range(n, -32768, -1)) {
			si->code_page = (int)(n + 65536);
		}
		else {
			si->code_page = (int)n;
		}

		si->encoding = de_windows_codepage_to_encoding(c, si->code_page,
			descr, sizeof(descr), 0x1);
		if(si->encoding==DE_ENCODING_UNKNOWN) {
			si->encoding = DE_ENCODING_ASCII;
		}
	}

	if(descr[0]) {
		de_dbg(c, "%s: %"I64_FMT" (%s)", name, n, descr);
	}
	else {
		de_dbg(c, "%s: %"I64_FMT, name, n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
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 -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movl 0x10(%rbp), %edx
movl 0x18(%rbp), %r8d
movl $0x1, %ecx
callq 0x165a80
movq %rax, -0x38(%rbp)
movb $0x0, -0x100(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xcb9dd
movq -0x38(%rbp), %rdi
movq $-0x8000, %rsi          # imm = 0x8000
movq $-0x1, %rdx
callq 0x15cd50
cmpl $0x0, %eax
je 0xcb98e
movq -0x38(%rbp), %rax
addq $0x10000, %rax          # imm = 0x10000
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0xcb99b
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
leaq -0x100(%rbp), %rdx
movl $0xc8, %ecx
movl $0x1, %r8d
callq 0x161e60
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xcb9db
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0xcb9dd
cmpb $0x0, -0x100(%rbp)
je 0xcba09
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x100(%rbp), %r8
leaq 0xd704d(%rip), %rsi     # 0x1a2a4d
movb $0x0, %al
callq 0x15b0d0
jmp 0xcba23
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0xe2303(%rip), %rsi     # 0x1add1f
movb $0x0, %al
callq 0x15b0d0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_FILETIME
static int do_prop_FILETIME(deark *c, lctx *d, struct propset_struct *si,
	struct prop_info_struct *pinfo, const char *name, i64 pos)
{
	i64 ts_as_FILETIME;
	int is_duration = 0;

	ts_as_FILETIME = dbuf_geti64le(d->f, pos);

	if(si->sfmtid==SFMTID_SUMMARYINFO && pinfo->prop_id==10) {
		is_duration = 1; // The "Editing time" property is special.
	}

	if(ts_as_FILETIME<=0) {
		de_dbg(c, "%s: %"I64_FMT, name, ts_as_FILETIME);
	}
	else if(is_duration) {
		dbg_FILETIME_as_duration(c, d, ts_as_FILETIME, name);
	}
	else {
		struct de_timestamp ts;
		char timestamp_buf[64];

		de_FILETIME_to_timestamp(ts_as_FILETIME, &ts, 0x1);
		de_timestamp_to_string(&ts, timestamp_buf, sizeof(timestamp_buf), 0);
		de_dbg(c, "%s: %"I64_FMT" (%s)", name, ts_as_FILETIME, timestamp_buf);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x1657e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0xcbae8
movq -0x20(%rbp), %rax
cmpl $0xa, (%rax)
jne 0xcbae8
movl $0x1, -0x3c(%rbp)
cmpq $0x0, -0x38(%rbp)
jg 0xcbb0b
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0xe221d(%rip), %rsi     # 0x1add1f
movb $0x0, %al
callq 0x15b0d0
jmp 0xcbb74
cmpl $0x0, -0x3c(%rbp)
je 0xcbb28
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xcc080
jmp 0xcbb72
movq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x1, %edx
callq 0x15d580
leaq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x90(%rbp), %r8
leaq 0xd6ee2(%rip), %rsi     # 0x1a2a4d
movb $0x0, %al
callq 0x15b0d0
jmp 0xcbb74
movl $0x1, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_CLSID
static void do_prop_CLSID(deark *c, lctx *d, struct propset_struct *si,
	struct prop_info_struct *pinfo, const char *name, i64 pos)
{
	u8 clsid[16];
	char clsid_string[50];

	dbuf_read(d->f, clsid, pos, 16);
	fmtutil_guid_to_uuid(clsid);
	fmtutil_render_uuid(c, clsid, clsid_string, sizeof(clsid_string));
	de_dbg(c, "%s: {%s}", name, clsid_string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
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 -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x10, %ecx
callq 0x164d10
leaq -0x40(%rbp), %rdi
callq 0x174010
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movl $0x32, %ecx
callq 0x173ee0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq 0xed89a(%rip), %rsi     # 0x1b9498
movb $0x0, %al
callq 0x15b0d0
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_CodePageString
static void do_prop_CodePageString(deark *c, lctx *d, struct propset_struct *si,
	const char *name, i64 dpos, int is_dict_name, i64 *bytes_consumed)
{
	de_ucstring *s = NULL;
	s = ucstring_create(c);
	do_prop_CodePageString2(c, d, si, name, dpos, is_dict_name, bytes_consumed, s);
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %r10
movq -0x38(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xcaf30
movq -0x38(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_UnicodeString
static void do_prop_UnicodeString(deark *c, lctx *d, struct propset_struct *si,
	const char *name, i64 dpos, i64 *bytes_consumed)
{
	i64 n, n_raw;
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	n_raw = dbuf_geti32le(d->f, dpos);
	n = n_raw;
	if(n>0) n--; // Ignore the trailing NUL
	if(n<0) n=0;
	dbuf_read_to_ucstring_n(d->f, dpos+4, n*2, DE_DBG_MAX_STRLEN*2, s,
		0, DE_ENCODING_UTF16LE);
	de_dbg(c, "%s: \"%s\"", name, ucstring_getpsz(s));

	ucstring_destroy(s);
	// TODO: This is supposed to be padded to a multiple of 4 bytes, but in the
	// sample files I have, it is not.
	*bytes_consumed = 4 + n_raw*2;
}

// 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 %r9, -0x30(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x165600
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jle 0xcbcf4
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0xcbd03
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movq -0x38(%rbp), %rdx
shlq %rdx
movq -0x48(%rbp), %r8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %r9d, %r9d
movl $0x3, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x172500
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0xebeaa(%rip), %rsi     # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x48(%rbp), %rdi
callq 0x171750
movq -0x40(%rbp), %rcx
shlq %rcx
addq $0x4, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: do_prop_blob
static void do_prop_blob(deark *c, lctx *d, struct propset_struct *si,
	struct prop_info_struct *pinfo, const char *name,
	i64 pos1, i64 *bytes_consumed)
{
	i64 blob_data_start;
	i64 blob_data_size;
	i64 pos = pos1;
	u8 magic[8];

	blob_data_size = dbuf_getu32le_p(d->f, &pos);
	de_dbg(c, "%s data size: %"I64_FMT, name, blob_data_size);

	blob_data_start = pos;
	if(blob_data_start + blob_data_size > d->f->len) return;

	*bytes_consumed = 4 + de_pad_to_4(blob_data_size);

	if(blob_data_size>=8) {
		// Minor hack. If a blob looks like a JPEG file, extract it.
		dbuf_read(d->f, magic, blob_data_start, 8);

		if(magic[0]==0xff && magic[1]==0xd8 && magic[2]==0xff) {
			dbuf_create_file_from_slice(d->f, blob_data_start, blob_data_size,
				"oleblob.jpg", NULL, DE_CREATEFLAG_IS_AUX);
			goto done;
		}
	}

	de_dbg_hexdump(c, d->f, blob_data_start, blob_data_size, 256, NULL, 0x1);

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
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 -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x165580
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq 0xed537(%rip), %rsi     # 0x1b94da
movb $0x0, %al
callq 0x15b0d0
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0xcbfcc
jmp 0xcc078
movq -0x40(%rbp), %rdi
callq 0x15ce30
movq %rax, %rcx
addq $0x4, %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x8, -0x40(%rbp)
jl 0xcc04e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl $0x8, %ecx
callq 0x164d10
movzbl -0x50(%rbp), %eax
cmpl $0xff, %eax
jne 0xcc04c
movzbl -0x4f(%rbp), %eax
cmpl $0xd8, %eax
jne 0xcc04c
movzbl -0x4e(%rbp), %eax
cmpl $0xff, %eax
jne 0xcc04c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0xed4b2(%rip), %rcx     # 0x1b94ec
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %r9d
callq 0x166be0
jmp 0xcc078
jmp 0xcc04e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, (%rsp)
callq 0x15b840
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/olepropset.c
// Function: dbg_FILETIME_as_duration
static void dbg_FILETIME_as_duration(deark *c, lctx *d, i64 t, const char *name)
{
	i64 n_d, n_h, n_m;
	double n_s;

	n_d = t/864000000000LL;
	n_h = (t%864000000000LL)/36000000000LL;
	n_m = (t%36000000000LL)/600000000;
	n_s = ((double)(t%600000000))/10000000.0;
	de_dbg(c, "%s: %"I64_FMT" (%"I64_FMT"d %"I64_FMT"h %"I64_FMT"m %.3fs)",
		name, t, n_d, n_h, n_m, n_s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movabsq $0xc92a69c000, %rcx     # imm = 0xC92A69C000
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movabsq $0xc92a69c000, %rcx     # imm = 0xC92A69C000
cqto
idivq %rcx
movq %rdx, %rax
movabsq $0x861c46800, %rcx      # imm = 0x861C46800
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movabsq $0x861c46800, %rcx      # imm = 0x861C46800
cqto
idivq %rcx
movq %rdx, %rax
movl $0x23c34600, %ecx       # imm = 0x23C34600
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl $0x23c34600, %ecx       # imm = 0x23C34600
cqto
idivq %rcx
cvtsi2sd %rdx, %xmm0
movsd 0xd2089(%rip), %xmm1    # 0x19e1a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rax
movsd -0x40(%rbp), %xmm0
leaq 0xed335(%rip), %rsi     # 0x1b9479
movq %rax, (%rsp)
movb $0x1, %al
callq 0x15b0d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: de_module_iso9660
void de_module_iso9660(deark *c, struct deark_module_info *mi)
{
	mi->id = "iso9660";
	mi->desc = "ISO 9660 (CD-ROM) image";
	mi->run_fn = de_run_iso9660;
	mi->identify_fn = de_identify_iso9660;
	mi->help_fn = de_help_iso9660;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xed397(%rip), %rcx     # 0x1b956e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xed391(%rip), %rcx     # 0x1b9576
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xcc220
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2fd(%rip), %rcx       # 0xcc500
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x33e(%rip), %rcx       # 0xcc550
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: de_module_cd_raw
void de_module_cd_raw(deark *c, struct deark_module_info *mi)
{
	mi->id = "cd_raw";
	mi->desc = "Raw CD image";
	mi->run_fn = de_run_cd_raw;
	mi->identify_fn = de_identify_cd_raw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xecfd7(%rip), %rcx     # 0x1b958e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xecfd0(%rip), %rcx     # 0x1b9595
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xcc5f0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xad(%rip), %rcx        # 0xcc690
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: de_run_cd_raw
static void de_run_cd_raw(deark *c, de_module_params *mparams)
{
	struct cdraw_params cdrp;

	cdraw_setdefaults(&cdrp);
	cdraw_detect_params(c->infile, &cdrp);
	if(!cdrp.ok) {
		de_err(c, "Failed to detect raw CD format");
		goto done;
	}

	de_dbg(c, "total bytes/sector: %"I64_FMT, cdrp.sector_total_len);
	de_dbg(c, "data bytes/sector: %"I64_FMT, cdrp.sector_dlen);
	de_dbg(c, "data offset: %"I64_FMT, cdrp.sector_data_offset);

	do_cdraw_convert(c, &cdrp);

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd0620
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd0670
cmpl $0x0, -0x38(%rbp)
jne 0xcc634
movq -0x8(%rbp), %rdi
leaq 0xedc57(%rip), %rsi     # 0x1ba282
movb $0x0, %al
callq 0x15bfb0
jmp 0xcc683
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xedc5e(%rip), %rsi     # 0x1ba2a1
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xedc60(%rip), %rsi     # 0x1ba2b9
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xf05da(%rip), %rsi     # 0x1bcc49
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd0890
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: de_identify_cd_raw
static int de_identify_cd_raw(deark *c)
{
	struct cdraw_params cdrp;

	cdraw_setdefaults(&cdrp);
	cdraw_detect_params(c->infile, &cdrp);
	if(cdrp.ok) return 70;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd0620
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd0670
cmpl $0x0, -0x38(%rbp)
je 0xcc6c5
movl $0x46, -0x4(%rbp)
jmp 0xcc6cc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: de_module_nrg
void de_module_nrg(deark *c, struct deark_module_info *mi)
{
	mi->id = "nrg";
	mi->desc = "NRG CD-ROM image";
	mi->run_fn = de_run_nrg;
	mi->identify_fn = de_identify_nrg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xeceab(%rip), %rcx     # 0x1b95a2
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xecea1(%rip), %rcx     # 0x1b95a6
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xcc730
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x27d(%rip), %rcx       # 0xcc9a0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: de_identify_nrg
static int de_identify_nrg(deark *c)
{
	if(!de_input_file_has_ext(c, "nrg")) return 0;
	if(detect_nrg_internal(c)>0) {
		return 85;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xecbeb(%rip), %rsi     # 0x1b95a2
callq 0x15d180
cmpl $0x0, %eax
jne 0xcc9ca
movl $0x0, -0x4(%rbp)
jmp 0xcc9e8
movq -0x10(%rbp), %rdi
callq 0xd0a90
cmpl $0x0, %eax
jle 0xcc9e1
movl $0x55, -0x4(%rbp)
jmp 0xcc9e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: is_hsf_volume_descriptor
static u8 is_hsf_volume_descriptor(deark *c, lctx *d, i64 secnum, i64 pos1)
{
	i64 n;

	n = getu32bbo(c->infile, pos1);
	if(n != secnum) return 0;
	if(dbuf_memcmp(c->infile, pos1+9, (const void*)g_sig_CDROM, 5)) {
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xcd5b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xcd23d
movb $0x0, -0x1(%rbp)
jmp 0xcd26d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x9, %rsi
movq 0x15854c(%rip), %rdx    # 0x2257a0
movl $0x5, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xcd269
movb $0x0, -0x1(%rbp)
jmp 0xcd26d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: get_vol_descr_type_name
static const char *get_vol_descr_type_name(enum voldesctype_enum vdt)
{
	const char *name = NULL;
	switch(vdt) {
	case VOLDESCTYPE_CD_BOOT: name="boot record"; break;
	case VOLDESCTYPE_CD_PRIMARY: name="primary volume descriptor"; break;
	case VOLDESCTYPE_CD_PRIMARY_HSF: name="High Sierra file structure"; break;
	case VOLDESCTYPE_CD_SUPPL: name="supplementary or enhanced volume descriptor"; break;
	case VOLDESCTYPE_CD_PARTDESCR: name="volume partition descriptor"; break;
	case VOLDESCTYPE_CD_TERM: name="volume descriptor set terminator"; break;
	case VOLDESCTYPE_BEA: name="beginning of extended descriptors"; break;
	case VOLDESCTYPE_TEA: name="end of extended descriptors"; break;
	case VOLDESCTYPE_NSR: name="UDF indicator"; break;
	case VOLDESCTYPE_OTHERVALID: name="(other/valid)"; break;
	case VOLDESCTYPE_UNKNOWN: break;
	}
	return name?name:"?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0xcd338
movq -0x18(%rbp), %rax
leaq 0xec285(%rip), %rcx     # 0x1b9530
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xec4e4(%rip), %rax     # 0x1b979f
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec4e3(%rip), %rax     # 0x1b97ab
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec4f0(%rip), %rax     # 0x1b97c5
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec4fe(%rip), %rax     # 0x1b97e0
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec51d(%rip), %rax     # 0x1b980c
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec52c(%rip), %rax     # 0x1b9828
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec540(%rip), %rax     # 0x1b9849
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec555(%rip), %rax     # 0x1b986b
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec564(%rip), %rax     # 0x1b9887
movq %rax, -0x10(%rbp)
jmp 0xcd338
leaq 0xec565(%rip), %rax     # 0x1b9895
movq %rax, -0x10(%rbp)
jmp 0xcd338
jmp 0xcd338
cmpq $0x0, -0x10(%rbp)
je 0xcd349
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xcd356
leaq 0xea8dd(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0xcd356
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: do_boot_volume_descr
static void do_boot_volume_descr(deark *c, lctx *d, i64 pos1)
{
	de_ucstring *tmpstr = NULL;
	struct de_stringreaderdata *boot_sys_id = NULL;
	i64 pos = pos1 + 7;
	i64 n;

	tmpstr = ucstring_create(c);
	boot_sys_id = dbuf_read_string(c->infile, pos, 32, 32, DE_CONVFLAG_STOP_AT_NUL,
		DE_ENCODING_ASCII);
	pos += 32;
	de_dbg(c, "boot system id: \"%s\"", ucstring_getpsz(boot_sys_id->str));

	handle_iso_string_p(c, d, NULL, "boot id", &pos, 32, tmpstr);

	if(!de_strcmp(boot_sys_id->sz, "EL TORITO SPECIFICATION")) {
		n = de_getu32le_p(&pos);
		de_dbg(c, "first sector of boot catalog: %u", (unsigned int)n);
	}

	ucstring_destroy(tmpstr);
	de_destroy_stringreaderdata(c, boot_sys_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movl $0x20, %ecx
movl $0x1, %r9d
movq %rcx, %rdx
movl %r9d, %r8d
callq 0x1664c0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x172500
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0xec4b1(%rip), %rsi     # 0x1b98a3
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0xec4a8(%rip), %rcx     # 0x1b98b8
leaq -0x30(%rbp), %r8
movl $0x20, %r9d
movq %rax, (%rsp)
callq 0xcd5e0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xec48e(%rip), %rsi     # 0x1b98c0
callq 0x191a0
cmpl $0x0, %eax
jne 0xcd469
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165580
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
leaq 0xec476(%rip), %rsi     # 0x1b98d8
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x166830
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_primary_or_suppl_volume_descr
static void do_primary_or_suppl_volume_descr(deark *c, lctx *d, i64 secnum,
	i64 pos1, int is_primary, u8 is_cdi, u8 is_hsf)
{
	struct vol_record *newvol;

	newvol = de_malloc(c, sizeof(struct vol_record));
	newvol->secnum = secnum;
	newvol->is_cdi = is_cdi;
	newvol->is_hsf = is_hsf;

	do_primary_or_suppl_volume_descr_internal(c, d, newvol, secnum, pos1, is_primary);

	if(newvol->quality==0) goto done; // not usable
	if(d->vol_desc_sector_forced && (secnum!=d->vol_desc_sector_to_use)) {
		// User told us not to use this volume descriptor.
		goto done;
	}

	if(d->vol) {
		// We already have a volume descriptor. Is the new one preferable?
		if(newvol->quality > d->vol->quality) {
			de_free(c, d->vol);
			d->vol = newvol;
			newvol = NULL;
		}
	}
	else {
		d->vol = newvol;
		newvol = NULL;
	}

done:
	if(newvol) de_free(c, newvol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
callq 0x15b780
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movb -0x25(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x27(%rax)
movb 0x10(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0xcd720
movq -0x30(%rbp), %rax
movzbl 0x29(%rax), %eax
cmpl $0x0, %eax
jne 0xcd513
jmp 0xcd590
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
cmpl $0x0, %eax
je 0xcd530
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xcd530
jmp 0xcd590
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xcd57a
movq -0x30(%rbp), %rax
movzbl 0x29(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
movzbl 0x29(%rcx), %ecx
cmpl %ecx, %eax
jle 0xcd578
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x15b820
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq $0x0, -0x30(%rbp)
jmp 0xcd58e
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq $0x0, -0x30(%rbp)
jmp 0xcd590
cmpq $0x0, -0x30(%rbp)
je 0xcd5a4
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: read_iso_string
static void read_iso_string(deark *c, lctx *d, struct vol_record *vol,
	i64 pos, i64 len, de_ucstring *s)
{
	de_encoding encoding;

	ucstring_empty(s);
	if(vol && (vol->encoding!=DE_ENCODING_UNKNOWN)) {
		encoding = vol->encoding;
	}
	else {
		encoding = DE_ENCODING_ASCII;
	}
	if(encoding==DE_ENCODING_UTF16BE) {
		if(len%2) {
			len--;
		}
	}
	dbuf_read_to_ucstring(c->infile, pos, len, s, 0, encoding);
	ucstring_truncate_at_NUL(s);
	ucstring_strip_trailing_spaces(s);
}

// 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 %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x171210
cmpq $0x0, -0x18(%rbp)
je 0xcd6b6
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xcd6b6
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0xcd6bd
movl $0x1, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jne 0xcd6e5
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0xcd6e3
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xcd6e5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r9d
xorl %r8d, %r8d
callq 0x1669f0
movq -0x30(%rbp), %rdi
callq 0x1712b0
movq -0x30(%rbp), %rdi
callq 0x171360
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: read_escape_sequences
static void read_escape_sequences(deark *c, lctx *d, struct vol_record *vol, i64 pos)
{
	u8 es[8];

	de_dbg(c, "escape sequences:");
	de_dbg_indent(c, 1);
	de_dbg_hexdump(c, c->infile, pos, 32, 32, NULL, 0);
	de_read(es, pos, sizeof(es));

	// 40, 43, 45 are for UCS-2.
	// 4a-4c are for UTF-16, probably not used by Joliet since it predates UTF-16,
	// but it shouldn't hurt to allow it.
	if(es[0]==0x25 && es[1]==0x2f && (es[2]==0x40 || es[2]==0x43 || es[2]==0x45 ||
		es[2]==0x4a || es[2]==0x4b || es[3]==0x4c))
	{
		vol->is_joliet = 1;
		vol->encoding = DE_ENCODING_UTF16BE;
	}
	de_dbg(c, "is joliet: %u", (unsigned int)vol->is_joliet);
	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
leaq 0xebbea(%rip), %rsi     # 0x1b9bdd
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movl $0x20, %r8d
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r8, %rcx
movl $0x0, (%rsp)
callq 0x15b840
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x8, %ecx
callq 0x164d10
movzbl -0x28(%rbp), %eax
cmpl $0x25, %eax
jne 0xce0a9
movzbl -0x27(%rbp), %eax
cmpl $0x2f, %eax
jne 0xce0a9
movzbl -0x26(%rbp), %eax
cmpl $0x40, %eax
je 0xce096
movzbl -0x26(%rbp), %eax
cmpl $0x43, %eax
je 0xce096
movzbl -0x26(%rbp), %eax
cmpl $0x45, %eax
je 0xce096
movzbl -0x26(%rbp), %eax
cmpl $0x4a, %eax
je 0xce096
movzbl -0x26(%rbp), %eax
cmpl $0x4b, %eax
je 0xce096
movzbl -0x25(%rbp), %eax
cmpl $0x4c, %eax
jne 0xce0a9
movq -0x18(%rbp), %rax
movb $0x1, 0x25(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x25(%rax), %edx
leaq 0xebb33(%rip), %rsi     # 0x1b9bef
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iso9660.c
// Function: find_CDi_root_dir
static void find_CDi_root_dir(deark *c, lctx *d, struct vol_record *vol,
	i64 path_tbl_M_loc)
{
	i64 ptpos;
	i64 rootpos;

	// Look at the first item in the path table, assume it is for the root dir.
	ptpos = sector_dpos(d, path_tbl_M_loc);
	de_dbg(c, "path table at %"I64_FMT, ptpos);
	de_dbg_indent(c, 1);
	vol->root_dir_extent_blk = de_getu32be(ptpos+2);
	de_dbg(c, "root dir pos: block #%u", (UI)vol->root_dir_extent_blk);

	// Peek at the first item in the root dir, to get the length of the root dir.
	rootpos = sector_dpos(d, vol->root_dir_extent_blk);
	vol->root_dir_data_len = de_getu32be(rootpos+14);
	vol->root_dir_data_len = 0xd88;
	de_dbg(c, "root dir len: %u", (unsigned int)vol->root_dir_data_len);
	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 -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcd1e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xeba65(%rip), %rsi     # 0x1b9bfd
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x2, %rsi
callq 0x165470
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
leaq 0xeba2d(%rip), %rsi     # 0x1b9c0f
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xcd1e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
addq $0xe, %rsi
callq 0x165470
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0xd88, 0x10(%rax)      # imm = 0xD88
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
leaq 0xeb9e8(%rip), %rsi     # 0x1b9c27
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)