LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/diet.c
// Function: check_for_com2exe
static void check_for_com2exe(deark *c, struct diet_identify_data *idd,
	struct fmtutil_exe_info *ei)
{
	UI n;

	if(!ei) return;
	// This seems to work, but I'm sure there's a better way to detect that
	// the original file was in COM format.
	n = (UI)de_getu16be(ei->end_of_dos_code - 13);
	if(n==0xed55) {
		idd->com2exe_flag = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ab6d
jmp 0x6ab9a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
subq $0xd, %rsi
callq 0x1651d0
movl %eax, -0x1c(%rbp)
cmpl $0xed55, -0x1c(%rbp)    # imm = 0xED55
jne 0x6ab9a
movq -0x10(%rbp), %rax
movb $0x1, 0xb(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/diet.c
// Function: diet_getbit
static u8 diet_getbit(deark *c, lctx *d)
{
	u8 v;

	if(d->errflag) return 0;

	if(d->bbll.nbits_in_bitbuf==0) {
		fill_bitbuf(c, d);
	}

	v = (u8)de_bitbuf_lowlevel_get_bits(&d->bbll, 1);

	if(d->bbll.nbits_in_bitbuf==0) {
		fill_bitbuf(c, d);
	}

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x6ac10
movb $0x0, -0x1(%rbp)
jmp 0x6ac59
movq -0x18(%rbp), %rax
cmpl $0x0, 0x74(%rax)
jne 0x6ac27
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6ad80
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
movl $0x1, %esi
callq 0x16a2a0
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x74(%rax)
jne 0x6ac53
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6ad80
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/diet.c
// Function: read_matchlen
static UI read_matchlen(deark *c, lctx *d)
{
	UI matchlen;
	u8 x, x1, x2, x3, x4, x5;
	u8 v;
	UI nbits_read = 0;

	// Read up to 4 bits, stopping early if we get a 1.
	while(1) {
		x = diet_getbit(c, d);
		nbits_read++;
		if(x) {
			matchlen = 2+nbits_read;
			goto done;
		}
		if(nbits_read>=4) break;
	}
	// At this point we've read 4 bits, all 0.

	x1 = diet_getbit(c, d);
	x2 = diet_getbit(c, d);

	if(x1==1) { // length 7-8
		matchlen = 7+x2;
		goto done;
	}

	if(x2==0) { // length 9-16
		x3 = diet_getbit(c, d);
		x4 = diet_getbit(c, d);
		x5 = diet_getbit(c, d);
		matchlen = 9 + 4*(UI)x3 + 2*(UI)x4 + (UI)x5;
		goto done;
	}

	// length 17-272
	v = de_getbyte_p(&d->dcmpr_cur_ipos);
	matchlen = 17 + (UI)v;

done:
	return matchlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6abf0
movb %al, -0x15(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpb $0x0, -0x15(%rbp)
je 0x6acb4
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ad6b
cmpl $0x4, -0x20(%rbp)
jb 0x6acbc
jmp 0x6acbe
jmp 0x6ac87
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6abf0
movb %al, -0x16(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6abf0
movb %al, -0x17(%rbp)
movzbl -0x16(%rbp), %eax
cmpl $0x1, %eax
jne 0x6acf3
movzbl -0x17(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ad6b
movzbl -0x17(%rbp), %eax
cmpl $0x0, %eax
jne 0x6ad49
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6abf0
movb %al, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6abf0
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6abf0
movb %al, -0x1a(%rbp)
movzbl -0x18(%rbp), %eax
shll $0x2, %eax
addl $0x9, %eax
movzbl -0x19(%rbp), %ecx
shll %ecx
addl %ecx, %eax
movzbl -0x1a(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ad6b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
callq 0x165170
movb %al, -0x1b(%rbp)
movzbl -0x1b(%rbp), %eax
addl $0x11, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/diet.c
// Function: fill_bitbuf
static void fill_bitbuf(deark *c, lctx *d)
{
	UI i;

	if(d->errflag) return;
	if(d->dcmpr_cur_ipos+2 > c->infile->len) {
		d->errflag = 1;
		d->need_errmsg = 1;
		return;
	}

	for(i=0; i<2; i++) {
		u8 b;
		b = de_getbyte_p(&d->dcmpr_cur_ipos);
		de_bitbuf_lowlevel_add_byte(&d->bbll, b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x6ad9c
jmp 0x6ae09
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x6adc8
movq -0x10(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x29(%rax)
jmp 0x6ae09
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jae 0x6ae09
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
callq 0x165170
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movzbl -0x15(%rbp), %esi
callq 0x16a230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6adcf
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/diet.c
// Function: decode_reloc_tbl
static void decode_reloc_tbl(deark *c, lctx *d, struct exe_dcmpr_ctx *ectx,
	dbuf *inf, i64 ipos1, i64 nrelocs, dbuf *outf)
{
	UI seg = 0;
	UI offs = 0;
	i64 i;
	i64 ipos = ipos1;

	for(i=0; i<nrelocs; i++) {
		UI n;

		n = (UI)dbuf_getu16le_p(inf, &ipos);
		if(n & 0x8000) {
			// Special code: segment stays the same, and offset is adjusted
			// relative to the previous offset.
			if(n >= 0xc000) {
				offs += n;
			}
			else {
				offs += (n-0x8000);
			}
			offs &= 0xffff;
		}
		else {
			seg = n;
			offs = (UI)dbuf_getu16le_p(inf, &ipos);
		}

		dbuf_writeu16le(outf, (i64)offs);
		dbuf_writeu16le(outf, (i64)seg);
	}

	if(d->hdr_flags1 & 0x20) {
		ectx->encoded_reloc_tbl_size = ipos - ipos1;
	}
	else {
		ectx->encoded_reloc_tbl_size = nrelocs*4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x6b20f
movq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1652c0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x6b1cc
cmpl $0xc000, -0x4c(%rbp)    # imm = 0xC000
jb 0x6b1b1
movl -0x4c(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x6b1bf
movl -0x4c(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x38(%rbp)
jmp 0x6b1e2
movl -0x4c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1652c0
movl %eax, -0x38(%rbp)
movq 0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x168a10
movq 0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x168a10
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x6b172
movq -0x10(%rbp), %rax
movzbl 0x2d(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x6b231
movq -0x48(%rbp), %rcx
subq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6b241
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: de_module_div_map
void de_module_div_map(deark *c, struct deark_module_info *mi)
{
	mi->id = "div_map";
	mi->desc = "DIV Games Studio .map";
	mi->run_fn = de_run_div_map;
	mi->identify_fn = de_identify_div_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x13ee4d(%rip), %rcx    # 0x1aa434
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x13ee47(%rip), %rcx    # 0x1aa43c
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x6b620
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1cd(%rip), %rcx       # 0x6b7e0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: de_module_div_fpg
void de_module_div_fpg(deark *c, struct deark_module_info *mi)
{
	mi->id = "div_fpg";
	mi->desc = "DIV Games Studio .fpg";
	mi->run_fn = de_run_div_fpg;
	mi->identify_fn = de_identify_div_fpg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x13ec1b(%rip), %rcx    # 0x1aa452
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x13ec15(%rip), %rcx    # 0x1aa45a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x6b870
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1ed(%rip), %rcx       # 0x6ba50
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: identify_div_fmt
static u8 identify_div_fmt(deark *c)
{
	u8 buf[7];

	if(de_getbyte(3) != 0x1a) return 0;
	de_read(buf, 0, sizeof(buf));
	if(de_memcmp(&buf[4], (const void*)"\x0d\x0a\0", 3)) return 0;
	if(!de_memcmp(buf, (const void*)"map", 3)) return DIVFMT_MAP;
	if(!de_memcmp(buf, (const void*)"fpg", 3)) return DIVFMT_FPG;
	if(!de_memcmp(buf, (const void*)"f16", 3)) return DIVFMT_F16;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x3, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0x1a, %eax
je 0x6bacf
movb $0x0, -0x1(%rbp)
jmp 0x6bb71
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x17(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x7, %ecx
callq 0x164d10
leaq -0x17(%rbp), %rdi
addq $0x4, %rdi
leaq 0x13e9fe(%rip), %rsi    # 0x1aa4f6
movl $0x3, %edx
callq 0x19170
cmpl $0x0, %eax
je 0x6bb0d
movb $0x0, -0x1(%rbp)
jmp 0x6bb71
leaq -0x17(%rbp), %rdi
leaq 0x136b4e(%rip), %rsi    # 0x1a2666
movl $0x3, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x6bb2d
movb $0x1, -0x1(%rbp)
jmp 0x6bb71
leaq -0x17(%rbp), %rdi
leaq 0x13e934(%rip), %rsi    # 0x1aa46c
movl $0x3, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x6bb4d
movb $0x2, -0x1(%rbp)
jmp 0x6bb71
leaq -0x17(%rbp), %rdi
leaq 0x146bf6(%rip), %rsi    # 0x1b274e
movl $0x3, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0x6bb6d
movb $0x3, -0x1(%rbp)
jmp 0x6bb71
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: div_read_cpoints_p
static void div_read_cpoints_p(deark *c, struct div_ctx *d, i64 *ppos)
{
	i64 n;

	// number of 4-byte "cpoints" items
	if(d->is_archive) {
		n = de_getu32le_p(ppos);
	}
	else {
		n = de_getu16le_p(ppos);
	}
	*ppos += 4*n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x5(%rax)
je 0x6bc45
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165580
movq %rax, -0x20(%rbp)
jmp 0x6bc5a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
shlq $0x2, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: div_do_bitmap
static void div_do_bitmap(deark *c, struct div_ctx *d, struct div_image_ctx *md)
{
	de_bitmap *img = NULL;

	de_dbg(c, "bitmap at %"I64_FMT, md->bitmap_pos);
	if(!de_good_image_dimensions(c, md->w, md->h)) goto done;
	img = de_bitmap_create(c, md->w, md->h, 3);

	if(d->fmt==DIVFMT_F16) {
		div_convert_f16(c, d, md, img);
	}
	else {
		de_convert_image_paletted(c->infile, md->bitmap_pos, 8,
			md->w, d->pal, img, 0);
	}
	de_bitmap_write_to_file_finfo(img, md->fi, DE_CREATEFLAG_OPT_IMAGE);
done:
	de_bitmap_destroy(img);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x156258(%rip), %rsi    # 0x1c1f07
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x16a850
cmpl $0x0, %eax
jne 0x6bcd9
jmp 0x6bd6c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movl $0x3, %ecx
callq 0x16b750
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x3, %eax
jne 0x6bd1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6bde0
jmp 0x6bd56
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %r8
addq $0x8, %r8
movq -0x20(%rbp), %r9
movl $0x8, %edx
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x16c520
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0x2, %edx
callq 0x16afa0
movq -0x20(%rbp), %rdi
callq 0x16af60
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: div_image_destroy
static void div_image_destroy(deark *c, struct div_image_ctx *md)
{
	if(!md) return;
	ucstring_destroy(md->descr);
	ucstring_destroy(md->fn);
	de_finfo_destroy(c, md->fi);
	de_free(c, md);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6bd99
jmp 0x6bdd1
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x171750
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x15d260
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: div_convert_f16
static void div_convert_f16(deark *c, struct div_ctx *d, struct div_image_ctx *md,
	de_bitmap *img)
{
	i64 i, j;

	for(j=0; j<md->h; j++) {
		i64 pxpos;

		pxpos = md->bitmap_pos + md->w*2*j;
		for(i=0; i<md->w; i++) {
			UI x;
			de_color clr;

			x = (UI)de_getu16le_p(&pxpos);
			clr = de_rgb565_to_888(x);
			de_bitmap_setpixel_rgb(img, i, j, clr);
		}
	}
}

// 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 $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jge 0x6be9b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
shlq %rcx
imulq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x6be88
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1652c0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
callq 0x1618a0
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x40(%rbp), %ecx
callq 0x16b310
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6be39
jmp 0x6be8a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6be00
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/divgs.c
// Function: div_read_descr_p
static void div_read_descr_p(deark *c, struct div_ctx *d,
	struct div_image_ctx *md, i64 *ppos)
{
	if(!md->descr) {
		md->descr = ucstring_create(c);
	}
	dbuf_read_to_ucstring(c->infile, *ppos, 32, md->descr, DE_CONVFLAG_STOP_AT_NUL,
		DE_EXTENC_MAKE(d->input_encoding, DE_ENCSUBTYPE_HYBRID));
	de_dbg(c, "description: \"%s\"", ucstring_getpsz_d(md->descr));
	*ppos += 32;
}

// 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 -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x6c137
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movl (%rax), %r9d
andl $0xff, %r9d
orl $0x300, %r9d            # imm = 0x300
movl $0x20, %edx
movl $0x1, %r8d
callq 0x1669f0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x172650
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x147586(%rip), %rsi    # 0x1b371c
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: de_module_dosbackup33
void de_module_dosbackup33(deark *c, struct deark_module_info *mi)
{
	mi->id = "dosbackup33";
	mi->desc = "MS-DOS BACKUP (v3.3+)";
	mi->run_fn = de_run_dosbackup33;
	mi->identify_fn = de_identify_dosbackup33;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x13e323(%rip), %rcx    # 0x1aa4fa
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x13e321(%rip), %rcx    # 0x1aa506
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x6c220
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x29d(%rip), %rcx       # 0x6c4a0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: de_module_dosbackup20
void de_module_dosbackup20(deark *c, struct deark_module_info *mi)
{
	mi->id = "dosbackup20";
	mi->desc = "MS-DOS BACKUP (v2.0-3.2)";
	mi->run_fn = de_run_dosbackup20;
	mi->identify_fn = de_identify_dosbackup20;
	mi->flags |= DE_MODFLAG_MULTIPART;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x13e025(%rip), %rcx    # 0x1aa51c
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x13e023(%rip), %rcx    # 0x1aa528
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x6c540
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x19d(%rip), %rcx       # 0x6c6c0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: de_run_dosbackup20
static void de_run_dosbackup20(deark *c, de_module_params *mparams)
{
	int v;
	lctx *d = NULL;

	d = de_malloc(c, sizeof(lctx));
	d->fmtver = DOSBK_VER_DOS20;
	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_CP437);
	de_declare_fmt(c, "MS-DOS BACKUP (MS-DOS 2.0-3.2)");

	d->num_input_files_tot = 1;
	if(c->mp_data) d->num_input_files_tot += c->mp_data->count;

	d->data_file_xidxs = de_mallocarray(c, d->num_input_files_tot, sizeof(int));
	for(v=0; v<d->num_input_files_tot; v++) {
		d->data_file_xidxs[v] = -1;
	}

	scan_input_files20(c, d);
	if(d->errflag) goto done;

	// Verify that we have all the needed files.
	for(v=0; v<d->num_input_files_tot; v++) {
		de_dbg2(c, "data file idx[%d] = %d", v, d->data_file_xidxs[v]);
		if(d->data_file_xidxs[v]<0) {
			d->need_errmsg = 1;
			goto done;
		}
	}

	dosbackup20_main(c, d);

done:
	dbk_destroy_lctx(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xd, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x13e1c7(%rip), %rsi    # 0x1aa761
callq 0x15e380
movq -0x20(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6c5c9
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq 0x10(%rax), %rsi
movl $0x4, %edx
callq 0x15c450
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x6c61b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c5f1
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d700
movq -0x20(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x6c634
jmp 0x6c6a1
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x6c694
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x13df7a(%rip), %rsi    # 0x1aa5de
movb $0x0, %al
callq 0x15b350
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x6c687
movq -0x20(%rbp), %rax
movb $0x1, 0x9(%rax)
jmp 0x6c6a1
jmp 0x6c689
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c63b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d7c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6cad0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: scan_input_files33
static void scan_input_files33(deark *c, lctx *d)
{
	int xidx;
	dbuf *inf = NULL;

	de_dbg(c, "[scanning input files]");
	de_dbg_indent(c, 1);

	for(xidx=0; xidx<d->num_input_files_tot; xidx++) {
		if(d->errflag) goto done;
		inf = de_mp_acquire_dbuf(c, xidx);
		if(!inf) {
			d->errflag = 1;
			goto done;
		}

		v33_scan_one_input_file(c, d, inf, xidx);

		de_mp_release_dbuf(c, xidx, &inf);
	}

done:
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x13dd32(%rip), %rsi    # 0x1aa5f5
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x6c947
movq -0x10(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x6c8f7
jmp 0x6c949
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15f890
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6c918
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x6c949
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x6cb70
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x15f970
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c8df
jmp 0x6c949
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: dosbackup33_main
static void dosbackup33_main(deark *c, lctx *d)
{
	int v;
	dbuf *ctrl_inf = NULL;
	dbuf *data_inf = NULL;
	int saved_indent_level;

	de_dbg_indent_save(c, &saved_indent_level);

	d->v33_cur_dir_name = ucstring_create(c);

	for(v=0; v<d->v33_num_volumes; v++) {
		if(d->errflag) goto done;
		de_dbg(c, "[volume %03d]", v+1);
		de_dbg_indent(c, 1);

		ctrl_inf = de_mp_acquire_dbuf(c, d->v33_control_file_xidxs[v]);
		if(!ctrl_inf) {
			d->errflag = 1;
			goto done;
		}
		data_inf = de_mp_acquire_dbuf(c, d->data_file_xidxs[v]);
		if(!data_inf) {
			d->errflag = 1;
			goto done;
		}

		do_one_volume33(c, d, v, ctrl_inf, data_inf);

		de_mp_release_dbuf(c, d->v33_control_file_xidxs[v], &ctrl_inf);
		de_mp_release_dbuf(c, d->data_file_xidxs[v], &data_inf);
		de_dbg_indent(c, -1);
	}

done:
	de_dbg_indent_restore(c, saved_indent_level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x15b580
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6cab6
movq -0x10(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x6c9c7
jmp 0x6cab8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq 0x13dc85(%rip), %rsi    # 0x1aa65d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x15f890
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6ca1d
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x6cab8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x15f890
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6ca4a
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x6cab8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x6cdb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq -0x20(%rbp), %rdx
callq 0x15f970
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq -0x28(%rbp), %rdx
callq 0x15f970
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c9a8
jmp 0x6cab8
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x15b5a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: dbk_destroy_lctx
static void dbk_destroy_lctx(deark *c, lctx *d)
{
	if(!d) return;

	logical_member_finish_and_free(c, d);

	if(d->need_errmsg) {
		de_err(c, "Failed to process this MS-DOS BACKUP set");
	}
	ucstring_destroy(d->v33_cur_dir_name);
	de_free(c, d->v33_control_file_xidxs);
	de_free(c, d->data_file_xidxs);
	de_free(c, d->v20_fsig_expected);
	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6cae9
jmp 0x6cb5f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6d630
movq -0x10(%rbp), %rax
cmpb $0x0, 0x9(%rax)
je 0x6cb12
movq -0x8(%rbp), %rdi
leaq 0x13dc2d(%rip), %rsi    # 0x1aa738
movb $0x0, %al
callq 0x15bfb0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15b820
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: v33_looks_like_control_file
static int v33_looks_like_control_file(dbuf *f)
{
	int has_sig1;
	UI sig2;

	has_sig1 = !dbuf_memcmp(f, 0, "\x8b" "BACKUP", 7);
	if(!has_sig1) return 0;

	// Found a compressed variant format where the next two bytes are
	// different, but no plans to support it.
	sig2 = (UI)dbuf_getu16be(f, 7);
	if(sig2!=0x2020) {
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x13d90a(%rip), %rdx    # 0x1aa655
movl $0x7, %ecx
callq 0x166ab0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6cd74
movl $0x0, -0x4(%rbp)
jmp 0x6cd9e
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x1651d0
movl %eax, -0x18(%rbp)
cmpl $0x2020, -0x18(%rbp)    # imm = 0x2020
je 0x6cd97
movl $0x0, -0x4(%rbp)
jmp 0x6cd9e
movl $0x1, -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/dosbackup.c
// Function: fixup_filename
static void fixup_filename(de_ucstring *s)
{
	i64 k;

	for(k=0; k<s->len; k++) {
		if(s->str[k]=='/' || s->str[k]=='\\') {
			s->str[k] = '_';
		}
	}

	if(ucstring_isempty(s)) {
		ucstring_append_char(s, '_');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x6d349
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $0x2f, (%rax,%rcx,4)
je 0x6d326
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $0x5c, (%rax,%rcx,4)
jne 0x6d339
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl $0x5f, (%rax,%rcx,4)
jmp 0x6d33b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6d2f4
movq -0x8(%rbp), %rdi
callq 0x1717b0
cmpl $0x0, %eax
je 0x6d365
movq -0x8(%rbp), %rdi
movl $0x5f, %esi
callq 0x1714c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: dbg_attribs
static void dbg_attribs(deark *c, UI x)
{
	de_ucstring *descr;

	descr = ucstring_create(c);
	de_describe_dos_attribs(c, x, descr, 0);
	de_dbg(c, "attribs: 0x%02x (%s)", x, ucstring_getpsz_d(descr));
	ucstring_destroy(descr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x15d9f0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x172650
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq %rax, %rcx
leaq 0x162039(%rip), %rsi    # 0x1cf3ff
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rdi
callq 0x171750
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: v33_extract_fragment
static void v33_extract_fragment(deark *c, lctx *d, struct fragment_ctx *fr,
	dbuf *data_inf)
{
	// TODO? There are a lot more things we could check, to make sure
	// things seem ok.
	if(fr->fragment_num<2 || !d->clm) {
		v33_logical_member_create(c, d, fr, data_inf);
	}
	if(d->errflag || !d->clm) goto done;

	dbuf_copy(data_inf, fr->pos_in_datafile, fr->len_in_datafile, d->clm->outf);
	d->clm->nbytes_written += fr->len_in_datafile;

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jl 0x6d44d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x6d462
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6d4c0
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x6d47a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x6d47c
jmp 0x6d4b8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rcx
callq 0x166070
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: v33_logical_member_create
static void v33_logical_member_create(deark *c, lctx *d, struct fragment_ctx *fr,
	dbuf *data_inf)
{
	de_finfo *fi = NULL;

	logical_member_finish_and_free(c, d);
	d->clm = de_malloc(c, sizeof(struct logical_member_ctx));
	d->clm->fullfn = ucstring_create(c);
	d->clm->v33_nbytes_expected = fr->orig_size;

	fi = de_finfo_create(c);

	ucstring_append_ucstring(d->clm->fullfn, d->v33_cur_dir_name);
	ucstring_append_ucstring(d->clm->fullfn, fr->filename_srd->str);

	de_finfo_set_name_from_ucstring(c, fi, d->clm->fullfn,
		DE_SNFLAG_FULLPATH);
	fi->original_filename_flag = 1;

	fi->timestamp[DE_TIMESTAMPIDX_MODIFY] = fr->mod_time;

	if((fr->attribs & 0x18) == 0x08) {
		fi->is_volume_label = 1;
	}

	d->clm->outf = dbuf_create_output_file(c, NULL, fi, 0);
	if(fr->pos_in_datafile + fr->len_in_datafile > data_inf->len) {
		d->errflag = 1;
		d->need_errmsg = 1;
	}

	de_finfo_destroy(c, fi);
}

// 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), %rdi
movq -0x10(%rbp), %rsi
callq 0x6d630
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x15b780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x171460
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x171460
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x15d2c0
movq -0x28(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x48(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %eax
andl $0x18, %eax
cmpl $0x8, %eax
jne 0x6d5ca
movq -0x28(%rbp), %rax
movb $0x1, 0xa(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
callq 0x166c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x10(%rcx), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0x6d615
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d260
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: logical_member_finish_and_free
static void logical_member_finish_and_free(deark *c, lctx *d)
{
	if(!d->clm) return;

	if(d->fmtver==DOSBK_VER_DOS33 && d->clm->nbytes_written!=d->clm->v33_nbytes_expected) {
		de_err(c, "%s: Expected %"I64_FMT" bytes, got %"I64_FMT,
			ucstring_getpsz_d(d->clm->fullfn), d->clm->v33_nbytes_expected,
			d->clm->nbytes_written);
	}
	dbuf_close(d->clm->outf);
	ucstring_destroy(d->clm->fullfn);
	de_free(c, d->clm);
	d->clm = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x6d650
jmp 0x6d6f8
movq -0x10(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jne 0x6d6ba
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpq 0x10(%rcx), %rax
je 0x6d6ba
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x172650
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %r8
leaq 0x13d065(%rip), %rsi    # 0x1aa718
movb $0x0, %al
callq 0x15bfb0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x1676a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x171750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x15b820
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: scan_input_files20
static void scan_input_files20(deark *c, lctx *d)
{
	int xidx;
	dbuf *inf = NULL;

	de_dbg(c, "[scanning input files]");
	de_dbg_indent(c, 1);

	for(xidx=0; xidx<d->num_input_files_tot; xidx++) {
		if(d->errflag) goto done;
		inf = de_mp_acquire_dbuf(c, xidx);
		if(!inf) {
			d->errflag = 1;
			goto done;
		}

		dbk20_scan_one_input_file(c, d, inf, xidx);

		de_mp_release_dbuf(c, xidx, &inf);
	}

done:
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x13ced2(%rip), %rsi    # 0x1aa5f5
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x6d7a7
movq -0x10(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x6d757
jmp 0x6d7a9
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15f890
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6d778
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x6d7a9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x6da80
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x15f970
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6d73f
jmp 0x6d7a9
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/dosbackup.c
// Function: v20_logical_member_create
static void v20_logical_member_create(deark *c, lctx *d, struct fragment_ctx *fr,
	dbuf *data_inf)
{
	de_finfo *fi = NULL;

	if(d->clm) {
		d->errflag = 1;
		d->need_errmsg = 1;
		goto done;
	}
	fi = de_finfo_create(c);
	d->clm = de_malloc(c, sizeof(struct logical_member_ctx));
	d->clm->fullfn = ucstring_clone(fr->filename_srd->str);
	de_arch_fixup_path(d->clm->fullfn, 0);
	if(ucstring_isempty(d->clm->fullfn)) {
		ucstring_append_char(d->clm->fullfn, '_');
	}

	de_finfo_set_name_from_ucstring(c, fi, d->clm->fullfn,
		DE_SNFLAG_FULLPATH);
	fi->original_filename_flag = 1;

	d->clm->outf = dbuf_create_output_file(c, NULL, fi, 0);

done:
	de_finfo_destroy(c, fi);
}

// 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 -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6dcb0
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x9(%rax)
jmp 0x6dd7c
movq -0x8(%rbp), %rdi
callq 0x15d230
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x15b780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x171700
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x17c2b0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x1717b0
cmpl $0x0, %eax
je 0x6dd35
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
movl $0x5f, %esi
callq 0x1714c0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x15d2c0
movq -0x28(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
callq 0x166c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d260
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/flif.c
// Function: de_module_flif
void de_module_flif(deark *c, struct deark_module_info *mi)
{
	mi->id = "flif";
	mi->desc = "FLIF image format";
	mi->run_fn = de_run_flif;
	mi->identify_fn = de_identify_flif;
	mi->flags |= DE_MODFLAG_NONWORKING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x13ca7d(%rip), %rcx    # 0x1aa824
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x13ca74(%rip), %rcx    # 0x1aa829
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x6ddf0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xdd(%rip), %rcx        # 0x6deb0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/flif.c
// Function: de_run_flif
static void de_run_flif(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;
	i64 bytes_consumed;

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

	pos = 0;

	if(!do_read_header(c, d, pos, &bytes_consumed)) goto done;
	pos += bytes_consumed;


	if(!do_read_metadata(c, d, pos, &bytes_consumed)) goto done;
	pos += bytes_consumed;

	if(!do_second_header(c, d, pos, &bytes_consumed)) goto done;

done:
	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 -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x6df00
cmpl $0x0, %eax
jne 0x6de3e
jmp 0x6de90
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x6e250
cmpl $0x0, %eax
jne 0x6de66
jmp 0x6de90
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x6e310
cmpl $0x0, %eax
jne 0x6de8e
jmp 0x6de90
jmp 0x6de90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/flif.c
// Function: do_read_metadata
static int do_read_metadata(deark *c, lctx *d, i64 pos1,
	i64 *bytes_consumed)
{
	u8 b;
	i64 pos = pos1;
	int saved_indent_level;
	int retval = 0;

	de_dbg_indent_save(c, &saved_indent_level);
	*bytes_consumed = 0;

	// peek at the next byte, to see if there is a metadata segment.
	b = de_getbyte(pos);
	if(b<32) {
		de_dbg(c, "[metadata segment not present]");
		retval = 1;
		goto done;
	}

	de_dbg(c, "metadata segment at %d", (int)pos1);
	de_err(c, "not implemented");

	// TODO (need samples)

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 -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x15b580
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x165060
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x20, %eax
jge 0x6e2c7
movq -0x8(%rbp), %rdi
leaq 0x13c621(%rip), %rsi    # 0x1aa8d8
movb $0x0, %al
callq 0x15b0d0
movl $0x1, -0x38(%rbp)
jmp 0x6e2f1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x13c61f(%rip), %rsi    # 0x1aa8f7
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
leaq 0x166a64(%rip), %rsi    # 0x1d4d4e
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x15b5a0
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/flif.c
// Function: do_second_header
static int do_second_header(deark *c, lctx *d, i64 pos1,
	i64 *bytes_consumed)
{
	u8 ct;
	i64 pos = pos1;

	de_dbg(c, "second header segment at %d", (int)pos1);
	de_dbg_indent(c, 1);

	ct = de_getbyte(pos++);
	de_dbg(c, "chunk type: 0x%02x", (unsigned int)ct);

	if(ct!=0x00) {
		de_err(c, "unsupported chunk type: 0x%02x", (unsigned int)ct);
		goto done;
	}

done:
	de_dbg_indent(c, -1);
	return 0;
}

// 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 -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x13c5cd(%rip), %rsi    # 0x1aa90e
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 %rsi, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x165060
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x21(%rbp), %edx
leaq 0x13c5b2(%rip), %rsi    # 0x1aa936
movb $0x0, %al
callq 0x15b0d0
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x6e3ac
movq -0x8(%rbp), %rdi
movzbl -0x21(%rbp), %edx
leaq 0x13c587(%rip), %rsi    # 0x1aa92a
movb $0x0, %al
callq 0x15bfb0
jmp 0x6e3ae
jmp 0x6e3ae
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/flif.c
// Function: read_varint
static int read_varint(deark *c, i64 pos1, i64 *result, i64 *bytes_consumed)
{
	i64 val = 0;
	u8 b;
	i64 pos = pos1;
	int retval = 0;

	*result = 0;

	while(1) {
		b = de_getbyte(pos++);
		val = (val<<7)|(b&0x7f);
		if((b&0x80)==0) break;
		if(pos - pos1 >= 8) {
			// We allow varints up to 8 bytes (8*7=56 bits).
			// If we've read 8 bytes without finding the terminating byte,
			// give up.
			// (Note that if we were to allow 63 bits, we could have int64
			// overflow when we convert from a physical value to a logical
			// value.)
			de_err(c, "Excessively large varint at %d", (int)pos1);
			goto done;
		}
	}

	*result = val;
	retval = 1;
done:
	*bytes_consumed = pos - pos1;
	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 $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
callq 0x165060
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
shlq $0x7, %rax
movzbl -0x29(%rbp), %ecx
andl $0x7f, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movzbl -0x29(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x6e452
jmp 0x6e47c
movq -0x38(%rbp), %rax
subq -0x10(%rbp), %rax
cmpq $0x8, %rax
jl 0x6e47a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %edx
leaq 0x13c448(%rip), %rsi    # 0x1aa8b9
movb $0x0, %al
callq 0x15bfb0
jmp 0x6e48e
jmp 0x6e40a
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
subq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/fnt.c
// Function: de_module_fnt
void de_module_fnt(deark *c, struct deark_module_info *mi)
{
	mi->id = "fnt";
	mi->desc = "Windows FNT font";
	mi->run_fn = de_run_fnt;
	mi->identify_fn = de_identify_fnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x13aab7(%rip), %rcx    # 0x1a8f7e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x13c479(%rip), %rcx    # 0x1aa94e
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x6e500
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x11d(%rip), %rcx       # 0x6e610
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)