LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: nxtarg
static char *
nxtarg(bool reterr)
{
	char *nap;

	if (iap < 1 || iap > iac)	/* should never (but can) be true */
		err(FC_ERR, FMT2S, getmyname(), ERR_AVIINVAL);

	if (iap == iac) {
		if (reterr) {
			iap++;
			return NULL;
		}
		err(FC_ERR, FMT3S, getmyname(), iav[iap - 1], ERR_ARGUMENT);
	}
	nap = iav[iap];
	iap++;
	return nap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpl $0x1, 0x97f1(%rip)      # 0x133b8
jl 0x9bd7
movl 0x97e9(%rip), %eax      # 0x133b8
cmpl 0x97d3(%rip), %eax      # 0x133a8
jle 0x9bf9
callq 0x8df0
movq %rax, %rdx
movl $0x7c, %edi
leaq 0x1bb6(%rip), %rsi      # 0xb7a1
leaq 0x2010(%rip), %rcx      # 0xbc02
movb $0x0, %al
callq 0x8af0
movl 0x97b9(%rip), %eax      # 0x133b8
cmpl 0x97a3(%rip), %eax      # 0x133a8
jne 0x9c5f
testb $0x1, -0x9(%rbp)
je 0x9c26
movl 0x97a5(%rip), %eax      # 0x133b8
addl $0x1, %eax
movl %eax, 0x979c(%rip)      # 0x133b8
movq $0x0, -0x8(%rbp)
jmp 0x9c8c
callq 0x8df0
movq %rax, %rdx
movq 0x977b(%rip), %rax      # 0x133b0
movl 0x977d(%rip), %ecx      # 0x133b8
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movl $0x7c, %edi
leaq 0x1b4c(%rip), %rsi      # 0xb79d
leaq 0x1fbd(%rip), %r8       # 0xbc15
movb $0x0, %al
callq 0x8af0
movq 0x974a(%rip), %rax      # 0x133b0
movslq 0x974b(%rip), %rcx      # 0x133b8
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl 0x973d(%rip), %eax      # 0x133b8
addl $0x1, %eax
movl %eax, 0x9734(%rip)      # 0x133b8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: e2
static bool
e2(void)
{

	if (equal(nxtarg(RETERR), "!"))
		return !e3();
	iap--;
	return e3();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
callq 0x9bb0
movq %rax, %rdi
leaq 0x1991(%rip), %rsi      # 0xb64d
callq 0x9b40
testb $0x1, %al
jne 0x9cc7
jmp 0x9cd5
callq 0x9d00
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9cee
movl 0x96dd(%rip), %eax      # 0x133b8
addl $-0x1, %eax
movl %eax, 0x96d4(%rip)      # 0x133b8
callq 0x9d00
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: ifaccess
static bool
ifaccess(const char *file, int mode)
{
	struct stat sb;
	bool ra;

	if (file == NULL || *file == EOS)
		return false;

	ra = access(file, mode) == 0;

	if (ra && mode == X_OK && sheuid == 0) {
		if (stat(file, &sb) < 0)
			ra = false;
		else if (S_ISDIR(sb.st_mode))
			ra = true;
		else
			ra = (sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) != 0;
	}

	return ra;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa325
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa32e
movb $0x0, -0x1(%rbp)
jmp 0xa3c2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2330
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
testb $0x1, -0xa9(%rbp)
je 0xa3b7
cmpl $0x1, -0x14(%rbp)
jne 0xa3b7
leaq 0x3f0e(%rip), %rax      # 0xe26c
cmpl $0x0, (%rax)
jne 0xa3b7
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jge 0xa381
movb $0x0, -0xa9(%rbp)
jmp 0xa3b5
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0xa39c
movb $0x1, -0xa9(%rbp)
jmp 0xa3b3
movl -0x90(%rbp), %eax
andl $0x49, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
jmp 0xa3b5
jmp 0xa3b7
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: ifstat1
static bool
ifstat1(const char *file, mode_t type)
{
	struct stat sb;
	bool rs;

	if (file == NULL || *file == EOS)
		return false;

	if (type == S_IFLNK) {
		if (lstat(file, &sb) < 0)
			rs = false;
		else
			rs = (sb.st_mode & S_IFMT) == type;
	} else if (stat(file, &sb) < 0)
		rs = false;
	else if (type == S_IFDIR || type == S_IFREG)
		rs = (sb.st_mode & S_IFMT) == type;
	else if (type == F_GZ)
		rs = sb.st_size > (off_t)0;
	else
		rs = false;

	return rs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa3f5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa3fe
movb $0x0, -0x1(%rbp)
jmp 0xa4bb
cmpl $0xa000, -0x14(%rbp)    # imm = 0xA000
jne 0xa440
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2210
cmpl $0x0, %eax
jge 0xa425
movb $0x0, -0xa9(%rbp)
jmp 0xa43e
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
jmp 0xa4b0
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jge 0xa45e
movb $0x0, -0xa9(%rbp)
jmp 0xa4ae
cmpl $0x4000, -0x14(%rbp)    # imm = 0x4000
je 0xa470
cmpl $0x8000, -0x14(%rbp)    # imm = 0x8000
jne 0xa48b
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
jmp 0xa4ac
cmpl $0x1, -0x14(%rbp)
jne 0xa4a3
cmpq $0x0, -0x78(%rbp)
setg %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
jmp 0xa4aa
movb $0x0, -0xa9(%rbp)
jmp 0xa4ac
jmp 0xa4ae
jmp 0xa4b0
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/util.c
// Function: ifstat2
static bool
ifstat2(const char *file1, const char *file2, int act)
{
	struct stat sb1, sb2;
	bool rs;

	if (file1 == NULL || *file1 == EOS)
		return false;
	if (file2 == NULL || *file2 == EOS)
		return false;

	if (stat(file1, &sb1) < 0)
		return false;
	if (stat(file2, &sb2) < 0)
		return false;

	if (act == F_OT)
		rs = sb1.st_mtime < sb2.st_mtime;
	else if (act == F_NT)
		rs = sb1.st_mtime > sb2.st_mtime;
	else if (act == F_EF)
		rs = sb1.st_dev == sb2.st_dev && sb1.st_ino == sb2.st_ino;
	else
		rs = false;

	return rs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa4f9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa502
movb $0x0, -0x1(%rbp)
jmp 0xa5f1
cmpq $0x0, -0x18(%rbp)
je 0xa515
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa51e
movb $0x0, -0x1(%rbp)
jmp 0xa5f1
movq -0x10(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jge 0xa53c
movb $0x0, -0x1(%rbp)
jmp 0xa5f1
movq -0x18(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
jge 0xa55a
movb $0x0, -0x1(%rbp)
jmp 0xa5f1
cmpl $0x2, -0x1c(%rbp)
jne 0xa578
movq -0x58(%rbp), %rax
cmpq -0xe8(%rbp), %rax
setl %al
andb $0x1, %al
movb %al, -0x141(%rbp)
jmp 0xa5e6
cmpl $0x3, -0x1c(%rbp)
jne 0xa596
movq -0x58(%rbp), %rax
cmpq -0xe8(%rbp), %rax
setg %al
andb $0x1, %al
movb %al, -0x141(%rbp)
jmp 0xa5e4
cmpl $0x4, -0x1c(%rbp)
jne 0xa5db
movq -0xb0(%rbp), %rcx
xorl %eax, %eax
cmpq -0x140(%rbp), %rcx
movb %al, -0x142(%rbp)
jne 0xa5cb
movq -0xa8(%rbp), %rax
cmpq -0x138(%rbp), %rax
sete %al
movb %al, -0x142(%rbp)
movb -0x142(%rbp), %al
andb $0x1, %al
movb %al, -0x141(%rbp)
jmp 0xa5e2
movb $0x0, -0x141(%rbp)
jmp 0xa5e4
jmp 0xa5e6
movb -0x141(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: smalloc
void* smalloc(size_t size, const char* fmt, ...)
{
    if (size <= 0)
        return NULL;

    void*   buf = NULL;

    va_list args;

    if ((buf = malloc(size)) == NULL) {
        if (fmt != NULL) {
            va_start(args, fmt);
            vfprintf(stderr, fmt, args);
            va_end(args);
        } else {
            fprintf(stderr, "%s: %d: neo_malloc(): %s\n",
                    __FILE__, __LINE__, strerror(errno));
        }

        return NULL;
    }
    memset(buf, '\0', size);

    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x11bb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
ja 0x11f3
movq $0x0, -0x8(%rbp)
jmp 0x12bc
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x12a5
cmpq $0x0, -0x18(%rbp)
je 0x125a
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x2db4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1090
leaq -0x40(%rbp), %rax
jmp 0x129b
movq 0x2d97(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x10a0
movq -0xf8(%rbp), %rdi
movq %rax, %r8
leaq 0xd78(%rip), %rsi       # 0x2000
leaq 0xd8b(%rip), %rdx       # 0x201a
movl $0x24, %ecx
movb $0x0, %al
callq 0x1060
movq $0x0, -0x8(%rbp)
jmp 0x12bc
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x1050
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: srealloc
void* srealloc(void* ptr, size_t size, const char* fmt, ...)
{
    if (size <= 0)
        return ptr;

    void*   buf = NULL;

    va_list args;

    if ((buf = realloc(ptr, size)) == NULL) {
        if (fmt != NULL) {
            va_start(args, fmt);
            vfprintf(stderr, fmt, args);
            va_end(args);
        } else {
            fprintf(stderr, "%s: %d: neo_realloc(): %s\n",
                    __FILE__, __LINE__, strerror(errno));
        }
        if (ptr != NULL)
            free(ptr);

        return NULL;
    }

    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x130b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x1340
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x140e
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1406
cmpq $0x0, -0x20(%rbp)
je 0x13ab
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0x2c63(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1090
leaq -0x40(%rbp), %rax
jmp 0x13ec
movq 0x2c46(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x10a0
movq -0xf8(%rbp), %rdi
movq %rax, %r8
leaq 0xc4a(%rip), %rsi       # 0x2023
leaq 0xc3a(%rip), %rdx       # 0x201a
movl $0x3e, %ecx
movb $0x0, %al
callq 0x1060
cmpq $0x0, -0x10(%rbp)
je 0x13fc
movq -0x10(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x140e
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/memory.c
// Function: free2d
void free2d(char** buf, int y)
{
    int     i   = 0,
            j   = y - 1;

    while (i <= j) {
        if (*(buf + i) != NULL) {
            free(*(buf + i));
            *(buf + i) = NULL;
        }
        if (*(buf + j) != NULL) {
            free(*(buf + j));
            *(buf + j) = NULL;
        }
        i++;
        j--;
    }
    free(buf);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x14bb
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1477
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14a7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x143f
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: fail
void fail(const char *fmt, ...)
{
  va_list ap;
  fflush(stdout);
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1305
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x16c9d(%rip), %rax     # 0x17fd0
movq (%rax), %rdi
callq 0x1150
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x16c92(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1180
leaq -0x20(%rbp), %rax
movq 0x16c77(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
leaq 0x13ec5(%rip), %rsi     # 0x15250
movb $0x0, %al
callq 0x1120
movl $0x1, %edi
callq 0x11a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: oscli
int oscli(M6502 *mpu, word address, byte data)
{
  byte *params= mpu->memory + mpu->registers->x + (mpu->registers->y << 8);
  char  command[1024], *ptr= command;
  while (('*' == *params) || (' ' == *params))
    ++params;
  while (13 != *params)
    *ptr++= *params++;
  *ptr= '\0';
  system(command);
  rts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %edx
movb $0x1, %al
movl $0x2a, %ecx
cmpl %edx, %ecx
movb %al, -0x42b(%rbp)
je 0x1819
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movl $0x20, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x42b(%rbp)
movb -0x42b(%rbp), %al
testb $0x1, %al
jne 0x1825
jmp 0x1833
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x17ea
jmp 0x1835
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movl $0xd, %eax
cmpl %ecx, %eax
je 0x186f
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x428(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x428(%rbp)
movb %cl, (%rax)
jmp 0x1835
movq -0x428(%rbp), %rax
movb $0x0, (%rax)
leaq -0x420(%rbp), %rdi
callq 0x1090
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movb 0x4(%rdx), %cl
addb $0x1, %cl
movb %cl, 0x4(%rdx)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movw %ax, -0x42a(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movb 0x4(%rdx), %cl
addb $0x1, %cl
movb %cl, 0x4(%rdx)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
shll $0x8, %ecx
movzwl -0x42a(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x42a(%rbp)
movzwl -0x42a(%rbp), %eax
addl $0x1, %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: oswrch
int oswrch(M6502 *mpu, word address, byte data)
{
  switch (mpu->registers->a)
    {
    case 0x0C:
      fputs("\033[2J\033[H", stdout);
      break;

    default:
      putchar(mpu->registers->a);
      break;
    }
  fflush(stdout);
  rts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
subb $0xc, %al
jne 0x194f
jmp 0x1937
movq 0x16692(%rip), %rax     # 0x17fd0
movq (%rax), %rsi
leaq 0x136da(%rip), %rdi     # 0x15022
callq 0x10b0
jmp 0x195e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %edi
callq 0x1040
movq 0x1666b(%rip), %rax     # 0x17fd0
movq (%rax), %rdi
callq 0x1150
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movb 0x4(%rdx), %cl
addb $0x1, %cl
movb %cl, 0x4(%rdx)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movb 0x4(%rdx), %cl
addb $0x1, %cl
movb %cl, 0x4(%rdx)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
shll $0x8, %ecx
movzwl -0xe(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
addl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: loadInterpreter
static int loadInterpreter(M6502 *mpu, word start, const char *path)
{
  FILE   *file= 0;
  int     count= 0;
  byte   *memory= mpu->memory + start;
  size_t  max= 0x10000 - start;
  int     c= 0;

  if ((!(file= fopen(path, "r"))) || ('#' != fgetc(file)) || ('!' != fgetc(file)))
    return 0;
  while ((c= fgetc(file)) >= ' ')
    ;
  while ((count= fread(memory, 1, max, file)) > 0)
    {
      memory += count;
      max -= count;
    }
  fclose(file);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0x12(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movzwl -0x12(%rbp), %ecx
movl $0x10000, %eax          # imm = 0x10000
subl %ecx, %eax
cltq
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x13e00(%rip), %rsi     # 0x15d5f
callq 0x1160
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1f96
movq -0x28(%rbp), %rdi
callq 0x10d0
movl %eax, %ecx
movl $0x23, %eax
cmpl %ecx, %eax
jne 0x1f96
movq -0x28(%rbp), %rdi
callq 0x10d0
movl %eax, %ecx
movl $0x21, %eax
cmpl %ecx, %eax
je 0x1f9f
movl $0x0, -0x4(%rbp)
jmp 0x2006
jmp 0x1fa1
movq -0x28(%rbp), %rdi
callq 0x10d0
movl %eax, -0x44(%rbp)
cmpl $0x20, %eax
jl 0x1fb4
jmp 0x1fa1
jmp 0x1fb6
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1070
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jle 0x1ff6
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movslq -0x2c(%rbp), %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x1fb6
movq -0x28(%rbp), %rdi
callq 0x1080
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: load
static int load(M6502 *mpu, word address, const char *path)
{
  FILE  *file= 0;
  int    count= 0;
  size_t max= 0x10000 - address;
  if (!(file= fopen(path, "r")))
    return 0;
  while ((count= fread(mpu->memory + address, 1, max, file)) > 0)
    {
      address += count;
      max -= count;
    }
  fclose(file);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movzwl -0x12(%rbp), %ecx
movl $0x10000, %eax          # imm = 0x10000
subl %ecx, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x13d0d(%rip), %rsi     # 0x15d5f
callq 0x1160
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x206a
movl $0x0, -0x4(%rbp)
jmp 0x20c5
jmp 0x206c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0x12(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1070
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jle 0x20b5
movl -0x2c(%rbp), %ecx
movzwl -0x12(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movslq -0x2c(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x206c
movq -0x28(%rbp), %rdi
callq 0x1080
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: doGtrap
static int doGtrap(int argc, char **argv, M6502 *mpu)
{
  unsigned addr;
  if (argc < 2) usage(1);
  addr= htol(argv[1]);
  M6502_setCallback(mpu, call, addr, gTrap);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x2483
movl $0x1, %edi
callq 0x29b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2c00
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
leaq 0x7ab(%rip), %rdx       # 0x2c50
movq %rdx, 0x100000(%rax,%rcx,8)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: doEtrap
static int doEtrap(int argc, char **argv, M6502 *mpu)
{
  unsigned addr;
  if (argc < 2) usage(1);
  addr= htol(argv[1]);
  M6502_setCallback(mpu, call, addr, eTrap);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x24e3
movl $0x1, %edi
callq 0x29b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2c00
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
leaq 0x7eb(%rip), %rdx       # 0x2cf0
movq %rdx, 0x100000(%rax,%rcx,8)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: doMtrap
static int doMtrap(int argc, char **argv, M6502 *mpu)
{
  unsigned addr= 0;
  if (argc < 2) usage(1);
  addr= htol(argv[1]);
  M6502_setCallback(mpu, read,  addr, mTrapRead);
  M6502_setCallback(mpu, write, addr, mTrapWrite);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x26da
movl $0x1, %edi
callq 0x29b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2c00
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
leaq 0x6b4(%rip), %rdx       # 0x2db0
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
leaq 0x6ce(%rip), %rdx       # 0x2de0
movq %rdx, 0x80000(%rax,%rcx,8)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: doPtrap
static int doPtrap(int argc, char **argv, M6502 *mpu)
{
  unsigned addr;
  if (argc < 2) usage(1);
  addr= htol(argv[1]);
  M6502_setCallback(mpu, call, addr, pTrap);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x27d3
movl $0x1, %edi
callq 0x29b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2c00
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
leaq 0x61b(%rip), %rdx       # 0x2e10
movq %rdx, 0x100000(%rax,%rcx,8)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: doXtrap
static int doXtrap(int argc, char **argv, M6502 *mpu)
{
  unsigned addr= 0;
  if (argc < 2) usage(1);
  addr= htol(argv[1]);
  M6502_setCallback(mpu, call, addr, xTrap);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x297a
movl $0x1, %edi
callq 0x29b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2c00
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
leaq 0x5c4(%rip), %rdx       # 0x2f60
movq %rdx, 0x100000(%rax,%rcx,8)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: eTrap
static int eTrap(M6502 *mpu, word addr, byte data)
{
	printf("> error:%d\n",mpu->registers->a);
	M6502_log_printall();
	printf("<\n");
	rts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %esi
leaq 0x1236d(%rip), %rdi     # 0x15086
movb $0x0, %al
callq 0x10a0
callq 0x7880
leaq 0x12366(%rip), %rdi     # 0x15092
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movb 0x4(%rdx), %cl
addb $0x1, %cl
movb %cl, 0x4(%rdx)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movb 0x4(%rdx), %cl
addb $0x1, %cl
movb %cl, 0x4(%rdx)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
shll $0x8, %ecx
movzwl -0xe(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
addl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/run6502.c
// Function: save
static int save(M6502 *mpu, word address, unsigned length, const char *path)
{
  FILE *file= 0;
  int   count= 0;
  if (!(file= fopen(path, "w")))
    return 0;
  while ((count= fwrite(mpu->memory + address, 1, length, file)))
    {
      address += count;
      length -= count;
    }
  fclose(file);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x121b1(%rip), %rsi     # 0x15095
callq 0x1160
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2efc
movl $0x0, -0x4(%rbp)
jmp 0x2f54
jmp 0x2efe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0x12(%rbp), %eax
cltq
addq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x11b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x2f44
movl -0x2c(%rbp), %ecx
movzwl -0x12(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x2efe
movq -0x28(%rbp), %rdi
callq 0x1080
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_dump.c
// Function: M6502_dump
void M6502_dump(M6502 *mpu, char buffer[64])
{
  M6502_Registers *r= mpu->registers;
  uint8_t p= r->p;
# define P(N,C) (p & (1 << (N)) ? (C) : '-')
  sprintf(buffer, "PC=%04X SP=%04X A=%02X X=%02X Y=%02X P=%02X %c%c%c%c%c%c%c%c",
	  r->pc, 0x0100 + r->s,
	  r->a, r->x, r->y, r->p,
	  P(7,'N'), P(6,'V'), P(5,'?'), P(4,'B'), P(3,'D'), P(2,'I'), P(1,'Z'), P(0,'C'));
# undef P
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x41(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movzwl 0x6(%rax), %edx
movq -0x40(%rbp), %rax
movzbl 0x4(%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movq -0x40(%rbp), %rax
movzbl (%rax), %r8d
movq -0x40(%rbp), %rax
movzbl 0x1(%rax), %r9d
movq -0x40(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, -0x4c(%rbp)
movzbl -0x41(%rbp), %esi
andl $0x80, %esi
movl $0x2d, %r13d
movl $0x4e, %eax
cmpl $0x0, %esi
cmovnel %eax, %r13d
movzbl -0x41(%rbp), %esi
andl $0x40, %esi
movl $0x2d, %r12d
movl $0x56, %eax
cmpl $0x0, %esi
cmovnel %eax, %r12d
movzbl -0x41(%rbp), %esi
andl $0x20, %esi
movl $0x2d, %r15d
movl $0x3f, %eax
cmpl $0x0, %esi
cmovnel %eax, %r15d
movzbl -0x41(%rbp), %esi
andl $0x10, %esi
movl $0x2d, %r14d
movl $0x42, %eax
cmpl $0x0, %esi
cmovnel %eax, %r14d
movzbl -0x41(%rbp), %esi
andl $0x8, %esi
movl $0x2d, %ebx
movl $0x44, %eax
cmpl $0x0, %esi
cmovnel %eax, %ebx
movzbl -0x41(%rbp), %esi
andl $0x4, %esi
movl $0x2d, %r11d
movl $0x49, %eax
cmpl $0x0, %esi
cmovnel %eax, %r11d
movzbl -0x41(%rbp), %esi
andl $0x2, %esi
movl $0x2d, %r10d
movl $0x5a, %eax
cmpl $0x0, %esi
cmovnel %eax, %r10d
movzbl -0x41(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x58(%rbp)
movl $0x2d, %esi
movl $0x43, %eax
movl %eax, -0x54(%rbp)
movl -0x58(%rbp), %eax
cmpl $0x0, %eax
movl -0x54(%rbp), %eax
cmovnel %eax, %esi
movl -0x50(%rbp), %eax
movl %esi, -0x48(%rbp)
leaq 0xe77d(%rip), %rsi      # 0x15e3f
movl %eax, (%rsp)
movl -0x4c(%rbp), %eax
movl %eax, 0x8(%rsp)
movl -0x48(%rbp), %eax
movl %r13d, 0x10(%rsp)
movl %r12d, 0x18(%rsp)
movl %r15d, 0x20(%rsp)
movl %r14d, 0x28(%rsp)
movl %ebx, 0x30(%rsp)
movl %r11d, 0x38(%rsp)
movl %r10d, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movb $0x0, %al
callq 0x1190
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_dump.c
// Function: M6502_log
void M6502_log(M6502 *mpu)
{
//	int i;
//	char *b;

	M6502_Registers *b;

	if(loginit==0)
	{
		loginit=1;
		memset(logbuffer,0,sizeof(logbuffer));
		memcpy(&logmpu,mpu,sizeof(M6502));
	}
/*	
	for(i=0;i<(LOGLINES-1);i++)
	{
		memcpy(logbuffer[i],logbuffer[i+1],LOGLINELEN);
	}
*/
#if 0
	b=&logbuffer[logptr][0];
	logptr++;if(logptr==LOGLINES) logptr=0;

	M6502_dump(mpu,b);
	b+=(strlen(b));
	*b++=' ';
	*b++=' ';
	M6502_disassemble(mpu,mpu->registers->pc,b);
#endif

	b=&logbuffer[logptr];
	logptr++;if(logptr==LOGLINES) logptr=0;
	memcpy(b,mpu->registers,sizeof(M6502_Registers));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x509fd(%rip)     # 0x58120
jne 0x7771
movl $0x1, 0x509f1(%rip)     # 0x58120
leaq 0x509fa(%rip), %rdi     # 0x58130
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x10c0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x50be0(%rip)     # 0x58330
movq 0x8(%rax), %rcx
movq %rcx, 0x50bdd(%rip)     # 0x58338
movq 0x10(%rax), %rcx
movq %rcx, 0x50bda(%rip)     # 0x58340
movq 0x18(%rax), %rax
movq %rax, 0x50bd7(%rip)     # 0x58348
movslq 0x50bd8(%rip), %rcx     # 0x58350
leaq 0x509b1(%rip), %rax     # 0x58130
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl 0x50bc0(%rip), %eax     # 0x58350
addl $0x1, %eax
movl %eax, 0x50bb7(%rip)     # 0x58350
cmpl $0x40, 0x50bb0(%rip)    # 0x58350
jne 0x77ac
movl $0x0, 0x50ba4(%rip)     # 0x58350
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_dump.c
// Function: M6502_log_printlast
void M6502_log_printlast(void)
{
//	char *b;
	M6502_Registers *b;
	int ptr;
	ptr=logptr-1;if(ptr<0) ptr=(LOGLINES-1);
//	b=&logbuffer[ptr][0];
	b=&logbuffer[ptr];

	logmpu.registers=b;

	M6502_dump(&logmpu,buffer);
	printf(";%s  ",buffer);
	M6502_disassemble(&logmpu,logmpu.registers->pc,buffer);
	printf("%s\n",buffer);
#if 0	
	if(*b)
	{
		printf(";%s\n",b);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x50b72(%rip), %eax     # 0x58350
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x77f1
movl $0x3f, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x50934(%rip), %rax     # 0x58130
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x50b1e(%rip)     # 0x58330
leaq 0x50b17(%rip), %rdi     # 0x58330
leaq 0x50b40(%rip), %rsi     # 0x58360
callq 0x7570
leaq 0xe650(%rip), %rdi      # 0x15e7c
leaq 0x50b2d(%rip), %rsi     # 0x58360
movb $0x0, %al
callq 0x10a0
movq 0x50aef(%rip), %rax     # 0x58330
leaq 0x50ae8(%rip), %rdi     # 0x58330
leaq 0x50b11(%rip), %rdx     # 0x58360
movzwl 0x6(%rax), %esi
callq 0x2f80
leaq 0xd8ad(%rip), %rdi      # 0x1510c
leaq 0x50afa(%rip), %rsi     # 0x58360
movb $0x0, %al
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_dump.c
// Function: M6502_log_printall
void M6502_log_printall(void)
{
	int i;
//	char *b;
	M6502_Registers *b;
	int ptr;
	ptr=logptr;
	for(i=0;i<(LOGLINES);i++)
	{
//		b=&logbuffer[ptr][0];
		b=&logbuffer[ptr];
		ptr++;if(ptr==LOGLINES) ptr=0;

		logmpu.registers=b;
			
		M6502_dump(&logmpu,buffer);
		printf(";%s  ",buffer);
		M6502_disassemble(&logmpu,logmpu.registers->pc,buffer);
		printf("%s\n",buffer);
		
#if 0
		if(*b)
		{
			printf(";%2d:%s\n",i,b);
		}
#endif
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x50ac2(%rip), %eax     # 0x58350
movl %eax, -0x14(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x7942
movslq -0x14(%rbp), %rcx
leaq 0x50883(%rip), %rax     # 0x58130
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jne 0x78ce
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x50a57(%rip)     # 0x58330
leaq 0x50a50(%rip), %rdi     # 0x58330
leaq 0x50a79(%rip), %rsi     # 0x58360
callq 0x7570
leaq 0xe589(%rip), %rdi      # 0x15e7c
leaq 0x50a66(%rip), %rsi     # 0x58360
movb $0x0, %al
callq 0x10a0
movq 0x50a28(%rip), %rax     # 0x58330
leaq 0x50a21(%rip), %rdi     # 0x58330
leaq 0x50a4a(%rip), %rdx     # 0x58360
movzwl 0x6(%rax), %esi
callq 0x2f80
leaq 0xd7e6(%rip), %rdi      # 0x1510c
leaq 0x50a33(%rip), %rsi     # 0x58360
movb $0x0, %al
callq 0x10a0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7898
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_main.c
// Function: M6502_irq
void M6502_irq(M6502 *mpu)
{
  if (!(mpu->registers->p & flagI))
    {
      mpu->memory[0x0100 + mpu->registers->s--] = (byte)(mpu->registers->pc >> 8);
      mpu->memory[0x0100 + mpu->registers->s--] = (byte)(mpu->registers->pc & 0xff);
      mpu->memory[0x0100 + mpu->registers->s--] = mpu->registers->p;
      mpu->registers->p &= ~flagB;
      mpu->registers->p |=  flagI;
      mpu->registers->pc = M6502_getVector(mpu, IRQ);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x3(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x7a72
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl 0x6(%rax), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movb 0x4(%rsi), %cl
movb %cl, %dil
addb $-0x1, %dil
movb %dil, 0x4(%rsi)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl 0x6(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movb 0x4(%rsi), %cl
movb %cl, %dil
addb $-0x1, %dil
movb %dil, 0x4(%rsi)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb 0x3(%rax), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movb 0x4(%rsi), %cl
movb %cl, %dil
addb $-0x1, %dil
movb %dil, 0x4(%rsi)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x3(%rax), %ecx
andl $-0x11, %ecx
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x3(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0xfffe(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0xffff(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_main.c
// Function: M6502_nmi
void M6502_nmi(M6502 *mpu)
{
  mpu->memory[0x0100 + mpu->registers->s--] = (byte)(mpu->registers->pc >> 8);
  mpu->memory[0x0100 + mpu->registers->s--] = (byte)(mpu->registers->pc & 0xff);
  mpu->memory[0x0100 + mpu->registers->s--] = mpu->registers->p;
  mpu->registers->p &= ~flagB;
  mpu->registers->p |=  flagI;
  mpu->registers->pc = M6502_getVector(mpu, NMI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl 0x6(%rax), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movb 0x4(%rsi), %cl
movb %cl, %dil
addb $-0x1, %dil
movb %dil, 0x4(%rsi)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl 0x6(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movb 0x4(%rsi), %cl
movb %cl, %dil
addb $-0x1, %dil
movb %dil, 0x4(%rsi)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb 0x3(%rax), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movb 0x4(%rsi), %cl
movb %cl, %dil
addb $-0x1, %dil
movb %dil, 0x4(%rsi)
movzbl %cl, %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x3(%rax), %ecx
andl $-0x11, %ecx
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x3(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0xfffa(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0xfffb(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_main.c
// Function: M6502_new
M6502 *M6502_new(M6502_Registers *registers, M6502_Memory memory, M6502_Callbacks *callbacks)
{
  M6502 *mpu= calloc(1, sizeof(M6502));
  if (!mpu) outOfMemory();

  if (!registers)  { registers = (M6502_Registers *)calloc(1, sizeof(M6502_Registers));  mpu->flags |= M6502_RegistersAllocated; }
  if (!memory   )  { memory    = (uint8_t         *)calloc(1, sizeof(M6502_Memory   ));  mpu->flags |= M6502_MemoryAllocated;    }
  if (!callbacks)  { callbacks = (M6502_Callbacks *)calloc(1, sizeof(M6502_Callbacks));  mpu->flags |= M6502_CallbacksAllocated; }

  if (!registers || !memory || !callbacks) outOfMemory();

  mpu->registers = registers;
  mpu->memory    = memory;
  mpu->callbacks = callbacks;

  return mpu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x140d3
callq 0x14190
cmpq $0x0, -0x8(%rbp)
jne 0x140fa
movl $0x1, %edi
movl $0x8, %esi
callq 0x10f0
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x14121
movl $0x1, %edi
movl $0x10000, %esi          # imm = 0x10000
callq 0x10f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x14148
movl $0x1, %edi
movl $0x180000, %esi         # imm = 0x180000
callq 0x10f0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x1415d
cmpq $0x0, -0x10(%rbp)
je 0x1415d
cmpq $0x0, -0x18(%rbp)
jne 0x14162
callq 0x14190
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrdudz[P]run6502/./lib6502_main.c
// Function: M6502_delete
void M6502_delete(M6502 *mpu)
{
  if (mpu->flags & M6502_CallbacksAllocated) free(mpu->callbacks);
  if (mpu->flags & M6502_MemoryAllocated   ) free(mpu->memory);
  if (mpu->flags & M6502_RegistersAllocated) free(mpu->registers);

  free(mpu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x141e8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14204
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1421f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: printAccounts
void *printAccounts(void *emptyPtr)
{
	while (1)
	{
		signal(SIGALRM, alarmHandler);
		alarm(20);
		sem_wait(&semaphore);
		
		printf("ACCOUNT LIST\n");
		int i=0;
		printf("---------------------------------------\n");
		for (i=0;(i<*numAcc && !strcasecmp(accountList[i].accountName,"")==0);i++)
		{
			printf("%s\n", accountList[i].accountName);
			printf("        %f\n", accountList[i].balance);
			(accountList[i].inUse==1) ? printf("        IN SESSION\n"):printf("        NOT IN SESSION\n");
		}
		
		printf("----------------------------------------\n");
		
		
	}
	pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xe, %edi
leaq -0x38(%rip), %rsi       # 0x13b0
callq 0x1160
movl $0x14, %edi
callq 0x1110
leaq 0x6d7a(%rip), %rdi      # 0x8178
callq 0x1060
leaq 0x1bfa(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x10e0
movl $0x0, -0xc(%rbp)
leaq 0x1c30(%rip), %rdi      # 0x304f
movb $0x0, %al
callq 0x10e0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq 0x6d61(%rip), %rdx      # 0x8198
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0xd(%rbp)
jge 0x1474
movq 0x6d59(%rip), %rdi      # 0x81a0
movslq -0xc(%rbp), %rax
imulq $0x6c, %rax, %rax
addq %rax, %rdi
leaq 0x1c1e(%rip), %rsi      # 0x3077
callq 0x1040
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x1480
jmp 0x150d
movq 0x6d19(%rip), %rsi      # 0x81a0
movslq -0xc(%rbp), %rax
imulq $0x6c, %rax, %rax
addq %rax, %rsi
leaq 0x1b79(%rip), %rdi      # 0x3012
movb $0x0, %al
callq 0x10e0
movq 0x6cf9(%rip), %rax      # 0x81a0
movslq -0xc(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movss 0x64(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1b54(%rip), %rdi      # 0x3016
movb $0x1, %al
callq 0x10e0
movq 0x6cd0(%rip), %rax      # 0x81a0
movslq -0xc(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x68(%rax)
jne 0x14f1
leaq 0x1b3a(%rip), %rdi      # 0x3022
movb $0x0, %al
callq 0x10e0
jmp 0x14ff
leaq 0x1b3e(%rip), %rdi      # 0x3036
movb $0x0, %al
callq 0x10e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x142d
leaq 0x1b3a(%rip), %rdi      # 0x304e
movb $0x0, %al
callq 0x10e0
jmp 0x13dc
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server2.c
// Function: exitHandler
void exitHandler()
{
	struct sockNode *iter=head;
	char input[strSize]="exit";
	int len= strlen(input);


	while (iter)
	{
		write(iter->sock, &len, sizeof(int));
		write(iter->sock, input, len);
		close(iter->sock);
		iter=iter->next;
	}
	exit(0);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq 0x6c76(%rip), %rax      # 0x81a8
movq %rax, -0x8(%rbp)
leaq -0x3f0(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1100
movb $0x65, -0x3f0(%rbp)
movb $0x78, -0x3ef(%rbp)
movb $0x69, -0x3ee(%rbp)
movb $0x74, -0x3ed(%rbp)
leaq -0x3f0(%rbp), %rdi
callq 0x10b0
movl %eax, -0x3f4(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15c7
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x3f4(%rbp), %rsi
movl $0x4, %edx
callq 0x1090
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x3f0(%rbp), %rsi
movslq -0x3f4(%rbp), %rdx
callq 0x1090
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x1120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1577
xorl %edi, %edi
callq 0x1250
nop