LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/bsave.c
// Function: do_2color
static void do_2color(deark *c, lctx *d)
{
	i64 w, h;
	i64 j;
	i64 src_rowspan;
	i64 pos;
	de_bitmap *img = NULL;

	pos = BSAVE_HDRSIZE;

	if(d->has_dimension_fields) {
		// 11-byte header that includes width & height
		w = d->metrics.maybe_bitsperrow;
		h = d->metrics.maybe_nrows;
		pos+=4;
	}
	else if(!d->interlaced) {
		w = get_width(c, d, 640);
		src_rowspan = (w+7)/8;
		h = d->data_size / src_rowspan;
		h = get_height(c, d, h);
	}
	else {
		w = get_width(c, d, 640);
		h = get_height(c, d, 200);
	}

	de_dbg_dimensions(c, w, h);
	src_rowspan = (w+7)/8;

	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 1);

	for(j=0; j<h; j++) {
		if(d->interlaced) {
			de_convert_row_bilevel(c->infile, pos + (j%2)*8192 + (j/2)*src_rowspan,
				img, j, 0);
		}
		else {
			de_convert_row_bilevel(c->infile, pos + j*src_rowspan, img, j, 0);
		}
	}

	de_bitmap_write_to_file(img, NULL, 0);
done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbp
cmpb $0x0, 0x2d(%rsi)
pushq $0x8
popq %r13
je 0x37be9
movq 0x440(%r14), %r12
movq 0x448(%r14), %rbx
pushq $0xb
jmp 0x37c33
movb 0x2c(%r14), %bl
movl $0x280, %esi            # imm = 0x280
movq %rbp, %rdi
callq 0x3843b
movq %rax, %r12
testb %bl, %bl
je 0x37c0b
movl $0xc8, %esi
movq %rbp, %rdi
jmp 0x37c29
movq %r12, %rax
addq $0x7, %rax
cqto
idivq %r13
movq %rax, %rcx
movq 0x10(%r14), %rax
cqto
idivq %rcx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x38484
movq %rax, %rbx
pushq $0x7
popq %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xdf038
leaq 0x7(%r12), %rax
cqto
idivq %r13
movq %rax, %r13
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe6be1
testl %eax, %eax
je 0x37cf8
movq %r14, 0x10(%rsp)
pushq $0x1
popq %rcx
movq %rbp, 0x8(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe7437
movq %rax, %r15
movq %rbx, %r12
xorl %ebx, %ebx
testq %r12, %r12
cmovleq %rbx, %r12
movq (%rsp), %r14
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x37cea
movq 0x10(%rsp), %rax
cmpb $0x0, 0x2c(%rax)
movq %r14, %rsi
je 0x37cc4
movl %ebx, %eax
andl $0x2000, %eax           # imm = 0x2000
addq (%rsp), %rax
movq %rbp, %rsi
shrq %rsi
imulq %r13, %rsi
addq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq %r15, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
callq 0xe779f
incq %rbp
addq $0x2000, %rbx           # imm = 0x2000
addq %r13, %r14
jmp 0x37c99
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe70b7
jmp 0x37cfb
xorl %r15d, %r15d
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe7084
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/bsave.c
// Function: do_256color
static void do_256color(deark *c, lctx *d)
{
	i64 w, h;
	i64 pos = BSAVE_HDRSIZE;
	de_bitmap *img = NULL;

	if(d->has_dimension_fields) {
		w = d->metrics.maybe_bytesperrow;
		h = d->metrics.maybe_nrows;
		pos += 4;
	}
	else {
		w = get_width(c, d, 320);
		h = d->data_size / w;
		h = get_height(c, d, h);
	}
	de_dbg_dimensions(c, w, h);

	if(!d->pal_valid) {
		de_copy_std_palette(DE_PALID_VGA256, 0, 0, d->pal, 256, 0);
	}

	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 3);
	de_convert_image_paletted(c->infile, pos, 8, w, d->pal, img, 0);
	de_bitmap_write_to_file(img, NULL, 0);
done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x2d(%rsi)
je 0x38180
movq 0x448(%rbx), %r13
movq 0x450(%rbx), %r15
pushq $0xb
jmp 0x381a9
movl $0x140, %esi            # imm = 0x140
movq %r14, %rdi
callq 0x3843b
movq %rax, %r15
movq 0x10(%rbx), %rax
cqto
idivq %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x38484
movq %rax, %r13
pushq $0x7
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xdf038
cmpl $0x0, 0x38(%rbx)
jne 0x381d8
leaq 0x3c(%rbx), %rcx
pushq $0x28
popq %rdi
movl $0x100, %r8d            # imm = 0x100
xorl %esi, %esi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0xe1b11
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe6be1
testl %eax, %eax
je 0x3822c
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe7437
movq %rax, %r13
movq 0x18(%r14), %rdi
addq $0x3c, %rbx
andl $0x0, (%rsp)
pushq $0x8
popq %rdx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %rax, %r9
callq 0xe7cbc
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe70b7
jmp 0x3822f
xorl %r13d, %r13d
movq %r13, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe7084
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/bsave.c
// Function: do_wh16
static void do_wh16(deark *c, lctx *d)
{
	de_bitmap *img = NULL;
	i64 w, h;
	i64 src_planespan;
	i64 src_rowspan;
	i64 pos;

	pos = BSAVE_HDRSIZE;
	w = d->metrics.maybe_bitsperrow;
	h = d->metrics.maybe_nrows;
	pos += 4;
	de_dbg_dimensions(c, w, h);
	if(!de_good_image_dimensions(c, w, h)) goto done;

	img = de_bitmap_create(c, w, h, 3);
	src_planespan = (w+7)/8;
	src_rowspan = src_planespan*4;

	de_copy_std_palette(DE_PALID_PC16, 0, 0, d->pal, 16, 0);
	de_convert_image_paletted_planar(c->infile, pos, 4, src_rowspan, src_planespan,
		d->pal, img, 0x2);
	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x440(%rsi), %r12
movq 0x448(%rsi), %r14
movq %r12, %rsi
movq %r14, %rdx
callq 0xdf038
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe6be1
testl %eax, %eax
je 0x382f2
pushq $0x3
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe7437
movq %rax, %r14
addq $0x7, %r12
pushq $0x8
popq %rcx
movq %r12, %rax
cqto
idivq %rcx
movq %rax, %r12
leaq (,%rax,4), %r13
addq $0x3c, %rbx
pushq $0x14
popq %rdi
pushq $0x10
popq %r8
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
xorl %r9d, %r9d
callq 0xe1b11
movq 0x18(%r15), %rdi
pushq $0xb
popq %rsi
pushq $0x4
popq %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbx, %r9
pushq $0x2
pushq %r14
callq 0xe7de1
popq %rax
popq %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe70b7
jmp 0x382f5
xorl %r14d, %r14d
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe7084
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/bsave.c
// Function: do_b265
static void do_b265(deark *c, lctx *d)
{
	static const de_color palette1[4] = { 0xffffff, 0x55ffff, 0x000000, 0xffffff };
	static const de_color palette2[4] = { 0xffffff, 0x000000, 0x000000, 0x000000 };
	int palent;
	i64 w, h;
	i64 i,j;
	i64 bits_per_scanline;
	de_bitmap *img = NULL;
	i64 fakewidth;

	w = 320;
	fakewidth = w/2;
	h = d->data_size * 4 / fakewidth;
	bits_per_scanline = w;

	de_dbg_dimensions(c, w, h);
	if(!de_good_image_dimensions(c, w, h)) goto done;
	img = de_bitmap_create(c, w, h, 3);

	for(j=0; j<h; j++) {
		for(i=0; i<fakewidth; i++) {
			palent = (int)de_get_bits_symbol(c->infile, 2,
				BSAVE_HDRSIZE + (j/8)*bits_per_scanline + (i/4)*8 + j%8, i%4);
			de_bitmap_setpixel_rgb(img, 2*i  , j, palette1[palent]);
			de_bitmap_setpixel_rgb(img, 2*i+1, j, palette2[palent]);
		}
	}

	de_bitmap_write_to_file(img, NULL, 0);

done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movq 0x10(%rsi), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
movl $0x140, %esi            # imm = 0x140
movq %rax, %rdx
callq 0xdf038
movl $0x140, %esi            # imm = 0x140
movq %r13, %rdi
movq %r14, %rdx
callq 0xe6be1
testl %eax, %eax
je 0x38421
pushq $0x3
popq %rcx
movl $0x140, %esi            # imm = 0x140
movq %r13, %rdi
movq %r14, %rdx
callq 0xe7437
xorl %r12d, %r12d
testq %r14, %r14
cmovleq %r12, %r14
movq %rax, %r15
movq %r14, 0x8(%rsp)
cmpq %r14, %r12
je 0x38413
movq %r12, %rax
shrq $0x3, %rax
imulq $0x140, %rax, %rax      # imm = 0x140
movl %r12d, %ecx
andl $0x7, %ecx
addq %rcx, %rax
addq $0x7, %rax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpq $0xa0, %r14
je 0x38406
movq 0x18(%r13), %rdi
movl %ebp, %edx
andl $0x1f8, %edx            # imm = 0x1F8
addq 0x10(%rsp), %rdx
movl %r14d, %ecx
andl $0x3, %ecx
pushq $0x2
popq %rsi
callq 0xe74bf
movzbl %al, %ebx
shll $0x2, %ebx
leaq 0xd3a1d(%rip), %rax     # 0x10bdf0
movl (%rbx,%rax), %ecx
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe7287
leaq 0x1(%rbp), %rsi
leaq 0xd3a11(%rip), %rax     # 0x10be00
movl (%rbx,%rax), %ecx
movq %r15, %rdi
movq %r12, %rdx
callq 0xe7287
incq %r14
addq $0x2, %rbp
jmp 0x3839e
incq %r12
movq 0x8(%rsp), %r14
jmp 0x38370
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe70b7
jmp 0x38424
xorl %r15d, %r15d
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe7084
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/bsave.c
// Function: detect_cga16_cbfn
static int detect_cga16_cbfn(struct de_bufferedreadctx *brctx, const u8 *buf,
	i64 buf_len)
{
	struct detect_cga16_struct *ctx = (struct detect_cga16_struct*)brctx->userdata;
	i64 k;

	for(k=0; k<buf_len; k++) {
		if(ctx->flag0) break;
		if(((brctx->offset+k)%2)==0) { // Even-numbered byte
			if(buf[k]==0xdd) ctx->count1++;
			else if(buf[k]==0xde) ctx->count2++;
			else ctx->flag0 = 1;
		}
		else { // Odd-numbered (color) byte.
			// We want to make sure there is a color byte that isn't one of the
			// special screen codes.
			if(ctx->flag1==0 && buf[k]!=0xdd && buf[k]!=0xde) {
				ctx->flag1 = 1;
			}
		}
	}

	return (ctx->flag0) ? 0 : 1;
}

// Assembly:
movq (%rdi), %rax
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
movb 0x8(%rax), %r8b
cmpq %rcx, %rdx
je 0x38566
testb %r8b, %r8b
jne 0x38566
movl 0x10(%rdi), %r8d
addl %ecx, %r8d
testb $0x1, %r8b
jne 0x38538
movzbl (%rsi,%rcx), %r8d
cmpl $0xde, %r8d
je 0x38552
cmpl $0xdd, %r8d
jne 0x3855d
incl (%rax)
jmp 0x38555
cmpb $0x0, 0x9(%rax)
jne 0x38555
movb (%rsi,%rcx), %r8b
addb $0x23, %r8b
cmpb $0x2, %r8b
jb 0x38555
movb $0x1, 0x9(%rax)
jmp 0x38555
incl 0x4(%rax)
xorl %r8d, %r8d
incq %rcx
jmp 0x38506
movb $0x1, 0x8(%rax)
movb $0x1, %r8b
jmp 0x38558
xorl %eax, %eax
testb %r8b, %r8b
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/aldus.c
// Function: de_module_aldus_inst
void de_module_aldus_inst(deark *c, struct deark_module_info *mi)
{
	mi->id = "aldus_inst";
	mi->desc = "Aldus LZW and PKZP";
	mi->run_fn = de_run_aldus_inst;
	mi->identify_fn = de_identify_aldus_inst;
}

// Assembly:
leaq 0xd3899(%rip), %rax     # 0x10be10
movq %rax, (%rsi)
leaq 0xd389a(%rip), %rax     # 0x10be1b
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x3859c
movq %rax, 0x18(%rsi)
leaq 0x48(%rip), %rax        # 0x385df
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/aldus.c
// Function: de_identify_aldus_inst
static int de_identify_aldus_inst(deark *c)
{
	if(dbuf_memcmp(c->infile, 0, (const u8*)"ALDUS ", 6)) return 0;

	if(!dbuf_memcmp(c->infile, 6, (const u8*)"PKZP  2.", 8))
		return 100;
	if(!dbuf_memcmp(c->infile, 6, (const u8*)"LZW   1.", 8))
		return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xd3a1d(%rip), %rdx     # 0x10c00e
xorl %r14d, %r14d
pushq $0x6
popq %rcx
xorl %esi, %esi
callq 0xe4d48
testl %eax, %eax
jne 0x38644
movq 0x18(%rbx), %rdi
leaq 0xd3a08(%rip), %rdx     # 0x10c015
pushq $0x6
popq %rsi
pushq $0x8
popq %rcx
callq 0xe4d48
testl %eax, %eax
je 0x38640
movq 0x18(%rbx), %rdi
leaq 0xd39f7(%rip), %rdx     # 0x10c01e
pushq $0x6
popq %rsi
pushq $0x8
popq %rcx
callq 0xe4d48
xorl %ecx, %ecx
testl %eax, %eax
pushq $0x64
popq %r14
cmovnel %ecx, %r14d
jmp 0x38644
pushq $0x64
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/adex.c
// Function: de_module_adex
void de_module_adex(deark *c, struct deark_module_info *mi)
{
	mi->id = "adex";
	mi->desc = "ADEX IMG/RLE";
	mi->run_fn = de_run_adex;
	mi->identify_fn = de_identify_adex;
}

// Assembly:
leaq 0xd3138(%rip), %rax     # 0x10c027
movq %rax, (%rsi)
leaq 0xd3133(%rip), %rax     # 0x10c02c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x38f14
movq %rax, 0x18(%rsi)
leaq 0x487(%rip), %rax       # 0x39396
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/adex.c
// Function: de_identify_adex
static int de_identify_adex(deark *c)
{
	u8 b;

	if((u32)de_getu32be(0)!=0x50494354U) return 0; // "PICT"
	b = de_getbyte(4);
	if(b!=0 && b!=1) return 0;
	b = de_getbyte(5);
	if(b!=4 && b!=8) return 0;
	return 65;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xe404f
cmpl $0x50494354, %eax       # imm = 0x50494354
jne 0x393d9
movq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
callq 0xe3eb4
cmpb $0x1, %al
ja 0x393d9
movq 0x18(%r14), %rdi
pushq $0x5
popq %rsi
callq 0xe3eb4
addb $-0x4, %al
xorl %ecx, %ecx
testb $-0x5, %al
pushq $0x41
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cab.c
// Function: de_module_cab
void de_module_cab(deark *c, struct deark_module_info *mi)
{
	mi->id = "cab";
	mi->desc = "Microsoft Cabinet (CAB)";
	mi->run_fn = de_run_cab;
	mi->identify_fn = de_identify_cab;
	mi->flags |= DE_MODFLAG_WARNPARSEONLY;
}

// Assembly:
leaq 0xd2cb6(%rip), %rax     # 0x10c0a1
movq %rax, (%rsi)
leaq 0xd2cb0(%rip), %rax     # 0x10c0a5
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x39414
movq %rax, 0x18(%rsi)
leaq 0xbc6(%rip), %rax       # 0x39fd1
movq %rax, 0x20(%rsi)
orb $0x20, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cardfile.c
// Function: de_module_cardfile
void de_module_cardfile(deark *c, struct deark_module_info *mi)
{
	mi->id = "cardfile";
	mi->desc = "Windows Cardfile address book";
	mi->run_fn = de_run_cardfile;
	mi->identify_fn = de_identify_cardfile;
}

// Assembly:
leaq 0xd24c1(%rip), %rax     # 0x10c4bc
movq %rax, (%rsi)
leaq 0xd24c0(%rip), %rax     # 0x10c4c5
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x3a020
movq %rax, 0x18(%rsi)
leaq 0x801(%rip), %rax       # 0x3a81c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cardfile.c
// Function: detect_crd_fmt
static int detect_crd_fmt(deark *c)
{
	u8 buf[4];
	de_read(buf, 0, 4);

	if(!de_memcmp(buf, "MGC", 3)) return DE_CRDFMT_MGC;
	if(!de_memcmp(buf, "RRG", 3)) return DE_CRDFMT_RRG;
	if(!de_memcmp(buf, "DKO", 3)) return DE_CRDFMT_DKO;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x18(%rdi), %rdi
leaq 0xc(%rsp), %rbx
pushq $0x4
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe3cb7
leaq 0xd1c95(%rip), %rsi     # 0x10c4e3
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x18230
testl %eax, %eax
je 0x3a895
leaq 0xd1c8c(%rip), %rsi     # 0x10c4f0
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x18230
testl %eax, %eax
je 0x3a899
leaq 0xd1c8f(%rip), %rsi     # 0x10c50b
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x18230
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x3a89c
pushq $0x1
jmp 0x3a89b
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cardfile.c
// Function: do_text
static void do_text(deark *c, lctx *d, struct page_ctx *pg,
	i64 text_pos, i64 text_len)
{
	de_finfo *fi_text = NULL;

	if(text_len<1) goto done;

	if(c->extract_level>=2) {
		fi_text = de_finfo_create(c);
		if(c->filenames_from_file)
			de_finfo_set_name_from_ucstring(c, fi_text, pg->name, 0);

		do_extract_text_data(c, d, fi_text, text_pos, text_len);
	}
	else {
		do_dbg_text_data(c, d, text_pos, text_len);
	}

done:
	de_finfo_destroy(c, fi_text);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %r8, %r8
jle 0x3a904
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
cmpl $0x2, 0x90(%rbx)
jl 0x3a90c
movq %rdx, %rbp
movq %rbx, %rdi
callq 0xdfd1a
movq %rax, %r14
cmpb $0x0, 0xd0(%rbx)
je 0x3a8ef
movq 0x20(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xdfd55
leaq (%r15,%r12), %rax
movq 0x18(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x3a961
xorl %ebp, %ebp
jmp 0x3a999
xorl %r14d, %r14d
jmp 0x3a9a1
movq %rbx, %rdi
callq 0xeac74
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movl 0x4(%r13), %eax
movl %eax, (%rsp)
xorl %r14d, %r14d
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0xe4ced
movq %rbp, %rdi
callq 0xeb877
leaq 0xf346a(%rip), %rsi     # 0x12ddb4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %rbp, %rdi
callq 0xeaf3c
jmp 0x3a9a1
leaq 0xe26f8(%rip), %rsi     # 0x11d060
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xe4e62
movq %rax, %rbp
movq 0x18(%rbx), %rdi
movzbl 0x4(%r13), %ecx
orl $0x300, %ecx            # imm = 0x300
pushq $0x6
popq %r9
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0xe66ec
movq %rbp, %rdi
callq 0xe5591
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdfd24
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: de_module_cfb
void de_module_cfb(deark *c, struct deark_module_info *mi)
{
	mi->id = "cfb";
	mi->desc = "Microsoft Compound File Binary File";
	mi->run_fn = de_run_cfb;
	mi->identify_fn = de_identify_cfb;
	mi->help_fn = de_help_cfb;
}

// Assembly:
leaq 0xd1d8d(%rip), %rax     # 0x10c750
movq %rax, (%rsi)
leaq 0xd1d87(%rip), %rax     # 0x10c754
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x3a9f3
movq %rax, 0x18(%rsi)
leaq 0xfd(%rip), %rax        # 0x3aae0
movq %rax, 0x20(%rsi)
leaq 0x114(%rip), %rax       # 0x3ab02
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: de_run_cfb
static void de_run_cfb(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	const char *cfbfmt_opt;

	d = de_malloc(c, sizeof(lctx));
	d->decode_streams = 1;
	d->subformat_req = SUBFMT_AUTO;

	if(de_get_ext_option(c, "cfb:extractstreams")) {
		d->extract_raw_streams = 1;
		d->decode_streams = 0;
	}
	if(de_get_ext_option(c, "cfb:dumpdir")) {
		d->dump_dir_structure = 1; // A low-level debugging feature
	}

	if(de_havemodcode(c, mparams, 'T')) {
		// TIFF tag 37680 mode
		// TODO: Handle 'OLE Property Set Storage' more generally.
		d->subformat_req = SUBFMT_TIFF37680;
	}

	if(d->subformat_req == SUBFMT_AUTO) {
		// If we haven't set subformat_req yet, look at the command-line option

		cfbfmt_opt = de_get_ext_option(c, "cfb:fmt");
		if(cfbfmt_opt) {
			if(!de_strcmp(cfbfmt_opt, "auto")) {
				d->subformat_req = SUBFMT_AUTO;
			}
			else if(!de_strcmp(cfbfmt_opt, "raw")) {
				d->subformat_req = SUBFMT_RAW;
			}
			else if(!de_strcmp(cfbfmt_opt, "thumbsdb")) {
				d->subformat_req = SUBFMT_THUMBSDB;
			}
		}
	}

	de_run_cfb_internal(c, d);

	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0xc8, %esi
callq 0xdecaf
movq %rax, %r14
movb $0x1, 0xd(%rax)
andl $0x0, (%rax)
leaq 0xd1d5f(%rip), %rsi     # 0x10c778
movq %rbx, %rdi
callq 0xdfa87
testq %rax, %rax
je 0x3aa2d
movw $0x1, 0xc(%r14)
leaq 0xd1d57(%rip), %rsi     # 0x10c78b
movq %rbx, %rdi
callq 0xdfa87
testq %rax, %rax
je 0x3aa46
movb $0x1, 0xe(%r14)
pushq $0x54
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdfcf4
testl %eax, %eax
je 0x3aa60
pushq $0x3
popq %rax
movl %eax, (%r14)
jmp 0x3aa66
cmpl $0x0, (%r14)
je 0x3aa81
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ab48
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xded32
leaq 0xd1d0f(%rip), %rsi     # 0x10c797
movq %rbx, %rdi
callq 0xdfa87
testq %rax, %rax
je 0x3aa66
movq %rax, %r15
leaq 0xc8ad8(%rip), %rsi     # 0x103577
movq %rax, %rdi
callq 0x181a0
testl %eax, %eax
je 0x3aad5
leaq 0xf0872(%rip), %rsi     # 0x12b324
movq %r15, %rdi
callq 0x181a0
testl %eax, %eax
je 0x3aad9
leaq 0xd1cda(%rip), %rsi     # 0x10c79f
movq %r15, %rdi
callq 0x181a0
testl %eax, %eax
jne 0x3aa66
pushq $0x2
jmp 0x3aa5a
xorl %eax, %eax
jmp 0x3aa5b
pushq $0x1
jmp 0x3aa5a
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: de_help_cfb
static void de_help_cfb(deark *c)
{
	de_msg(c, "-opt cfb:extractstreams : Extract raw streams, instead of decoding");
	de_msg(c, "-opt cfb:fmt=raw : Do not try to detect the document type");
	de_msg(c, "-opt cfb:fmt=thumbsdb : Assume Thumbs.db format");
	de_msg(c, "-opt cfb:msrgbamode=0 : Disable special processing of nonstandard-"
		"JPEG Thumbs.db thumbnails");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xd25b3(%rip), %rsi     # 0x10d0c0
xorl %eax, %eax
callq 0xdf42e
leaq 0xd25e8(%rip), %rsi     # 0x10d103
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
leaq 0xd2611(%rip), %rsi     # 0x10d13d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdf42e
leaq 0xd2630(%rip), %rsi     # 0x10d16d
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0xdf42e
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: describe_sec_id
static void describe_sec_id(deark *c, lctx *d, i64 sec_id,
	char *buf, size_t buf_len)
{
	i64 sec_offset;

	if(sec_id >= 0) {
		sec_offset = sec_id_to_offset(c, d, sec_id);
		de_snprintf(buf, buf_len, "offs=%d", (int)sec_offset);
	}
	else if(sec_id == -1) {
		de_strlcpy(buf, "free", buf_len);
	}
	else if(sec_id == -2) {
		de_strlcpy(buf, "end of chain", buf_len);
	}
	else if(sec_id == -3) {
		de_strlcpy(buf, "FAT SecID", buf_len);
	}
	else if(sec_id == -4) {
		de_strlcpy(buf, "DIFAT SecID", buf_len);
	}
	else {
		de_strlcpy(buf, "?", buf_len);
	}
}

// Assembly:
movq %rdx, %rax
movq %rsi, %rcx
testq %rsi, %rsi
js 0x3cd9a
incl %ecx
imull 0x20(%rdi), %ecx
leaq 0xe32d5(%rip), %rdx     # 0x120062
pushq $0x50
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
jmp 0xde40c
addq $0x4, %rcx
cmpq $0x3, %rcx
ja 0x3cdd8
leaq 0xcf96d(%rip), %rdx     # 0x10c718
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0xcfb67(%rip), %rsi     # 0x10c922
jmp 0x3cddf
leaq 0xcfb51(%rip), %rsi     # 0x10c915
jmp 0x3cddf
leaq 0xcfb43(%rip), %rsi     # 0x10c910
jmp 0x3cddf
leaq 0xcfb4e(%rip), %rsi     # 0x10c924
jmp 0x3cddf
leaq 0xe2102(%rip), %rsi     # 0x11eee1
pushq $0x50
popq %rdx
movq %rax, %rdi
jmp 0xde492
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: read_and_cvt_timestamp
static void read_and_cvt_timestamp(deark *c, dbuf *f, i64 pos,
	struct de_timestamp *ts)
{
	i64 ts_as_FILETIME;

	de_zeromem(ts, sizeof(struct de_timestamp));
	ts_as_FILETIME = dbuf_geti64le(f, pos);
	if(ts_as_FILETIME!=0) {
		de_FILETIME_to_timestamp(ts_as_FILETIME, ts, 0x1);
	}
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
callq 0xe418b
testq %rax, %rax
je 0x3ce26
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xe0051
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: do_dump_dir_structure
static void do_dump_dir_structure(deark *c, lctx *d)
{
	i64 i;

	de_dbg(c, "dir structure:");
	de_dbg_indent(c, 1);
	for(i=0; i<d->num_dir_entries; i++) {
		de_dbg(c, "[%d] t=%d p=%d c=%d s=%d,%d", (int)i,
			(int)d->dir_entry[i].entry_type,
			(int)d->dir_entry[i].parent_id,
			(int)d->dir_entry[i].child_id,
			(int)d->dir_entry[i].sibling_id[0],
			(int)d->dir_entry[i].sibling_id[1]);
		de_dbg_indent(c, 1);
		if(d->dir_entry[i].fname_srd && d->dir_entry[i].fname_srd->str) {
			de_dbg(c, "fname: \"%s\"",
				ucstring_getpsz(d->dir_entry[i].fname_srd->str));
		}
		if(d->dir_entry[i].path) {
			de_dbg(c, "path: \"%s\"",
				ucstring_getpsz(d->dir_entry[i].path));
		}
		de_dbg_indent(c, -1);
	}
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xcfe14(%rip), %rsi     # 0x10cc54
xorl %eax, %eax
callq 0xde896
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdeba7
leaq 0xcfe0a(%rip), %r15     # 0x10cc63
pushq $-0x1
popq %r12
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq 0x70(%r14), %r13
jge 0x3cf24
movq 0x98(%r14), %rax
movzbl 0x4(%rax,%rbp), %ecx
movl 0x70(%rax,%rbp), %r8d
movl 0x64(%rax,%rbp), %r9d
movl 0x68(%rax,%rbp), %r10d
movl 0x6c(%rax,%rbp), %r11d
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0xde896
popq %rax
popq %rcx
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0xdeba7
movq 0x98(%r14), %rax
movq 0x28(%rax,%rbp), %rcx
testq %rcx, %rcx
je 0x3cee7
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x3cee7
callq 0xeb7e4
movq %rbx, %rdi
leaq 0xcfda9(%rip), %rsi     # 0x10cc7f
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq 0x98(%r14), %rax
movq 0x78(%rax,%rbp), %rdi
testq %rdi, %rdi
je 0x3cf0a
callq 0xeb7e4
movq %rbx, %rdi
leaq 0xf9fd9(%rip), %rsi     # 0x136ed9
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
movl %r12d, %esi
callq 0xdeba7
incq %r13
addq $0x88, %rbp
jmp 0x3ce62
pushq $-0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdeba7
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: do_mark_dir_entries_recursively
static void do_mark_dir_entries_recursively(deark *c, lctx *d, i32 parent_id,
	i32 dir_entry_idx, int level)
{
	struct dir_entry_info *dei;
	int k;

	if(dir_entry_idx<0 || (i64)dir_entry_idx>=d->num_dir_entries) return;

	dei = &d->dir_entry[dir_entry_idx];

	if(dei->entry_type!=OBJTYPE_STORAGE && dei->entry_type!=OBJTYPE_STREAM) return;

	dei->parent_id = parent_id;

	if(dei->entry_type==OBJTYPE_STORAGE && dei->fname_srd && dei->fname_srd->str && !dei->path) {
		// Set the full pathname
		dei->path = ucstring_create(c);
		if(parent_id>0 && d->dir_entry[parent_id].path) {
			ucstring_append_ucstring(dei->path, d->dir_entry[parent_id].path);
			ucstring_append_sz(dei->path, "/", DE_ENCODING_LATIN1);
		}
		ucstring_append_ucstring(dei->path, dei->fname_srd->str);
	}

	if(level>50) return;
	for(k=0; k<2; k++) {
		do_mark_dir_entries_recursively(c, d, parent_id, dei->sibling_id[k], level+1);
	}

	if(dei->entry_type==OBJTYPE_STORAGE) {
		// This is a "subdirectory" entry, so examine its children (starting with the
		// one that we know about).
		do_mark_dir_entries_recursively(c, d, dir_entry_idx, dei->child_id, level+1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %r12d, %r12d
js 0x3d046
movl %r12d, %eax
cmpq %rax, 0x70(%r14)
jle 0x3d046
movq 0x98(%r14), %r13
imulq $0x88, %rax, %rcx
movb 0x4(%r13,%rcx), %al
leal -0x1(%rax), %edx
cmpb $0x1, %dl
ja 0x3d046
addq %rcx, %r13
movl %ebp, 0x70(%r13)
cmpb $0x1, %al
jne 0x3d003
movq 0x28(%r13), %rax
testq %rax, %rax
je 0x3d003
cmpq $0x0, 0x18(%rax)
je 0x3d003
cmpq $0x0, 0x78(%r13)
jne 0x3d003
movq %r15, %rdi
callq 0xeac74
movq %rax, %rdi
movq %rax, 0x78(%r13)
testl %ebp, %ebp
jle 0x3cff6
movq 0x98(%r14), %rax
movl %ebp, %ecx
imulq $0x88, %rcx, %rcx
movq 0x78(%rax,%rcx), %rsi
testq %rsi, %rsi
je 0x3cff6
callq 0xead71
movq 0x78(%r13), %rdi
leaq 0xc8074(%rip), %rsi     # 0x10505e
pushq $0x5
popq %rdx
callq 0xeae42
movq 0x78(%r13), %rdi
movq 0x28(%r13), %rax
movq 0x18(%rax), %rsi
callq 0xead71
cmpl $0x32, %ebx
jg 0x3d046
movl %r12d, 0x4(%rsp)
incl %ebx
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x3d032
movl 0x68(%r13,%r12,4), %ecx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %r8d
callq 0x3cf3d
incq %r12
jmp 0x3d012
cmpb $0x1, 0x4(%r13)
movl 0x4(%rsp), %ebp
jne 0x3d046
movl 0x64(%r13), %r12d
jmp 0x3cf56
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: copy_normal_stream_to_dbuf
static void copy_normal_stream_to_dbuf(deark *c, lctx *d, i64 first_sec_id,
	i64 stream_startpos, i64 stream_size,
	dbuf *outf)
{
	i64 sec_id;
	i64 bytes_left_to_copy;
	i64 bytes_left_to_skip;

	if(stream_size<=0) return;
	if(stream_startpos+stream_size > c->infile->len) {
		// This is a not-too-strict emergency brake. If the file has been
		// truncated, we might still be able to process some of the data
		// that is there.
		stream_size = c->infile->len - stream_startpos;
	}

	bytes_left_to_copy = stream_size;
	bytes_left_to_skip = stream_startpos;
	sec_id = first_sec_id;
	while(bytes_left_to_copy > 0) {
		i64 sec_offs;
		i64 bytes_to_copy;
		i64 bytes_to_skip;

		if(sec_id<0) break;
		sec_offs = sec_id_to_offset(c, d, sec_id);

		bytes_to_skip = bytes_left_to_skip;
		if(bytes_to_skip > d->sec_size) bytes_to_skip = d->sec_size;

		bytes_to_copy = d->sec_size - bytes_to_skip;
		if(bytes_to_copy > bytes_left_to_copy) bytes_to_copy = bytes_left_to_copy;

		dbuf_copy(c->infile, sec_offs + bytes_to_skip, bytes_to_copy, outf);

		bytes_left_to_copy -= bytes_to_copy;
		bytes_left_to_skip -= bytes_to_skip;
		sec_id = get_next_sec_id(c, d, sec_id);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
testq %r8, %r8
jle 0x3d13e
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
leaq (%r8,%rcx), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, %rbx
subq %r14, %rbx
cmpq %rcx, %rax
cmovleq %r8, %rbx
testq %rbx, %rbx
jle 0x3d13e
testq %r13, %r13
js 0x3d13e
movq 0x20(%r15), %rbp
leaq 0x1(%r13), %rsi
imulq %rbp, %rsi
cmpq %rbp, %r14
movq %rbp, %r12
cmovlq %r14, %r12
subq %r12, %rbp
cmpq %rbx, %rbp
cmovgeq %rbx, %rbp
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
addq %r12, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
callq 0xe45f4
subq %rbp, %rbx
subq %r12, %r14
movq %r15, %rdi
movq %r13, %rsi
callq 0x3cdea
movq %rax, %r13
jmp 0x3d0e5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cfb.c
// Function: copy_any_stream_to_dbuf
static void copy_any_stream_to_dbuf(deark *c, lctx *d, struct dir_entry_info *dei,
	i64 stream_startpos, i64 stream_size,
	dbuf *outf)
{
	if(dei->is_mini_stream) {
		copy_mini_stream_to_dbuf(c, d, dei->minisec_id, stream_startpos, stream_size, outf);
	}
	else {
		copy_normal_stream_to_dbuf(c, d, dei->normal_sec_id, stream_startpos, stream_size, outf);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
cmpl $0x0, 0x8(%rdx)
je 0x3d1a0
movq 0xa0(%r12), %rax
testq %rax, %rax
sete %cl
testq %r14, %r14
setle %sil
orb %cl, %sil
jne 0x3d191
movq 0x18(%rdi), %rcx
cmpq %r14, 0x18(%rcx)
jl 0x3d191
cmpq %r14, 0x18(%rax)
jge 0x3d1c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rdx), %rdx
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d09d
movq %r9, (%rsp)
movq 0x20(%rdx), %rax
testq %r14, %r14
movq (%rsp), %rcx
jle 0x3d191
movq %rax, %r13
testq %rax, %rax
js 0x3d191
movq 0x50(%r12), %rbp
movq 0xa0(%r12), %rdi
movq %rbp, %rsi
imulq %r13, %rsi
cmpq %rbp, %r15
movq %rbp, %rbx
cmovlq %r15, %rbx
subq %rbx, %rbp
cmpq %r14, %rbp
cmovgeq %r14, %rbp
addq %rbx, %rsi
movq %rbp, %rdx
callq 0xe45f4
subq %rbp, %r14
subq %rbx, %r15
movq 0x88(%r12), %rdi
pushq $-0x2
popq %rax
testq %rdi, %rdi
je 0x3d1c8
shlq $0x2, %r13
movq %r13, %rsi
callq 0xe40f2
jmp 0x3d1c8
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cpio.c
// Function: de_module_cpio
void de_module_cpio(deark *c, struct deark_module_info *mi)
{
	mi->id = "cpio";
	mi->desc = "cpio archive";
	mi->run_fn = de_run_cpio;
	mi->identify_fn = de_identify_cpio;
}

// Assembly:
leaq 0xcfc45(%rip), %rax     # 0x10d1fc
movq %rax, (%rsi)
leaq 0xcfc40(%rip), %rax     # 0x10d201
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x3d5dc
movq %rax, 0x18(%rsi)
leaq 0x772(%rip), %rax       # 0x3dd49
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/cpio.c
// Function: identify_cpio_internal
static int identify_cpio_internal(deark *c, i64 pos, int *subfmt)
{
	u8 b[6];

	*subfmt = 0;
	de_read(b, pos, sizeof(b));

	if(!de_memcmp(b, "070707", 6)) {
		*subfmt = SUBFMT_ASCII_PORTABLE;
		return 100;
	}
	if(!de_memcmp(b, "070701", 6)) {
		*subfmt = SUBFMT_ASCII_NEW;
		return 100;
	}
	if(!de_memcmp(b, "070702", 6)) {
		*subfmt = SUBFMT_ASCII_NEWCRC;
		return 100;
	}
	if(b[0]==0xc7 && b[1]==0x71) {
		*subfmt = SUBFMT_BINARY_LE;
		return 70;
	}
	if(b[0]==0x71 && b[1]==0xc7) {
		*subfmt = SUBFMT_BINARY_BE;
		return 70;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
andl $0x0, (%rbx)
movq 0x18(%rdi), %rdi
leaq 0x2(%rsp), %r14
pushq $0x6
popq %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0xe3cb7
leaq 0xcf4b7(%rip), %rsi     # 0x10d23e
movq %r14, %rdi
movq %r15, %rdx
callq 0x18230
pushq $0x64
popq %rbp
testl %eax, %eax
je 0x3dde7
leaq 0xcf4a5(%rip), %rsi     # 0x10d245
leaq 0x2(%rsp), %rdi
pushq $0x6
popq %rdx
callq 0x18230
testl %eax, %eax
je 0x3ddeb
leaq 0xcf494(%rip), %rsi     # 0x10d24c
leaq 0x2(%rsp), %rdi
pushq $0x6
popq %rdx
callq 0x18230
testl %eax, %eax
je 0x3ddef
movb 0x2(%rsp), %cl
movb 0x3(%rsp), %dl
movl %ecx, %eax
xorb $-0x39, %al
movl %edx, %esi
xorb $0x71, %sil
pushq $0x46
popq %rbp
orb %al, %sil
jne 0x3ddf3
pushq $0x1
jmp 0x3de01
pushq $0x3
jmp 0x3de01
pushq $0x4
jmp 0x3de01
pushq $0x5
jmp 0x3de01
xorb $0x71, %cl
xorb $-0x39, %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x3de06
pushq $0x2
popq %rax
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/d64.c
// Function: de_module_d64
void de_module_d64(deark *c, struct deark_module_info *mi)
{
	mi->id = "d64";
	mi->desc = "D64 (C64 disk image)";
	mi->run_fn = de_run_d64;
	mi->identify_fn = de_identify_d64;
}

// Assembly:
leaq 0xcf491(%rip), %rax     # 0x10d414
movq %rax, (%rsi)
leaq 0xcf48b(%rip), %rax     # 0x10d418
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x3dfa8
movq %rax, 0x18(%rsi)
leaq 0x500(%rip), %rax       # 0x3e4a3
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/d64.c
// Function: de_identify_d64
static int de_identify_d64(deark *c)
{
	if(!de_input_file_has_ext(c, "d64")) return 0;
	if(!dbuf_memcmp(c->infile, 357*256, "\x12\x01\x41\x00", 4)) {
		return 100;
	}
	if(c->infile->len==683*256) return 30;
	if(c->infile->len==683*256+683) return 30;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xcef66(%rip), %rsi     # 0x10d414
callq 0xdfcd5
testl %eax, %eax
je 0x3e4f6
movq 0x18(%rbx), %rdi
leaq 0xcef3e(%rip), %rdx     # 0x10d400
pushq $0x4
popq %rcx
movl $0x16500, %esi          # imm = 0x16500
callq 0xe4d48
testl %eax, %eax
je 0x3e4fa
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpq $0x2adab, %rcx          # imm = 0x2ADAB
pushq $0x1e
popq %rdx
cmovel %edx, %eax
cmpq $0x2ab00, %rcx          # imm = 0x2AB00
cmovel %edx, %eax
jmp 0x3e4fd
xorl %eax, %eax
jmp 0x3e4fd
pushq $0x64
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/d64.c
// Function: sector_offset
static i64 sector_offset(i64 track, i64 sector)
{
	i64 global_sector_index;
	i64 t;

	global_sector_index = 0;
	for(t=1; t<track; t++) {
		if(t<=17) global_sector_index+=21;
		else if(t<=24) global_sector_index+=19;
		else if(t<=30) global_sector_index+=18;
		else global_sector_index+=17;
	}
	global_sector_index += sector;

	return 256*(global_sector_index);
}

// Assembly:
pushq $0x1
popq %rcx
xorl %eax, %eax
pushq $0x15
popq %rdx
pushq $0x13
popq %r8
cmpq %rdi, %rcx
jge 0x3e538
movq %rdx, %r9
cmpq $0x12, %rcx
jb 0x3e530
movq %r8, %r9
cmpq $0x19, %rcx
jb 0x3e530
cmpq $0x1f, %rcx
movl $0x0, %r9d
adcq $0x11, %r9
addq %r9, %rax
incq %rcx
jmp 0x3e50b
addq %rsi, %rax
shlq $0x8, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/drhalo.c
// Function: de_module_drhalocut
void de_module_drhalocut(deark *c, struct deark_module_info *mi)
{
	mi->id = "drhalocut";
	mi->desc = "Dr. Halo .CUT image";
	mi->run_fn = de_run_drhalocut;
	mi->identify_fn = de_identify_drhalocut;
	mi->help_fn = de_help_drhalocut;
}

// Assembly:
leaq 0xcf079(%rip), %rax     # 0x10d5c0
movq %rax, (%rsi)
leaq 0xcf079(%rip), %rax     # 0x10d5ca
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x3e577
movq %rax, 0x18(%rsi)
leaq 0x393(%rip), %rax       # 0x3e8fa
movq %rax, 0x20(%rsi)
leaq 0x3fc(%rip), %rax       # 0x3e96e
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/drhalo.c
// Function: de_identify_drhalocut
static int de_identify_drhalocut(deark *c)
{
	i64 n;

	if(!de_input_file_has_ext(c, "cut")) return 0;
	n = de_getu16le(4);
	if(n!=0) return 0;
	n = de_getu16le(0);
	if(n<1 || n>4096) return 0;
	n = de_getu16le(2);
	if(n<1 || n>4096) return 0;
	return 10;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xcecbe(%rip), %rsi     # 0x10d5c6
callq 0xdfcd5
xorl %r14d, %r14d
testl %eax, %eax
je 0x3e963
movq 0x18(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0xe3fa3
testq %rax, %rax
jne 0x3e963
movq 0x18(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xe3fa3
addq $-0x1001, %rax          # imm = 0xEFFF
cmpq $-0x1000, %rax          # imm = 0xF000
jb 0x3e963
movq 0x18(%rbx), %rdi
pushq $0x2
popq %rsi
callq 0xe3fa3
addq $-0x1001, %rax          # imm = 0xEFFF
xorl %ecx, %ecx
cmpq $-0x1000, %rax          # imm = 0xF000
pushq $0xa
popq %r14
cmovbl %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/drhalo.c
// Function: de_module_drhalopic
void de_module_drhalopic(deark *c, struct deark_module_info *mi)
{
	mi->id = "drhalopic";
	mi->desc = "Dr. Halo .PIC image";
	mi->run_fn = de_run_drhalopic;
	mi->identify_fn = de_identify_drhalopic;
	mi->help_fn = de_help_drhalopic;
}

// Assembly:
leaq 0xcec4e(%rip), %rax     # 0x10d5de
movq %rax, (%rsi)
leaq 0xcec4e(%rip), %rax     # 0x10d5e8
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x3e9c0
movq %rax, 0x18(%rsi)
leaq 0x72a(%rip), %rax       # 0x3f0da
movq %rax, 0x20(%rsi)
leaq 0x76e(%rip), %rax       # 0x3f129
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/drhalo.c
// Function: do_write_image_pal
static void do_write_image_pal(deark *c, lctx *d, dbuf *unc_pixels)
{
	de_bitmap *img = NULL;

	img = de_bitmap_create(c, d->w, d->h, 3);
	de_convert_image_paletted(unc_pixels, 0, 8, d->w, d->pal, img, 0);
	de_bitmap_write_to_file(img, NULL, DE_CREATEFLAG_OPT_IMAGE);
	de_bitmap_destroy(img);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
pushq $0x3
popq %rcx
callq 0xe7437
movq %rax, %r15
movq (%r14), %rcx
addq $0x18, %r14
andl $0x0, (%rsp)
pushq $0x8
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %r8
movq %rax, %r9
callq 0xe7cbc
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0xe70b7
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe7084
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: de_module_ebml
void de_module_ebml(deark *c, struct deark_module_info *mi)
{
	mi->id = "ebml";
	mi->desc = "EBML";
	mi->run_fn = de_run_ebml;
	mi->identify_fn = de_identify_ebml;
	mi->help_fn = de_help_ebml;
}

// Assembly:
leaq 0xce591(%rip), %rax     # 0x10da48
movq %rax, (%rsi)
leaq 0xce58c(%rip), %rax     # 0x10da4d
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x3f4e7
movq %rax, 0x18(%rsi)
leaq 0x7d(%rip), %rax        # 0x3f554
movq %rax, 0x20(%rsi)
leaq 0x94(%rip), %rax        # 0x3f576
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: de_run_ebml
static void de_run_ebml(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;

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

	if(de_get_ext_option(c, "ebml:encodedid")) {
		d->show_encoded_id = 1;
	}

	pos = 0;
	do_element_sequence(c, d, pos, c->infile->len);

	if(d) {
		destroy_attachment_data(c, d);
		de_free(c, d);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rsi
callq 0xdecaf
movq %rax, %r14
leaq 0xce552(%rip), %rsi     # 0x10da52
movq %rbx, %rdi
callq 0xdfa87
testq %rax, %rax
je 0x3f515
movl $0x1, 0x4(%r14)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3f584
testq %r14, %r14
je 0x3f54c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fb6f
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xded32
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: destroy_attachment_data
static void destroy_attachment_data(deark *c, lctx *d)
{
	if(!d->attachmentctx) return;
	ucstring_destroy(d->attachmentctx->filename);
	de_free(c, d->attachmentctx);
	d->attachmentctx = NULL;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3fba2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rax), %rdi
callq 0xeaf3c
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xded32
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: get_var_size_int
static int get_var_size_int(dbuf *f, i64 *val, i64 *pos,
	i64 nbytes_avail)
{
	i64 pos1;
	u8 b;
	u8 mask;
	unsigned int k;
	int retval = 0;
	u8 test_bit;
	unsigned int initial_zero_bits;

	pos1 = *pos;
	if(nbytes_avail<1) goto done;

	// This is an unsigned int. In a i64, we can support up to 63
	// bits.
	// For now we'll hope that 8 octets is the most we'll have to support,
	// but it's possible we'll have to support 9 or even more, which will
	// require additional logic.
	//
	//  1xxxxxxx width_nbits=0, octets=1, data_bits=7
	//  01xxxxxx width_nbits=1, octets=2, data_bits=14
	//  ...
	//  00000001 width_nbits=7, octets=8, data_bits=56
	//  00000000 1xxxxxxx width_nbits=8, octets=9, data_bits=63

	b = dbuf_getbyte(f, *pos);
	(*pos)++;

	test_bit = 0x80;
	initial_zero_bits = 0;
	while(1) {
		if(b>=test_bit) {
			break;
		}

		// "Not it". Try the next-larger number of initial 0 bits.
		initial_zero_bits++;
		test_bit >>= 1;
		if(test_bit==0) {
			goto done;
		}
	}

	mask = 0x7f >> initial_zero_bits;

	*val = (i64)(b & mask);

	// Read remaining bytes, if any.
	for(k=0; k<initial_zero_bits; k++) {
		if(*pos >= pos1+nbytes_avail) goto done;
		b = dbuf_getbyte(f, *pos);
		(*pos)++;
		if(*val > 0x07ffffffffffffffLL) {
			goto done;
		}
		*val = ((*val)<<8) | ((i64)b);
	}

	if(initial_zero_bits==0 && (*val)==0x7f) {
		// TODO: Fully handle "reserved" element value of all 1 bits.
		retval = 2;
		goto done;
	}

	retval = 1;

done:
	if(retval!=1) {
		*val = 0;
	}
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rcx, %rcx
jle 0x3fbe4
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %r15
movq (%rdx), %r12
movq %r12, %rsi
callq 0xe3eb4
incq (%r14)
movzbl %al, %edx
xorl %ebp, %ebp
movl $0x80, %eax
cmpl %edx, %eax
jbe 0x3fbfd
incl %ebp
shrl %eax
cmpl $0x8, %ebp
jne 0x3fbd7
xorl %r13d, %r13d
andq $0x0, (%rbx)
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%rsp)
pushq $0x7f
popq %rax
movl %ebp, %ecx
shrl %cl, %eax
andl %edx, %eax
movq %rax, (%rbx)
addq %r13, %r12
movl %ebp, %r15d
xorl %r13d, %r13d
subl $0x1, %r15d
jb 0x3fc51
movq (%r14), %rsi
cmpq %r12, %rsi
jge 0x3fbe7
movq (%rsp), %rdi
callq 0xe3eb4
incq (%r14)
movq (%rbx), %rcx
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
cmpq %rdx, %rcx
jg 0x3fbe7
shlq $0x8, %rcx
movzbl %al, %eax
orq %rcx, %rax
movq %rax, (%rbx)
jmp 0x3fc16
pushq $0x1
popq %r13
testl %ebp, %ebp
jne 0x3fbeb
cmpq $0x7f, %rax
jne 0x3fbeb
pushq $0x2
popq %r13
jmp 0x3fbe7
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: decode_string
static void decode_string(deark *c, lctx *d, const struct ele_id_info *ele_id,
	  i64 pos, i64 len, de_ext_encoding ee)
{
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, len, DE_DBG_MAX_STRLEN, s,
		DE_CONVFLAG_STOP_AT_NUL, ee);
	de_dbg(c, "value: \"%s\"", ucstring_getpsz_d(s));

	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0xeac74
movq %rax, %rbx
movq 0x18(%r14), %rdi
movl %ebp, (%rsp)
pushq $0x1
popq %r9
movl $0x1f4, %ecx            # imm = 0x1F4
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0xe4ced
movq %rbx, %rdi
callq 0xeb877
leaq 0xc5a9a(%rip), %rsi     # 0x10574b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xde896
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xeaf3c
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: handler_filename
static void handler_filename(deark *c, lctx *d, struct handler_params *hp)
{
	if(!d->attachmentctx) return;
	if(d->attachmentctx->filename) return;
	if(hp->dlen<1) return;

	d->attachmentctx->filename = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, hp->dpos, hp->dlen, 300,
		d->attachmentctx->filename,
		DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_UTF8);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3fd5d
cmpq $0x0, (%rax)
jne 0x3fd5d
movq %rdx, %rbx
cmpq $0x0, 0x8(%rdx)
jle 0x3fd5d
movq %rsi, %r15
movq %rdi, %r14
callq 0xeac74
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movq 0x18(%r14), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movl $0x2, (%rsp)
pushq $0x1
popq %r9
movl $0x12c, %ecx            # imm = 0x12C
movq %rax, %r8
callq 0xe4ced
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/ebml.c
// Function: handler_attachedfile
static void handler_attachedfile(deark *c, lctx *d, struct handler_params *hp)
{
	if(hp->end_flag) {
		handler_attachedfile_end(c, d);
	}
	else {
		handler_attachedfile_start(c, d, hp);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%rdx)
movq 0x8(%rsi), %rax
je 0x3fdc4
testq %rax, %rax
je 0x3fdbf
cmpq $0x0, 0x8(%rax)
je 0x3fdbf
movq %r14, %rdi
callq 0xdfd1a
movq %rax, %r15
movq 0x8(%rbx), %rax
movq (%rax), %rdx
testq %rdx, %rdx
je 0x3fde9
cmpq $0x0, 0x10(%rdx)
jle 0x3fde9
cmpb $0x0, 0xd0(%r14)
je 0x3fde9
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0xdfd55
jmp 0x3fe01
xorl %r15d, %r15d
jmp 0x3fe1f
testq %rax, %rax
je 0x3fdd4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3fb6f
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0xdecaf
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe86ed(%rip), %rdx     # 0x1284dd
pushq $0x2
popq %r8
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0xdffbd
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
pushq $0x1
popq %r9
xorl %ecx, %ecx
movq %r15, %r8
callq 0xe4e0b
movq %r14, %rdi
movq %r15, %rsi
callq 0xdfd24
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3fb6f
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/emf.c
// Function: de_module_emf
void de_module_emf(deark *c, struct deark_module_info *mi)
{
	mi->id = "emf";
	mi->desc = "Enhanced Windows Metafile";
	mi->desc2 = "extract bitmaps only";
	mi->run_fn = de_run_emf;
	mi->identify_fn = de_identify_emf;
}

// Assembly:
leaq 0xce21e(%rip), %rax     # 0x10e085
movq %rax, (%rsi)
leaq 0xce218(%rip), %rax     # 0x10e089
movq %rax, 0x8(%rsi)
leaq 0xce227(%rip), %rax     # 0x10e0a3
movq %rax, 0x10(%rsi)
leaq 0x10(%rip), %rax        # 0x3fe97
movq %rax, 0x18(%rsi)
leaq 0x23f(%rip), %rax       # 0x400d1
movq %rax, 0x20(%rsi)
retq