LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: handler_ECD_or_metadata
static void handler_ECD_or_metadata(deark *c, lctx *d, struct handler_params *hp)
{
	i64 descr_count;
	i64 k;
	i64 pos = hp->dpos;

	descr_count = de_getu16le_p(&pos);
	de_dbg(c, "descriptor count: %d", (int)descr_count);

	for(k=0; k<descr_count; k++) {
		i64 bytes_consumed = 0;
		int ret;

		if(pos >= hp->dpos + hp->dlen) {
			break;
		}
		if(hp->uui->short_id==SID_ECD) {
			ret = do_ECD_entry(c, d, pos, hp->dpos+hp->dlen-pos, &bytes_consumed);
		}
		else if(hp->uui->short_id==SID_METADATA || hp->uui->short_id==SID_METADATALIB) {
			ret = do_metadata_entry(c, d, hp, pos, hp->dpos+hp->dlen-pos, &bytes_consumed);
		}
		else {
			break;
		}
		if(!ret || (bytes_consumed<6)) break;
		pos += bytes_consumed;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x17aada(%rip), %rsi    # 0x19e7c0
movb $0x0, %al
callq 0x15b0d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x23de9
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jl 0x23d29
jmp 0x23de9
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0xd2, (%rax)
jne 0x23d67
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x18(%rax), %rcx
subq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x24cc0
movl %eax, -0x3c(%rbp)
jmp 0x23dbd
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x133, (%rax)          # imm = 0x133
je 0x23d87
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x134, (%rax)          # imm = 0x134
jne 0x23db9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x18(%rbp), %rax
addq 0x18(%rax), %r8
subq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
callq 0x24eb0
movl %eax, -0x3c(%rbp)
jmp 0x23dbb
jmp 0x23de9
jmp 0x23dbd
cmpl $0x0, -0x3c(%rbp)
je 0x23dca
cmpq $0x6, -0x38(%rbp)
jge 0x23dcc
jmp 0x23de9
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23cf5
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x2, 0x18(%rax)
jge 0x246d8
jmp 0x24819
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1652c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %edx
leaq 0x17a3da(%rip), %rsi    # 0x19ead8
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x24817
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jle 0x2474a
jmp 0x24819
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rcx
leaq 0x17a396(%rip), %rsi    # 0x19eaf5
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x171210
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %r8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %r9d, %r9d
movl $0x3, (%rsp)
callq 0x166a40
movq -0x38(%rbp), %rdi
callq 0x1712b0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x172650
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x194f6a(%rip), %rsi    # 0x1b974f
movb $0x0, %al
callq 0x15b0d0
movq -0x40(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2471a
jmp 0x24819
movq -0x38(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x24861
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x179d02(%rip), %rsi    # 0x19e55c
callq 0x15aa30
jmp 0x24886
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x15d580
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rdi
xorl %ecx, %ecx
callq 0x15e130
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: find_uuid_info
static const struct uuid_info *find_uuid_info(const u8 *uuid)
{
	size_t k;
	for(k=0; k<DE_ARRAYCOUNT(uuid_info_arr); k++) {
		if(!de_memcmp(uuid, uuid_info_arr[k].uuid, 16)) {
			return &uuid_info_arr[k];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0x249a1
movq -0x10(%rbp), %rax
leaq 0x1ef80e(%rip), %rcx    # 0x214160
imulq $0x28, -0x18(%rbp), %rdx
addq %rdx, %rcx
addq $0x8, %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x24991
leaq 0x1ef7dd(%rip), %rax    # 0x214160
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x249a9
jmp 0x24993
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x24940
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: get_codec_type_name
static const char *get_codec_type_name(unsigned int t)
{
	const char *name = "?";
	switch(t) {
	case 0x0001: name="video"; break;
	case 0x0002: name="audio"; break;
	case 0xffff: name="unknown"; break;
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x192fbf(%rip), %rax    # 0x1b7c2d
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x24c95
jmp 0x24c7f
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x24ca2
jmp 0x24c89
movl -0x14(%rbp), %eax
subl $0xffff, %eax           # imm = 0xFFFF
je 0x24caf
jmp 0x24cba
leaq 0x193b19(%rip), %rax    # 0x1b87b5
movq %rax, -0x10(%rbp)
jmp 0x24cba
leaq 0x193b1d(%rip), %rax    # 0x1b87c6
movq %rax, -0x10(%rbp)
jmp 0x24cba
leaq 0x1798a6(%rip), %rax    # 0x19e55c
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x179362(%rip), %rsi    # 0x19e87d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x17934b(%rip), %rsi    # 0x19e896
leaq 0x197549(%rip), %rdx    # 0x1bca9b
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x1792ff(%rip), %rsi    # 0x19e89a
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x1792cb(%rip), %rsi    # 0x19e896
leaq 0x18a00d(%rip), %rdx    # 0x1af5df
callq 0x15cab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x17951d(%rip), %rcx    # 0x19eb24
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x179513(%rip), %rcx    # 0x19eb28
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x25650
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x5d(%rip), %rcx        # 0x25690
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: de_identify_cas
static int de_identify_cas(deark *c)
{
	u8 buf[16];
	de_read(buf, 0, 16);

	if(!de_memcmp(buf, "FUJI", 4)) {
		// Note - Make sure Fujifilm RAF has higher confidence.
		return 70;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x10, %ecx
callq 0x164d10
leaq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x494a5546, %eax       # imm = 0x494A5546
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x256d5
movl $0x46, -0x4(%rbp)
jmp 0x256dc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x179436(%rip), %rcx    # 0x19eb3d
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x17942c(%rip), %rcx    # 0x19eb41
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x25740
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x5d(%rip), %rcx        # 0x25790
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: de_run_atr
static void de_run_atr(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

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

	do_atr(c, d);

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25dc0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: de_identify_atr
static int de_identify_atr(deark *c)
{
	u8 buf[16];
	de_read(buf, 0, 16);

	if(buf[0]==0x96 && buf[1]==0x02) {
		return 60;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x10, %ecx
callq 0x164d10
movzbl -0x20(%rbp), %eax
cmpl $0x96, %eax
jne 0x257d3
movzbl -0x1f(%rbp), %eax
cmpl $0x2, %eax
jne 0x257d3
movl $0x3c, -0x4(%rbp)
jmp 0x257da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x179500(%rip), %rcx    # 0x19ed07
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x179348(%rip), %rcx    # 0x19eb5d
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x25850
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x1dd(%rip), %rcx       # 0x25a10
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x23e(%rip), %rcx       # 0x25a80
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1651d0
movq %rax, -0x18(%rbp)
cmpq $0xe0f, -0x18(%rbp)     # imm = 0xE0F
je 0x25a44
movl $0x0, -0x4(%rbp)
jmp 0x25a6d
movq -0x10(%rbp), %rdi
leaq 0x1792b8(%rip), %rsi    # 0x19ed07
callq 0x15d180
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x25a66
movl $0x64, -0x4(%rbp)
jmp 0x25a6d
movl $0x2d, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1790a7(%rip), %rcx    # 0x19eb7e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x17909f(%rip), %rcx    # 0x19eb84
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x25b20
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x16d(%rip), %rcx       # 0x25c70
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x1ae(%rip), %rcx       # 0x25cc0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: de_run_pasti
static void de_run_pasti(deark *c, de_module_params *mparams)
{
	struct pastictx *d = NULL;

	d = de_malloc(c, sizeof(struct pastictx));
	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_ATARIST);

	if(de_get_ext_option_bool(c, "pasti:toraw", 0)) {
		d->outfmt = ATARIST_OUTFMT_ST;
	}
	else {
		d->outfmt = ATARIST_OUTFMT_FILES;
	}

	if(!do_pasti_header(c, d, 0)) goto done;

	if(!do_pasti_tracks(c, d, 16)) goto done;
	if(!d->diskbuf) goto done;

	if(d->oob_sector_count>0) {
		de_warn(c, "%d of %d sectors are outside the bounds of the disk geometry, and will "
			"be ignored.", (int)d->oob_sector_count, (int)d->num_nonempty_sectors_found);
	}

	if(d->num_nonempty_sectors_found<=0) goto done;

	if(d->outfmt==ATARIST_OUTFMT_ST) {
		pasti_extract_to_raw(c, d);
	}
	else {
		pasti_decode_fat(c, d);
	}

done:
	if(d) {
		dbuf_close(d->diskbuf);
		de_free(c, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x50, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x12, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x179368(%rip), %rsi    # 0x19eed7
xorl %edx, %edx
callq 0x15cbc0
cmpl $0x0, %eax
je 0x25b88
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0x25b93
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x26d20
cmpl $0x0, %eax
jne 0x25bae
jmp 0x25c3a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x26e80
cmpl $0x0, %eax
jne 0x25bc7
jmp 0x25c3a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x25bd4
jmp 0x25c3a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jle 0x25c05
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %ecx
leaq 0x1792e5(%rip), %rsi    # 0x19eee3
movb $0x0, %al
callq 0x15bc10
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jg 0x25c12
jmp 0x25c3a
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x25c2b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26f60
jmp 0x25c38
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26fd0
jmp 0x25c3a
cmpq $0x0, -0x18(%rbp)
je 0x25c5b
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1676a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_cas
static void do_cas(deark *c)
{
	i64 pos;
	u8 chunk_id[4];
	i64 chunk_len;
	i64 chunk_extra;

	pos = 0;
	while(1) {
		if(pos >= c->infile->len-8) break; // Reached end of file

		de_read(chunk_id, pos, 4);
		chunk_len = de_getu16le(pos+4);
		chunk_extra = de_getu16le(pos+6);

		de_dbg(c, "chunk at %d, data_len=%d, extra=%d", (int)pos, (int)chunk_len,
			(int)chunk_extra);

		pos += 8;

		pos += chunk_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
jl 0x25d22
jmp 0x25db0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x14(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x4, %ecx
callq 0x164d10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x6, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %eax, %r8d
leaq 0x178e3d(%rip), %rsi    # 0x19ebc9
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x25d04
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_atr
static void do_atr(deark *c, lctx *d)
{
	i64 pos;
	i64 image_size_hi, image_size_lo; // In 16-byte "paragraphs"
	i64 image_size_bytes;
	dbuf *diskimg = NULL;

	pos = 0;

	image_size_lo = de_getu16le(pos+2);
	d->sector_size = de_getu16le(pos+4);
	image_size_hi = de_getu16le(pos+6);
	image_size_bytes = 16*(image_size_lo + 65536*image_size_hi);

	de_dbg(c, "image size=%d bytes, sector size=%d", (int)image_size_bytes, (int)d->sector_size);

	diskimg = dbuf_open_input_subfile(c->infile, 16, c->infile->len-16);

	do_atr_disk_image(c, d, diskimg);

	dbuf_close(diskimg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x165280
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x165280
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0x165280
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x10, %rcx
addq %rcx, %rax
shlq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
leaq 0x178d8a(%rip), %rsi    # 0x19ebec
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
subq $0x10, %rdx
movl $0x10, %esi
callq 0x1691b0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x25eb0
movq -0x38(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: get_sector_offset_and_size
static int get_sector_offset_and_size(deark *c, lctx *d,
	i64 sector_num, i64 *sector_offset, i64 *sector_size)
{
	if(sector_num<1) return 0;

	*sector_size = d->sector_size;
	*sector_offset = (sector_num-1) * d->sector_size;

	if(d->sector_size==256) {
		// The first 3 sectors are 128 bytes
		if(sector_num<=3) {
			*sector_size = 128;
			*sector_offset = (sector_num-1) * 128;
		}
		else {
			*sector_offset -= 3*128;
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x26088
movl $0x0, -0x4(%rbp)
jmp 0x260fb
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
imulq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x100, (%rax)          # imm = 0x100
jne 0x260f4
cmpq $0x3, -0x20(%rbp)
jg 0x260e1
movq -0x30(%rbp), %rax
movq $0x80, (%rax)
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
shlq $0x7, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x260f2
movq -0x28(%rbp), %rax
movq (%rax), %rcx
subq $0x180, %rcx            # imm = 0x180
movq %rcx, (%rax)
jmp 0x260f4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_extract_file_contents
static void do_extract_file_contents(deark *c, lctx *d, dbuf *inf, dbuf *outf,
	i64 starting_sector, i64 sector_count)
{
	i64 sectors_extracted = 0;
	i64 sector_pos = 0;
	i64 sector_size = 0;
	i64 cur_sector;
	i64 next_sector;
	u8 mdata[3];
	i64 nbytes;

	cur_sector = starting_sector;
	while(sectors_extracted < sector_count) {
		get_sector_offset_and_size(c, d, cur_sector, &sector_pos, &sector_size);
		de_dbg(c, "sector %d, #%d, at %d", (int)sectors_extracted, (int)cur_sector, (int)sector_pos);
		de_dbg_indent(c, 1);

		dbuf_read(inf, mdata, sector_pos + sector_size-3, 3);
		next_sector = ((mdata[0]&0x3) << 8) | mdata[1];

		// TODO: Some documentation says the high bit of mdata[2] is a
		// "short flag" that indicates that the other bits are valid. But I haven't
		// found any files that use it. And it can't work with sectors > 128 bytes.
		nbytes = (i64)mdata[2];
		if(sector_size<=128)
			nbytes = nbytes & 0x7f;

		de_dbg(c, "byte count: %d, next sector: %d", (int)nbytes, (int)next_sector);

		dbuf_copy(inf, sector_pos, nbytes, outf);

		de_dbg_indent(c, -1);
		sectors_extracted++;
		cur_sector = next_sector;
		if(next_sector<1) break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x264df
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %r8
callq 0x26060
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %edx
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %eax, %r8d
leaq 0x1788b3(%rip), %rsi    # 0x19ecc8
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rdi
leaq -0x5b(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq -0x48(%rbp), %rdx
subq $0x3, %rdx
movl $0x3, %ecx
callq 0x164d10
movzbl -0x5b(%rbp), %eax
andl $0x3, %eax
shll $0x8, %eax
movzbl -0x5a(%rbp), %ecx
orl %ecx, %eax
cltq
movq %rax, -0x58(%rbp)
movzbl -0x59(%rbp), %eax
movq %rax, -0x68(%rbp)
cmpq $0x80, -0x48(%rbp)
jg 0x2647c
movq -0x68(%rbp), %rax
andq $0x7f, %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x68(%rbp), %rax
movl %eax, %edx
movq -0x58(%rbp), %rax
movl %eax, %ecx
leaq 0x17884b(%rip), %rsi    # 0x19ecde
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x166070
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x1, -0x58(%rbp)
jge 0x264da
jmp 0x264df
jmp 0x263d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_msa_tracks
static int do_msa_tracks(deark *c, struct msactx *d, i64 pos1, dbuf *diskbuf)
{
	i64 tk, sd;
	i64 pos = pos1;
	int retval = 0;

	de_dbg(c, "tracks at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);

	for(tk=d->first_track; tk<=d->last_track; tk++) {
		for(sd=0; sd<d->sides; sd++) {
			i64 dlen;
			i64 tkpos = pos;

			if(pos+2 >= c->infile->len) {
				de_err(c, "Unexpected end of file");
				goto after_decompress;
			}

			dlen = de_getu16be_p(&pos);
			if(!do_msa_track(c, d, tk, sd, tkpos, dlen, diskbuf)) goto done;
			pos += dlen;
		}
	}
after_decompress:
	retval = 1;
done:
	de_dbg_indent(c, -1);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x17866b(%rip), %rsi    # 0x19edb1
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jg 0x26836
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x26823
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x267c5
movq -0x8(%rbp), %rdi
leaq 0x178603(%rip), %rsi    # 0x19edbf
movb $0x0, %al
callq 0x15bfb0
jmp 0x26838
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165210
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x20(%rbp), %rax
movq %rax, (%rsp)
callq 0x26a50
cmpl $0x0, %eax
jne 0x26806
jmp 0x2683f
movq -0x48(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x26781
jmp 0x26825
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26767
jmp 0x26838
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl -0x3c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: msa_extract_to_raw
static void msa_extract_to_raw(deark *c, struct msactx *d, dbuf *diskbuf)
{
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "st", NULL, 0);
	dbuf_copy(diskbuf, 0, d->disk_size, outf);
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1a8dde(%rip), %rsi    # 0x1cf665
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x166070
movq -0x20(%rbp), %rdi
callq 0x1676a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: msa_extract_to_uncmsa
static void msa_extract_to_uncmsa(deark *c, struct msactx *d, dbuf *diskbuf)
{
	dbuf *outf = NULL;
	i64 i;

	outf = dbuf_create_output_file(c, "msa", NULL, 0);
	dbuf_copy(c->infile, 0, 10, outf);

	for(i=0; i<d->num_tracks_total; i++) {
		dbuf_writeu16be(outf, d->track_size);
		dbuf_copy(diskbuf, i*d->track_size, d->track_size, outf);
	}

	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x178420(%rip), %rsi    # 0x19ed07
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x166070
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jge 0x26967
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x168a50
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
imulq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x166070
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26918
movq -0x20(%rbp), %rdi
callq 0x1676a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: msa_decode_fat
static void msa_decode_fat(deark *c, struct msactx *d, dbuf *diskbuf)
{
	de_module_params *mparams = NULL;

	mparams = de_malloc(c, sizeof(de_module_params));
	de_dbg(c, "decoding as FAT");
	de_dbg_indent(c, 1);
	mparams->in_params.codes = "A";
	mparams->in_params.input_encoding = d->input_encoding;
	de_run_module_by_id_on_slice(c, "fat", mparams, diskbuf, 0, diskbuf->len);
	if(mparams->out_params.flags & 0x1) {
		de_info(c, "Note: Use \"-opt msa:toraw\" to decompress to a raw .ST file");
	}
	de_free(c, mparams);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x178474(%rip), %rsi    # 0x19ee2d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x20(%rbp), %rax
leaq 0x1a457c(%rip), %rcx    # 0x1caf55
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %r9
leaq 0x178439(%rip), %rsi    # 0x19ee3d
xorl %eax, %eax
movl %eax, %r8d
callq 0x15c9f0
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x26a2f
movq -0x8(%rbp), %rdi
leaq 0x178419(%rip), %rsi    # 0x19ee41
movb $0x0, %al
callq 0x15c0c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_msa_track
static int do_msa_track(deark *c, struct msactx *d, i64 tk, i64 sd, i64 pos1, i64 dlen, dbuf *outf)
{
	int is_compressed;
	int retval = 0;
	i64 outf_startsize = outf->len;

	de_dbg2(c, "track (t=%d, s=%d) at %"I64_FMT", dlen=%"I64_FMT, (int)tk, (int)sd, pos1, dlen);
	de_dbg_indent(c, 1);
	if(dlen > d->track_size) {
		de_err(c, "Invalid compressed track size");
		goto done;
	}
	is_compressed = (dlen!=d->track_size);
	de_dbg2(c, "compressed: %d", is_compressed);

	if(is_compressed) {
		if(!msa_decompress_rle(c, d, pos1+2, dlen, outf)) goto done;
		d->total_track_sides_cmpr++;
	}
	else {
		dbuf_copy(c->infile, pos1+2, dlen, outf);
	}
	d->total_cmpr_bytes += dlen;
	d->total_track_sides++;

	dbuf_truncate(outf, outf_startsize + d->track_size);
	retval = 1;

done:
	dbuf_flush(outf);
	de_dbg_indent(c, -1);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq 0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x178330(%rip), %rsi    # 0x19edd6
movb $0x0, %al
callq 0x15b350
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jle 0x26ae0
movq -0x8(%rbp), %rdi
leaq 0x178326(%rip), %rsi    # 0x19edfa
movb $0x0, %al
callq 0x15bfb0
jmp 0x26ba1
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq 0x19cf7b(%rip), %rsi    # 0x1c3a80
movb $0x0, %al
callq 0x15b350
cmpl $0x0, -0x34(%rbp)
je 0x26b48
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x2, %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x26bd0
cmpl $0x0, %eax
jne 0x26b36
jmp 0x26ba1
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
jmp 0x26b65
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x2, %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x166070
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq 0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rsi
callq 0x168900
movl $0x1, -0x38(%rbp)
movq 0x10(%rbp), %rdi
callq 0x167c30
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: msa_decompress_rle
static int msa_decompress_rle(deark *c, struct msactx *d, i64 pos1, i64 dlen,
	dbuf *outf)
{
	i64 endpos = pos1+dlen;
	i64 pos = pos1;
	i64 outcount = 0;
	int retval = 0;

	while(1) {
		u8 b;
		i64 count;

		if(outcount >= d->track_size) {
			retval = 1;
			goto done; // Have enough output
		}

		if(pos >= endpos) {
			goto done;
		}

		b = de_getbyte_p(&pos);
		if(b != 0xe5) {
			dbuf_writebyte(outf, b);
			outcount++;
			continue;
		}

		if(pos+3 > endpos) {
			goto done;
		}
		b = de_getbyte_p(&pos);
		count = de_getu16be_p(&pos);
		if(outcount+count > d->track_size) {
			count = d->track_size - outcount;
		}
		dbuf_write_run(outf, b, count);
		outcount += count;
	}

done:
	if(!retval) {
		de_err(c, "Decompression failed");
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jl 0x26c29
movl $0x1, -0x44(%rbp)
jmp 0x26cf1
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x26c38
jmp 0x26cf1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165170
movb %al, -0x45(%rbp)
movzbl -0x45(%rbp), %eax
cmpl $0xe5, %eax
je 0x26c72
movq -0x28(%rbp), %rdi
movzbl -0x45(%rbp), %esi
callq 0x168380
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x26c0f
movq -0x38(%rbp), %rax
addq $0x3, %rax
cmpq -0x30(%rbp), %rax
jle 0x26c82
jmp 0x26cf1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165170
movb %al, -0x45(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x165210
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
addq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jle 0x26ccd
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movb -0x45(%rbp), %al
movq -0x50(%rbp), %rdx
movzbl %al, %esi
callq 0x168800
movq -0x50(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x26c0f
cmpl $0x0, -0x44(%rbp)
jne 0x26d09
movq -0x8(%rbp), %rdi
leaq 0x178116(%rip), %rsi    # 0x19ee18
movb $0x0, %al
callq 0x15bfb0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_pasti_header
static int do_pasti_header(deark *c, struct pastictx *d, i64 pos1)
{
	i64 pos = pos1;
	int retval = 0;

	de_dbg(c, "file descriptor at %"I64_FMT, pos1);
	de_dbg_indent(c, 1);
	pos += 4; // signature
	d->version = (UI)de_getu16le_p(&pos);
	de_dbg(c, "version: %u", d->version);
	pos += 2; // tool
	pos += 2; // reserved_1
	d->track_count = (i64)de_getbyte_p(&pos);
	de_dbg(c, "track count: %d", (int)d->track_count);
	d->revision = (UI)de_getbyte_p(&pos);
	de_dbg(c, "revision: %u", d->revision);
	if(d->version!=3 || d->revision!=2) {
		de_err(c, "Unsupported format version: %ur%u", d->version, d->revision);
		goto done;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1781e4(%rip), %rsi    # 0x19ef36
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1652c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x19b8e7(%rip), %rsi    # 0x1c2686
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movzbl %al, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
leaq 0x17815c(%rip), %rsi    # 0x19ef4d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x165170
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x178138(%rip), %rsi    # 0x19ef5d
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x26e40
movq -0x10(%rbp), %rax
cmpl $0x2, 0xc(%rax)
je 0x26e62
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
leaq 0x178111(%rip), %rsi    # 0x19ef6a
movb $0x0, %al
callq 0x15bfb0
jmp 0x26e69
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: do_pasti_tracks
static int do_pasti_tracks(deark *c, struct pastictx *d, i64 pos1)
{
	i64 trkidx;
	i64 pos = pos1;
	int retval = 0;

	for(trkidx=0; trkidx<d->track_count; trkidx++) {
		i64 recsize;

		if(pos+16 > c->infile->len) goto done;
		recsize = de_getu32le(pos);
		if(recsize<16) goto done;
		if(!do_pasti_track(c, d, trkidx, pos, recsize)) goto done;
		pos += recsize;
	}
	retval = 1;
done:
	if(!retval) {
		de_err(c, "Bad data or unexpected end of file");
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x26f29
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jle 0x26ed1
jmp 0x26f30
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x165540
movq %rax, -0x38(%rbp)
cmpq $0x10, -0x38(%rbp)
jge 0x26eef
jmp 0x26f30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x270b0
cmpl $0x0, %eax
jne 0x26f0f
jmp 0x26f30
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26eab
movl $0x1, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x26f48
movq -0x8(%rbp), %rdi
leaq 0x17804b(%rip), %rsi    # 0x19ef8c
movb $0x0, %al
callq 0x15bfb0
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: pasti_extract_to_raw
static void pasti_extract_to_raw(deark *c, struct pastictx *d)
{
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "st", NULL, 0);
	dbuf_copy(d->diskbuf, 0, d->diskbuf->len, outf);
	dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1a86e2(%rip), %rsi    # 0x1cf665
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x166070
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/atari-dsk.c
// Function: pasti_decode_fat
static void pasti_decode_fat(deark *c, struct pastictx *d)
{
	de_module_params *mparams = NULL;

	mparams = de_malloc(c, sizeof(de_module_params));
	de_dbg(c, "decoding as FAT");
	de_dbg_indent(c, 1);
	mparams->in_params.codes = "A";
	mparams->in_params.input_encoding = d->input_encoding;
	de_run_module_by_id_on_slice(c, "fat", mparams, d->diskbuf, 0, d->diskbuf->len);
	if(mparams->out_params.flags & 0x1) {
		de_info(c, "Note: Use \"-opt pasti:toraw\" to decompress to a raw .ST file");
	}
	de_free(c, mparams);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x177e28(%rip), %rsi    # 0x19ee2d
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
leaq 0x1a3f30(%rip), %rcx    # 0x1caf55
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x18(%rax), %r9
leaq 0x177de5(%rip), %rsi    # 0x19ee3d
xorl %eax, %eax
movl %eax, %r8d
callq 0x15c9f0
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x27083
movq -0x8(%rbp), %rdi
leaq 0x178209(%rip), %rsi    # 0x19f285
movb $0x0, %al
callq 0x15c0c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1778d9(%rip), %rcx    # 0x19f320
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1778d1(%rip), %rcx    # 0x19f326
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0x27a90
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4fd(%rip), %rcx       # 0x27f70
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x62e(%rip), %rcx       # 0x280b0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)