LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/TheDiamondProject[P]lib68/cpu/mmu.c
// Function: m68_mmu_write_long
void m68_mmu_write_long(uint32_t address, uint32_t value)
{
	uint8_t *ptr = m68_mmu_translate(address);
	value = TO_BIG_LONG(value);
	*(ptr + 3) = (value >> 24);
	*(ptr + 2) = (value >> 16);
	*(ptr + 1) = (value >> 8);
	*(ptr + 0) = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
callq 0x4add
andl $0xfff, %r14d           # imm = 0xFFF
bswapl %ebx
movl %ebx, (%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/wgsim.c
// Function: ran_normal
double ran_normal()
{ 
	static int iset = 0; 
	static double gset; 
	double fac, rsq, v1, v2; 
	if (iset == 0) {
		do { 
			v1 = 2.0 * drand48() - 1.0;
			v2 = 2.0 * drand48() - 1.0; 
			rsq = v1 * v1 + v2 * v2;
		} while (rsq >= 1.0 || rsq == 0.0);
		fac = sqrt(-2.0 * log(rsq) / rsq); 
		gset = v1 * fac; 
		iset = 1;
		return v2 * fac;
	} else {
		iset = 0;
		return gset;
	}
}

// Assembly:
cmpb $0x0, 0x3285(%rip)      # 0x5128
je 0x1eb9
movb $0x0, 0x327c(%rip)      # 0x5128
movsd 0x327c(%rip), %xmm1     # 0x5130
jmp 0x1f75
subq $0x18, %rsp
callq 0x11d0
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0x1136(%rip), %xmm0     # 0x3008
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x11d0
addsd %xmm0, %xmm0
addsd 0x111c(%rip), %xmm0     # 0x3008
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
ucomisd 0x1107(%rip), %xmm2     # 0x3010
jae 0x1ebd
ucomisd 0x110d(%rip), %xmm2     # 0x3020
jne 0x1f17
jnp 0x1ebd
movsd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x10c0
mulsd 0x10e4(%rip), %xmm0     # 0x3018
divsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1f4a
sqrtsd %xmm0, %xmm0
jmp 0x1f4f
callq 0x11b0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x31d0(%rip)     # 0x5130
movb $0x1, 0x31c1(%rip)      # 0x5128
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
addq $0x18, %rsp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/asm.c
// Function: appendef
void appendef(char *file, char *ext) {
	char *pos;                          /* position of ] if any */
	pos = strchr(file, ']');            /* end of vax path */
	if (!strchr(pos ? pos : file, '.')) /* already a dot? */
		strcat(file, ext);          /* if not, append extention */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5d, %esi
callq 0x10d0
testq %rax, %rax
cmoveq %r14, %rax
movq %rax, %rdi
movl $0x2e, %esi
callq 0x10d0
testq %rax, %rax
je 0x1e82
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11e0
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/asm.c
// Function: error_msg
void error_msg(char *msg, char *info, int fatal) { /* serious error messages */
	printf("\n%s%s", msg, info);
	if (fatal <= 1) return;
	fclose(file_tmp); /* close temporary file */
	remove(tmpdev);   /* delete temporary file */
	exit(fatal);
}

// Assembly:
pushq %rbx
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8393(%rip), %rdi      # 0xa237
xorl %eax, %eax
callq 0x10e0
cmpl $0x1, %ebx
jg 0x1eb2
popq %rbx
retq
movq 0xb88f(%rip), %rdi      # 0xd748
callq 0x10a0
leaq 0xba0b(%rip), %rdi      # 0xd8d0
callq 0x1060
movl %ebx, %edi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/asm.c
// Function: display_error
void display_error(char c) {
/* append another error to error field if this error has not occurred before */
	char *p = error_field;
	while (*p) {
		if (*p == ' ') *p = c;
		if (*p == c) break;
		p++;
	}
}

// Assembly:
leaq 0xbd98(%rip), %rax      # 0xdc70
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x1ee6
testl %ecx, %ecx
jne 0x1ee9
jmp 0x1ef5
movb %dil, (%rax)
leaq 0x1(%rax), %rcx
cmpb %dil, (%rax)
movq %rcx, %rax
jne 0x1ed8
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/direct1.c
// Function: pushcond
int pushcond(int cond) {
	int i = 1 << (++condlevel & 15);
	if (cond)
		condstk[condlevel >> 4] |= i;
	else
		condstk[condlevel >> 4] &= ~i;
	if (condlevel >= 16 * MAXCNDLEV - 1)
		error_msg("conditional nesting depth exceeds maximum", "", 4);
	condit &= cond;
	return 1;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0xbc52(%rip), %rax      # 0xdb60
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %edx, %eax
andb $0xf, %al
sarl $0x4, %edx
movslq %edx, %rdx
leaq 0xbdaa(%rip), %rsi      # 0xdcd0
movzwl (%rsi,%rdx,2), %edi
movl %edi, %r8d
btrl %eax, %r8d
btsl %eax, %edi
testl %ebx, %ebx
cmovel %r8d, %edi
movw %di, (%rsi,%rdx,2)
cmpl $0x7fe, %ecx            # imm = 0x7FE
jl 0x1f5e
leaq 0x82f0(%rip), %rdi      # 0xa23d
leaq 0x8be3(%rip), %rsi      # 0xab37
movl $0x4, %edx
callq 0x1e94
leaq 0xbc03(%rip), %rax      # 0xdb68
andl %ebx, (%rax)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/direct2.c
// Function: isstring
int isstring(char *p) {
	if (*p == '\'' || *p == '\"') {
		char c, delimiter = *p;
		while ((c = *++p))
			if (c == delimiter)
				if (*++p != delimiter) return !*p;
	}
	return 0;
}

// Assembly:
movzbl (%rdi), %ecx
cmpl $0x27, %ecx
je 0x42bf
cmpl $0x22, %ecx
jne 0x4307
movb 0x1(%rdi), %r8b
testb %r8b, %r8b
sete %dl
je 0x42f8
leaq 0x1(%rdi), %rsi
cmpb %cl, %r8b
jne 0x42e4
movb 0x2(%rdi), %sil
cmpb %cl, %sil
jne 0x42fa
addq $0x2, %rdi
movq %rdi, %rsi
movq %rsi, %rdi
incq %rsi
movb 0x1(%rdi), %r8b
testb %r8b, %r8b
sete %dl
jne 0x42cf
jmp 0x4302
jmp 0x4302
xorl %eax, %eax
testb %sil, %sil
sete %al
testb $0x1, %dl
je 0x4309
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: evalsym
long evalsym() {
	char sym[32]; /* save symbol */
	int i = 0;    /* position of last character added to sym */

	sym[i++] = toupper(*(lp - 1));
	while (isalpha(*lp) || isdigit(*lp) || *lp == '$' || *lp == '.' ||
	       *lp == '_') {
		sym[i] = toupper(*lp); /* gather the symbol name */
		lp++;
		if (i < 31) i++;
	}
	sym[i] = 0;             /* terminate the symbol name */
	ptr = find_symbol(sym); /* get a pointer to the symbol table entry */
	if (!ptr)
		insert_symbol(sym, 0L, 0, 0,
		              0); /* insert an undefined symbol */
	else
		addref(&ptr->xref,
		       0); /* add a reference to symbol is it exists */
	if (ptr->section)  /* bad idea to use section names in expressions */
		display_error(error = 'S');
	if (ptr->multiple) /* use of multiply defined symbol */
		display_error(error = 'S');
	if (ptr->known)              /* is the value of the symbol known? */
		return (ptr->value); /* value of symbol */
	if (pass == 2) display_error(error = 'U');
	expdef = FALSE; /* symbol value is unknown */
	return (0L);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
callq 0x1030
movq %rax, %rbx
movq (%rax), %rax
movq 0x9fac(%rip), %rcx      # 0xe2d0
movsbq -0x1(%rcx), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rsp)
movl $0x1, %ebp
callq 0x1230
movabsq $0x800000000000401, %rcx # imm = 0x800000000000401
movq (%rax), %rdi
movq 0x9f83(%rip), %rdx      # 0xe2d0
movsbq (%rdx), %rsi
movzwl (%rdi,%rsi,2), %edi
testl $0xc00, %edi            # imm = 0xC00
jne 0x436f
movzbl %sil, %edi
addl $-0x24, %edi
cmpl $0x3b, %edi
ja 0x438e
btq %rdi, %rcx
jae 0x438e
movq (%rbx), %rdi
movb (%rdi,%rsi,4), %sil
movl %ebp, %edi
movb %sil, (%rsp,%rdi)
incq %rdx
movq %rdx, 0x9f4a(%rip)      # 0xe2d0
cmpl $0x1f, %ebp
adcl $0x0, %ebp
jmp 0x4343
movl %ebp, %eax
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
callq 0x8e30
leaq 0x989d(%rip), %rbx      # 0xdc40
movq %rax, (%rbx)
testq %rax, %rax
je 0x43bb
addq $0x10, %rax
movq %rax, %rdi
xorl %esi, %esi
callq 0x8a36
jmp 0x43cc
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8b5e
movq (%rbx), %rax
testb $0x10, 0x20(%rax)
je 0x43e9
leaq 0x9a14(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ed1
movq (%rbx), %rax
testb $0x8, 0x20(%rax)
je 0x4406
leaq 0x99f7(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ed1
movq (%rbx), %rax
testb $0x1, 0x21(%rax)
jne 0x4440
leaq 0x93de(%rip), %rax      # 0xd7f4
cmpl $0x2, (%rax)
jne 0x442f
leaq 0x99ce(%rip), %rax      # 0xddf0
movb $0x55, (%rax)
movl $0x55, %edi
callq 0x1ed1
leaq 0x99a2(%rip), %rax      # 0xddd8
movl $0x0, (%rax)
xorl %eax, %eax
jmp 0x4444
movq 0x18(%rax), %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: evalcon
long evalcon(int r) { /* evaluate a constant in radix r */
	char c;
	long con = 0;

	while (isxdigit(*lp)) {
		c = toupper(*lp) - '0';
		if (c > 9) c -= 7;
		if (c < 0 || c >= r) return (con);
		con *= r;
		con += c;
		lp++;
	}
	return (con);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x1230
movq %rax, %r14
movq (%rax), %rax
movq 0x9e69(%rip), %r15      # 0xe2d0
movsbq (%r15), %r12
testb $0x10, 0x1(%rax,%r12,2)
jne 0x4477
xorl %eax, %eax
jmp 0x44d5
callq 0x1030
movq %rax, %rcx
movl %ebx, %edx
incq %r15
xorl %eax, %eax
movq (%rcx), %rsi
movb (%rsi,%r12,4), %sil
leal -0x30(%rsi), %edi
addb $-0x37, %sil
cmpb $0xa, %dil
movzbl %sil, %r8d
movzbl %dil, %esi
cmovgel %r8d, %esi
testb %sil, %sil
js 0x44d5
movsbl %sil, %edi
cmpl %ebx, %edi
jge 0x44d5
imulq %rdx, %rax
movzbl %sil, %esi
addq %rsi, %rax
movq %r15, 0x9e0d(%rip)      # 0xe2d0
movq (%r14), %rsi
movsbq (%r15), %r12
incq %r15
testb $0x10, 0x1(%rsi,%r12,2)
jne 0x4486
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: evalocal
long evalocal() { /* evaluate a local symbol */
	int loc = 0;
	char *p, sym[8];

	for (p = lp; isdigit(*p); p++)
		loc = loc * 10 + *p -
		      '0'; /* get the decimal # part of local symbol */
	if (*p == '$') {   /* yes it is a local symbol */
		lp = ++p;  /* point past the $ */
		if (loc < 1 ||
		    loc > 255) { /* it is a valid local symbol name */
			display_error(error = 'E');
			return (0L);
		}
		makelocal(loc, sym);
		ptr = find_symbol(
		        sym); /* get a pointer to the symbol table entry */
		if (!ptr)
			insert_symbol(sym, 0L, 0, 0,
			              1); /* insert an undefined symbol */
		if (ptr->section)         /* bad idea to use section names in
		                             expressions */
			display_error(error = 'S');
		if (ptr->multiple) /* use of multiply defined symbol */
			display_error(error = 'S');
		if (ptr->known) /* is the value of the symbol known? */
			return (ptr->value); /* value of symbol */
		if (pass == 2) display_error(error = 'U');
		expdef = FALSE; /* symbol value is unknown */
		return (0L);
	}
	/* wasn't local symbol - must be a constant */
	return (evalcon(radix));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x9de3(%rip), %rbx      # 0xe2d0
callq 0x1230
movq (%rax), %rcx
movsbq (%rbx), %rax
xorl %edi, %edi
testb $0x8, 0x1(%rcx,%rax,2)
je 0x451f
xorl %edi, %edi
movsbl %al, %eax
leal (%rdi,%rdi,4), %edx
leal (%rax,%rdx,2), %edi
addl $-0x30, %edi
movsbq 0x1(%rbx), %rax
incq %rbx
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x4504
cmpb $0x24, %al
jne 0x4552
incq %rbx
movq %rbx, 0x9da3(%rip)      # 0xe2d0
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
leal (%rdi,%rax), %ecx
cmpl %eax, %ecx
ja 0x4565
leaq 0x98b0(%rip), %rax      # 0xddf0
movb $0x45, (%rax)
movl $0x45, %edi
callq 0x1ed1
jmp 0x460f
leaq 0x960b(%rip), %rax      # 0xdb64
movl (%rax), %edi
addq $0x10, %rsp
popq %rbx
jmp 0x444b
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x8b0f
movq %rbx, %rdi
callq 0x8e30
leaq 0x96bf(%rip), %rbx      # 0xdc40
movq %rax, (%rbx)
testq %rax, %rax
jne 0x459f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x8b5e
movq (%rbx), %rax
testb $0x10, 0x20(%rax)
je 0x45bc
leaq 0x9841(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ed1
movq (%rbx), %rax
testb $0x8, 0x20(%rax)
je 0x45d9
leaq 0x9824(%rip), %rax      # 0xddf0
movb $0x53, (%rax)
movl $0x53, %edi
callq 0x1ed1
movq (%rbx), %rax
testb $0x1, 0x21(%rax)
jne 0x4613
leaq 0x920b(%rip), %rax      # 0xd7f4
cmpl $0x2, (%rax)
jne 0x4602
leaq 0x97fb(%rip), %rax      # 0xddf0
movb $0x55, (%rax)
movl $0x55, %edi
callq 0x1ed1
leaq 0x97cf(%rip), %rax      # 0xddd8
movl $0x0, (%rax)
xorl %eax, %eax
jmp 0x4617
movq 0x18(%rax), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: evalchar
long evalchar(char t) {
	long con = 0;
	char c;
	while ((c = *lp)) { /* test for end of field */
		lp++;
		if (t != c) /* test for terminator */
			con = (con << 8) + c;
		else if (*lp == t) { /* if double terminator use as char */
			con = (con << 8) + *lp;
			lp++;
		} else
			break; /* terminator found */
	}
	if (!con || con & 0xffff0000) /* error if more than 2 chars or */
		display_error(
		        error = 'V'); /* no characters and no terminator */
	return (con);                 /* end of expression found */
}

// Assembly:
pushq %rbx
movq 0x9cab(%rip), %rax      # 0xe2d0
movb (%rax), %cl
xorl %ebx, %ebx
testb %cl, %cl
je 0x466f
leaq 0x1(%rax), %rdx
movq %rdx, 0x9c98(%rip)      # 0xe2d0
cmpb %dil, %cl
jne 0x465d
movsbq (%rdx), %rcx
cmpb %dil, %cl
jne 0x466f
shlq $0x8, %rbx
addq %rcx, %rbx
addq $0x2, %rax
movq %rax, 0x9c78(%rip)      # 0xe2d0
movq %rax, %rdx
jmp 0x466b
shlq $0x8, %rbx
movsbq %cl, %rax
addq %rax, %rbx
movq %rdx, %rax
movb (%rdx), %cl
jmp 0x4629
testq %rbx, %rbx
setne %al
movq %rbx, %rcx
shrq $0x10, %rcx
testw %cx, %cx
sete %cl
testb %cl, %al
jne 0x469a
leaq 0x9763(%rip), %rax      # 0xddf0
movb $0x56, (%rax)
movl $0x56, %edi
callq 0x1ed1
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: priority
int priority(char c) {
	if (c == '$') return (0);
	if (c == '(') return (1);
	if (c == '+' || c == '-') return (2);
	if (c == '*' || c == '/' || c == '&' || c == '|' || c == '^')
		return (3);
	display_error(error = 'C'); /* invalid operator on stack */
	return (9);
}

// Assembly:
leal -0x24(%rdi), %eax
cmpl $0xb, %eax
ja 0x46bd
leaq 0x5e0e(%rip), %rcx      # 0xa4bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, %eax
retq
cmpl $0x5e, %edi
je 0x46c7
cmpl $0x7c, %edi
jne 0x46cd
movl $0x3, %eax
retq
pushq %rax
leaq 0x971b(%rip), %rax      # 0xddf0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x1ed1
movl $0x9, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: pushval
void pushval(long l) {
	int k = 0;
	do_unary(&l, &k); /* do unary operations before pushing value */
	stack[--vsp] = l; /* push value */
	osp += k;
	lastval = TRUE; /* last item scanned was a value */
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4756
movq (%rbx), %rax
movslq 0x9d4b(%rip), %rcx      # 0xe470
leaq -0x1(%rcx), %rdx
movl %edx, 0x9d41(%rip)      # 0xe470
leaq 0x9baa(%rip), %rdx      # 0xe2e0
movq %rax, -0x8(%rdx,%rcx,8)
movl (%r14), %eax
addl %eax, 0x9d30(%rip)      # 0xe474
movl $0x1, 0x9d2a(%rip)      # 0xe478
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: do_oper
void do_oper() { /* perform binary operations */

	long l = stack[vsp++];
	char c = opstk[osp++];
	if (vsp > MAXESTK) {
		vsp = MAXESTK;
		display_error(error = 'C');
	}
	if (osp > MAXESTK) {
		osp = MAXESTK;
		display_error(error = 'C');
	}
	lastval = TRUE;
	switch (c) {
		case '+':
			stack[vsp] += l;
			break;
		case '-':
			stack[vsp] -= l;
			break;
		case '*':
			stack[vsp] *= l;
			break;
		case '^':
			stack[vsp] ^= l;
			break;
		case '&':
			stack[vsp] &= l;
			break;
		case '|':
			stack[vsp] |= l;
			break;
		case '/':
			if (l)
				stack[vsp] /= l; /* divide by 0? */
			else
				display_error(error = 'E');
			break;
		default:
			display_error(error = 'C');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x9caa(%rip), %rax      # 0xe470
leal 0x1(%rax), %ecx
movslq 0x9ca4(%rip), %rdx      # 0xe474
leal 0x1(%rdx), %esi
movl %ecx, 0x9c97(%rip)      # 0xe470
leaq 0x9b00(%rip), %rbx      # 0xe2e0
movl %esi, 0x9c8e(%rip)      # 0xe474
leaq 0x9c93(%rip), %rcx      # 0xe480
movzbl (%rdx,%rcx), %r15d
movq (%rbx,%rax,8), %r14
cmpq $0x32, %rax
jl 0x481a
movl $0x32, 0x9c6a(%rip)     # 0xe470
leaq 0x95e3(%rip), %rax      # 0xddf0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x1ed1
cmpl $0x33, 0x9c53(%rip)     # 0xe474
jl 0x4841
movl $0x32, 0x9c47(%rip)     # 0xe474
leaq 0x95bc(%rip), %rax      # 0xddf0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x1ed1
movl $0x1, 0x9c2d(%rip)      # 0xe478
leal -0x26(%r15), %eax
cmpl $0x9, %eax
ja 0x4871
leaq 0x5c91(%rip), %rcx      # 0xa4ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq 0x9c05(%rip), %rax      # 0xe470
andq %r14, (%rbx,%rax,8)
jmp 0x48ed
cmpl $0x5e, %r15d
je 0x48e2
cmpl $0x7c, %r15d
jne 0x488a
movslq 0x9bec(%rip), %rax      # 0xe470
orq %r14, (%rbx,%rax,8)
jmp 0x48ed
leaq 0x955f(%rip), %rax      # 0xddf0
movb $0x43, (%rax)
movl $0x43, %edi
jmp 0x4902
movslq 0x9bce(%rip), %rax      # 0xe470
imulq (%rbx,%rax,8), %r14
movq %r14, (%rbx,%rax,8)
jmp 0x48ed
movslq 0x9bbc(%rip), %rax      # 0xe470
addq %r14, (%rbx,%rax,8)
jmp 0x48ed
movslq 0x9baf(%rip), %rax      # 0xe470
subq %r14, (%rbx,%rax,8)
jmp 0x48ed
testq %r14, %r14
je 0x48f3
movslq 0x9b9d(%rip), %rcx      # 0xe470
movq (%rbx,%rcx,8), %rax
cqto
idivq %r14
movq %rax, (%rbx,%rcx,8)
jmp 0x48ed
movslq 0x9b87(%rip), %rax      # 0xe470
xorq %r14, (%rbx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x94f6(%rip), %rax      # 0xddf0
movb $0x45, (%rax)
movl $0x45, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x1ed1
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/express.c
// Function: eval
void eval(char op) {
	int more = TRUE;
	if (op == '_' || op == '<' || op == '>' || op == '~' ||
	    op == '(') { /* unary operators */
		opstk[--osp] = op;
		more = lastval = FALSE;
	}
	while (more)
		if (priority(opstk[osp]) < priority(op)) {
			opstk[--osp] = op;
			more = lastval = FALSE;
		} else
			do_oper();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
leal -0x28(%rbx), %eax
cmpl $0x37, %eax
ja 0x492e
movabsq $0x80000000500001, %rcx # imm = 0x80000000500001
btq %rax, %rcx
jb 0x4933
cmpl $0x7e, %ebx
jne 0x4962
movslq 0x9b3a(%rip), %rax      # 0xe474
leaq -0x1(%rax), %rcx
movl %ecx, 0x9b30(%rip)      # 0xe474
leaq 0x9b35(%rip), %rcx      # 0xe480
movb %bl, -0x1(%rax,%rcx)
movl $0x0, 0x9b1f(%rip)      # 0xe478
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9b17(%rip), %r12      # 0xe480
movsbl %bl, %ebp
movslq 0x9b01(%rip), %rax      # 0xe474
movsbl (%rax,%r12), %edi
callq 0x469f
movl %eax, %r14d
movl %ebp, %edi
callq 0x469f
movl %eax, %r15d
cmpl %eax, %r14d
jae 0x49b1
movslq 0x9ade(%rip), %rax      # 0xe474
leaq -0x1(%rax), %rcx
movl %ecx, 0x9ad4(%rip)      # 0xe474
movb %bl, -0x1(%rax,%r12)
movl $0x0, 0x9ac9(%rip)      # 0xe478
jmp 0x49b6
callq 0x47ba
cmpl %r15d, %r14d
jae 0x496c
jmp 0x4959
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/help.c
// Function: help
void help() {
	printf("\nthe assembler command line consists of the file names and "
	       "switches\n");
	printf("\nC65> "
	       "[object],[listing]=source[,source]...[,source][/switch]...[/"
	       "switch]\n");
	printf("\nItems enclosed in brackets [...] are optional.\n");
	printf("\nThe default file extentions are .obj , .lst and .src\n");
	printf("\nSwitches  (either upper or lower case)\n");
	printf("/A absolute assembly (default)\n");
	printf("/Cn cpu instruction set /C0 for NMOS 6502   /C1 for CMOS "
	       "6502\n");
	printf("     /C2 for CMOS 6502 w/bit instructions   /C3 for Commodore "
	       "4502 (default)\n");
	printf("/Dpath specify path for intermediate file ( usually RAM disk "
	       "on PCs).\n");
	printf("/H help - prints this message\n");
	printf("/L assume long branches on pass1. (default= assume short "
	       "branches)\n");
	printf("/Mnnn maximum macro nesting depth (default=50, "
	       "limits=2-999).\n");
	printf("/Pnn maximum number of passes to try (default=15, "
	       "limits=2-99).\n");
	printf("/N don't print errors to console during assembly\n");
	printf("/R relocatable assembly - illegal since this is an absolute "
	       "assembler only\n");
	printf("/S narrow list format\n");
	printf("/T don't print symbol table\n");
	printf("/V don't print cross reference\n");
	printf("/X print cross reference (default)\n");
}

// Assembly:
pushq %rax
leaq 0x57fb(%rip), %rdi      # 0xa587
callq 0x1090
leaq 0x5833(%rip), %rdi      # 0xa5cb
callq 0x1090
leaq 0x5871(%rip), %rdi      # 0xa615
callq 0x1090
leaq 0x5895(%rip), %rdi      # 0xa645
callq 0x1090
leaq 0x58bf(%rip), %rdi      # 0xa67b
callq 0x1090
leaq 0x58db(%rip), %rdi      # 0xa6a3
callq 0x1090
leaq 0x58ee(%rip), %rdi      # 0xa6c2
callq 0x1090
leaq 0x5920(%rip), %rdi      # 0xa700
callq 0x1090
leaq 0x5961(%rip), %rdi      # 0xa74d
callq 0x1090
leaq 0x599b(%rip), %rdi      # 0xa793
callq 0x1090
leaq 0x59ad(%rip), %rdi      # 0xa7b1
callq 0x1090
leaq 0x59e4(%rip), %rdi      # 0xa7f4
callq 0x1090
leaq 0x5a16(%rip), %rdi      # 0xa832
callq 0x1090
leaq 0x5a4a(%rip), %rdi      # 0xa872
callq 0x1090
leaq 0x5a6f(%rip), %rdi      # 0xa8a3
callq 0x1090
leaq 0x5aae(%rip), %rdi      # 0xa8ee
callq 0x1090
leaq 0x5ab8(%rip), %rdi      # 0xa904
callq 0x1090
leaq 0x5ac8(%rip), %rdi      # 0xa920
callq 0x1090
leaq 0x5adb(%rip), %rdi      # 0xa93f
popq %rax
jmp 0x1090
nop
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/macrodef.c
// Function: macro_tab
void macro_tab() {
	long s = 0;
	int i = 0;
	char *p;
	if ((tmpmac = macro_head))
		fprintf(file_lst,
		        "\n\n size  name                            "
		        "parameters\n");
	while (tmpmac) {
		i++;
		s += tmpmac->size;
		fprintf(file_lst, "%5u. %-31s", tmpmac->size, tmpmac->name);
		p = tmpmac->name;
		while (*p++)
			;
		while (*p) {
			fprintf(file_lst, " %s", p);
			while (*p++)
				;
		}
		fprintf(file_lst, "\n");
		tmpmac = tmpmac->nextmac;
	}
	if (macro_head)
		fprintf(file_lst,
		        "\nMemory used to store %d macro definitions: %ld. "
		        "bytes.\n",
		        i, s);
	else
		fprintf(file_lst, "\n\nNo macros defined.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7f84(%rip), %rax      # 0xdaa8
movq (%rax), %rax
leaq 0x814a(%rip), %r13      # 0xdc78
movq %rax, (%r13)
testq %rax, %rax
je 0x5b57
leaq 0x7f52(%rip), %rax      # 0xda90
movq (%rax), %rcx
leaq 0x4ee2(%rip), %rdi      # 0xaa2a
movl $0x34, %esi
movl $0x1, %edx
callq 0x1210
movq (%r13), %rcx
testq %rcx, %rcx
je 0x5bf4
leaq 0x7f25(%rip), %r14      # 0xda90
leaq 0x4ef8(%rip), %r15      # 0xaa6a
xorl %ebp, %ebp
xorl %ebx, %ebx
movl 0x8(%rcx), %r12d
movq (%r14), %rdi
addq $0xc, %rcx
leaq 0x4ed7(%rip), %rsi      # 0xaa5f
movl %r12d, %edx
xorl %eax, %eax
callq 0x1140
movq (%r13), %r13
addq $0xc, %r13
cmpb $0x0, (%r13)
leaq 0x1(%r13), %r13
jne 0x5b9a
jmp 0x5bc2
movq (%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1140
cmpb $0x0, (%r13)
leaq 0x1(%r13), %r13
jne 0x5bb7
cmpb $0x0, (%r13)
jne 0x5ba7
incl %ebp
addq %r12, %rbx
movq (%r14), %rsi
movl $0xa, %edi
callq 0x1110
leaq 0x8096(%rip), %r13      # 0xdc78
movq (%r13), %rax
movq (%rax), %rcx
movq %rcx, (%r13)
testq %rcx, %rcx
jne 0x5b76
jmp 0x5bf8
xorl %ebx, %ebx
xorl %ebp, %ebp
leaq 0x7ea9(%rip), %rax      # 0xdaa8
cmpq $0x0, (%rax)
leaq 0x7e86(%rip), %rax      # 0xda90
movq (%rax), %rcx
je 0x5c33
leaq 0x4e58(%rip), %rsi      # 0xaa6e
movq %rcx, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
leaq 0x4e6d(%rip), %rdi      # 0xaaa7
movl $0x15, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1210
nop
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/opcode.c
// Function: opcode
void opcode() {
	int i;
	for (wrt = i = 0; nmi[i]; i += 2)
		wrt |= s2[0] == nmi[i] &&
		       s2[1] == nmi[i + 1] && /* is a write and */
		       ((s3[0] != 'a' && s3[0] != 'A') ||
		        s3[1]); /* not accumulator */
	addr = print = data = known = 1;
	i = d[0] = parseopr();
	if (data) {
		loc_cntr += data; /* increment the current location counter */
		if (mpulevel[i & 255] > cputype) display_error(error = 'I');
	}
}

// Assembly:
pushq %rbx
leaq 0x817c(%rip), %rax      # 0xdddc
movl $0x0, (%rax)
movb 0x7a13(%rip), %r8b      # 0xd680
testb %r8b, %r8b
je 0x5cd3
movl (%rax), %ecx
leaq 0x841d(%rip), %rdx      # 0xe098
movq (%rdx), %rdx
leaq 0x841b(%rip), %rsi      # 0xe0a0
movq (%rsi), %rsi
leaq 0x79f3(%rip), %rdi      # 0xd682
xorl %r9d, %r9d
cmpb %r8b, (%rdx)
jne 0x5cc2
movb 0x1(%rdx), %r8b
cmpb -0x1(%rdi), %r8b
jne 0x5cc2
movzbl (%rsi), %r8d
orl $0x20, %r8d
cmpl $0x61, %r8d
jne 0x5cbc
xorl %r9d, %r9d
cmpb $0x0, 0x1(%rsi)
setne %r9b
jmp 0x5cc2
movl $0x1, %r9d
orl %r9d, %ecx
movl %ecx, (%rax)
movb (%rdi), %r8b
addq $0x2, %rdi
testb %r8b, %r8b
jne 0x5c8f
leaq 0x85e9(%rip), %rax      # 0xe2c3
movb $0x1, %cl
movb %cl, (%rax)
leaq 0x85dc(%rip), %rbx      # 0xe2c1
movb %cl, (%rbx)
leaq 0x80fe(%rip), %rax      # 0xddec
movl $0x1, (%rax)
leaq 0x85c5(%rip), %rax      # 0xe2c0
movb %cl, (%rax)
callq 0x5da3
leaq 0x84b7(%rip), %rcx      # 0xe1c0
movb %al, (%rcx)
movsbq (%rbx), %rcx
testq %rcx, %rcx
je 0x5d4c
leaq 0x7af5(%rip), %rdx      # 0xd810
addq %rcx, (%rdx)
movzbl %al, %eax
leaq 0x7418(%rip), %rcx      # 0xd140
movsbl (%rax,%rcx), %eax
leaq 0x7b85(%rip), %rcx      # 0xd8b8
cmpl %eax, (%rcx)
jge 0x5d4c
leaq 0x80b2(%rip), %rax      # 0xddf0
movb $0x49, (%rax)
movl $0x49, %edi
popq %rbx
jmp 0x1ed1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/opcode.c
// Function: searchstr
int searchstr(char *str, char *key, int size) {
	int i, j, k;
	for (i = j = 0; str[i]; i += size, j++) {
		for (k = 0; k < size && str[i + k] == key[k]; k++)
			;
		if (k == size) return (j);
	}
	return (-1);
}

// Assembly:
cmpb $0x0, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
je 0x5da2
pushq %rbp
pushq %rbx
movl %edx, %ecx
movslq %edx, %r8
xorl %r9d, %r9d
movq %rdi, %r10
xorl %r11d, %r11d
movl $0x0, %ebx
testl %edx, %edx
jle 0x5d87
xorl %ebx, %ebx
movb (%r10,%rbx), %bpl
cmpb (%rsi,%rbx), %bpl
jne 0x5d87
incq %rbx
cmpq %rbx, %rcx
jne 0x5d73
movl %ecx, %ebx
cmpl %edx, %ebx
je 0x5d9d
addq %r8, %r9
incl %r11d
addq %r8, %r10
cmpb $0x0, (%rdi,%r9)
jne 0x5d68
jmp 0x5da0
movl %r11d, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/outline.c
// Function: outhex
void outhex(unsigned int addr, char data) {
	if (!binptr) {
		sprintf(binbuf, ";00%04X", binadr = addr);
		chksum = addr >> 8 & 255;
		chksum += addr & 255;
		binptr = 5;
	}
	if (addr == binadr && binptr < 37) {
		sprintf(&binbuf[binptr += 2], "%02X", data & 255);
		chksum += data & 255;
		binadr++;
	} else {
		int i = (binptr - 5) / 2;
		chksum += i;
		if (i > 15) {
			binbuf[1] = '1';
			i &= 15;
		}
		binbuf[2] = i + (i > 9 ? '7' : '0');
		sprintf(&binbuf[binptr += 2], "%04X\0", chksum);
		fprintf(file_obj, "%s\n", binbuf);
		binlin++;
		binptr = 0;
		outhex(addr, data);
	}
	binadr = addr + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
leaq 0x5d4a(%rip), %r15      # 0xd800
cmpl $0x0, (%r15)
jne 0x7afc
leaq 0x5d41(%rip), %rax      # 0xd804
movl %ebx, (%rax)
leaq 0x61c4(%rip), %rdi      # 0xdc90
leaq 0x3123(%rip), %rsi      # 0xabf6
movl %ebx, %edx
xorl %eax, %eax
callq 0x11f0
movl %ebx, %eax
shrl $0x8, %eax
movl $0xff, %ecx
andl %ecx, %eax
andl %ebx, %ecx
addl %eax, %ecx
leaq 0x5d09(%rip), %rax      # 0xd7fc
movl %ecx, (%rax)
movl $0x5, (%r15)
leaq 0x5d01(%rip), %r12      # 0xd804
cmpl %ebx, (%r12)
sete %cl
movl (%r15), %eax
movslq %eax, %rdi
cmpl $0x25, %eax
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x7b51
addq $0x2, %rdi
movl %edi, (%r15)
addq 0x54c5(%rip), %rdi      # 0xcff0
movzbl %bpl, %ebp
leaq 0x3062(%rip), %rsi      # 0xab98
movl %ebp, %edx
xorl %eax, %eax
callq 0x11f0
leaq 0x5cb6(%rip), %rax      # 0xd7fc
addl %ebp, (%rax)
incl (%r12)
jmp 0x7be8
leal -0x5(%rax), %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
addl $-0x5, %ecx
sarl %ecx
leaq 0x5c97(%rip), %rsi      # 0xd7fc
movl (%rsi), %edx
addl %ecx, %edx
movl %edx, (%rsi)
cmpl $0x25, %eax
jl 0x7b7e
leaq 0x6119(%rip), %rsi      # 0xdc90
movb $0x31, 0x1(%rsi)
andl $0xf, %ecx
leal 0x30(%rcx), %esi
leal 0x37(%rcx), %r8d
cmpl $0xa, %ecx
cmovll %esi, %r8d
leaq 0x60fd(%rip), %r14      # 0xdc90
movb %r8b, 0x2(%r14)
addl $0x2, %eax
movl %eax, (%r15)
addq %r14, %rdi
addq $0x2, %rdi
leaq 0x3053(%rip), %rsi      # 0xabfe
xorl %eax, %eax
callq 0x11f0
leaq 0x5c6f(%rip), %rax      # 0xd828
movq (%rax), %rdi
leaq 0x28ee(%rip), %rsi      # 0xa4b1
movq %r14, %rdx
xorl %eax, %eax
callq 0x1140
leaq 0x5c34(%rip), %rax      # 0xd808
incl (%rax)
movl $0x0, (%r15)
movsbl %bpl, %esi
movl %ebx, %edi
callq 0x7aa3
incl %ebx
movl %ebx, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/outline.c
// Function: outline
void outline(char addr, char data, char *d, char equ, char known) {
	int i;
	linenum++;
	outline1(file_tmp, addr, data, d, equ, known);
	if (prnerrcon && *error_field != ' ' && pass == 2) {
		outline1(stdout, addr, data, d, equ, known);
		errcount--;
	}
	print = error = 0;
	dbyt = byte = word = FALSE;
	spechar = ' ';
	if (!equ) codebytes += data;
	if (emitobj && pass == 2 && !equ)
		for (i = 0; i < data; i++)
			outhex((unsigned int)(old_loc + i), d[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r14d
movq %rdx, %rbx
leaq 0x5f66(%rip), %rax      # 0xdb78
incl (%rax)
movl %esi, %ebp
movl %edi, %r12d
leaq 0x5b28(%rip), %rax      # 0xd748
movq (%rax), %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x7694
leaq 0x5bbb(%rip), %rax      # 0xd7f8
cmpl $0x0, (%rax)
leaq 0x5bad(%rip), %r13      # 0xd7f4
je 0x7c87
leaq 0x6020(%rip), %rax      # 0xdc70
cmpb $0x20, (%rax)
je 0x7c87
cmpl $0x2, (%r13)
jne 0x7c87
movq 0x5365(%rip), %rax      # 0xcfc8
movq (%rax), %rdi
movsbl %r12b, %esi
movsbl %bpl, %edx
movsbl %r14b, %r8d
movsbl %r15b, %r9d
movq %rbx, %rcx
callq 0x7694
leaq 0x5b93(%rip), %rax      # 0xd818
decl (%rax)
leaq 0x6162(%rip), %rax      # 0xddf0
movb $0x0, (%rax)
leaq 0x6154(%rip), %rax      # 0xddec
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0x5df9(%rip), %rax      # 0xda9c
movl %ecx, (%rax)
leaq 0x5dec(%rip), %rax      # 0xda98
movl %ecx, (%rax)
leaq 0x5deb(%rip), %rax      # 0xdaa0
movl %ecx, (%rax)
leaq 0x5f58(%rip), %rax      # 0xdc16
movb $0x20, (%rax)
testb %r14b, %r14b
jne 0x7cd4
movsbq %bpl, %rax
leaq 0x5b17(%rip), %rcx      # 0xd7e8
addq %rax, (%rcx)
testb %r14b, %r14b
setne %al
leaq 0x5b3f(%rip), %rcx      # 0xd820
cmpl $0x0, (%rcx)
sete %cl
cmpl $0x2, (%r13)
setne %dl
orb %cl, %dl
testb %bpl, %bpl
setle %cl
orb %al, %cl
orb %dl, %cl
jne 0x7d24
movzbl %bpl, %r14d
xorl %r15d, %r15d
leaq 0x60c5(%rip), %r12      # 0xddd0
movl (%r12), %edi
addl %r15d, %edi
movsbl (%rbx,%r15), %esi
callq 0x7aa3
incq %r15
cmpq %r15, %r14
jne 0x7d0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/pass1.c
// Function: good_symbol
int good_symbol(char *p) {
	int i = 1;
	if (isalpha(*p) || *p == '.' || *p == '_') /* global symbol */
		for (; i < 32 && p[i]; i++)
			if (!isalpha(p[i]) && !isdigit(p[i]) && p[i] != '.' &&
			    p[i] != '_' & p[i] != '$') {
				display_error(error = 'C');
				return (0);
			}
	return (1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1230
movq (%rax), %rcx
movsbq (%rbx), %rax
movzwl (%rcx,%rax,2), %edx
btl $0xa, %edx
jb 0x7d60
movzbl %al, %edx
cmpl $0x5f, %edx
je 0x7d60
movl $0x1, %eax
cmpl $0x2e, %edx
jne 0x7db6
movl $0x1, %edx
movl $0x1, %eax
movsbq (%rbx,%rdx), %rsi
testq %rsi, %rsi
je 0x7db6
cmpb $0x2e, %sil
je 0x7d95
movzwl (%rcx,%rsi,2), %edi
andl $0xc00, %edi            # imm = 0xC00
jne 0x7d95
cmpb $0x24, %sil
je 0x7d95
movzbl %sil, %esi
cmpl $0x5f, %esi
jne 0x7da0
incq %rdx
cmpq $0x20, %rdx
jne 0x7d6a
jmp 0x7db6
leaq 0x6049(%rip), %rax      # 0xddf0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x1ed1
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/pass1.c
// Function: good_label
int good_label(char *p) {
	int i;

	if (!*p) return (1); /* empty labels are okay */
	if (isdigit(*p)) {   /* must be a local symbol */
		for (i = error = 0; isdigit(*p) && *p; p++)
			i = i * 10 + *p - '0';
		if (*p++ != '$') display_error(error = 'F');
		if (*p) display_error(error = 'F');
		if (i > 255 || i < 1) display_error(error = 'F');
		return (!error);
	}
	return (good_symbol(p));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movsbq (%rdi), %r14
testq %r14, %r14
je 0x7de4
movq %rdi, %rbx
callq 0x1230
movq (%rax), %rcx
testb $0x8, 0x1(%rcx,%r14,2)
jne 0x7dee
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7d34
movl $0x1, %eax
jmp 0x7e8e
leaq 0x5ffb(%rip), %r14      # 0xddf0
movb $0x0, (%r14)
movsbq (%rbx), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x7e4b
movq (%rax), %rax
movzwl (%rax,%rcx,2), %edx
andl $0x800, %edx            # imm = 0x800
je 0x7e4b
xorl %edx, %edx
movsbl %cl, %ecx
leal (%rdx,%rdx,4), %edx
leal (%rcx,%rdx,2), %edx
addl $-0x30, %edx
movsbq 0x1(%rbx), %rcx
incq %rbx
testq %rcx, %rcx
je 0x7e3b
movzwl (%rax,%rcx,2), %esi
andl $0x800, %esi            # imm = 0x800
jne 0x7e16
addl $0xffffff00, %edx       # imm = 0xFFFFFF00
cmpl $0xffffff01, %edx       # imm = 0xFFFFFF01
setb %bpl
cmpb $0x24, %cl
je 0x7e5e
movb $0x46, (%r14)
movl $0x46, %edi
callq 0x1ed1
cmpb $0x0, 0x1(%rbx)
je 0x7e72
movb $0x46, (%r14)
movl $0x46, %edi
callq 0x1ed1
testb %bpl, %bpl
je 0x7e85
movb $0x46, (%r14)
movl $0x46, %edi
callq 0x1ed1
xorl %eax, %eax
cmpb $0x0, (%r14)
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/pass1.c
// Function: get_label
void get_label(char *p, int endlocal) {
	if (!*p || isspace(*p)) return; /* no label */
	addr = TRUE;
	if (isdigit(*p)) { /* must be a local symbol */
		int i;
		char s[32];
		for (i = 0; isdigit(*p) && *p; p++) i = i * 10 + *p - '0';
		makelocal(i, s);
		insert_symbol(s, loc_cntr, 1, 1, 1);
	} else {
		insert_symbol(p, loc_cntr, 1, 1, 0);
		if (endlocal) clear_local();
	}
	ptr->label = TRUE;
	if (ptr->multiple) display_error(error = 'M');
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsbq (%rdi), %r14
testq %r14, %r14
je 0x7fab
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1230
movq (%rax), %rcx
testb $0x20, 0x1(%rcx,%r14,2)
jne 0x7fab
leaq 0x63f8(%rip), %rcx      # 0xe2c0
movb $0x1, (%rcx)
movq (%rax), %rcx
movsbq (%rbx), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x7f05
leaq 0x5930(%rip), %rax      # 0xd810
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8b5e
testl %ebp, %ebp
je 0x7f78
xorl %eax, %eax
callq 0x9127
jmp 0x7f78
movsbq (%rbx), %rcx
xorl %edi, %edi
testq %rcx, %rcx
je 0x7f4b
movq (%rax), %rax
movzwl (%rax,%rcx,2), %edx
andl $0x800, %edx            # imm = 0x800
je 0x7f4b
incq %rbx
xorl %edi, %edi
movsbl %cl, %ecx
leal (%rdi,%rdi,4), %edx
leal (%rcx,%rdx,2), %edi
addl $-0x30, %edi
movsbq (%rbx), %rcx
testq %rcx, %rcx
je 0x7f4b
movzwl (%rax,%rcx,2), %edx
andl $0x800, %edx            # imm = 0x800
incq %rbx
testw %dx, %dx
jne 0x7f24
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x8b0f
leaq 0x58b3(%rip), %rax      # 0xd810
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x8b5e
leaq 0x5cc1(%rip), %rax      # 0xdc40
movq (%rax), %rax
movzwl 0x20(%rax), %ecx
movl %ecx, %edx
orl $0x200, %edx            # imm = 0x200
movw %dx, 0x20(%rax)
testb $0x8, %cl
je 0x7fab
leaq 0x5e52(%rip), %rax      # 0xddf0
movb $0x4d, (%rax)
movl $0x4d, %edi
callq 0x1ed1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: allocsym
char *allocsym(int symlen) {
	/* returns a pointer for use as a symbol table entry */

	int symptr = symbol_ptr;
	symbol_ptr += sizeof(struct smbl) - 31 + symlen;
	if (symbol_ptr >= SYMBLKSZ) {
		symbol_buf = (char *)calloc(SYMBLKSZ, 1);
		if (!symbol_buf)
			error_msg("Available memory exceeded storing symbol",
			          "", 4);
		symptr = 0;
		symbol_ptr = sizeof(struct smbl) - 31 + symlen;
		symblk++;
	}
	return (symbol_buf + symptr);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x4f13(%rip), %eax      # 0xd69c
leal (%rax,%rbx), %ecx
addl $0x29, %ecx
movl %ecx, 0x4f07(%rip)      # 0xd69c
cmpl $0x1000, %ecx           # imm = 0x1000
jl 0x87e1
addl $0x29, %ebx
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x1120
movq %rax, 0x5d12(%rip)      # 0xe4c8
testq %rax, %rax
jne 0x87d3
leaq 0x2484(%rip), %rdi      # 0xac46
leaq 0x236e(%rip), %rsi      # 0xab37
movl $0x4, %edx
callq 0x1e94
movl %ebx, 0x4ec3(%rip)      # 0xd69c
incl 0x4eb9(%rip)            # 0xd698
xorl %eax, %eax
cltq
addq 0x5cde(%rip), %rax      # 0xe4c8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: move
void move() {
	if (direction[level] == direction[level + 1]) {
		head(level + 1);
		xchg(level, level + 1);
		path[level]->weight = path[level + 1]->weight = BALANCED;
	} else {
		head(level + 2);
		xchg(level, level + 2);
		xchg(level + 1, level + 2);
		path[level + 2]->weight = BALANCED;
		if (direction[level + 1] == direction[level + 2]) {
			path[level]->weight = BALANCED;
			path[level + 1]->weight = !direction[level + 1];
		} else if (direction[level + 2] != BALANCED) {
			path[level]->weight = !direction[level];
			path[level + 1]->weight = BALANCED;
		} else
			path[level]->weight = path[level + 1]->weight =
			        BALANCED;
	}
}

// Assembly:
pushq %rbx
movslq 0x5c2d(%rip), %rdi      # 0xe4d0
leaq 0x5d26(%rip), %rbx      # 0xe5d0
movl (%rbx,%rdi,4), %eax
cmpl 0x4(%rbx,%rdi,4), %eax
jne 0x8929
incq %rdi
callq 0x87ec
movslq 0x5c0e(%rip), %rax      # 0xe4d0
leaq 0x5c17(%rip), %rcx      # 0xe4e0
movq (%rcx,%rax,8), %rdx
movq 0x8(%rcx,%rax,8), %rsi
movzwl 0x20(%rdx), %edi
xorl %r8d, %r8d
andl $0x3, %edi
sete %r8b
movq (%rsi,%r8,8), %rsi
movl %edi, %edi
movq %rsi, (%rdx,%rdi,8)
movq (%rcx,%rax,8), %rdx
movq 0x8(%rcx,%rax,8), %rsi
movzwl 0x20(%rdx), %edi
xorl %r8d, %r8d
testb $0x3, %dil
sete %r8b
movq %rdx, (%rsi,%r8,8)
movq 0x8(%rcx,%rax,8), %rdx
movl 0x20(%rdx), %esi
andl $-0x4, %esi
orl $0x2, %esi
movw %si, 0x20(%rdx)
movq (%rcx,%rax,8), %rax
addq $0x20, %rax
movw $0x2, %dx
jmp 0x89fb
addl $0x2, %edi
callq 0x87ec
movslq 0x5b98(%rip), %rax      # 0xe4d0
leaq 0x5ba1(%rip), %rcx      # 0xe4e0
movq (%rcx,%rax,8), %rdx
movq 0x10(%rcx,%rax,8), %rsi
movzwl 0x20(%rdx), %edi
xorl %r8d, %r8d
andl $0x3, %edi
sete %r8b
movq (%rsi,%r8,8), %rsi
movl %edi, %edi
movq %rsi, (%rdx,%rdi,8)
movq (%rcx,%rax,8), %rdx
movq 0x10(%rcx,%rax,8), %rsi
movzwl 0x20(%rdx), %edi
xorl %r8d, %r8d
testb $0x3, %dil
sete %r8b
movq %rdx, (%rsi,%r8,8)
movq 0x8(%rcx,%rax,8), %rdx
movq 0x10(%rcx,%rax,8), %rsi
movzwl 0x20(%rdx), %edi
xorl %r8d, %r8d
andl $0x3, %edi
sete %r8b
movq (%rsi,%r8,8), %rsi
movl %edi, %edi
movq %rsi, (%rdx,%rdi,8)
movq 0x8(%rcx,%rax,8), %rdx
movq 0x10(%rcx,%rax,8), %rsi
movzwl 0x20(%rdx), %edi
xorl %r8d, %r8d
testb $0x3, %dil
sete %r8b
movq %rdx, (%rsi,%r8,8)
movq 0x10(%rcx,%rax,8), %rdx
movl 0x20(%rdx), %esi
andl $-0x4, %esi
orl $0x2, %esi
movw %si, 0x20(%rdx)
movl 0x8(%rbx,%rax,4), %edx
cmpl %edx, 0x4(%rbx,%rax,4)
jne 0x8a0a
movq (%rcx,%rax,8), %rdx
movl 0x20(%rdx), %esi
andl $-0x4, %esi
orl $0x2, %esi
movw %si, 0x20(%rdx)
xorl %edx, %edx
cmpl $0x0, 0x4(%rbx,%rax,4)
sete %dl
movq 0x8(%rcx,%rax,8), %rax
addq $0x20, %rax
movl (%rax), %ecx
andl $-0x4, %ecx
movzwl %dx, %edx
orl %ecx, %edx
movw %dx, (%rax)
popq %rbx
retq
cmpl $0x2, %edx
je 0x8906
xorl %edx, %edx
cmpl $0x0, (%rbx,%rax,4)
sete %dl
movq (%rcx,%rax,8), %rsi
movl 0x20(%rsi), %edi
andl $-0x4, %edi
orl %edx, %edi
movw %di, 0x20(%rsi)
movq 0x8(%rcx,%rax,8), %rax
jmp 0x891c
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: addref
void addref(struct xrfr **xref, int def) {
	struct xrfr *new;
	if (pass > 1) return;
	if (--xrefcnt <= 0) {
		xrefcnt = XREFALLOC;
		if (!(xrefheap = (struct xrfr *)calloc(XREFALLOC,
		                                       sizeof(struct xrfr))))
			error_msg("Available memory exceeded adding reference",
			          "", 4);
	}
	new = xrefheap++;        /* pointer to memory to be used for xref */
	new->linenumb = linenum; /* line number of reference */
	new->def = def;          /* is symbol defined on this line? */
	new->wrt = wrt;          /* is it a write operation to this symbol? */
	new->known = ptr->known; /* is symbol defined at this point? */
	new->next = *xref;       /* pointer to next reference */
	*xref = new;             /* add the reference to the list */
}

// Assembly:
leaq 0x4db7(%rip), %rax      # 0xd7f4
cmpl $0x1, (%rax)
jg 0x8b0e
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x5a6c(%rip), %eax      # 0xe4c0
leal -0x1(%rax), %ecx
movl %ecx, 0x5a63(%rip)      # 0xe4c0
cmpl $0x1, %eax
jg 0x8a9f
movl $0x200, 0x5a54(%rip)    # imm = 0x200
movl $0x200, %edi            # imm = 0x200
movl $0x10, %esi
callq 0x1120
movq %rax, 0x5bc6(%rip)      # 0xe648
testq %rax, %rax
jne 0x8a9f
leaq 0x21e1(%rip), %rdi      # 0xac6f
leaq 0x20a2(%rip), %rsi      # 0xab37
movl $0x4, %edx
callq 0x1e94
movq 0x5ba2(%rip), %rax      # 0xe648
leaq 0x10(%rax), %rcx
movq %rcx, 0x5b97(%rip)      # 0xe648
leaq 0x50c0(%rip), %rcx      # 0xdb78
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movb 0x8(%rax), %cl
andb $0x1, %bpl
andb $-0x2, %cl
orb %bpl, %cl
movb %cl, 0x8(%rax)
leaq 0x5308(%rip), %rdx      # 0xdddc
movb (%rdx), %dl
addb %dl, %dl
andb $0x2, %dl
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0x8(%rax)
leaq 0x5156(%rip), %rdx      # 0xdc40
movq (%rdx), %rdx
movzwl 0x20(%rdx), %edx
shrl $0x6, %edx
andb $0x4, %dl
andb $-0x5, %cl
orb %dl, %cl
movb %cl, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: makelocal
void makelocal(int i, char *s) {
	/*
	        local symbols are stored in the permanent symbol table. The only
	        difference between permanent and local symbols is that cross
	        references to local symbols are not kept and that local symbols
	        are not printed in the symbol table listing.

	        local symbol names consist of a - follow by a 4 character
	        base 26 local symbol block number AAAA BAAA CAAA ... YZZZ ZZZZ,
	        followed by the 2 hex digit local symbol number. this function
	        creates the local symbol name.
	*/
	int j = i >> 4 & 15;
	i &= 15;
	s[0] = '-';    /* the first character indicating a local symbol */
	s[1] = lbn[0]; /* the local symbol block number */
	s[2] = lbn[1];
	s[3] = lbn[2];
	s[4] = lbn[3];
	s[5] = j + (j > 9 ? '7' : '0'); /* the local symbol number in hex */
	s[6] = i + (i > 9 ? '7' : '0');
	s[7] = 0; /* null to terminate string */
}

// Assembly:
movl %edi, %eax
shrl $0x4, %eax
andl $0xf, %eax
andl $0xf, %edi
movb $0x2d, (%rsi)
leaq 0x4cf8(%rip), %rcx      # 0xd81c
movb (%rcx), %dl
movb %dl, 0x1(%rsi)
movb 0x1(%rcx), %dl
movb %dl, 0x2(%rsi)
movb 0x2(%rcx), %dl
movb %dl, 0x3(%rsi)
movb 0x3(%rcx), %cl
movb %cl, 0x4(%rsi)
leal 0x30(%rax), %ecx
leal 0x37(%rax), %edx
cmpl $0xa, %eax
cmovbl %ecx, %edx
movb %dl, 0x5(%rsi)
leal 0x30(%rdi), %eax
leal 0x37(%rdi), %ecx
cmpl $0xa, %edi
cmovbl %eax, %ecx
movb %cl, 0x6(%rsi)
movb $0x0, 0x7(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: find_symbol
struct smbl *find_symbol(char *sym) { /* find the address of a symbol's entry */
	struct smbl *pntr;
	int i;
	pntr = root_symtab;
	while (pntr)                             /* while not a terminal node */
		if ((i = strcmp(pntr->name, sym))) /* if symbol name not equal */
			pntr = pntr->link[i <
			                  0]; /* try the appropriate sub-node */
		else
			return (pntr); /* found the symbol in table */
	return (NULL);                 /* symbol not found */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4c75(%rip), %rax      # 0xdab0
movq (%rax), %rbx
testq %rbx, %rbx
je 0x8e62
movq %rdi, %r14
leaq 0x22(%rbx), %rdi
movq %r14, %rsi
callq 0x1130
testl %eax, %eax
je 0x8e64
shrl $0x1f, %eax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
jne 0x8e46
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: output_symbol
void output_symbol(struct smbl *pntr) {
	char c;
	symknt++;
	if (pntr->link[0]) output_symbol(pntr->link[0]);
	if (pntr->name[0] == '-')
		locknt++;
	else {
		c = ' ';
		if (pntr->equate) c = '=';   /* equated symbol */
		if (pntr->multiple) c = 'M'; /* multiply defined symbol */
		if (!pntr->defined) c = '?'; /* undefined symbol */
		if (pntr->section) c = 'S';  /* program section name */
		fprintf(file_lst, "\n%c %04lX %-31s ", c, pntr->value & 0xffffL,
		        pntr->name);
		if (prnxref) prnref(pntr->xref);
	}
	if (pntr->link[1]) output_symbol(pntr->link[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3f, %r15d
leaq 0x4c06(%rip), %r12      # 0xda90
movl $0x53, %r13d
leaq 0x1e03(%rip), %r14      # 0xac9a
leaq 0x4abe(%rip), %rbp      # 0xd95c
incl 0x57ac(%rip)            # 0xe650
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8eb1
callq 0x8e6f
cmpb $0x2d, 0x22(%rbx)
jne 0x8ebf
incl 0x5797(%rip)            # 0xe654
jmp 0x8f0c
movzwl 0x20(%rbx), %eax
movl $0x20, %edx
testb $0x20, %al
je 0x8ed1
movl $0x3d, %edx
leaq 0x22(%rbx), %r8
testb $0x8, %al
movl $0x4d, %ecx
cmovnel %ecx, %edx
testb $0x4, %al
cmovel %r15d, %edx
testb $0x10, %al
movq (%r12), %rdi
cmovnel %r13d, %edx
movzwl 0x18(%rbx), %ecx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
cmpl $0x0, (%rbp)
je 0x8f0c
movq 0x10(%rbx), %rdi
callq 0x8f24
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x8e9e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: prnref
void prnref(struct xrfr *tmp) {
	int i = 0;
	char c;
	while (tmp) {
		c = ' '; /* nothing interesting about this reference */
		if (tmp->def)
			c = '#'; /* symbol defined on this line */
		else if (tmp->wrt)
			c = '$'; /* symbol is operand of write instruction */
		else if (!tmp->known)
			c = '?'; /* symbol is undefined here */
		fprintf(file_lst, "%6d%c", tmp->linenumb, c);
		tmp = tmp->next;
		refknt++;
		i++;
		if (i > (wide ? 12 : 4)) {
			i = 0;
			fprintf(file_lst, "\n       %31s ", " ");
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x8fdd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4b4e(%rip), %r13      # 0xda90
leaq 0x1e4c(%rip), %r14      # 0xad95
leaq 0x4a14(%rip), %rbp      # 0xd964
leaq 0x1133(%rip), %r12      # 0xa08a
xorl %r15d, %r15d
movb 0x8(%rbx), %al
movl $0x23, %ecx
testb $0x1, %al
jne 0x8f7e
movl $0x24, %ecx
testb $0x2, %al
jne 0x8f7e
testb $0x4, %al
movl $0x20, %ecx
movl $0x3f, %eax
cmovel %eax, %ecx
movq (%r13), %rdi
movl 0xc(%rbx), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
movq (%rbx), %rbx
incl 0x56c0(%rip)            # 0xe658
xorl %eax, %eax
cmpl $0x0, (%rbp)
setne %al
leal 0x4(,%rax,8), %eax
cmpl %eax, %r15d
jge 0x8fb2
incl %r15d
jmp 0x8fca
movq (%r13), %rdi
xorl %r15d, %r15d
leaq 0x1ddb(%rip), %rsi      # 0xad9b
movq %r12, %rdx
xorl %eax, %eax
callq 0x1140
testq %rbx, %rbx
jne 0x8f5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq