LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2bmp.c
// Function: do_bitmap_header
static int do_bitmap_header(deark *c, struct os2icoctx *d, struct srcbitmap *srcbmp,
	i64 pos, const char *bitmapname)
{
	i64 pal_start;
	int saved_indent_level;
	int retval = 0;

	de_dbg_indent_save(c, &saved_indent_level);
	de_dbg(c, "%s %s bitmap header at %"I64_FMT, d->fmtname, bitmapname, pos);
	de_dbg_indent(c, 1);

	if(!get_bitmap_info(c, srcbmp, d->fmt, d->fmtname, pos))
		goto done;

	// read palette
	if (srcbmp->bi.pal_entries > 0) {
		pal_start = pos+14+srcbmp->bi.infohdrsize;
		de_dbg(c, "palette at %d", (int)pal_start);
		de_dbg_indent(c, 1);
		de_read_palette_rgb(c->infile, pal_start, srcbmp->bi.pal_entries, srcbmp->bi.bytes_per_pal_entry,
			srcbmp->pal, 256, DE_GETRGBFLAG_BGR);
		de_dbg_indent(c, -1);
	}

	if(srcbmp->bi.size_of_headers_and_pal<26) {
		de_err(c, "Bad %s image", d->fmtname);
		goto done;
	}

	retval = 1;

done:
	de_dbg_indent_restore(c, saved_indent_level);
	return retval;
}

