LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-cmd.c
// Function: colormode_opt
static void colormode_opt(struct cmdctx *cc, const char *modestr)
{
	if(!strcmp(modestr, "auto")) {
		cc->color_method_req = CM_AUTOCOLOR;
	}
	else if(!strcmp(modestr, "ansi")) {
		cc->color_method_req = CM_ANSI;
	}
	else if(!strcmp(modestr, "ansi24")) {
		cc->color_method_req = CM_ANSI24;
	}
	else if(!strcmp(modestr, "winconsole")) {
		cc->color_method_req = CM_WINCONSOLE;
	}
	else  if(!strcmp(modestr, "none")) {
		cc->color_method_req = CM_NOCOLOR;
	}
	else {
		de_printf(cc->c, DE_MSGTYPE_MESSAGE, "Invalid colormode: %s\n", modestr);
		cc->error_flag = 1;
		return;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf740f(%rip), %rsi     # 0x11058b
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x191f3
leaq 0xf757f(%rip), %rsi     # 0x11070e
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x191ff
leaq 0xf7571(%rip), %rsi     # 0x110713
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x1920b
leaq 0xf7565(%rip), %rsi     # 0x11071a
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x19217
leaq 0xf755d(%rip), %rsi     # 0x110725
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x19223
movq (%rbx), %rdi
leaq 0xf754c(%rip), %rdx     # 0x11072a
xorl %esi, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0xe917a
movl $0x1, 0x18(%rbx)
jmp 0x1922d
movl $0x1, 0x84(%rbx)
jmp 0x1922d
movl $0x2, 0x84(%rbx)
jmp 0x1922d
movl $0x3, 0x84(%rbx)
jmp 0x1922d
movl $0x4, 0x84(%rbx)
jmp 0x1922d
movl $0x0, 0x84(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-cmd.c
// Function: handle_an_input_filename
static void handle_an_input_filename(struct cmdctx *cc, char *fn)
{
	if(!cc->input_filename) {
		cc->input_filename = fn;
		de_set_input_filename(cc->c, cc->input_filename, 0);
		return;
	}

	if(cc->mp_mode) {
		de_set_input_filename(cc->c, fn, 0x1);
		return;
	}

	cc->error_flag = 1;
	cc->show_usage_message = 1;
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x19252
cmpb $0x0, 0x80(%rdi)
je 0x19260
movq (%rdi), %rdi
movl $0x1, %edx
jmp 0x10964f
movq %rsi, 0x10(%rdi)
movq (%rdi), %rdi
xorl %edx, %edx
jmp 0x10964f
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x18(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-modules.c
// Function: de_register_modules_internal
static void de_register_modules_internal(deark *c)
{
	static const de_module_getinfo_fn infofunc_list[] = {
#define DE_MODULE(x)      x,
#define DE_MODULE_LAST(x) x
#include "deark-modules.h"
#undef DE_MODULE
#undef DE_MODULE_LAST
	};
	size_t num_modules;
	size_t i;

	if(c->module_info) return; // Already done.

	num_modules = DE_ARRAYCOUNT(infofunc_list);

	c->module_info = de_mallocarray(c, num_modules, sizeof(struct deark_module_info));

	for(i=0; i<num_modules; i++) {
		register_a_module(c, infofunc_list[i]);
	}

	disable_modules_as_requested(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x1b0(%rdi)
je 0x1929b
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl $0x179, %esi            # imm = 0x179
movl $0x48, %edx
callq 0xea259
movq %rax, 0x1b0(%rbx)
xorl %r14d, %r14d
leaq 0x1638e2(%rip), %r15    # 0x17cba0
movslq 0x1a8(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x1a8(%rbx)
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x1b0(%rbx), %rsi
movq %rbx, %rdi
callq *(%r14,%r15)
addq $0x8, %r14
cmpq $0xbc8, %r14            # imm = 0xBC8
jne 0x192be
cmpq $0x0, 0x170(%rbx)
jne 0x1931d
cmpq $0x0, 0x178(%rbx)
jne 0x1931d
cmpq $0x0, 0x180(%rbx)
jne 0x1931d
cmpq $0x0, 0x188(%rbx)
je 0x19295
movslq 0x1a8(%rbx), %rsi
movq %rbx, %rdi
callq 0xe969b
movq %rax, %r14
movq 0x170(%rbx), %rsi
testq %rsi, %rsi
je 0x1937e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x194bf
cmpl $0x0, 0x1a8(%rbx)
jle 0x1937e
movl $0x18, %eax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpb $0x0, (%r14,%rcx)
jne 0x1936b
movq 0x1b0(%rbx), %rdx
movups %xmm0, (%rdx,%rax)
incq %rcx
movslq 0x1a8(%rbx), %rdx
addq $0x48, %rax
cmpq %rdx, %rcx
jl 0x19359
cmpq $0x0, 0x178(%rbx)
je 0x193e3
movslq 0x1a8(%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x18140
movq 0x178(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x194bf
cmpl $0x0, 0x1a8(%rbx)
jle 0x193e3
movl $0x18, %eax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpb $0x0, (%r14,%rcx)
je 0x193d0
movq 0x1b0(%rbx), %rdx
movups %xmm0, (%rdx,%rax)
incq %rcx
movslq 0x1a8(%rbx), %rdx
addq $0x48, %rax
cmpq %rdx, %rcx
jl 0x193be
cmpq $0x0, 0x180(%rbx)
je 0x19449
movslq 0x1a8(%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x18140
movq 0x180(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x194bf
movslq 0x1a8(%rbx), %rax
testq %rax, %rax
jle 0x19449
shlq $0x3, %rax
leaq (%rax,%rax,8), %rax
xorl %ecx, %ecx
movq %r14, %rdx
cmpb $0x0, (%rdx)
jne 0x1943d
movq 0x1b0(%rbx), %rsi
orl $0x100, 0x30(%rsi,%rcx) # imm = 0x100
addq $0x48, %rcx
incq %rdx
cmpq %rcx, %rax
jne 0x19429
cmpq $0x0, 0x188(%rbx)
je 0x194af
movslq 0x1a8(%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x18140
movq 0x188(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x194bf
movslq 0x1a8(%rbx), %rax
testq %rax, %rax
jle 0x194af
shlq $0x3, %rax
leaq (%rax,%rax,8), %rax
xorl %ecx, %ecx
movq %r14, %rdx
cmpb $0x0, (%rdx)
je 0x194a3
movq 0x1b0(%rbx), %rsi
orl $0x100, 0x30(%rsi,%rcx) # imm = 0x100
addq $0x48, %rcx
incq %rdx
cmpq %rcx, %rax
jne 0x1948f
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe9752
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/src/deark-modules.c
// Function: module_list_string_to_set
static void module_list_string_to_set(deark *c, const char *s, u8 *mod_set)
{
	char tmpname[80];
	const char *ptr1, *ptr2;

	if(!s) return;

	ptr1 = s;
	while(1) {
		int idx;

		tmpname[0] = '\0';
		ptr2 = de_strchr(ptr1, ',');
		if(ptr2) {
			size_t len;
			len = (size_t)(ptr2-ptr1);
			if(len<sizeof(tmpname)) {
				de_memcpy(tmpname, ptr1, len);
				tmpname[len] = '\0';
			}
			ptr1 = ptr2 + 1;
		}
		else {
			de_strlcpy(tmpname, ptr1, sizeof(tmpname));
		}

		idx = de_get_module_idx_by_id(c, tmpname);
		if(idx>=0) {
			mod_set[idx] = 1;
		}

		if(!ptr2) break;
	}
}

// Assembly:
testq %rsi, %rsi
je 0x19557
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movb $0x0, (%rsp)
movq %r15, %rdi
movl $0x2c, %esi
callq 0xe8ed3
movq %rax, %r13
testq %rax, %rax
je 0x1951f
movq %r13, %rbp
subq %r15, %rbp
cmpq $0x4f, %rbp
ja 0x19519
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x181e0
movb $0x0, (%rsp,%rbp)
leaq 0x1(%r13), %r15
jmp 0x1952f
movl $0x50, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe8ded
movq %r14, %rdi
movq %r12, %rsi
callq 0xea3fc
testl %eax, %eax
js 0x19544
movl %eax, %eax
movb $0x1, (%rbx,%rax)
testq %r13, %r13
jne 0x194e2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/abk.c
// Function: de_module_abk
void de_module_abk(deark *c, struct deark_module_info *mi)
{
	mi->id = "abk";
	mi->desc = "AMOS resource (AmBk, sprite, icon, AmBs)";
	mi->run_fn = de_run_abk;
	mi->identify_fn = de_identify_abk;
	mi->help_fn = de_help_abk;
}

// Assembly:
leaq 0xf7c37(%rip), %rax     # 0x111196
movq %rax, (%rsi)
leaq 0xf7818(%rip), %rax     # 0x110d81
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x1958f
movq %rax, 0x18(%rsi)
leaq 0x271(%rip), %rax       # 0x197f0
movq %rax, 0x20(%rsi)
leaq 0x325(%rip), %rax       # 0x198af
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/abk.c
// Function: de_identify_abk
static int de_identify_abk(deark *c)
{
	int ext_bonus = 0;
	UI sig;

	if(de_input_file_has_ext(c, "abk")) ext_bonus=40;

	sig = (UI)de_getu32be(0);
	if(sig==CODE_AmBk)
		return 60+ext_bonus;
	if(sig==CODE_AmSp)
		return 60+ext_bonus;
	if(sig==CODE_AmIc)
		return 60+ext_bonus;
	if(sig==CODE_AmBs)
		return 60+ext_bonus;
	if(sig==AMOS_PIC_HDR_ID || is_scr_hdr_id(sig)) {
		if(is_amos_picture_file(c, sig)) {
			return 60+ext_bonus;
		}
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xf7997(%rip), %rsi     # 0x111196
callq 0xea936
testl %eax, %eax
movl $0x3c, %eax
movl $0x64, %ebx
cmovel %eax, %ebx
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0xef32a
cmpl $0x416d426a, %eax       # imm = 0x416D426A
jg 0x19845
movl $0x5a, %r15d
cmpl $0x1203008f, %eax       # imm = 0x1203008F
jg 0x1985c
cmpl $0x31990, %eax          # imm = 0x31990
je 0x1986a
cmpl $0x6071963, %eax        # imm = 0x6071963
jne 0x19895
xorl %r15d, %r15d
jmp 0x1986a
cmpl $0x416d4962, %eax       # imm = 0x416D4962
jg 0x19899
cmpl $0x416d426b, %eax       # imm = 0x416D426B
je 0x198a7
cmpl $0x416d4273, %eax       # imm = 0x416D4273
je 0x198a7
jmp 0x19895
cmpl $0x12030090, %eax       # imm = 0x12030090
je 0x1986a
cmpl $0x12031990, %eax       # imm = 0x12031990
jne 0x19895
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xef32a
cmpl $0x6071963, %eax        # imm = 0x6071963
jne 0x19895
movq 0x18(%r14), %rdi
addq $0xe, %r15
movq %r15, %rsi
callq 0xef169
addl $-0x7, %eax
cmpl $-0x7, %eax
ja 0x198a7
xorl %ebx, %ebx
jmp 0x198a7
cmpl $0x416d4963, %eax       # imm = 0x416D4963
je 0x198a7
cmpl $0x416d5370, %eax       # imm = 0x416D5370
jne 0x19895
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/abk.c
// Function: de_module_amos_source
void de_module_amos_source(deark *c, struct deark_module_info *mi)
{
	mi->id = "amos_source";
	mi->desc = "AMOS source code";
	mi->run_fn = de_run_amos_source;
	mi->identify_fn = de_identify_amos_source;
}

// Assembly:
leaq 0xf74e6(%rip), %rax     # 0x110daa
movq %rax, (%rsi)
leaq 0xf74e8(%rip), %rax     # 0x110db6
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x198e9
movq %rax, 0x18(%rsi)
leaq 0x137(%rip), %rax       # 0x19a1b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/abk.c
// Function: de_run_amos_source
static void de_run_amos_source(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 basic_len;
	i64 pos;
	i64 nbanks;

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

	pos = 16;
	basic_len = de_getu32be(pos);
	pos += 4;
	de_dbg(c, "BASIC code at %"I64_FMT", len=%"I64_FMT, pos, basic_len);
	pos += basic_len;
	if(pos >= c->infile->len) goto done;
	if(dbuf_memcmp(c->infile, pos, "AmBs", 4)) {
		de_err(c, "AmBs segment not found, expected at offset %"I64_FMT, pos);
		goto done;
	}

	de_dbg(c, "AmBs segment at %"I64_FMT, pos);
	nbanks = de_getu16be(pos+4);
	de_dbg_indent(c, 1);
	de_dbg(c, "number of banks: %d", (int)nbanks);
	if(nbanks>0 || c->extract_level>=2) {
		dbuf_create_file_from_slice(c->infile, pos, c->infile->len-pos, "AmBs.abk", NULL, 0);
	}
	else {
		de_dbg(c, "not extracting empty AmBs segment");
	}
	de_dbg_indent(c, -1);


done:
	de_free(c, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0xe969b
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x10, %esi
callq 0xef32a
movq %rax, %r12
leaq 0xf7911(%rip), %rsi     # 0x11122a
movl $0x14, %edx
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9226
leaq 0x14(%r12), %r15
movq 0x18(%rbx), %rdi
cmpq 0x18(%rdi), %r15
jge 0x199f2
leaq 0xf7900(%rip), %rdx     # 0x111245
movl $0x4, %ecx
movq %r15, %rsi
callq 0xf025e
testl %eax, %eax
je 0x1996f
leaq 0xf78ed(%rip), %rsi     # 0x11124a
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe9df7
jmp 0x199f2
leaq 0xf7903(%rip), %rsi     # 0x111279
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%rbx), %rdi
addq $0x18, %r12
movq %r12, %rsi
callq 0xef169
movq %rax, %r12
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
leaq 0xf781f(%rip), %rsi     # 0x1111c9
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
testq %r12, %r12
jg 0x199c5
cmpl $0x2, 0x90(%rbx)
jl 0x19a08
movq 0x18(%rbx), %rdi
movq 0x18(%rdi), %rdx
subq %r15, %rdx
leaq 0xf78b6(%rip), %rcx     # 0x11128d
movq %r15, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf0321
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe9752
leaq 0xf7887(%rip), %rsi     # 0x111296
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9226
jmp 0x199e5
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/abk.c
// Function: de_identify_amos_source
static int de_identify_amos_source(deark *c)
{
	u8 b[10];
	int ext_bonus = 0;

	if(de_input_file_has_ext(c, "amos")) ext_bonus=20;

	de_read(b, 0, 10);
	if(!de_memcmp(b, "AMOS Basic", 10))
		return 80+ext_bonus;
	if(!de_memcmp(b, "AMOS Pro", 8))
		return 80+ext_bonus;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xf788a(%rip), %rsi     # 0x1112b8
callq 0xea936
testl %eax, %eax
movl $0x50, %eax
movl $0x64, %ebx
cmovel %eax, %ebx
movq 0x18(%r14), %rdi
xorl %r15d, %r15d
leaq 0x6(%rsp), %r14
movl $0xa, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0xeeee8
movabsq $0x73614220534f4d41, %rax # imm = 0x73614220534F4D41
xorq (%r14), %rax
movzwl 0x8(%r14), %ecx
xorq $0x6369, %rcx           # imm = 0x6369
orq %rax, %rcx
je 0x19a91
movabsq $0x6f725020534f4d41, %rax # imm = 0x6F725020534F4D41
cmpq %rax, 0x6(%rsp)
cmovel %ebx, %r15d
movl %r15d, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/abk.c
// Function: do_read_sprite_or_pic_palette
static void do_read_sprite_or_pic_palette(deark *c, lctx *d, struct amosbank *bk)
{
	i64 k;
	UI n;
	u8 cr, cg, cb;
	u8 cr1, cg1, cb1;
	i64 pos;
	i64 colors_used;
	char tmps[64];

	pos = bk->pal_pos;
	de_dbg(c, "palette at %"I64_FMT, pos);
	de_dbg_indent(c, 1);

	colors_used = de_pow2(bk->max_planes);

	for(k=0; k<32; k++) {
		n = (UI)dbuf_getu16be(bk->f, pos+k*2);
		cr1 = (u8)((n>>8)&0xf);
		cg1 = (u8)((n>>4)&0xf);
		cb1 = (u8)(n&0xf);
		cr = cr1*17;
		cg = cg1*17;
		cb = cb1*17;
		bk->pal[k] = DE_MAKE_RGB(cr, cg, cb);
		de_snprintf(tmps, sizeof(tmps), "0x%04x (%2d,%2d,%2d) "DE_CHAR_RIGHTARROW" ",
			n, (int)cr1, (int)cg1, (int)cb1);
		de_dbg_pal_entry2(c, k, bk->pal[k], tmps, NULL,
			(k>=colors_used)?" [unused]":"");

		// Set up colors #32-63 for 6-plane "Extra Half-Brite" mode.
		// For normal images (<=5 planes), these colors won't be used.
		bk->pal[k+32] = DE_MAKE_RGB(cr/2, cg/2, cb/2);
	}

	bk->pal[0] = DE_SET_ALPHA(bk->pal[0], 0); // First color is transparent.
	// (Don't know if pal[32] should be transparent also.)

	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %r12
leaq 0x11bae8(%rip), %rsi    # 0x1361a8
movq %r12, %rdx
xorl %eax, %eax
callq 0xe9226
movq %rbx, 0x18(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe9585
movq %r14, 0x10(%rsp)
movq 0x488(%r14), %rdi
callq 0xea7f2
movq %rax, 0x20(%rsp)
xorl %r13d, %r13d
movq 0x10(%rsp), %r15
movq %r12, 0x28(%rsp)
movq 0x50(%r15), %rdi
movq %r12, %rsi
callq 0xef169
movl %eax, %ebx
shrl $0x8, %ebx
andl $0xf, %ebx
movl %eax, %r12d
shrl $0x4, %r12d
movl %eax, %ecx
andl $0xf, %ecx
andl $0xf, %r12d
movl %ecx, %ebp
shll $0x4, %ebp
orl %ecx, %ebp
imull $0x110000, %ebx, %edx   # imm = 0x110000
imull $0x1100, %r12d, %esi    # imm = 0x1100
orl %edx, %esi
orl %ebp, %esi
movl $0xff000000, %edx       # imm = 0xFF000000
orl %edx, %esi
movl %esi, 0x70(%r15,%r13,4)
movl %ecx, (%rsp)
movl $0x40, %esi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
leaq 0xf6824(%rip), %rdx     # 0x110f82
movl %eax, %ecx
movl %ebx, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0xe8d67
movl 0x70(%r15,%r13,4), %edx
cmpq 0x20(%rsp), %r13
leaq 0xf681e(%rip), %r9      # 0x110f9c
leaq 0x12a44b(%rip), %rax    # 0x144bd0
cmovlq %rax, %r9
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xe9c1e
imull $0x88000, %ebx, %eax    # imm = 0x88000
andl $0x7f0000, %eax         # imm = 0x7F0000
imull $0x880, %r12d, %ecx     # imm = 0x880
movq 0x28(%rsp), %r12
andl $0x7f00, %ecx           # imm = 0x7F00
shrl %ebp
orl %ecx, %ebp
orl %eax, %ebp
movl $0xff000000, %eax       # imm = 0xFF000000
orl %eax, %ebp
movl %ebp, 0xf0(%r15,%r13,4)
incq %r13
addq $0x2, %r12
cmpq $0x20, %r13
jne 0x1a6fa
movq 0x10(%rsp), %rax
movb $0x0, 0x73(%rax)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/alphabmp.c
// Function: de_module_alphabmp
void de_module_alphabmp(deark *c, struct deark_module_info *mi)
{
	mi->id = "alphabmp";
	mi->desc = "Alpha Microsystems BMP";
	mi->run_fn = de_run_alphabmp;
	mi->identify_fn = de_identify_alphabmp;
}

// Assembly:
leaq 0xf6872(%rip), %rax     # 0x1112d1
movq %rax, (%rsi)
leaq 0xf6871(%rip), %rax     # 0x1112da
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x1aa84
movq %rax, 0x18(%rsi)
leaq 0x4b2(%rip), %rax       # 0x1af31
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amigaicon.c
// Function: de_module_amigaicon
void de_module_amigaicon(deark *c, struct deark_module_info *mi)
{
	mi->id = "amigaicon";
	mi->desc = "Amiga Workbench icon (.info), NewIcons, GlowIcons";
	mi->run_fn = de_run_amigaicon;
	mi->identify_fn = de_identify_amigaicon;
}

// Assembly:
leaq 0xf6495(%rip), %rax     # 0x111408
movq %rax, (%rsi)
leaq 0xf6495(%rip), %rax     # 0x111412
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x1af98
movq %rax, 0x18(%rsi)
leaq 0xf87(%rip), %rax       # 0x1bf1a
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amigaicon.c
// Function: do_newicons_process_bit
static void do_newicons_process_bit(deark *c, lctx *d, dbuf *f, u8 b)
{
	UI nbits_needed;

	de_bitbuf_lowlevel_add_bits(&d->newicons_bbll, (u64)b, 1);

	// If line_count==0, we're still reading palette samples, which are always 8 bits.
	nbits_needed = (d->newicons_finished_pal==0) ? 8 : d->newicons_bits_per_pixel;

	if(d->newicons_bbll.nbits_in_bitbuf >= nbits_needed) {
		UI x;

		x = (UI)de_bitbuf_lowlevel_get_bits(&d->newicons_bbll, nbits_needed);
		if(x>255 && d->newicons_finished_pal) {
			// For now at least, we only support 9-bit images if they don't
			// actually use the 9th bit.
			d->newicons_largepalentry_flag = 1;
		}
		dbuf_writebyte(f, (u8)x);
		d->newicons_bbll.nbits_in_bitbuf = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %r15
movl %edx, %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0xf21bc
cmpb $0x0, 0x54(%rbx)
je 0x1bf69
movl 0x50(%rbx), %esi
jmp 0x1bf6e
movl $0x8, %esi
cmpl %esi, 0x5c(%rbx)
jb 0x1bf9e
movq %r15, %rdi
callq 0xf221e
testl $0xffffff00, %eax       # imm = 0xFFFFFF00
je 0x1bf8c
cmpb $0x0, 0x54(%rbx)
je 0x1bf8c
movb $0x1, 0x55(%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0xf11be
movl $0x0, 0x5c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/amigaicon.c
// Function: glowdata_decompress
static void glowdata_decompress(dbuf *f, i64 pos, i64 len,
	dbuf *outf, UI bits_per_pixel)
{
	i64 x;
	i64 i;
	u8 b, b2;
	struct de_bitreader bitrd;

	de_zeromem(&bitrd, sizeof(struct de_bitreader));
	bitrd.f = f;
	bitrd.curpos = pos;
	bitrd.endpos = pos + len;
	bitrd.bbll.is_lsb = 0;
	de_bitbuf_lowlevel_empty(&bitrd.bbll);

	while(1) {
		b = (u8)de_bitreader_getbits(&bitrd, 8);
		if(bitrd.eof_flag) break;

		if(b<=127) {
			// 1+b literal pixels
			x = 1+(i64)b;
			for(i=0; i<x; i++) {
				b2 = (u8)de_bitreader_getbits(&bitrd, bits_per_pixel);
				dbuf_writebyte(outf, b2);
			}
		}
		else if(b>=129) {
			// 257-b repeated pixels
			x = 257 - (i64)b;
			b2 = (u8)de_bitreader_getbits(&bitrd, bits_per_pixel);
			for(i=0; i<x; i++) {
				dbuf_writebyte(outf, b2);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %ebx
movq %rcx, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, -0x20(%rax)
movaps %xmm0, -0x10(%rax)
movaps %xmm0, (%rax)
movq %rdi, -0x20(%rax)
movq %rsi, -0x18(%rax)
addq %rsi, %rdx
movq %rdx, -0x10(%rax)
movb $0x0, (%rax)
movq %rax, %rdi
callq 0xf2261
movq %rsp, %r15
movq %r15, %rdi
movl $0x8, %esi
callq 0xf2271
cmpb $0x0, 0x18(%r15)
jne 0x1c4e9
movq %rsp, %r15
movzbl %al, %ecx
cmpl $0x7f, %ecx
ja 0x1c4a6
movzbl %al, %r12d
incq %r12
movq %r15, %rdi
movl %ebx, %esi
callq 0xf2271
movzbl %al, %esi
movq %r14, %rdi
callq 0xf11be
decq %r12
jne 0x1c48a
jmp 0x1c4d5
cmpl $0x80, %ecx
je 0x1c4d5
movzbl %al, %r12d
movq %r15, %rdi
movl %ebx, %esi
callq 0xf2271
addq $-0x101, %r12           # imm = 0xFEFF
movzbl %al, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0xf11be
incq %r12
jne 0x1c4c6
movq %r15, %rdi
movl $0x8, %esi
callq 0xf2271
cmpb $0x0, 0x18(%rsp)
je 0x1c47b
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ansiart.c
// Function: de_module_ansiart
void de_module_ansiart(deark *c, struct deark_module_info *mi)
{
	mi->id = "ansiart";
	mi->id_alias[0] = "ansi";
	mi->desc = "ANSI Art character graphics";
	mi->run_fn = de_run_ansiart;
	mi->identify_fn = de_identify_ansiart;
	mi->help_fn = de_help_ansiart;
}

// Assembly:
leaq 0xf5651(%rip), %rax     # 0x111b50
movq %rax, (%rsi)
leaq 0xf4205(%rip), %rax     # 0x11070e
movq %rax, 0x38(%rsi)
leaq 0xf5644(%rip), %rax     # 0x111b58
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x1c53a
movq %rax, 0x18(%rsi)
leaq 0x1249(%rip), %rax      # 0x1d773
movq %rax, 0x20(%rsi)
leaq 0x130d(%rip), %rax      # 0x1d842
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ansiart.c
// Function: de_identify_ansiart
static int de_identify_ansiart(deark *c)
{
	u8 buf[4];
	int has_ans_ext;

	if(!c->detection_data->SAUCE_detection_attempted) {
		de_err(c, "ansiart detection requires sauce module");
		return 0;
	}

	de_read(buf, 0, 4);

	if(!de_memcmp(buf, "\x04\x31\x2e\x34", 4)) {
		// Looks like iCEDraw format, which may use the same SAUCE identifiers
		// as ANSI Art, even though it is incompatible.
		return 0;
	}

	has_ans_ext = de_input_file_has_ext(c, "ans");

	if(c->detection_data->sauce.has_SAUCE) {
		if(c->detection_data->sauce.data_type==1 &&
			c->detection_data->sauce.file_type==1)
		{
			// Unfortunately, iCEDraw and possibly other formats may use the
			// same SAUCE identifiers as ANSI Art, so we probably shouldn't always
			// return 100.
			if(has_ans_ext)
				return 100;
			return 91;
		}
	}

	// ANSI Art files usually start with an ANSI escape sequence.
	// TODO: Another possibility is that the file could start with email headers.
	if(buf[0]==0x1b && buf[1]==0x5b && (buf[2]=='?' ||
		(buf[2]>='0' && buf[2]<='9')))
	{
		return has_ans_ext ? 100 : 50;
	}

	if(has_ans_ext)
		return 10;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpb $0x0, 0x5(%rax)
je 0x1d7e4
movq 0x18(%r14), %rdi
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
movl $0x4, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0xeeee8
cmpl $0x342e3104, (%r15)     # imm = 0x342E3104
je 0x1d836
leaq 0x11e3cc(%rip), %rsi    # 0x13bb83
movq %r14, %rdi
callq 0xea936
movq 0x28(%r14), %rcx
cmpb $0x0, 0x10(%rcx)
je 0x1d7f9
cmpb $0x1, 0x11(%rcx)
jne 0x1d7f9
cmpb $0x1, 0x12(%rcx)
jne 0x1d7f9
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,8), %ebx
addl $0x5b, %ebx
jmp 0x1d836
leaq 0xf4656(%rip), %rsi     # 0x111e41
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0xe9df7
jmp 0x1d836
cmpb $0x1b, 0xc(%rsp)
jne 0x1d82c
cmpb $0x5b, 0xd(%rsp)
jne 0x1d82c
movb 0xe(%rsp), %cl
cmpb $0x3f, %cl
setne %dl
addb $-0x30, %cl
cmpb $0xa, %cl
setae %cl
testb %cl, %dl
jne 0x1d82c
testl %eax, %eax
movl $0x32, %eax
movl $0x64, %ebx
jmp 0x1d833
testl %eax, %eax
movl $0xa, %ebx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ansiart.c
// Function: de_help_ansiart
static void de_help_ansiart(deark *c)
{
	de_msg(c, "-opt ansiart:no24bitcolor : Disable extended colors");
	de_msg(c, "-opt ansiart:noblink : Disable blinking characters");
	de_msg(c, "-opt ansiart:vt100 : Use VT100 mode");
	de_msg(c, "-opt char:output=image : Write an image file instead of HTML");
	de_msg(c, " -opt char:charwidth=<8|9> : Width of a character cell");
	de_msg(c, "-opt char:width=<n> : Number of characters per row");
	// TODO: SAUCE help is relevant to more formats than this one.
	de_msg(c, "-opt sauce:combinecomments=1 : Don't put line breaks between comments");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xf4621(%rip), %rsi     # 0x111e6e
xorl %eax, %eax
callq 0xe9fc3
leaq 0xf4647(%rip), %rsi     # 0x111ea2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9fc3
leaq 0xf4669(%rip), %rsi     # 0x111ed5
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9fc3
leaq 0xf467c(%rip), %rsi     # 0x111ef9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9fc3
leaq 0xf46a8(%rip), %rsi     # 0x111f36
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9fc3
leaq 0xf46ce(%rip), %rsi     # 0x111f6d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe9fc3
leaq 0xf46f0(%rip), %rsi     # 0x111fa0
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0xe9fc3
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ansiart.c
// Function: get_cell_at
static struct de_char_cell *get_cell_at(deark *c, struct de_char_screen *screen,
	i64 xpos, i64 ypos)
{
	i64 i;
	struct de_char_cell *cell;

	if(xpos<0 || ypos<0) return NULL;
	if(xpos>=screen->width || ypos>=MAX_ROWS) return NULL;
	if(!screen->cell_rows[ypos]) {
		screen->cell_rows[ypos] = de_mallocarray(c, screen->width, sizeof(struct de_char_cell));
		for(i=0; i<screen->width; i++) {
			// Initialize each new cell
			cell = &screen->cell_rows[ypos][i];
			init_cell(c, cell);
		}
	}
	return &(screen->cell_rows[ypos][xpos]);
}

// Assembly:
movq %rcx, %rax
orq %rdx, %rax
js 0x1d8ec
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rsi
cmpq %rdx, %rsi
setle %al
cmpq $0x1388, %rcx           # imm = 0x1388
setge %cl
orb %al, %cl
je 0x1d8ef
xorl %eax, %eax
jmp 0x1d944
xorl %eax, %eax
retq
movq 0x10(%r15), %rax
cmpq $0x0, (%rax,%rbx,8)
jne 0x1d934
movl $0x14, %edx
callq 0xea259
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%rbx,8)
movq (%r15), %rax
testq %rax, %rax
jle 0x1d934
movq 0x10(%r15), %rcx
movq (%rcx,%rbx,8), %rcx
addq $0xc, %rcx
movaps 0xf4109(%rip), %xmm0    # 0x111a30
movups %xmm0, -0xc(%rcx)
addq $0x14, %rcx
decq %rax
jne 0x1d927
movq 0x10(%r15), %rcx
leaq (%r14,%r14,4), %rax
shlq $0x2, %rax
addq (%rcx,%rbx,8), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ansiart.c
// Function: do_code_H
static void do_code_H(deark *c, lctx *d)
{
	i64 row, col;

	parse_params(c, d, 1, 0);

	if(d->parse_results.num_params>=1) row = d->parse_results.params[0];
	else row = 1;

	if(d->parse_results.num_params>=2) col = d->parse_results.params[1];
	else col = 1;

	d->xpos = col-1;
	d->ypos = row-1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x1d997
movl 0x120(%rbx), %eax
testl %eax, %eax
jle 0x1d974
movq 0x128(%rbx), %r14
decq %r14
cmpl $0x2, %eax
jl 0x1d985
movq 0x130(%rbx), %rax
decq %rax
jmp 0x1d987
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %r14, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ansiart.c
// Function: parse_params
static void parse_params(deark *c, lctx *d, i64 default_val, i64 offset)
{
	i64 buf_len;
	i64 ppos;
	i64 param_len;
	char *p_ptr;
	int last_param = 0;

	d->parse_results.num_params = 0;

	buf_len = de_strlen((const char*)d->param_string_buf);

	ppos = offset;
	while(1) {
		if(d->parse_results.num_params >= MAX_ESC_PARAMS) {
			break;
		}

		p_ptr = de_strchr((const char*)&d->param_string_buf[ppos], ';');
		if(p_ptr) {
			param_len = p_ptr - (char*)&d->param_string_buf[ppos];
		}
		else {
			param_len = buf_len - ppos;
			last_param = 1;
		}

		if(param_len>=1) {
			d->parse_results.params[d->parse_results.num_params] = de_atoi64((const char*)&d->param_string_buf[ppos]);
		}
		else {
			d->parse_results.params[d->parse_results.num_params] = default_val;
		}
		d->parse_results.num_params++;

		if(last_param) {
			break;
		}

		// Advance past the parameter data and the terminating semicolon.
		ppos += param_len + 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movl $0x0, 0x120(%rdi)
addq $0xb8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x180e0
movq %rax, %r12
movq 0x8(%rsp), %rax
leaq (%rax,%rbx), %r14
movq %r14, %rdi
movl $0x3b, %esi
callq 0xe8ed3
movq %rax, %rbp
subq %r14, %rax
movq %r12, %r13
subq %rbx, %r13
testq %rbp, %rbp
cmovneq %rax, %r13
movq 0x10(%rsp), %rax
testq %r13, %r13
jle 0x1da09
movq %r14, %rdi
callq 0xea786
movslq 0x120(%r15), %rcx
leal 0x1(%rcx), %edx
movq %rax, 0x128(%r15,%rcx,8)
movl %edx, 0x120(%r15)
testq %rbp, %rbp
je 0x1da37
addq %r13, %rbx
incq %rbx
cmpl $0x10, 0x120(%r15)
jl 0x1d9ce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/ar.c
// Function: de_module_ar
void de_module_ar(deark *c, struct deark_module_info *mi)
{
	mi->id = "ar";
	mi->desc = "ar archive";
	mi->run_fn = de_run_ar;
	mi->identify_fn = de_identify_ar;
}

// Assembly:
leaq 0x1019f6(%rip), %rax    # 0x11f445
movq %rax, (%rsi)
leaq 0x11dd48(%rip), %rax    # 0x13b7a1
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x1da74
movq %rax, 0x18(%rsi)
leaq 0x4b2(%rip), %rax       # 0x1df21
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: de_module_asf
void de_module_asf(deark *c, struct deark_module_info *mi)
{
	mi->id = "asf";
	mi->desc = "ASF, WMV, WMA";
	mi->run_fn = de_run_asf;
	mi->identify_fn = de_identify_asf;
}

// Assembly:
leaq 0xf4189(%rip), %rax     # 0x1120d8
movq %rax, (%rsi)
leaq 0xf4183(%rip), %rax     # 0x1120dc
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x1df74
movq %rax, 0x18(%rsi)
leaq 0x4e(%rip), %rax        # 0x1dfbd
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: read_and_render_guid
static void read_and_render_guid(dbuf *f, u8 *id, i64 pos,
	char *id_string, size_t id_string_len)
{
	dbuf_read(f, id, pos, 16);
	fmtutil_guid_to_uuid(id);
	if(id_string) {
		fmtutil_render_uuid(f->c, id, id_string, id_string_len);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %ecx
callq 0xeeee8
movq %r14, %rdi
callq 0xf8617
testq %rbx, %rbx
je 0x1e2db
movq 0x8(%r15), %rdi
movl $0x32, %ecx
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf8559
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: handler_Header
static void handler_Header(deark *c, lctx *d, struct handler_params *hp)
{
	i64 numhdrobj;

	if(hp->dlen<6) return;
	numhdrobj = de_getu32le(hp->dpos);
	de_dbg(c, "number of header objects: %u", (unsigned int)numhdrobj);
	do_object_sequence(c, d, hp->dpos+6, hp->dlen-6, hp->level+1, 1, numhdrobj);
}

// Assembly:
cmpq $0x6, 0x18(%rdx)
jl 0x1e354
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x10(%rdx), %rsi
callq 0xef37e
movq %rax, %r12
leaq 0xf4099(%rip), %rsi     # 0x1123a9
movq %r14, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
addq $0x6, %rdx
addq $-0x6, %rcx
movl 0x20(%r15), %r8d
incl %r8d
movq %r12, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %r9d
callq 0x1dfe3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: handler_HeaderExtension
static void handler_HeaderExtension(deark *c, lctx *d, struct handler_params *hp)
{
	i64 datasize;

	if(hp->dlen<22) return;
	datasize = de_getu32le(hp->dpos+18);
	de_dbg(c, "extension data size: %u", (unsigned int)datasize);
	if(datasize > hp->dlen-22) datasize = hp->dlen-22;
	do_object_sequence(c, d, hp->dpos+22, datasize, hp->level+1, 0, 0);
}

// Assembly:
cmpq $0x16, 0x18(%rdx)
jl 0x1e8a0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x10(%rdx), %rsi
addq $0x12, %rsi
callq 0xef37e
movq %rax, %r12
leaq 0xf3d9f(%rip), %rsi     # 0x1125f3
movq %r14, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0xe9226
movq 0x18(%r15), %rcx
addq $-0x16, %rcx
cmpq %rcx, %r12
cmovlq %r12, %rcx
movq 0x10(%r15), %rdx
addq $0x16, %rdx
movl 0x20(%r15), %r8d
incl %r8d
movq $0x0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x1dfe3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: handler_ContentDescr
static void handler_ContentDescr(deark *c, lctx *d, struct handler_params *hp)
{
	i64 lengths[5];
	const char *names[5] = { "title", "author", "copyright",
		"description", "rating" };
	de_ucstring *s = NULL;
	i64 pos = hp->dpos;
	size_t k;

	if(hp->dlen<10) return;

	for(k=0; k<5; k++) {
		lengths[k] = de_getu16le_p(&pos);
	}

	s = ucstring_create(c);
	for(k=0; k<5; k++) {
		if(pos+lengths[k] > hp->dpos+hp->dlen) break;
		ucstring_empty(s);
		dbuf_read_to_ucstring_n(c->infile, pos, lengths[k], DE_DBG_MAX_STRLEN*2, s,
			0, DE_ENCODING_UTF16LE);
		ucstring_truncate_at_NUL(s);
		de_dbg(c, "%s: \"%s\"", names[k], ucstring_getpsz_d(s));
		pos += lengths[k];
	}

	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x10(%rdx), %rax
movq %rax, 0x8(%rsp)
cmpq $0xa, 0x18(%rdx)
jl 0x1ef0e
movq %rdx, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xef1ed
movq %rax, 0x10(%rsp,%r12,8)
incq %r12
cmpq $0x5, %r12
jne 0x1ee51
movq %r14, %rdi
callq 0xf6870
movq %rax, %r15
xorl %r12d, %r12d
movq 0x10(%rsp,%r12,2), %r13
movq 0x8(%rsp), %rax
addq %r13, %rax
movq 0x18(%rbx), %rcx
addq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jg 0x1ef06
movq %r15, %rdi
callq 0xf6883
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
movl $0x3, (%rsp)
movl $0x3e8, %ecx            # imm = 0x3E8
movq %r13, %rdx
movq %r15, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %r15, %rdi
callq 0xf68c1
leaq 0xf3b77(%rip), %rax     # 0x112a44
movslq (%r12,%rax), %rbp
addq %rax, %rbp
movq %r15, %rdi
callq 0xf7557
movq %r14, %rdi
leaq 0x10cf5c(%rip), %rsi    # 0x12be42
movq %rbp, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe9226
addq %r13, 0x8(%rsp)
addq $0x4, %r12
cmpq $0x14, %r12
jne 0x1ee79
movq %r15, %rdi
callq 0xf6bb0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: handler_LanguageList
static void handler_LanguageList(deark *c, lctx *d, struct handler_params *hp)
{
	i64 pos = hp->dpos;
	i64 nlangs;
	i64 k;
	de_ucstring *s = NULL;

	if(hp->dlen<2) goto done;

	nlangs = de_getu16le_p(&pos);
	de_dbg(c, "language id record count: %d", (int)nlangs);

	s = ucstring_create(c);

	for(k=0; k<nlangs; k++) {
		i64 id_len;

		if(pos+1 > hp->dpos+hp->dlen) goto done;
		de_dbg(c, "language id record[%d] at %"I64_FMT, (int)k, pos);
		de_dbg_indent(c, 1);

		id_len = (i64)de_getbyte_p(&pos);

		ucstring_empty(s);
		dbuf_read_to_ucstring_n(c->infile, pos, id_len, DE_DBG_MAX_STRLEN*2, s,
			0, DE_ENCODING_UTF16LE);
		ucstring_truncate_at_NUL(s);
		de_dbg(c, "id: \"%s\"", ucstring_getpsz_d(s));
		pos += id_len;

		de_dbg_indent(c, -1);
	}

done:
	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x10(%rdx), %rax
movq %rax, 0x10(%rsp)
cmpq $0x2, 0x18(%rdx)
jge 0x1f93a
xorl %r12d, %r12d
jmp 0x1fa30
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x10(%rsp), %rsi
callq 0xef1ed
movq %rax, %r15
leaq 0xf30b0(%rip), %rsi     # 0x112a08
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
callq 0xf6870
movq %rax, %r12
testq %r15, %r15
jle 0x1fa30
xorl %ebp, %ebp
movq 0x10(%rsp), %rcx
movq 0x18(%rbx), %rax
addq 0x10(%rbx), %rax
cmpq %rax, %rcx
jge 0x1fa30
movq %r14, %rdi
leaq 0xf308a(%rip), %rsi     # 0x112a25
movl %ebp, %edx
xorl %eax, %eax
callq 0xe9226
movq %r14, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0xef14d
movzbl %al, %r13d
movq %r12, %rdi
callq 0xf6883
movq 0x18(%r14), %rdi
movq 0x10(%rsp), %rsi
movl $0x3, (%rsp)
movl $0x3e8, %ecx            # imm = 0x3E8
movq %r13, %rdx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xf0203
movq %r12, %rdi
callq 0xf68c1
movq %r12, %rdi
callq 0xf7557
movq %r14, %rdi
leaq 0x10df31(%rip), %rsi    # 0x12d939
movq %rax, %rdx
xorl %eax, %eax
callq 0xe9226
addq %r13, 0x10(%rsp)
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xe9585
incq %rbp
cmpq %rbp, %r15
jne 0x1f97b
movq %r12, %rdi
callq 0xf6bb0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: format_date
static char *format_date(i64 t_FILETIME, char *buf, size_t buf_len)
{
	struct de_timestamp timestamp;

	if(t_FILETIME==0) {
		de_strlcpy(buf, "unknown", buf_len);
	}
	else {
		de_FILETIME_to_timestamp(t_FILETIME, &timestamp, 0x1);
		de_timestamp_to_string(&timestamp, buf, buf_len, 0);
	}
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1fa7c
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movl $0x1, %edx
callq 0xead1a
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xeb4f8
jmp 0x1fa90
leaq 0xf2a09(%rip), %rsi     # 0x11248c
movl $0x40, %edx
movq %rbx, %rdi
callq 0xe8ded
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: do_ECD_ID3
static void do_ECD_ID3(deark *c, lctx *d, i64 pos, i64 len)
{
	de_dbg(c, "ID3 data at %"I64_FMT", len=%"I64_FMT, pos, len);
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, "id3", "I", c->infile, pos, len);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf2a4a(%rip), %rsi     # 0x1127ad
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe9226
movq %r15, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%r15), %rcx
leaq 0xf2a3e(%rip), %rsi     # 0x1127c6
leaq 0x110e32(%rip), %rdx    # 0x130bc1
movq %r15, %rdi
movq %r14, %r8
movq %rbx, %r9
callq 0xea66a
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0xe9585
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/asf.c
// Function: do_ECD_WMPicture
static void do_ECD_WMPicture(deark *c, lctx *d, i64 pos, i64 len)
{
	de_dbg(c, "WM/Picture data at %"I64_FMT", len=%"I64_FMT, pos, len);
	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice2(c, "id3", "P", c->infile, pos, len);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf2a06(%rip), %rsi     # 0x1127ca
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe9226
movq %r15, %rdi
movl $0x1, %esi
callq 0xe9585
movq 0x18(%r15), %rcx
leaq 0xf29dd(%rip), %rsi     # 0x1127c6
leaq 0x103cde(%rip), %rdx    # 0x123ace
movq %r15, %rdi
movq %r14, %r8
movq %rbx, %r9
callq 0xea66a
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0xe9585
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-dsk.c
// Function: de_module_atari_cas
void de_module_atari_cas(deark *c, struct deark_module_info *mi)
{
	mi->id = "cas";
	mi->desc = "Atari CAS tape image";
	mi->run_fn = de_run_cas;
	mi->identify_fn = de_identify_cas;
	mi->flags |= DE_MODFLAG_NONWORKING;
}

// Assembly:
leaq 0xf2c52(%rip), %rax     # 0x112a69
movq %rax, (%rsi)
leaq 0xf2c4c(%rip), %rax     # 0x112a6d
movq %rax, 0x8(%rsi)
leaq 0x14(%rip), %rax        # 0x1fe40
movq %rax, 0x18(%rsi)
leaq 0xaf(%rip), %rax        # 0x1fee6
movq %rax, 0x20(%rsi)
orb $0x2, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-dsk.c
// Function: de_module_atr
void de_module_atr(deark *c, struct deark_module_info *mi)
{
	mi->id = "atr";
	mi->desc = "ATR Atari floppy disk image";
	mi->run_fn = de_run_atr;
	mi->identify_fn = de_identify_atr;
}

// Assembly:
leaq 0xf2b5e(%rip), %rax     # 0x112a82
movq %rax, (%rsi)
leaq 0xf2b58(%rip), %rax     # 0x112a86
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x1ff49
movq %rax, 0x18(%rsi)
leaq 0x548(%rip), %rax       # 0x2048c
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-dsk.c
// Function: de_module_msa
void de_module_msa(deark *c, struct deark_module_info *mi)
{
	mi->id = "msa";
	mi->desc = "MSA - Atari ST floppy disk image";
	mi->run_fn = de_run_msa;
	mi->identify_fn = de_identify_msa;
	mi->help_fn = de_help_msa;
}

// Assembly:
leaq 0xf277c(%rip), %rax     # 0x112c4c
movq %rax, (%rsi)
leaq 0xf25c8(%rip), %rax     # 0x112aa2
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x20500
movq %rax, 0x18(%rsi)
leaq 0x609(%rip), %rax       # 0x20af9
movq %rax, 0x20(%rsi)
leaq 0x646(%rip), %rax       # 0x20b41
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-dsk.c
// Function: de_identify_msa
static int de_identify_msa(deark *c)
{
	i64 sig;
	int has_ext;

	sig = de_getu16be(0);
	if(sig != 0x0e0f) return 0;
	has_ext = de_input_file_has_ext(c, "msa");
	if(has_ext) return 100;
	return 45;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xef169
cmpq $0xe0f, %rax            # imm = 0xE0F
jne 0x20b36
leaq 0xf212f(%rip), %rsi     # 0x112c4c
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
movl $0x2d, %eax
movl $0x64, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-dsk.c
// Function: de_module_pasti
void de_module_pasti(deark *c, struct deark_module_info *mi)
{
	mi->id = "pasti";
	mi->desc = "Pasti - Atari ST floppy disk image";
	mi->run_fn = de_run_pasti;
	mi->identify_fn = de_identify_pasti;
	mi->help_fn = de_help_pasti;
}

// Assembly:
leaq 0xf1f57(%rip), %rax     # 0x112ac3
movq %rax, (%rsi)
leaq 0xf1f53(%rip), %rax     # 0x112ac9
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x20b9c
movq %rax, 0x18(%rsi)
leaq 0x992(%rip), %rax       # 0x2151e
movq %rax, 0x20(%rsi)
leaq 0x9ad(%rip), %rax       # 0x21544
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-img.c
// Function: de_module_degas
void de_module_degas(deark *c, struct deark_module_info *mi)
{
	mi->id = "degas";
	mi->desc = "Atari DEGAS or DEGAS Elite image";
	mi->run_fn = de_run_degas;
	mi->identify_fn = de_identify_degas;
	mi->help_fn = de_help_degas;
}

// Assembly:
leaq 0xf1de5(%rip), %rax     # 0x113340
movq %rax, (%rsi)
leaq 0xf1de1(%rip), %rax     # 0x113346
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x2158b
movq %rax, 0x18(%rsi)
leaq 0x51e(%rip), %rax       # 0x21a99
movq %rax, 0x20(%rsi)
leaq 0x5b1(%rip), %rax       # 0x21b37
movq %rax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-img.c
// Function: de_identify_degas
static int de_identify_degas(deark *c)
{
	static const char *exts[6] = {"pi1", "pi2", "pi3", "pc1", "pc2", "pc3" };
	i64 i;
	int flag;
	i64 sig;

	flag = 0;
	for(i=0; i<6; i++) {
		if(de_input_file_has_ext(c, exts[i])) {
			flag = 1;
			break;
		}
	}
	if(!flag) return 0;

	sig = de_getu16be(0);
	if(sig==0x0000 || sig==0x0001 || sig==0x0002) {
		if(c->infile->len==32034) return 100; // DEGAS
		if(c->infile->len==32066) return 100; // DEGAS Elite
		if(c->infile->len==32128) return 40; // Could be padded to a multiple of 128 bytes
		if(c->infile->len>16000) return 10;
	}
	else if(sig==0x8000 || sig==0x8001 || sig==0x8002) {
		return 60;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xf17e1(%rip), %r15     # 0x11328c
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0xea936
testl %eax, %eax
jne 0x21aca
addq $0x4, %r14
cmpq $0x18, %r14
jne 0x21aab
jmp 0x21b1f
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xef169
cmpq $0x2, %rax
ja 0x21b0a
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
movl $0x64, %eax
cmpq $0x7d22, %rcx           # imm = 0x7D22
je 0x21b21
cmpq $0x7d42, %rcx           # imm = 0x7D42
je 0x21b21
cmpq $0x7d80, %rcx           # imm = 0x7D80
jne 0x21b27
movl $0x28, %eax
jmp 0x21b21
movq %rax, %rcx
addq $-0x8000, %rcx          # imm = 0x8000
movl $0x3c, %eax
cmpq $0x3, %rcx
jb 0x21b21
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0xa, %eax
cmpq $0x3e80, %rcx           # imm = 0x3E80
jle 0x21b1f
jmp 0x21b21
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-img.c
// Function: de_module_prismpaint
void de_module_prismpaint(deark *c, struct deark_module_info *mi)
{
	mi->id = "prismpaint";
	mi->desc = "Atari Prism Paint .PNT, a.k.a. TruePaint .TPI";
	mi->run_fn = de_run_prismpaint;
	mi->identify_fn = de_identify_prismpaint;
}

// Assembly:
leaq 0xf180e(%rip), %rax     # 0x113367
movq %rax, (%rsi)
leaq 0xf180f(%rip), %rax     # 0x113372
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x21b7e
movq %rax, 0x18(%rsi)
leaq 0x4c0(%rip), %rax       # 0x22039
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-img.c
// Function: de_module_ftc
void de_module_ftc(deark *c, struct deark_module_info *mi)
{
	mi->id = "ftc";
	mi->desc = "Atari Falcon True Color .FTC";
	mi->run_fn = de_run_ftc;
	mi->identify_fn = de_identify_ftc;
}

// Assembly:
leaq 0xf133a(%rip), %rax     # 0x1133a0
movq %rax, (%rsi)
leaq 0xf1334(%rip), %rax     # 0x1133a4
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x2208b
movq %rax, 0x18(%rsi)
leaq 0xc5(%rip), %rax        # 0x2214b
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-img.c
// Function: de_run_ftc
static void de_run_ftc(deark *c, de_module_params *mparams)
{
	struct atari_img_decode_data *adata = NULL;
	de_finfo *fi = NULL;

	adata = de_malloc(c, sizeof(struct atari_img_decode_data));
	adata->bpp = 16;
	adata->w = 384;
	adata->h = 240;
	adata->unc_pixels = c->infile;
	adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
	fi = de_finfo_create(c);
	fi->density.code = DE_DENSITY_UNK_UNITS;
	fi->density.xdens = 288;
	fi->density.ydens = 240;
	fmtutil_atari_decode_image(c, adata);
	de_bitmap_write_to_file_finfo(adata->img, fi, 0);
	de_bitmap_destroy(adata->img);
	de_finfo_destroy(c, fi);
	de_free(c, adata);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x40, %esi
callq 0xe969b
movq %rax, %r14
movq $0x10, (%rax)
movq $0x180, 0x10(%rax)      # imm = 0x180
movq $0xf0, 0x18(%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x20(%r14)
movl $0x180, %esi            # imm = 0x180
movl $0xf0, %edx
movq %rbx, %rdi
movl $0x3, %ecx
callq 0xf2cab
movq %rax, 0x38(%r14)
movq %rbx, %rdi
callq 0xea9a9
movq %rax, %r15
movl $0x1, 0x78(%rax)
movabsq $0x4072000000000000, %rax # imm = 0x4072000000000000
movq %rax, 0x80(%r15)
movabsq $0x406e000000000000, %rax # imm = 0x406E000000000000
movq %rax, 0x88(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf900c
movq 0x38(%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xf2917
movq 0x38(%r14), %rdi
callq 0xf28d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0xea9b3
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe9752
// File: /workspace/github_c_makefile_star2_O1/jsummers[P]deark/modules/atari-img.c
// Function: de_module_eggpaint
void de_module_eggpaint(deark *c, struct deark_module_info *mi)
{
	mi->id = "eggpaint";
	mi->desc = "Atari EggPaint .TRP";
	mi->run_fn = de_run_eggpaint;
	mi->identify_fn = de_identify_eggpaint;
}

// Assembly:
leaq 0xf1241(%rip), %rax     # 0x1133c1
movq %rax, (%rsi)
leaq 0xf1240(%rip), %rax     # 0x1133ca
movq %rax, 0x8(%rsi)
leaq 0x10(%rip), %rax        # 0x221a5
movq %rax, 0x18(%rsi)
leaq 0xf5(%rip), %rax        # 0x22295
movq %rax, 0x20(%rsi)
retq