LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/colorix.c
// Function: detect_old_fmt
static int detect_old_fmt(dbuf *f, u8 strict)
{
	size_t i;
	u8 cmpr_flag = 0;
	u8 buf[16];

	if(f->len<RIX_MIN_FILE_SIZE) return 0;

	// Check the palette
	dbuf_read(f, buf, 0, 16);
	for(i=0; i<16; i++) {
		if(i==0) {
			if((buf[i] & 0x80)!=0) {
				cmpr_flag = 1;
				buf[i] -= 0x80;
			}
			else {
				if(f->len!=RIX_UNC_SCR_FILE_SIZE) return 0;
			}
		}

		if(buf[i]>0x3f) return 0;
	}
	if(!cmpr_flag) return RIXFMT_OLD_U;
	if(!strict) return RIXFMT_OLD_C;

	if(looks_like_compressed_data(f, 16)) {
		return RIXFMT_OLD_C;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x24, 0x18(%rdi)
jge 0x4aa97
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r14d
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movl $0x10, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xee8d4
movb (%r15), %al
xorl %ecx, %ecx
xorl %ebp, %ebp
testq %rcx, %rcx
jne 0x4aad9
testb %al, %al
js 0x4aad0
cmpq $0x1b590, 0x18(%rbx)    # imm = 0x1B590
je 0x4aad9
jmp 0x4aa86
andb $0x7f, %al
movb %al, 0x10(%rsp)
movb $0x1, %r12b
cmpb $0x3f, 0x10(%rsp,%rcx)
ja 0x4aa88
incq %rcx
cmpq $0x10, %rcx
jne 0x4aabb
testb %r12b, %r12b
je 0x4abe5
movl $0x2, %ebp
testb %r14b, %r14b
je 0x4aa88
leaq 0x8(%rsp), %rsi
movq $0x10, (%rsi)
movq %rbx, %rdi
callq 0xeebeb
leaq -0x202(%rax), %rcx
cmpq $-0x1ff, %rcx           # imm = 0xFE01
jb 0x4aa86
leaq (%rax,%rax), %r14
addq 0x8(%rsp), %r14
cmpq 0x18(%rbx), %r14
jg 0x4aa86
addq $-0x2, %rax
movl $0x10, %esi
movq %rax, %rdi
callq 0xe9c3b
testq %rax, %rax
jle 0x4ab93
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xeebeb
cmpl $0xfff, %eax            # imm = 0xFFF
ja 0x4ab83
testb $0x1, %al
jne 0x4aa86
andl $0xfff, %eax            # imm = 0xFFF
addq 0x8(%rsp), %rax
cmpq %r14, %rax
jl 0x4ab8e
jmp 0x4aa86
cmpl $0x10ff, %eax           # imm = 0x10FF
ja 0x4aa86
decq %r15
jne 0x4ab55
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movl $0x4, %r12d
addq $0x3, %r14
cmpq 0x18(%rbx), %r14
jg 0x4aa86
movq %rbx, %rdi
movq %r15, %rsi
callq 0xeebeb
cmpq $0x64, %rax
jl 0x4aa86
movq %rax, %r14
addq 0x8(%rsp), %r14
movq %r14, 0x8(%rsp)
decq %r12
jne 0x4aba1
cmpq 0x18(%rbx), %r14
jne 0x4aa86
jmp 0x4aa88
movl $0x1, %ebp
jmp 0x4aa88
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/diet.c
// Function: de_module_diet
void de_module_diet(deark *c, struct deark_module_info *mi)
{
	mi->id = "diet";
	mi->desc = "DIET compression";
	mi->run_fn = de_run_diet;
	mi->identify_fn = de_identify_diet;
	mi->help_fn = de_help_diet;
}

// Assembly:
leaq 0xd3165(%rip), %rax     # 0x11e4c0
movq %rax, (%rsi)
leaq 0xd3160(%rip), %rax     # 0x11e4c5
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x4b38b
movq %rax, 0x18(%rsi)
leaq 0x8fe(%rip), %rax       # 0x4bc79
movq %rax, 0x20(%rsi)
leaq 0x92f(%rip), %rax       # 0x4bcb5
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/diet.c
// Function: write_data_or_com_file
static void write_data_or_com_file(deark *c, lctx *d)
{
	dbuf *outf = NULL;
	const char *ext;

	if(d->idd.ftype==FTYPE_COM || d->idd.com2exe_flag) ext = "com";
	else ext = "bin";

	outf = dbuf_create_output_file(c, ext, NULL, 0);
	dbuf_copy(d->dcmpr_code, 0, d->dcmpr_code->len, outf);

	if(d->idd.ftype==FTYPE_COM) {
		de_stdwarn_execomp(c);
	}

	dbuf_close(outf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x4(%rsi)
jne 0x4c102
leaq 0xd77a5(%rip), %rsi     # 0x1238a5
jmp 0x4c119
cmpb $0x0, 0xb(%r14)
leaq 0xe96af(%rip), %rax     # 0x1357bd
leaq 0xd7790(%rip), %rsi     # 0x1238a5
cmoveq %rax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xefda1
movq %rax, %r15
movq 0x58(%r14), %rdi
movq 0x18(%rdi), %rdx
xorl %esi, %esi
movq %rax, %rcx
callq 0xef481
cmpl $0x2, 0x4(%r14)
jne 0x4c149
movq %rbx, %rdi
callq 0xe8f9c
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf052b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x28(%rsi)
je 0x4c878
xorl %r15d, %r15d
jmp 0x4c8b4
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsi), %r15
cmpl $0x0, 0x74(%rsi)
jne 0x4c893
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c8bd
movq %r15, %rdi
movl $0x1, %esi
callq 0xf1b93
movq %rax, %r15
cmpl $0x0, 0x74(%rbx)
jne 0x4c8b4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c8bd
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x28(%rsi)
jne 0x4c8e6
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rsi), %rax
addq $0x2, %rax
movq 0x18(%rdi), %rcx
cmpq 0x18(%rcx), %rax
jle 0x4c8ec
movw $0x101, 0x28(%rbx)      # imm = 0x101
popq %rbx
popq %r14
popq %r15
retq
leaq 0x68(%rbx), %r15
addq $0x70, %rbx
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %esi
movq %rbx, %rdi
callq 0xf1b5e
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xeeb4b
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf1b5e
nop
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0xd1f89(%rip), %rax     # 0x11e8b8
movq %rax, (%rsi)
leaq 0xd1f87(%rip), %rax     # 0x11e8c0
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x4c954
movq %rax, 0x18(%rsi)
leaq 0x165(%rip), %rax       # 0x4cab4
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/divgs.c
// Function: de_run_div_map
static void de_run_div_map(deark *c, de_module_params *mparams)
{
	struct div_ctx *d = NULL;
	struct div_image_ctx *md = NULL;
	i64 pos;

	d = de_malloc(c, sizeof(struct div_ctx));
	d->fmt = identify_div_fmt(c);
	if(d->fmt==DIVFMT_MAP) {
		de_declare_fmt(c, "DIV MAP");
	}
	else {
		d->need_errmsg = 1;
		goto done;
	}
	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_CP850);

	md = de_malloc(c, sizeof(struct div_image_ctx));
	if(de_getbyte(7) != 0) {
		d->need_errmsg = 1;
		goto done;
	}

	pos = 8;
	md->w = de_getu16le_p(&pos);
	md->h = de_getu16le_p(&pos);
	de_dbg_dimensions(c, md->w, md->h);

	pos = 16;

	// TODO: Figure out why the description is often garbage
	//div_read_descr_p(c, d, md, &pos);
	pos += 32;

	div_read_pal_p(c, d, &pos);

	div_read_cpoints_p(c, d, &pos);

	md->bitmap_pos = pos;
	div_do_bitmap(c, d, md);

done:
	div_image_destroy(c, md);
	if(d) {
		if(d->need_errmsg) {
			de_err(c, "Bad or unsupported MAP file");
		}
		de_free(c, d);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x408, %esi            # imm = 0x408
callq 0xe8b2b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ce6c
movb %al, 0x4(%r14)
cmpb $0x1, %al
jne 0x4c9c9
leaq 0xd1f71(%rip), %rsi     # 0x11e8f4
movq %rbx, %rdi
callq 0xeb125
movq %rbx, %rdi
xorl %esi, %esi
movl $0xe, %edx
callq 0xeb220
movl %eax, (%r14)
movl $0x40, %esi
movq %rbx, %rdi
callq 0xe8b2b
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x7, %esi
callq 0xeead3
testb %al, %al
je 0x4c9d6
movb $0x1, 0x6(%r14)
jmp 0x4ca7a
movb $0x1, 0x6(%r14)
xorl %r15d, %r15d
jmp 0x4ca7a
movq %rsp, %r12
movq $0x8, (%r12)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x18(%r15)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xeebeb
movq %rax, 0x20(%r15)
movq 0x18(%r15), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe8f88
movq $0x30, (%r12)
movq 0x18(%rbx), %rsi
movq %r14, %r9
addq $0x8, %r9
subq $0x8, %rsp
movl $0x30, %edx
movl $0x100, %ecx            # imm = 0x100
movl $0x3, %r8d
movq %rbx, %rdi
pushq $0x0
pushq $0x2
pushq $0x100                  # imm = 0x100
callq 0xf2cb1
addq $0x20, %rsp
addq $0x540, (%r12)          # imm = 0x540
movzbl 0x5(%r14), %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4cf14
movq (%r12), %rax
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4cf3c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d05f
cmpb $0x0, 0x6(%r14)
je 0x4ca9d
leaq 0xd1e69(%rip), %rsi     # 0x11e8fc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9295
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8be2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0xd1e07(%rip), %rax     # 0x11e8d6
movq %rax, (%rsi)
leaq 0xd1e05(%rip), %rax     # 0x11e8de
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x4caf4
movq %rax, 0x18(%rsi)
leaq 0x369(%rip), %rax       # 0x4ce58
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x3, %esi
callq 0xeead3
cmpb $0x1a, %al
jne 0x4cf00
movq 0x18(%rbx), %rdi
xorl %ebx, %ebx
leaq 0x1(%rsp), %r14
movl $0x7, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movzwl 0x4(%r14), %eax
xorl $0xa0d, %eax            # imm = 0xA0D
movzbl 0x6(%r14), %ecx
orw %ax, %cx
jne 0x4cf02
movzwl 0x1(%rsp), %eax
xorl $0x616d, %eax           # imm = 0x616D
movzbl 0x3(%rsp), %ecx
xorl $0x70, %ecx
orw %ax, %cx
je 0x4cf0c
movzwl 0x1(%rsp), %eax
xorl $0x7066, %eax           # imm = 0x7066
movzbl 0x3(%rsp), %ecx
xorl $0x67, %ecx
orw %ax, %cx
je 0x4cf10
movzwl 0x1(%rsp), %eax
xorl $0x3166, %eax           # imm = 0x3166
movzbl 0x3(%rsp), %ecx
xorl $0x36, %ecx
xorl %edx, %edx
orw %ax, %cx
sete %dl
leal (%rdx,%rdx,2), %ebx
jmp 0x4cf02
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %bl
jmp 0x4cf02
movb $0x2, %bl
jmp 0x4cf02
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdx, %rbx
movq 0x18(%rdi), %rdi
testb %sil, %sil
je 0x4cf2b
movq %rbx, %rsi
callq 0xeed83
jmp 0x4cf33
movq %rbx, %rsi
callq 0xeebeb
shlq $0x2, %rax
addq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x10(%rdx), %rdx
leaq 0xe96a7(%rip), %rsi     # 0x136605
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xe8617
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r15, %rdi
callq 0xf1db1
testl %eax, %eax
je 0x4d048
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r15, %rdi
movl $0x3, %ecx
callq 0xf266a
movq %rax, %r14
cmpb $0x3, 0x4(%r12)
jne 0x4d010
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
jle 0x4d037
movq 0x18(%rbx), %rax
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
movq %rax, %rdx
imulq %r12, %rdx
addq %rdx, %rdx
addq 0x10(%rbx), %rdx
movq %rdx, 0x10(%rsp)
testq %rax, %rax
jle 0x4d006
xorl %ebp, %ebp
movq 0x18(%r15), %rdi
movq %r13, %rsi
callq 0xeebeb
movl %eax, %edi
callq 0xec844
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0xf24ba
incq %rbp
movq 0x18(%rbx), %rax
cmpq %rax, %rbp
jl 0x4cfd3
movq 0x20(%rbx), %rcx
incq %r12
cmpq %rcx, %r12
jl 0x4cfb9
jmp 0x4d037
movq 0x18(%r15), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
addq $0x8, %r12
movl $0x0, (%rsp)
movl $0x8, %edx
movq %r12, %r8
movq %r14, %r9
callq 0xf2f79
movq 0x38(%rbx), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0xf22d0
movq %r14, %rdi
callq 0xf228d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x4d09e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rdi
callq 0xf6753
movq 0x30(%rbx), %rdi
callq 0xf6753
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xea50e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8be2
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0xd18d7(%rip), %rax     # 0x11e97e
movq %rax, (%rsi)
leaq 0xd18d9(%rip), %rax     # 0x11e98a
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x4d0d0
movq %rax, 0x18(%rsi)
leaq 0x9dd(%rip), %rax       # 0x4daa4
movq %rax, 0x20(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0xd0edf(%rip), %rax     # 0x11e9a0
movq %rax, (%rsi)
leaq 0xd0ee1(%rip), %rax     # 0x11e9ac
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x4daea
movq %rax, 0x18(%rsi)
leaq 0x55e(%rip), %rax       # 0x4e03f
movq %rax, 0x20(%rsi)
orb $0x40, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/dosbackup.c
// Function: de_identify_dosbackup20
static int de_identify_dosbackup20(deark *c)
{
	u8 b0;
	u8 b;
	u8 fnlen;
	UI seq_num;
	UI n;
	i64 nulpos;

	if(c->infile->len<128) return 0;
	b0 = de_getbyte(0);
	if(b0!=0 && b0!=0xff) return 0;

	// first letter of filename
	b = de_getbyte(5);
	if(b!='\\' && b!='/') return 0;

	seq_num = (UI)de_getu16le(1);
	if(seq_num==0 || seq_num>255) return 0;

	n = (UI)de_getu16le(3); // unknown bytes, expecting 0
	if(n!=0) return 0;

	// len seems to include the trailing NUL
	fnlen = de_getbyte(83);
	if(fnlen<3 || fnlen>78) return 0;
	nulpos = 5+(i64)fnlen-1;

	// last letter of filename
	b = de_getbyte(nulpos-1);
	if(b<33) return 0;

	// Expecting zeros from the filename trailing NUL, until the fn
	// length byte.
	if(!dbuf_is_all_zeroes(c->infile, nulpos, 83-nulpos)) return 0;

	// Expecting zeroes to fill out the 128-byte header.
	if(!dbuf_is_all_zeroes(c->infile, 84, 44)) return 0;

	return (b0==0xff && seq_num==1) ? 45 : 29;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
cmpq $0x80, 0x18(%rdi)
jl 0x4e141
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeead3
movl %eax, %r14d
leal -0x1(%r14), %eax
cmpb $-0x2, %al
jb 0x4e141
movq 0x18(%r15), %rdi
movl $0x5, %esi
callq 0xeead3
cmpb $0x5c, %al
je 0x4e095
movzbl %al, %eax
cmpl $0x2f, %eax
jne 0x4e141
movq 0x18(%r15), %rdi
movl $0x1, %esi
callq 0xeebc8
movq %rax, %r12
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
cmpl $0xffffff01, %eax       # imm = 0xFFFFFF01
jb 0x4e141
movq 0x18(%r15), %rdi
movl $0x3, %esi
callq 0xeebc8
testl %eax, %eax
jne 0x4e141
movq 0x18(%r15), %rdi
movl $0x53, %esi
callq 0xeead3
leal -0x4f(%rax), %ecx
cmpb $-0x4c, %cl
jb 0x4e141
movzbl %al, %r13d
movq 0x18(%r15), %rdi
leaq 0x3(%r13), %rsi
callq 0xeead3
cmpb $0x21, %al
jb 0x4e141
addq $0x4, %r13
movq 0x18(%r15), %rdi
movl $0x53, %edx
subq %r13, %rdx
movq %r13, %rsi
callq 0xf1856
testl %eax, %eax
je 0x4e141
movq 0x18(%r15), %rdi
movl $0x54, %esi
movl $0x2c, %edx
callq 0xf1856
testl %eax, %eax
je 0x4e141
xorl %eax, %eax
cmpl $0x1, %r12d
sete %al
shll $0x4, %eax
addl $0x1d, %eax
cmpb $-0x1, %r14b
movl $0x1d, %ebx
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x4e1b7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4e224
cmpb $0x0, 0x9(%rbx)
je 0x4e178
leaq 0xd0a4e(%rip), %rsi     # 0x11ebbc
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9295
movq 0x38(%rbx), %rdi
callq 0xf6753
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8be2
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xd0913(%rip), %rdx     # 0x11ead9
xorl %ebx, %ebx
movl $0x7, %ecx
xorl %esi, %esi
callq 0xefc85
testl %eax, %eax
jne 0x4e1ef
movl $0x7, %esi
movq %r14, %rdi
callq 0xeeb67
xorl %ebx, %ebx
cmpl $0x2020, %eax           # imm = 0x2020
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x4e2a4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x3, 0x4(%rsi)
jne 0x4e274
movq 0x8(%rax), %rcx
cmpq 0x10(%rax), %rcx
je 0x4e274
movq 0x18(%rax), %rdi
callq 0xf70f6
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %rcx
leaq 0xd0939(%rip), %rsi     # 0x11eb9c
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9295
movq 0x30(%rbx), %rax
movq (%rax), %rdi
callq 0xf052b
movq 0x30(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0xf6753
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0xe8be2
movq $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0xd09f9(%rip), %rax     # 0x11eca8
movq %rax, (%rsi)
leaq 0xd09f4(%rip), %rax     # 0x11ecad
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x4e2d8
movq %rax, 0x18(%rsi)
leaq 0x311(%rip), %rax       # 0x4e5e0
movq %rax, 0x20(%rsi)
orb $0x2, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rdx)
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (%r14,%r13), %rsi
movq 0x18(%r15), %rdi
callq 0xeead3
movq %rbp, %rcx
shlq $0x7, %rcx
movl %eax, %edx
andb $0x7f, %dl
movzbl %dl, %ebp
orq %rcx, %rbp
testb %al, %al
jns 0x4e66d
incq %r13
cmpq $0x8, %r13
jb 0x4e629
leaq 0xd06e1(%rip), %rsi     # 0x11ed3d
xorl %ebp, %ebp
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe9295
jmp 0x4e679
movq %rbp, (%r12)
incq %r13
movl $0x1, %ebp
movq %r13, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0xced36(%rip), %rax     # 0x11d3cd
movq %rax, (%rsi)
leaq 0xd0731(%rip), %rax     # 0x11edd2
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x4e6bc
movq %rax, 0x18(%rsi)
leaq 0xba1(%rip), %rax       # 0x4f258
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gemfont.c
// Function: de_module_gemfont
void de_module_gemfont(deark *c, struct deark_module_info *mi)
{
	mi->id = "gemfont";
	mi->desc = "GEM bitmap font";
	mi->run_fn = de_run_gemfont;
	mi->identify_fn = de_identify_gemfont;
}

// Assembly:
leaq 0xcfdbd(%rip), %rax     # 0x11f064
movq %rax, (%rsi)
leaq 0xcfdbb(%rip), %rax     # 0x11f06c
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x4f2cc
movq %rax, 0x18(%rsi)
leaq 0x635(%rip), %rax       # 0x4f8fc
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gemfont.c
// Function: de_identify_gemfont
static int de_identify_gemfont(deark *c)
{
	int has_usual_lm;
	i64 fdoffs, fwidth, fheight, eofd;

	if(!de_input_file_has_ext(c, "fnt") &&
		!de_input_file_has_ext(c, "gft"))
	{
		return 0;
	}

	has_usual_lm = !dbuf_memcmp(c->infile, 62, "UUUU", 4);
	fdoffs = de_getu32le(76);
	if(fdoffs<88) return 0;
	fwidth = de_getu16le(80);
	fheight = de_getu16le(82);
	if(fwidth<1 || fheight<1) return 0;
	eofd = fdoffs + fwidth*fheight; // end of font data
	if(eofd > c->infile->len) return 0;
	if(eofd==c->infile->len && has_usual_lm) return 100;
	if(eofd==c->infile->len) return 70;
	if(has_usual_lm) return 25;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xcdabf(%rip), %rsi     # 0x11d3cd
callq 0xea491
testl %eax, %eax
jne 0x4f92e
leaq 0xcf8f1(%rip), %rsi     # 0x11f20f
movq %rbx, %rdi
callq 0xea491
testl %eax, %eax
je 0x4f9d9
movq 0x18(%rbx), %rdi
leaq 0xcf8da(%rip), %rdx     # 0x11f213
movl $0x3e, %esi
movl $0x4, %ecx
callq 0xefc85
movl %eax, %ebp
movq 0x18(%rbx), %rdi
movl $0x4c, %esi
callq 0xeed61
xorl %r14d, %r14d
cmpq $0x58, %rax
jl 0x4f9dc
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x50, %esi
callq 0xeebc8
movq %rax, %r12
movq 0x18(%rbx), %rdi
movl $0x52, %esi
callq 0xeebc8
testq %r12, %r12
setle %cl
testq %rax, %rax
setle %dl
orb %cl, %dl
jne 0x4f9dc
imulq %r12, %rax
addq %r15, %rax
movq 0x18(%rbx), %rcx
movq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jg 0x4f9dc
testl %ebp, %ebp
sete %dl
cmpq %rcx, %rax
sete %sil
movl $0x64, %r14d
testb %dl, %sil
jne 0x4f9dc
xorl %edx, %edx
testl %ebp, %ebp
movl $0x19, %esi
cmovnel %edx, %esi
cmpq %rcx, %rax
movl $0x46, %r14d
cmovnel %esi, %r14d
jmp 0x4f9dc
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gemmeta.c
// Function: de_module_gemmeta
void de_module_gemmeta(deark *c, struct deark_module_info *mi)
{
	mi->id = "gemmeta";
	mi->desc = "GEM VDI Metafile";
	mi->run_fn = de_run_gemmeta;
	mi->identify_fn = de_identify_gemmeta;
}

// Assembly:
leaq 0xcf829(%rip), %rax     # 0x11f218
movq %rax, (%rsi)
leaq 0xcf827(%rip), %rax     # 0x11f220
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x4fa14
movq %rax, 0x18(%rsi)
leaq 0x23c(%rip), %rax       # 0x4fc4b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gemmeta.c
// Function: do_opcode_5
static void do_opcode_5(deark *c, lctx *d, struct opcode_data *op)
{
	i64 sub_opcode_id;
	const char *name;

	if(op->func_id!=99) return;
	if(op->intin_count<1) return;
	sub_opcode_id = de_getu16le(op->intin_pos);

	switch(sub_opcode_id) {
	case 10: name="Start Group"; break;
	case 11: name="End Group"; break;
	case 49: name="Set No Line Style"; break;
	case 50: name="Set Attribute Shadow On"; break;
	case 51: name="Set Attribute Shadow Off"; break;
	case 80: name="Start Draw Area Type Primitive"; break;
	case 81: name="End Draw Area Type Primitive"; break;
	default:
		if(sub_opcode_id>100) {
			name="for developer use";
		}
		else {
			name="?";
		}
	}

	de_dbg(c, "sub-opcode id: %d (%s)", (int)sub_opcode_id, name);
}

// Assembly:
cmpq $0x63, 0x20(%rdx)
jne 0x4fcb1
cmpq $0x0, 0x30(%rdx)
jle 0x4fcb1
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x10(%rdx), %rsi
callq 0xeebc8
cmpq $0x31, %rax
jle 0x4fcb2
cmpq $0x4f, %rax
jg 0x4fccd
cmpq $0x32, %rax
je 0x4fd03
cmpq $0x33, %rax
jne 0x4fceb
leaq 0xcf81f(%rip), %rcx     # 0x11f4ce
jmp 0x4fd1c
retq
cmpq $0xa, %rax
je 0x4fce2
cmpq $0xb, %rax
je 0x4fd15
cmpq $0x31, %rax
jne 0x4fceb
leaq 0xcf7d9(%rip), %rcx     # 0x11f4a4
jmp 0x4fd1c
cmpq $0x50, %rax
je 0x4fd0c
cmpq $0x51, %rax
jne 0x4fceb
leaq 0xcf826(%rip), %rcx     # 0x11f506
jmp 0x4fd1c
leaq 0xcf7a5(%rip), %rcx     # 0x11f48e
jmp 0x4fd1c
cmpq $0x65, %rax
leaq 0xcf82d(%rip), %rdx     # 0x11f523
leaq 0xdc454(%rip), %rcx     # 0x12c151
cmovgeq %rdx, %rcx
jmp 0x4fd1c
leaq 0xcf7ac(%rip), %rcx     # 0x11f4b6
jmp 0x4fd1c
leaq 0xcf7d4(%rip), %rcx     # 0x11f4e7
jmp 0x4fd1c
leaq 0xcf77e(%rip), %rcx     # 0x11f49a
leaq 0xcf812(%rip), %rsi     # 0x11f535
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
popq %rbx
jmp 0xe8617
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gemras.c
// Function: de_module_gemraster
void de_module_gemraster(deark *c, struct deark_module_info *mi)
{
	mi->id = "gemraster";
	mi->id_alias[0] = "gemras";
	mi->desc = "GEM VDI Bit Image, a.k.a. GEM Raster";
	mi->run_fn = de_run_gemraster;
	mi->identify_fn = de_identify_gemraster;
	mi->help_fn = de_help_gemraster;
}

// Assembly:
leaq 0xcf8b5(%rip), %rax     # 0x11f620
movq %rax, (%rsi)
leaq 0xcf8b5(%rip), %rax     # 0x11f62a
movq %rax, 0x38(%rsi)
leaq 0xcf8b1(%rip), %rax     # 0x11f631
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x4fda6
movq %rax, 0x18(%rsi)
leaq 0x624(%rip), %rax       # 0x503ba
movq %rax, 0x20(%rsi)
leaq 0x848(%rip), %rax       # 0x505e9
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: de_module_gif
void de_module_gif(deark *c, struct deark_module_info *mi)
{
	mi->id = "gif";
	mi->desc = "GIF image";
	mi->run_fn = de_run_gif;
	mi->identify_fn = de_identify_gif;
	mi->help_fn = de_help_gif;
}

// Assembly:
leaq 0xced29(%rip), %rax     # 0x11faf8
movq %rax, (%rsi)
leaq 0xced23(%rip), %rax     # 0x11fafc
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x50dff
movq %rax, 0x18(%rsi)
leaq 0x1745(%rip), %rax      # 0x52534
movq %rax, 0x20(%rsi)
leaq 0x179b(%rip), %rax      # 0x52595
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: de_identify_gif
static int de_identify_gif(deark *c)
{
	u8 buf[6];

	de_read(buf, 0, 6);
	if(!de_memcmp(buf, "GIF87a", 6)) return 100;
	if(!de_memcmp(buf, "GIF89a", 6)) return 100;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
leaq 0x2(%rsp), %r14
movl $0x6, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xee8d4
movl $0x38464947, %eax       # imm = 0x38464947
movl (%r14), %ecx
xorl %eax, %ecx
movzwl 0x4(%r14), %edx
xorl $0x6137, %edx           # imm = 0x6137
orl %ecx, %edx
je 0x52586
xorl 0x2(%rsp), %eax
movzwl 0x6(%rsp), %ecx
xorl $0x6139, %ecx           # imm = 0x6139
orl %eax, %ecx
movl $0x64, %eax
cmovel %eax, %ebx
jmp 0x5258b
movl $0x64, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: do_read_subblocks_p
static void do_read_subblocks_p(deark *c, lctx *d, dbuf *inf,
	subblock_callback_fn_type cbfn, void *userdata, i64 *ppos)
{
	struct subblock_reader_data sbrd;
	int eof_flag = 0;

	de_zeromem(&sbrd, sizeof(struct subblock_reader_data));
	sbrd.userdata = userdata;
	sbrd.inf = inf;

	while(1) {
		sbrd.subblkpos = *ppos;

		if(*ppos >= inf->len) {
			on_unexpected_eof(c, d);
			*ppos = inf->len;
			return;
		}
		sbrd.reported_dlen = (i64)de_getbyte_p(ppos);

		sbrd.dpos = *ppos;

		if(sbrd.dpos + sbrd.reported_dlen > inf->len) {
			eof_flag = 1;
			sbrd.dlen = inf->len - sbrd.dpos;
		}
		else {
			sbrd.dlen = sbrd.reported_dlen;
		}

		*ppos += sbrd.dlen;

		if(sbrd.dlen>0 || !eof_flag) {
			cbfn(c, d, &sbrd);
		}

		if(eof_flag) {
			on_unexpected_eof(c, d);
			*ppos = inf->len;
			return;
		}

		if(sbrd.reported_dlen==0) break;
		sbrd.subblock_idx++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movq %r8, (%rsp)
movq %rdx, 0x10(%rsp)
movq (%r9), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rdx), %rax
cmpq %rax, %rcx
jge 0x52672
movq %rsp, %rbp
movq 0x18(%r12), %rdi
movq %rbx, %rsi
callq 0xeeb4b
movzbl %al, %eax
movq %rax, 0x20(%rsp)
movq (%rbx), %rcx
movq %rcx, 0x28(%rsp)
leaq (%rcx,%rax), %rsi
movq 0x18(%r14), %rdx
cmpq %rdx, %rsi
jg 0x5267b
movq %rax, 0x30(%rsp)
movq %rsi, (%rbx)
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq *%r13
cmpq $0x0, 0x20(%rsp)
je 0x526be
incq 0x8(%rsp)
movq (%rbx), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%r14), %rax
cmpq %rax, %rcx
jl 0x52616
cmpb $0x0, 0x10(%r15)
jne 0x526bb
jmp 0x5269e
movq %rdx, %rax
subq %rcx, %rax
movq %rax, 0x30(%rsp)
movq %rdx, (%rbx)
jle 0x52697
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq *%r13
cmpb $0x0, 0x10(%r15)
jne 0x526b7
addq $0x10, %r15
leaq 0xc066b(%rip), %rsi     # 0x112d14
movq %r12, %rdi
xorl %eax, %eax
callq 0xe9295
movb $0x1, (%r15)
movq 0x18(%r14), %rax
movq %rax, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: decode_text_color
static void decode_text_color(deark *c, lctx *d, const char *name, u8 clr_idx,
	de_color *pclr)
{
	de_color clr;
	const char *alphastr;
	char csamp[32];

	clr = d->global_ct[(unsigned int)clr_idx];
	*pclr = clr;

	if(d->gce && d->gce->trns_color_idx_valid && d->gce->trns_color_idx==clr_idx) {
		alphastr = ",A=0";
		*pclr = DE_SET_ALPHA(*pclr, 0);
	}
	else {
		alphastr = "";
	}
	de_get_colorsample_code(c, clr, csamp, sizeof(csamp));
	de_dbg(c, "%s color: idx=%3u (%3u,%3u,%3u%s)%s", name,
		(unsigned int)clr_idx, (unsigned int)DE_COLOR_R(clr),
		(unsigned int)DE_COLOR_G(clr), (unsigned int)DE_COLOR_B(clr),
		alphastr, csamp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %r15
movl %ecx, %eax
movl 0x38(%rsi,%rax,4), %ebx
movl %ebx, (%r8)
movq 0x440(%rsi), %rax
leaq 0xf2510(%rip), %r13     # 0x1450b0
testq %rax, %rax
je 0x52bc1
cmpb $0x0, 0x1(%rax)
je 0x52bc1
cmpb %cl, 0x2(%rax)
jne 0x52bc1
movl %ebx, %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, (%r8)
leaq 0xcd168(%rip), %r13     # 0x11fd29
movzbl %cl, %ebp
movq %rsp, %r12
movl $0x20, %ecx
movq %r15, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0xe903b
movl %ebx, %r8d
shrl $0x10, %r8d
movl $0xff, %eax
andl %eax, %r8d
movl %ebx, %r9d
shrl $0x8, %r9d
andl %eax, %r9d
andl %eax, %ebx
subq $0x8, %rsp
leaq 0xcd12f(%rip), %rsi     # 0x11fd2e
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
pushq %r12
pushq %r13
pushq %rbx
callq 0xe8617
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: callback_for_comment_ext
static void callback_for_comment_ext(deark *c, lctx *d, struct subblock_reader_data *sbrd)
{
	struct comment_ext_ctx *ctx = (struct comment_ext_ctx*)sbrd->userdata;

	if(sbrd->dlen<1) return;

	if(ctx->outf) {
		// GIF comments are supposed to be 7-bit ASCII, so just copy them as-is.
		dbuf_copy(sbrd->inf, sbrd->dpos, sbrd->dlen, ctx->outf);
	}

	if(ctx->s->len<DE_DBG_MAX_STRLEN) {
		dbuf_read_to_ucstring(sbrd->inf, sbrd->dpos, sbrd->dlen, ctx->s, 0, DE_ENCODING_ASCII);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x30(%rdx), %rdx
testq %rdx, %rdx
jle 0x52c79
movq (%rbx), %r14
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x52c4b
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0xef481
movq (%r14), %rcx
cmpq $0x1f3, 0x10(%rcx)      # imm = 0x1F3
jg 0x52c79
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
xorl %r8d, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xefbd7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: do_mgk8bim_extension
static void do_mgk8bim_extension(deark *c, lctx *d, i64 pos)
{
	dbuf *tmpf = NULL;
	tmpf = dbuf_create_membuf(c, 0, 0);
	do_copy_subblocks_to_dbuf(c, d, tmpf, pos, 1, 4*1048576);
	de_dbg(c, "photoshop data at %"I64_FMT, pos);
	de_dbg_indent(c, 1);
	fmtutil_handle_photoshop_rsrc(c, tmpf, 0, tmpf->len, 0x0);
	de_dbg_indent(c, -1);
	dbuf_close(tmpf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0xf09c5
movq %rax, %r14
movq %rsp, %r9
movq %r15, (%r9)
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movl $0x1, 0x8(%r8)
movq $0x400000, 0x10(%r8)    # imm = 0x400000
movq $0x0, 0x18(%r8)
movq 0x18(%rbx), %rdx
leaq 0x22e(%rip), %rcx       # 0x52f00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x525ca
leaq 0xcd223(%rip), %rsi     # 0x11ff07
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0xf7eb8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq %r14, %rdi
callq 0xf052b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: do_mgkiptc_extension
static void do_mgkiptc_extension(deark *c, lctx *d, i64 pos)
{
	dbuf *tmpf = NULL;
	tmpf = dbuf_create_membuf(c, 0, 0);
	do_copy_subblocks_to_dbuf(c, d, tmpf, pos, 1, 4*1048576);
	de_dbg(c, "IPTC-IIM data at %"I64_FMT, pos);
	de_dbg_indent(c, 1);
	fmtutil_handle_iptc(c, tmpf, 0, tmpf->len, 0x0);
	de_dbg_indent(c, -1);
	dbuf_close(tmpf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0xf09c5
movq %rax, %r14
movq %rsp, %r9
movq %r15, (%r9)
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movl $0x1, 0x8(%r8)
movq $0x400000, 0x10(%r8)    # imm = 0x400000
movq $0x0, 0x18(%r8)
movq 0x18(%rbx), %rdx
leaq 0x17c(%rip), %rcx       # 0x52f00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x525ca
leaq 0xcd187(%rip), %rsi     # 0x11ff1d
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe8617
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe8a15
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0xf7a74
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe8a15
movq %r14, %rdi
callq 0xf052b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: do_giflite_extension
static void do_giflite_extension(deark *c, lctx *d, i64 pos1)
{
	i64 sub_block_len;
	i64 pos = pos1;
	UI vmajor, vminor;
	i64 olen;

	sub_block_len = (i64)de_getbyte_p(&pos);
	if(sub_block_len<2) return;
	vmajor = (UI)de_getbyte_p(&pos);
	vminor = (UI)de_getbyte_p(&pos);
	de_dbg(c, "GIFLITE ver: %u.%02u", vmajor, vminor);
	if(sub_block_len<6) return;
	olen = de_getu32le_p(&pos);
	de_dbg(c, "orig file size: %"I64_FMT, olen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
movq 0x18(%rdi), %rdi
movq %rax, %rsi
callq 0xeeb4b
cmpb $0x2, %al
jb 0x52e63
movl %eax, %ebp
movq 0x18(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xeeb4b
movzbl %al, %r15d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xeeb4b
movzbl %al, %ecx
leaq 0xcd102(%rip), %rsi     # 0x11ff32
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe8617
cmpb $0x6, %bpl
jb 0x52e63
movq 0x18(%rbx), %rdi
movq %rsp, %rsi
callq 0xeed83
leaq 0xcd0f1(%rip), %rsi     # 0x11ff47
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe8617
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: do_unknown_extension
static void do_unknown_extension(deark *c, lctx *d, i64 pos)
{
	dbuf *tmpf = NULL;
	tmpf = dbuf_create_membuf(c, 0, 0);
	do_copy_subblocks_to_dbuf(c, d, tmpf, pos, 1, 256);
	de_dbg_hexdump(c, tmpf, 0, tmpf->len, 256, NULL, 0x1);
	dbuf_close(tmpf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0xf09c5
movq %rax, %r14
leaq 0x8(%rsp), %r9
movq %r15, (%r9)
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movl $0x1, %ebp
movl %ebp, 0x8(%r8)
movq $0x100, 0x10(%r8)       # imm = 0x100
movq $0x0, 0x18(%r8)
movq 0x18(%rbx), %rdx
leaq 0x3d(%rip), %rcx        # 0x52f00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x525ca
movq 0x18(%r14), %rcx
movl %ebp, (%rsp)
movl $0x100, %r8d            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0xe8bea
movq %r14, %rdi
callq 0xf052b
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: callback_for_copy_subblocks
static void callback_for_copy_subblocks(deark *c, lctx *d, struct subblock_reader_data *sbrd)
{
	struct copy_subblocks_ctx *ctx = (struct copy_subblocks_ctx*)sbrd->userdata;
	i64 nbytes_to_copy;

	if(ctx->has_max && (ctx->nbytes_copied >= ctx->maxlen)) return;
	if(sbrd->dlen<1) return;

	nbytes_to_copy = sbrd->dlen;
	if(ctx->has_max) {
		if(ctx->nbytes_copied + nbytes_to_copy > ctx->maxlen) {
			nbytes_to_copy = ctx->maxlen - ctx->nbytes_copied;
		}
	}
	dbuf_copy(sbrd->inf, sbrd->dpos, nbytes_to_copy, ctx->outf);
	ctx->nbytes_copied += nbytes_to_copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdx), %r14
cmpl $0x0, 0x8(%r14)
je 0x52f33
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rax, %rbx
subq %rcx, %rbx
jle 0x52f53
movq 0x30(%rdx), %rsi
testq %rsi, %rsi
jle 0x52f53
addq %rsi, %rcx
cmpq %rax, %rcx
cmovleq %rsi, %rbx
jmp 0x52f3c
movq 0x30(%rdx), %rbx
testq %rbx, %rbx
jle 0x52f53
movq 0x10(%rdx), %rdi
movq 0x28(%rdx), %rsi
movq (%r14), %rcx
movq %rbx, %rdx
callq 0xef481
addq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: my_giflzw_write_cb
static void my_giflzw_write_cb(dbuf *f, void *userdata,
	const u8 *buf, i64 size)
{
	i64 i;
	struct my_giflzw_userdata *u = (struct my_giflzw_userdata*)userdata;

	for(i=0; i<(i64)size; i++) {
		do_record_pixel(u->c, u->d, u->gi,
			buf[i], i);
	}
	u->gi->pixels_set += (i64)size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
testq %rcx, %rcx
jle 0x53000
movq %rdx, %r15
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
movq 0x28(%rsi), %rax
addq %r12, %rax
cqto
idivq 0x18(%rsi)
movq 0x50(%rsi), %rcx
testq %rcx, %rcx
je 0x52f9d
cmpq 0x20(%rsi), %rax
jge 0x52f9d
movzwl (%rcx,%rax,2), %eax
movq 0x8(%r14), %r8
movzbl (%r15,%r12), %edi
cmpl $0x0, 0x34(%rsi)
je 0x52fb8
cmpq %rdi, 0x48(%rsi)
jle 0x52fb8
leaq 0x58(%rsi), %rcx
jmp 0x52fbc
leaq 0x38(%r8), %rcx
movl (%rcx,%rdi,4), %ecx
movq 0x440(%r8), %r8
testq %r8, %r8
je 0x52fe0
cmpb $0x0, 0x1(%r8)
je 0x52fe0
cmpb %dil, 0x2(%r8)
jne 0x52fe0
andl $0xffffff, %ecx         # imm = 0xFFFFFF
jmp 0x52fe6
orl $0xff000000, %ecx       # imm = 0xFF000000
movq (%rsi), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xf24ba
incq %r12
cmpq %r12, %rbx
jne 0x52f79
movq 0x10(%r14), %rax
addq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/gif.c
// Function: callback_for_image_subblock
static void callback_for_image_subblock(deark *c, lctx *d, struct subblock_reader_data *sbrd)
{
	struct gif_image_data *gi = (struct gif_image_data*)sbrd->userdata;

	if(sbrd->reported_dlen==0) {
		de_dbg(c, "block terminator at %"I64_FMT, sbrd->subblkpos);
		return;
	}
	de_dbg2(c, "sub-block at %"I64_FMT", size=%"I64_FMT, sbrd->subblkpos, sbrd->reported_dlen);

	if(!gi->failure_flag && !gi->dfctx->finished_flag) {
		de_dfilter_addslice(gi->dfctx, sbrd->inf, sbrd->dpos, sbrd->dlen);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x18(%rdx), %rdx
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x53052
movq (%rbx), %r14
leaq 0xcd096(%rip), %rsi     # 0x1200c8
xorl %eax, %eax
callq 0xe87e4
cmpl $0x0, 0x38(%r14)
jne 0x5304a
movq 0x40(%r14), %rdi
cmpb $0x0, 0x20(%rdi)
je 0x53067
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xcd057(%rip), %rsi     # 0x1200b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8617
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfa404
nop
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/grasp.c
// Function: de_module_graspgl
void de_module_graspgl(deark *c, struct deark_module_info *mi)
{
	mi->id = "graspgl";
	mi->desc = "GRASP GL animation";
	mi->run_fn = de_run_graspgl;
	mi->identify_fn = de_identify_graspgl;
}

// Assembly:
leaq 0xcd1b9(%rip), %rax     # 0x120240
movq %rax, (%rsi)
leaq 0xcd1b7(%rip), %rax     # 0x120248
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x530ac
movq %rax, 0x18(%rsi)
leaq 0x34f(%rip), %rax       # 0x533f6
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/grasp.c
// Function: de_identify_graspgl
static int de_identify_graspgl(deark *c)
{
	i64 index_size;
	i64 index_pos;
	i64 first_offset;
	int is_le = 1;
	int gl_ext;

	index_size = de_getu16le(0);
	if(index_size==0x4741) {
		if((UI)de_getu16be(2)==0x0100U) {
			is_le = 0; // Amiga GL?
			index_size = de_getu16be(4);
		}
	}

	// Header should be a nonzero multiple of 17 bytes.
	if(index_size==0 || (index_size%17 != 0)) return 0;
	index_pos = is_le ? 2 : 6;
	if(index_pos+index_size>c->infile->len) return 0;

	gl_ext = de_input_file_has_ext(c, "gl");

	// Most likely, the first embedded file immediately follows
	// the header. If so, it's pretty good evidence this is a
	// grasp_gl file.
	first_offset = dbuf_getu32x(c->infile, index_pos, is_le);

	if(first_offset>c->infile->len || first_offset<index_pos+index_size) return 0;
	if(first_offset == index_pos+index_size)
		return gl_ext ? 100 : 70;

	if(gl_ext) return 5;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0xeebc8
movl $0x1, %ebp
cmpq $0x4741, %rax           # imm = 0x4741
jne 0x5345a
movq 0x18(%r14), %rdi
movl $0x2, %r12d
movl $0x2, %esi
callq 0xeeb67
movl $0x4741, %r15d          # imm = 0x4741
cmpl $0x100, %eax            # imm = 0x100
jne 0x53463
movq 0x18(%r14), %rdi
movl $0x4, %esi
callq 0xeeb67
movq %rax, %r15
xorl %ebp, %ebp
movl $0x6, %r12d
jmp 0x53463
movq %rax, %r15
movl $0x2, %r12d
movabsq $0x7878787878787879, %rcx # imm = 0x7878787878787879
movq %r15, %rax
imulq %rcx
testq %r15, %r15
je 0x534a5
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x3, %rdx
addq %rax, %rdx
movq %rdx, %rax
shlq $0x4, %rax
addq %rdx, %rax
movq %r15, %rcx
subq %rax, %rcx
jne 0x534a5
addq %r12, %r15
movq 0x18(%r14), %rax
cmpq 0x18(%rax), %r15
jle 0x534b6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xccd88(%rip), %rsi     # 0x120245
movq %r14, %rdi
callq 0xea491
movl %eax, %r13d
movq 0x18(%r14), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xeeff3
cmpq %r15, %rax
jl 0x534a5
movq 0x18(%r14), %rcx
cmpq 0x18(%rcx), %rax
jg 0x534a5
cmpq %r15, %rax
jne 0x534fc
testl %r13d, %r13d
movl $0x46, %eax
movl $0x64, %ebx
cmovel %eax, %ebx
jmp 0x534a5
xorl %eax, %eax
testl %r13d, %r13d
setne %al
leal (%rax,%rax,4), %ebx
jmp 0x534a5
// File: /workspace/github_c_makefile_star2_O3/jsummers[P]deark/modules/grasp.c
// Function: de_module_graspfont
void de_module_graspfont(deark *c, struct deark_module_info *mi)
{
	mi->id = "graspfont";
	mi->desc = "GRASP font";
	mi->run_fn = de_run_graspfont;
	mi->identify_fn = de_identify_graspfont;
}

// Assembly:
leaq 0xccd4b(%rip), %rax     # 0x12025b
movq %rax, (%rsi)
leaq 0xccd4b(%rip), %rax     # 0x120265
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x53535
movq %rax, 0x18(%rsi)
leaq 0x57b(%rip), %rax       # 0x53aab
movq %rax, 0x20(%rsi)
retq