// 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)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x15b580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0xd6b13(%rip), %rsi     # 0x1bd2ed
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %r8
callq 0xe6d40
cmpl $0x0, %eax
jne 0xe6818
jmp 0xe68d8
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jle 0xe68a8
movq -0x20(%rbp), %rax
addq $0xe, %rax
movq -0x18(%rbp), %rcx
addq 0x20(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
leaq 0xd5704(%rip), %rsi     # 0x1bbf50
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %r8
addq $0xb8, %r8
movl $0x100, %r9d            # imm = 0x100
movl $0x1, (%rsp)
callq 0x16c0c0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x18(%rbp), %rax
cmpq $0x1a, 0x90(%rax)
jge 0xe68d1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xd6a40(%rip), %rsi     # 0x1bd308
movb $0x0, %al
callq 0x15bfb0
jmp 0xe68d8
movl $0x1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x15b5a0
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2bmp.c
// Function: do_read_bitmap
static int do_read_bitmap(deark *c, struct srcbitmap *srcbmp, int mask_mode, const char *bitmapname)
{
	int retval = 0;

	if(!srcbmp) goto done;
	if(srcbmp->img) goto done;

	if(mask_mode && srcbmp->bi.bitcount!=1) {
		mask_mode = 0;
	}

	srcbmp->img = de_bitmap_create(c, srcbmp->bi.width, srcbmp->bi.height, mask_mode?1:4);

	de_dbg(c, "%s pixel data at %"I64_FMT, bitmapname, srcbmp->bi.bitsoffset);

	if(mask_mode) {
		de_convert_image_bilevel(c->infile, srcbmp->bi.bitsoffset, srcbmp->bi.rowspan,
			srcbmp->img, 0);
	}
	else if(srcbmp->bi.bitcount<=8) {
		de_convert_image_paletted(c->infile, srcbmp->bi.bitsoffset, srcbmp->bi.bitcount,
			srcbmp->bi.rowspan, srcbmp->pal, srcbmp->img, 0);
	}
	else if(srcbmp->bi.bitcount==24) {
		de_convert_image_rgb(c->infile, srcbmp->bi.bitsoffset, srcbmp->bi.rowspan, 3,
			srcbmp->img, DE_GETRGBFLAG_BGR);
	}
	else {
		goto done;
	}

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe691a
jmp 0xe6a5f
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe6929
jmp 0xe6a5f
cmpl $0x0, -0x14(%rbp)
je 0xe6941
movq -0x10(%rbp), %rax
cmpq $0x1, 0x38(%rax)
je 0xe6941
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movl -0x14(%rbp), %r8d
movl $0x4, %ecx
movl $0x1, %eax
cmpl $0x0, %r8d
cmovnel %eax, %ecx
callq 0x16b750
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xd69be(%rip), %rsi     # 0x1bd34e
movb $0x0, %al
callq 0x15b0d0
cmpl $0x0, -0x14(%rbp)
je 0xe69c9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %r8d, %r8d
callq 0x16bee0
jmp 0xe6a58
movq -0x10(%rbp), %rax
cmpq $0x8, 0x38(%rax)
jg 0xe6a16
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %r8
addq $0xb8, %r8
movq -0x10(%rbp), %rax
movq (%rax), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x16c520
jmp 0xe6a56
movq -0x10(%rbp), %rax
cmpq $0x18, 0x38(%rax)
jne 0xe6a52
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %r8
movl $0x3, %ecx
movl $0x1, %r9d
callq 0x16c8b0
jmp 0xe6a54
jmp 0xe6a5f
jmp 0xe6a56
jmp 0xe6a58
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2bmp.c
// Function: do_write_final_image
static void do_write_final_image(deark *c, struct os2icoctx *d, de_bitmap *img)
{
	de_finfo *fi = NULL;

	fi = de_finfo_create(c);
	if(d->srcbmp) {
		if(d->srcbmp->has_hotspot) {
			fi->has_hotspot = 1;
			fi->hotspot_x = d->srcbmp->bi.hotspot_x;
			fi->hotspot_y = (int)img->height - 1 - d->srcbmp->bi.hotspot_y;
		}
	}
	else if(d->maskbmp) {
		if(d->maskbmp->has_hotspot) {
			fi->has_hotspot = 1;
			fi->hotspot_x = d->maskbmp->bi.hotspot_x;
			fi->hotspot_y = (int)img->height - 1 - d->maskbmp->bi.hotspot_y;
		}
	}

	de_bitmap_write_to_file_finfo(img, fi, DE_CREATEFLAG_OPT_IMAGE | DE_CREATEFLAG_FLIP_IMAGE);

	de_finfo_destroy(c, fi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe6cb6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0xa8(%rax)
je 0xe6cb4
movq -0x20(%rbp), %rax
movb $0x1, 0xe(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
subl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x9c(%rax)
jmp 0xe6d15
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe6d13
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpb $0x0, 0xa8(%rax)
je 0xe6d11
movq -0x20(%rbp), %rax
movb $0x1, 0xe(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x9c(%rax)
jmp 0xe6d13
jmp 0xe6d15
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x6, %edx
callq 0x16afa0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15d260
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2bmp.c
// Function: get_bitmap_info
static int get_bitmap_info(deark *c, struct srcbitmap *srcbmp, enum fmtcode fmt,
	const char *fmtname, i64 pos)
{
	int retval = 0;
	unsigned int flags;

	flags = DE_BMPINFO_HAS_FILEHEADER;
	if(fmt==DE_OS2FMT_CP || fmt==DE_OS2FMT_PT) {
		srcbmp->has_hotspot = 1;
		flags |= DE_BMPINFO_HAS_HOTSPOT;
	}
	if(!fmtutil_get_bmpinfo(c, c->infile, &srcbmp->bi, pos, c->infile->len - pos, flags)) {
		de_err(c, "Invalid or unsupported bitmap");
		goto done;
	}

	if(srcbmp->bi.is_compressed) {
		if(srcbmp->bi.sizeImage_field) {
			srcbmp->bitssize = srcbmp->bi.sizeImage_field;
		}
		else {
			de_err(c, "Cannot determine bits size");
			goto done;
		}
	}
	else {
		srcbmp->bitssize = srcbmp->bi.rowspan * srcbmp->bi.height;
	}

	retval = 1;
done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
cmpl $0xa, -0x14(%rbp)
je 0xe6d75
cmpl $0x6, -0x14(%rbp)
jne 0xe6d89
movq -0x10(%rbp), %rax
movb $0x1, 0xa8(%rax)
movl -0x30(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r8
subq -0x28(%rbp), %r8
movl -0x30(%rbp), %r9d
callq 0x172d70
cmpl $0x0, %eax
jne 0xe6dd3
movq -0x8(%rbp), %rdi
leaq 0xd654b(%rip), %rsi     # 0x1bd315
movb $0x0, %al
callq 0x15bfb0
jmp 0xe6e39
movq -0x10(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
je 0xe6e16
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe6e00
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb0(%rax)
jmp 0xe6e14
movq -0x8(%rbp), %rdi
leaq 0xd6528(%rip), %rsi     # 0x1bd333
movb $0x0, %al
callq 0x15bfb0
jmp 0xe6e39
jmp 0xe6e32
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
imulq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb0(%rax)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2bmp.c
// Function: do_extract_one_image
static void do_extract_one_image(deark *c, i64 pos, enum fmtcode fmt,
	const char *fmtname, const char *ext)
{
	struct srcbitmap *srcbmp = NULL;
	dbuf *f = NULL;

	de_dbg(c, "%s image at %d", fmtname, (int)pos);
	de_dbg_indent(c, 1);

	srcbmp = de_malloc(c, sizeof(struct srcbitmap));

	if(!get_bitmap_info(c, srcbmp, fmt, fmtname, pos))
		goto done;

	f = dbuf_create_output_file(c, ext, NULL, 0);

	// First 10 bytes of the FILEHEADER can be copied unchanged.
	dbuf_copy(c->infile, pos, 10, f);

	// The "bits offset" is probably the only thing we need to adjust.
	dbuf_writeu32le(f, srcbmp->bi.size_of_headers_and_pal);

	// Copy the infoheader & palette
	dbuf_copy(c->infile, pos+14, srcbmp->bi.size_of_headers_and_pal-14, f);

	// Copy the bitmap
	if(srcbmp->bi.bitsoffset+srcbmp->bitssize > c->infile->len) goto done;
	dbuf_copy(c->infile, srcbmp->bi.bitsoffset, srcbmp->bitssize, f);

done:
	de_dbg_indent(c, -1);
	dbuf_close(f);
	do_free_srcbmp(c, srcbmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl %eax, %ecx
leaq 0xd602f(%rip), %rsi     # 0x1bd3ff
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movl $0x4b8, %esi            # imm = 0x4B8
callq 0x15b780
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
callq 0xe6d40
cmpl $0x0, %eax
jne 0xe7419
jmp 0xe74cd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rcx
movl $0xa, %edx
callq 0x166070
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x168c30
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0xe, %rsi
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rdx
subq $0xe, %rdx
movq -0x38(%rbp), %rcx
callq 0x166070
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
addq 0xb0(%rcx), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0xe74a9
jmp 0xe74cd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rax
movq 0xb0(%rax), %rdx
movq -0x38(%rbp), %rcx
callq 0x166070
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x38(%rbp), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe6740
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: de_module_ole1
void de_module_ole1(deark *c, struct deark_module_info *mi)
{
	mi->id = "ole1";
	mi->desc = "OLE1.0 objects";
	mi->run_fn = de_run_ole1;
	mi->identify_fn = NULL;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xbdef0(%rip), %rcx     # 0x1a5407
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd5f14(%rip), %rcx     # 0x1bd439
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xe7560
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: de_run_ole1
static void de_run_ole1(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 bytes_consumed = 0;
	int u_flag;

	if(mparams) {
		mparams->out_params.flags = 0;
	}

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

	d->input_encoding = de_get_input_encoding(c, mparams, DE_ENCODING_WINDOWS1252);
	// Use the "U" code if the exact size of the object is unknown. This will
	// improve the debug messages.
	u_flag = de_havemodcode(c, mparams, 'U');
	d->extract_all = de_get_ext_option_bool(c, "ole1:extractall",
		((c->extract_level>=2)?1:0));

	(void)do_ole_object(c, d, 0, c->infile->len, (u_flag?0:1),
		0, &bytes_consumed);
	calc_ole_obj_size(c, d);
	if(d->calculated_size>0 && d->calculated_size<=c->infile->len) {
		if(mparams) {
			mparams->out_params.flags |= 0x1;
			mparams->out_params.int64_1 = d->calculated_size;
		}
		de_dbg3(c, "ole1: calculated size=%"I64_FMT, d->calculated_size);
	}
	else {
		de_dbg3(c, "ole1: failed to calculate object size");
	}

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe7592
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x9, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x55, %edx
callq 0x15d1d0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x2, %ecx
cmovgel %eax, %edx
leaq 0xd5e53(%rip), %rsi     # 0x1bd448
callq 0x15cbc0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movl -0x24(%rbp), %edx
movl $0x1, %r8d
xorl %eax, %eax
cmpl $0x0, %edx
cmovnel %eax, %r8d
xorl %eax, %eax
movl %eax, %edx
xorl %r9d, %r9d
leaq -0x20(%rbp), %rax
movq %rax, (%rsp)
callq 0xe76d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe7940
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jle 0xe76ab
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jg 0xe76ab
cmpq $0x0, -0x10(%rbp)
je 0xe768f
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xd5db6(%rip), %rsi     # 0x1bd458
movb $0x0, %al
callq 0x15b400
jmp 0xe76bd
movq -0x8(%rbp), %rdi
leaq 0xd5dbc(%rip), %rsi     # 0x1bd472
movb $0x0, %al
callq 0x15b400
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: get_FormatID_name
static const char *get_FormatID_name(unsigned int t)
{
	const char *name;
	switch(t) {
	case 0: name="none"; break;
	case 1: name="linked"; break;
	case 2: name="embedded"; break;
	case 3: name="static"; break;
	case 5: name="presentation"; break;
	default: name="?"; break;
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xe7b89
movq -0x18(%rbp), %rax
leaq 0xd58dd(%rip), %rcx     # 0x1bd41c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb4bbe(%rip), %rax     # 0x19c70d
movq %rax, -0x10(%rbp)
jmp 0xe7b94
leaq 0xd7cb2(%rip), %rax     # 0x1bf80e
movq %rax, -0x10(%rbp)
jmp 0xe7b94
leaq 0xd598f(%rip), %rax     # 0x1bd4f8
movq %rax, -0x10(%rbp)
jmp 0xe7b94
leaq 0xd598b(%rip), %rax     # 0x1bd501
movq %rax, -0x10(%rbp)
jmp 0xe7b94
leaq 0xd5985(%rip), %rax     # 0x1bd508
movq %rax, -0x10(%rbp)
jmp 0xe7b94
leaq 0xd009d(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: extract_unknown_ole_obj
static void extract_unknown_ole_obj(deark *c, lctx *d, i64 pos, i64 len,
	struct de_stringreaderdata *classname_srd)
{
	de_finfo *fi = NULL;
	de_ucstring *s = NULL;

	fi = de_finfo_create(c);
	s = ucstring_create(c);

	ucstring_append_sz(s, "oleobj", DE_ENCODING_LATIN1);
	if(ucstring_isnonempty(classname_srd->str)) {
		ucstring_append_sz(s, ".", DE_ENCODING_LATIN1);
		ucstring_append_ucstring(s, classname_srd->str);
	}

	de_finfo_set_name_from_ucstring(c, fi, s, 0);

	dbuf_create_file_from_slice(c->infile, pos, len, "bin", fi, 0);

	ucstring_destroy(s);
	de_finfo_destroy(c, fi);
}

// 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 $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xd4969(%rip), %rsi     # 0x1bd6da
movl $0x5, %edx
callq 0x1715e0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1717f0
cmpl $0x0, %eax
je 0xe8db3
movq -0x38(%rbp), %rdi
leaq 0xde40b(%rip), %rsi     # 0x1c71a3
movl $0x5, %edx
callq 0x1715e0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x171460
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
xorl %ecx, %ecx
callq 0x15d2c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
leaq 0xd8426(%rip), %rcx     # 0x1c1207
xorl %r9d, %r9d
callq 0x166be0
movq -0x38(%rbp), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15d260
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: do_static_bitmap
static void do_static_bitmap(deark *c, lctx *d, i64 pos1, i64 len)
{
	i64 dlen;
	i64 pos = pos1;

	pos += 8; // ??
	dlen = de_getu32le_p(&pos);
	de_dbg(c, "bitmap size: %d", (int)dlen);

	de_dbg(c, "BITMAP16 at %"I64_FMT, pos);
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, "ddb", "N", c->infile, pos,
		de_min_int(dlen, pos1+len-pos));
	de_dbg_indent(c, -1);
}

// 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
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
leaq 0xd4946(%rip), %rsi     # 0x1bd7a8
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xc00ed(%rip), %rsi     # 0x1a8f65
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
subq -0x30(%rbp), %rsi
callq 0x15ccf0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
movq %rax, %r9
leaq 0xc5edd(%rip), %rsi     # 0x1aedb1
leaq 0xb6f21(%rip), %rdx     # 0x19fdfc
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: calc_chkver
static int calc_chkver(deark *c, lctx *d)
{
	UI ver_code;

	ver_code = (UI)de_getu32le_p(&d->pos_for_calc_size);
	if((ver_code & 0xff0000ffU)==0x00000001) {
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff0000ff, %eax       # imm = 0xFF0000FF
cmpl $0x1, %eax
jne 0xe8f3e
movl $0x1, -0x4(%rbp)
jmp 0xe8f45
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: calc_skip_presentation_obj
static int calc_skip_presentation_obj(deark *c, lctx *d)
{
	UI format;
	int retval = 0;
	int ret;
	i64 n;

	if(!calc_chkver(c, d)) goto done;

	format = (UI)de_getu32le_p(&d->pos_for_calc_size);
	if(format==0) {
		retval = 1;
		goto done;
	}

	ret = calc_chkstring(c, d);
	if(ret) {
		d->pos_for_calc_size += 8; // width, height
		n = de_getu32le_p(&d->pos_for_calc_size);
		d->pos_for_calc_size += n; // Presentation data
	}
	else {
		n = de_getu32le_p(&d->pos_for_calc_size);
		if(n==0) {
			n = de_getu32le_p(&d->pos_for_calc_size);
			d->pos_for_calc_size += n; // Clipboard format name
		}
		n = de_getu32le_p(&d->pos_for_calc_size);
		d->pos_for_calc_size += n; // Presentation data
	}
	retval = 1;

done:
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe8f00
cmpl $0x0, %eax
jne 0xe8f7e
jmp 0xe9072
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xe8fa8
movl $0x1, -0x18(%rbp)
jmp 0xe9072
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe9080
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xe8ff9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0xe906b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe9042
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ole1.c
// Function: calc_chkstring
static int calc_chkstring(deark *c, lctx *d)
{
	i64 n;
	struct de_stringreaderdata *srd = NULL;
	int retval = 0;

	n = de_getu32le_p(&d->pos_for_calc_size);
	if(n<16) {
		srd = dbuf_read_string(c->infile, d->pos_for_calc_size, n, n,
			DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_LATIN1);
		if(!de_strcmp(srd->sz, "DIB") ||
			!de_strcmp(srd->sz, "BITMAP") ||
			!de_strcmp(srd->sz, "METAFILEPICT"))
		{
			retval = 1;
		}
	}
	d->pos_for_calc_size += n;

	de_destroy_stringreaderdata(c, srd);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x165580
movq %rax, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jge 0xe9144
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %r8d
movl $0x5, %r9d
callq 0x1664c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe362e(%rip), %rsi     # 0x1cc72d
callq 0x191a0
cmpl $0x0, %eax
je 0xe913b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xed0bc(%rip), %rsi     # 0x1d61d4
callq 0x191a0
cmpl $0x0, %eax
je 0xe913b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xed0ad(%rip), %rsi     # 0x1d61de
callq 0x191a0
cmpl $0x0, %eax
jne 0xe9142
movl $0x1, -0x24(%rbp)
jmp 0xe9144
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x166830
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2pack.c
// Function: de_module_os2pack
void de_module_os2pack(deark *c, struct deark_module_info *mi)
{
	mi->id = "os2pack";
	mi->desc = "OS/2 PACK archive";
	mi->run_fn = de_run_os2pack;
	mi->identify_fn = de_identify_os2pack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd4631(%rip), %rcx     # 0x1bd7b8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd462b(%rip), %rcx     # 0x1bd7c0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xe91c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x3d(%rip), %rcx        # 0xe91f0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2pack.c
// Function: de_module_os2pack2
void de_module_os2pack2(deark *c, struct deark_module_info *mi)
{
	mi->id = "os2pack2";
	mi->desc = "OS/2 PACK2 archive";
	mi->run_fn = de_run_os2pack2;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
	mi->identify_fn = de_identify_os2pack2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd458b(%rip), %rcx     # 0x1bd7d2
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd4586(%rip), %rcx     # 0x1bd7db
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xe9290
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
leaq 0x40(%rip), %rcx        # 0xe92c0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2pack.c
// Function: os2pack2_is_member_at
static UI os2pack2_is_member_at(dbuf *f, i64 pos)
{
	UI sig;

	sig = (UI)dbuf_getu32be(f, pos);
	if(sig!=0xa596fdffU) return 0;
	if(dbuf_memcmp(f, pos+24, (const void*)"FTCOMP", 6)) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x165470
movl %eax, -0x1c(%rbp)
cmpl $0xa596fdff, -0x1c(%rbp) # imm = 0xA596FDFF
je 0xe9bb2
movl $0x0, -0x4(%rbp)
jmp 0xe9be4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq 0xd3c72(%rip), %rdx     # 0x1bd837
movl $0x6, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xe9bdd
movl $0x0, -0x4(%rbp)
jmp 0xe9be4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/os2pack.c
// Function: os2pack_is_member_at
static UI os2pack_is_member_at(dbuf *f, i64 pos)
{
	UI sig;

	sig = (UI)dbuf_getu32be(f, pos);
	return (sig==0xa596feffU || sig==0xa596ffffU ||
		sig==0xa5960014U || sig==0xa596140aU) ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x165470
movl %eax, -0x14(%rbp)
movb $0x1, %al
cmpl $0xa596feff, -0x14(%rbp) # imm = 0xA596FEFF
movb %al, -0x15(%rbp)
je 0xe9c47
movb $0x1, %al
cmpl $0xa596ffff, -0x14(%rbp) # imm = 0xA596FFFF
movb %al, -0x15(%rbp)
je 0xe9c47
movb $0x1, %al
cmpl $0xa5960014, -0x14(%rbp) # imm = 0xA5960014
movb %al, -0x15(%rbp)
je 0xe9c47
cmpl $0xa596140a, -0x14(%rbp) # imm = 0xA596140A
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/officeart.c
// Function: de_module_officeart
void de_module_officeart(deark *c, struct deark_module_info *mi)
{
	mi->id = "officeart";
	mi->desc = "Office Art data";
	mi->run_fn = de_run_officeart;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xbbdee(%rip), %rcx     # 0x1a5cd5
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd3a2e(%rip), %rcx     # 0x1bd923
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xe9f20
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/officeart.c
// Function: de_run_officeart
static void de_run_officeart(deark *c, de_module_params *mparams)
{
	struct officeartctx * oactx = NULL;
	dbuf *inf = c->infile;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);
	oactx = de_malloc(c, sizeof(struct officeartctx));

	oactx->record_pos = 0;
	while(1) {
		i64 ret;

		if(oactx->record_pos >= inf->len-8) break;

		// Have we reached the end of any containers?
		while(oactx->container_end_stackptr>0 &&
			oactx->record_pos>=oactx->container_end_stack[oactx->container_end_stackptr-1])
		{
			oactx->container_end_stackptr--;
			de_dbg_indent(c, -1);
		}

		ret = do_OfficeArtStream_record(c, oactx, inf);
		if(!ret || oactx->record_bytes_consumed<=0) break;

		oactx->record_pos += oactx->record_bytes_consumed;

		// Is a new container open?
		if(oactx->is_container && oactx->container_end_stackptr<OACTX_STACKSIZE) {
			oactx->container_end_stack[oactx->container_end_stackptr++] = oactx->container_endpos;
			de_dbg_indent(c, 1);
		}
	}

	de_free(c, oactx);
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x15b580
movq -0x8(%rbp), %rdi
movl $0x78, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
jl 0xe9f8d
jmp 0xea074
jmp 0xe9f8f
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, -0x31(%rbp)
jbe 0xe9fc1
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq 0x50(%rdx), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
setge %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xe9fca
jmp 0xe9fea
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
jmp 0xe9f8f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xea0a0
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xea013
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jg 0xea015
jmp 0xea074
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0xea06f
movq -0x18(%rbp), %rax
cmpq $0xa, 0x50(%rax)
jae 0xea06f
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rdx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
jmp 0xe9f6f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x15b5a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/officeart.c
// Function: get_officeart_rectype_name
static const char *get_officeart_rectype_name(unsigned int t)
{
	size_t k;

	for(k=0; k<DE_ARRAYCOUNT(officeart_rectype_arr); k++) {
		if((unsigned int)officeart_rectype_arr[k].rectype == t) {
			return officeart_rectype_arr[k].name;
		}
	}
	return "?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0xea696
leaq 0x131093(%rip), %rax    # 0x21b6f0
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movzwl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xea686
leaq 0x13107c(%rip), %rax    # 0x21b6f0
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xea6a1
jmp 0xea688
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xea64f
leaq 0xcd590(%rip), %rax     # 0x1b7c2d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_module_lbr
void de_module_lbr(deark *c, struct deark_module_info *mi)
{
	mi->id = "lbr";
	mi->desc = "LBR archive";
	mi->run_fn = de_run_lbr;
	mi->identify_fn = de_identify_lbr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd3393(%rip), %rcx     # 0x1bda5a
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd3389(%rip), %rcx     # 0x1bda5e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xea700
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x12d(%rip), %rcx       # 0xea820
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_run_lbr
static void de_run_lbr(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos = 0;

	d = de_malloc(c, sizeof(lctx));
	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_ASCII);

	d->crco = de_crcobj_create(c, DE_CRCOBJ_CRC16_XMODEM);

	// Read directory
	if(!do_entry(c, d, pos, 1)) goto done;
	pos += LBR_DIRENT_SIZE;

	// Read member files
	while(pos+LBR_DIRENT_SIZE <= c->infile->len &&
		pos+LBR_DIRENT_SIZE <= d->dir_len_in_bytes)
	{
		if(!do_entry(c, d, pos, 0)) goto done;
		pos += LBR_DIRENT_SIZE;
	}

done:
	if(d) {
		de_crcobj_destroy(d->crco);
		de_free(c, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x15eac0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0xebae0
cmpl $0x0, %eax
jne 0xea782
jmp 0xea7f2
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
addq $0x20, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jg 0xea7bf
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xea7c8
jmp 0xea7f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0xebae0
cmpl $0x0, %eax
jne 0xea7e2
jmp 0xea7f2
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0xea78e
jmp 0xea7f2
cmpq $0x0, -0x18(%rbp)
je 0xea813
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15f2e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_module_squeeze
void de_module_squeeze(deark *c, struct deark_module_info *mi)
{
	mi->id = "squeeze";
	mi->desc = "Squeeze (CP/M)";
	mi->run_fn = de_run_squeeze;
	mi->identify_fn = de_identify_squeeze;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xebd46(%rip), %rcx     # 0x1d65cd
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd31d5(%rip), %rcx     # 0x1bda6a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xea8c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x45d(%rip), %rcx       # 0xead10
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_identify_squeeze
static int de_identify_squeeze(deark *c)
{
	i64 id;

	id = de_getu16le(0);
	if(id==0xff76) return 70;
	if(id==0xfffa) return 25; // SQ2
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165280
movq %rax, -0x18(%rbp)
cmpq $0xff76, -0x18(%rbp)    # imm = 0xFF76
jne 0xead44
movl $0x46, -0x4(%rbp)
jmp 0xead5e
cmpq $0xfffa, -0x18(%rbp)    # imm = 0xFFFA
jne 0xead57
movl $0x19, -0x4(%rbp)
jmp 0xead5e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_module_crunch
void de_module_crunch(deark *c, struct deark_module_info *mi)
{
	mi->id = "crunch";
	mi->desc = "Crunch (CP/M)";
	mi->run_fn = de_run_crunch;
	mi->identify_fn = de_identify_crunch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd2cf2(%rip), %rcx     # 0x1bda79
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd2ceb(%rip), %rcx     # 0x1bda80
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xeadc0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x23d(%rip), %rcx       # 0xeaff0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_module_crlzh
void de_module_crlzh(deark *c, struct deark_module_info *mi)
{
	mi->id = "crlzh";
	mi->desc = "CRLZH (CP/M)";
	mi->run_fn = de_run_crlzh;
	mi->identify_fn = de_identify_crlzh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd2a37(%rip), %rcx     # 0x1bda8e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd2a2f(%rip), %rcx     # 0x1bda94
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xeb090
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x21d(%rip), %rcx       # 0xeb2a0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_module_zsq
void de_module_zsq(deark *c, struct deark_module_info *mi)
{
	mi->id = "zsq";
	mi->desc = "ZSQ (ZSQUSQ, LZW-compressed file)";
	mi->run_fn = de_run_zsq;
	mi->identify_fn = de_identify_zsq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd279a(%rip), %rcx     # 0x1bdaa1
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd2790(%rip), %rcx     # 0x1bdaa5
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xeb340
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x26d(%rip), %rcx       # 0xeb5a0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: de_module_lzwcom
void de_module_lzwcom(deark *c, struct deark_module_info *mi)
{
	mi->id = "lzwcom";
	mi->desc = "LZWCOM compressed file";
	mi->run_fn = de_run_lzwcom;
	mi->identify_fn = NULL;
	mi->help_fn = de_help_lzwcom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xd24d0(%rip), %rcx     # 0x1bdac7
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xd24c9(%rip), %rcx     # 0x1bdace
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xeb640
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x481(%rip), %rcx       # 0xebab0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: read_8_3_filename
static void read_8_3_filename(deark *c, lctx *d, struct member_data *md, i64 pos)
{
	de_ucstring *ext = NULL;

	dbuf_read_to_ucstring(c->infile, pos, 8, md->fn, 0, d->input_encoding);
	ucstring_strip_trailing_spaces(md->fn);
	if(md->fn->len==0) {
		ucstring_append_char(md->fn, '_');
	}

	ext = ucstring_create(c);
	dbuf_read_to_ucstring(c->infile, pos+8, 3, ext, 0, d->input_encoding);
	ucstring_strip_trailing_spaces(ext);
	if(ext->len>0) {
		ucstring_append_char(md->fn, '.');
		ucstring_append_ucstring(md->fn, ext);
	}

	ucstring_destroy(ext);
}

// 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 $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movl (%rax), %r9d
movl $0x8, %edx
xorl %r8d, %r8d
callq 0x1669f0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x171360
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0xebff6
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x5f, %esi
callq 0x1714c0
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movl (%rax), %r9d
movl $0x3, %edx
xorl %r8d, %r8d
callq 0x1669f0
movq -0x28(%rbp), %rdi
callq 0x171360
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jle 0xec062
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x2e, %esi
callq 0x1714c0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x171460
movq -0x28(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: handle_timestamp
static void handle_timestamp(deark *c, lctx *d, i64 date_raw, i64 time_raw,
	struct de_timestamp *ts, const char *name)
{
	i64 ut;
	char timestamp_buf[64];

	if(date_raw==0) {
		de_dbg(c, "%s: [not set]", name);
		return;
	}

	// Day 0 is Dec 31, 1977 (or it would be, if 0 weren't reserved).
	// Difference from Unix time (Jan 1, 1970) =
	//  365 days in 1970, 1971, 1973, 1974, 1975
	//  + 366 days in 1972, 1976
	//  + 364 days in 1977.
	ut = 86400 * (date_raw + (365*5 + 366*2 + 364));

	// Time of day is in DOS format.
	ut += 3600*(time_raw>>11); // hours
	ut += 60*(time_raw&0x07e0)>>5; // minutes
	ut += 2*(time_raw&0x001f); // seconds
	de_unix_time_to_timestamp(ut, ts, 0);
	de_timestamp_to_string(ts, timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "%s: %s", name, timestamp_buf);
}

// 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)
cmpq $0x0, -0x18(%rbp)
jne 0xec0c5
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xd1ae6(%rip), %rsi     # 0x1bdb9f
movb $0x0, %al
callq 0x15b0d0
jmp 0xec15b
movq -0x18(%rbp), %rax
addq $0xb69, %rax            # imm = 0xB69
imulq $0x15180, %rax, %rax    # imm = 0x15180
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
sarq $0xb, %rax
imulq $0xe10, %rax, %rax      # imm = 0xE10
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
andq $0x7e0, %rax            # imm = 0x7E0
imulq $0x3c, %rax, %rax
sarq $0x5, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
andq $0x1f, %rax
shlq %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x15d530
movq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq 0xe8d72(%rip), %rsi     # 0x1d4ec6
movb $0x0, %al
callq 0x15b0d0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/lbr.c
// Function: read_squeeze_headers
static int read_squeeze_headers(deark *c, struct squeeze_ctx *sqctx, i64 pos1)
{
	i64 pos = pos1;
	int retval = 0;

	read_squeeze_checksum(c, sqctx, pos);
	pos += 2;

	// I don't know the correct way to interpret the Squeeze filename field, if
	// there even is such a way.
	// Some Unsqueeze utilities accept it as-is, some truncate it after the third
	// filename extension byte, some interpret it the same as Crunch format
	// (including ignoring the high bit of every byte, for some reason).
	// Doing it the Crunch way is probably safe.
	if(!crcr_read_filename_etc(c, pos, &sqctx->fnd)) goto done;
	pos += sqctx->fnd.size;

	sqctx->cmpr_data_pos = pos;
	retval = 1;
done:
	if(!retval) {
		de_err(c, "Malformed header");
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xeca20
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0xec7b0
cmpl $0x0, %eax
jne 0xec5ac
jmp 0xec5cf
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x1, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xec5e7
movq -0x8(%rbp), %rdi
leaq 0xd1687(%rip), %rsi     # 0x1bdc67
movb $0x0, %al
callq 0x15bfb0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq