LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: constnode
Tree constnode(unsigned n, Type ty) {
	Tree p;

	if (isarray(ty))
		p = tree(CNST+P, atop(ty), 0, 0);
	else
		p = tree(CNST + ttob(ty), ty, 0, 0);
	p->u.v.u = n;
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x90a5
movq 0x10(%r14), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0x90bc
movq %r14, %rdi
callq 0x18a0a
movl $0x17, %edi
movq %rax, %rsi
jmp 0x90ca
movq %r14, %rdi
callq 0x1a1c9
leal 0x10(%rax), %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x179e5
movl %ebx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: binary
static Type binary(Type xty, Type yty) {
	if (isdouble(xty) || isdouble(yty))
		return doubletype;
	if (xty == floattype || yty == floattype)
		return floattype;
	if (isunsigned(xty) || isunsigned(yty))
		return unsignedtype;
	return inttype;
}

// Assembly:
movl (%rdi), %eax
movl %eax, %ecx
cmpl $0xf, %eax
jb 0x90ed
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
leaq 0x29e94(%rip), %rdx     # 0x32f88
cmpl $0x2, %ecx
je 0x915d
movl (%rsi), %ecx
movl %ecx, %r8d
cmpl $0xf, %ecx
jb 0x910a
movq 0x10(%rsi), %r8
movl (%r8), %r8d
cmpl $0x2, %r8d
je 0x915d
leaq 0x29e79(%rip), %rdx     # 0x32f90
movq (%rdx), %r8
cmpq %rdi, %r8
sete %r9b
cmpq %rsi, %r8
sete %r8b
orb %r9b, %r8b
jne 0x915d
cmpl $0xf, %eax
jb 0x9138
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x6, %eax
je 0x914d
cmpl $0xf, %ecx
jb 0x9148
movq 0x10(%rsi), %rax
movl (%rax), %ecx
cmpl $0x6, %ecx
jne 0x9156
leaq 0x29e84(%rip), %rdx     # 0x32fd8
jmp 0x915d
leaq 0x29e3b(%rip), %rdx     # 0x32f98
movq (%rdx), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: callnode
Tree callnode(Tree f, Type ty, Tree args) {
	Tree p;

	if (args)
		f = tree(RIGHT, f->type, args, f);
	if (isstruct(ty)) {
		Symbol t1 = temporary(AUTO, unqual(ty));
		if (ty->size == 0)
			error("illegal use of incomplete type `%t'\n", ty);
		p = tree(RIGHT, ty, tree(CALL+B, ty, f, lvalue(idnode(t1))),
			idnode(t1));
	} else {
		Type rty = ty;
		if (isenum(ty))
			rty = unqual(ty)->type;
		else if (isptr(ty))
			rty = unsignedtype;
		p = tree(CALL + widen(rty), rty, f, 0);
		if (isptr(ty))
			p = cast(p, ty);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x9185
movq 0x8(%r14), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rcx
callq 0x179e5
movq %rax, %r14
movl (%rbx), %eax
cmpl $0xf, %eax
jb 0x919c
movq 0x10(%rbx), %rsi
movl (%rsi), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x91a7
jmp 0x9214
leal -0x9(%rax), %ecx
movq %rbx, %rsi
cmpl $0x1, %ecx
ja 0x9211
movl $0x43, %edi
callq 0x176c4
movq %rax, %r15
cmpl $0x0, 0x8(%rbx)
jne 0x91cb
leaq 0x15434(%rip), %rdi     # 0x1e5f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x974c
movq %r15, %rdi
callq 0x9d8b
movq %rax, %rdi
callq 0xb318
movl $0xd9, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x179e5
movq %rax, %r14
movq %r15, %rdi
callq 0x9d8b
movl $0x2a0, %edi            # imm = 0x2A0
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x179e5
movq %rbx, %rsi
cmpl $0xd, %eax
jne 0x921f
movq 0x10(%rsi), %r15
jmp 0x9231
movq %rbx, %r15
cmpl $0x7, %eax
jne 0x9231
leaq 0x29daa(%rip), %rax     # 0x32fd8
movq (%rax), %r15
movl (%r15), %eax
cmpl $0xf, %eax
jb 0x923f
movq 0x10(%r15), %rax
movl (%rax), %eax
cmpl $0x2, %eax
jbe 0x9253
movl $0xd5, %edi
cmpl $0x7, %eax
jb 0x9263
cmpl $0xd, %eax
je 0x9263
movq %r15, %rdi
callq 0x1a1c9
movl %eax, %edi
addl $0xd0, %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x179e5
movl (%rbx), %ecx
cmpl $0xf, %ecx
jb 0x927d
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
cmpl $0x7, %ecx
jne 0x9292
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa2f7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: compatible
static int compatible(Type ty1, Type ty2) {
	if (isptr(ty1) && isptr(ty2)) {
		do {
			ty1 = unqual(ty1->type);
			ty2 = unqual(ty2->type);
		} while (isptr(ty1) && isptr(ty2));
		return eqtype(ty1, ty2, 0);
	}
	return 0;
}

// Assembly:
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x96ec
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x9748
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x96fe
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x9748
movq 0x10(%rdi), %rdi
cmpl $0xf, (%rdi)
jb 0x9710
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
cmpl $0xf, (%rsi)
jb 0x971d
movq 0x10(%rsi), %rsi
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x972a
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x9741
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x973c
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
je 0x9703
xorl %edx, %edx
jmp 0x190d9
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: error
void error(fmt, va_alist) char *fmt; va_dcl {
#endif
	va_list ap;

	va_init(ap, fmt);
	if (firstfile != file && firstfile && *firstfile)
		fprint(2, "%s: ", firstfile);		/* omit */
	fprint(2, "%w: ", &src);
	vfprint(2, fmt, ap);
	if (++errcnt >= errlimit) {
		errcnt = -1;
		error("too many errors\n");
		exit(1);
	}
	va_end(ap);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x97ab
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
leaq 0x22156(%rip), %rax     # 0x2b928
movq (%rax), %rdx
testq %rdx, %rdx
je 0x97fe
leaq 0x2212f(%rip), %rax     # 0x2b910
cmpq (%rax), %rdx
je 0x97fe
cmpb $0x0, (%rdx)
je 0x97fe
leaq 0x15562(%rip), %rsi     # 0x1ed54
movl $0x2, %edi
xorl %eax, %eax
callq 0x115a8
leaq 0x15554(%rip), %rsi     # 0x1ed59
leaq 0x2312c(%rip), %rdx     # 0x2c938
movl $0x2, %edi
xorl %eax, %eax
callq 0x115a8
movq %rsp, %rdx
movl $0x2, %edi
movq %rbx, %rsi
callq 0x1162c
movl 0x2107e(%rip), %eax     # 0x2a8ac
incl %eax
movl %eax, 0x21076(%rip)     # 0x2a8ac
cmpl 0x1fd24(%rip), %eax     # 0x29560
jge 0x9847
addq $0xd0, %rsp
popq %rbx
retq
movl $0xffffffff, 0x2105b(%rip) # imm = 0xFFFFFFFF
leaq 0x15506(%rip), %rdi     # 0x1ed5e
xorl %eax, %eax
callq 0x974c
movl $0x1, %edi
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: expect
int expect(int tok) {
	if (t == tok) {
		t = gettok();
		return t;
	}
	errcnt--;
	error("syntax error; found");
	printtoken();
	fprint(2, " expecting `%k'\n", tok);
	errcnt++;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x2316c(%rip), %r14     # 0x2c9e0
cmpl %edi, (%r14)
jne 0x9885
callq 0xe195
movl %eax, %ebx
movl %eax, (%r14)
jmp 0x98bd
movl %edi, %ebp
decl 0x2101f(%rip)           # 0x2a8ac
leaq 0x154db(%rip), %rdi     # 0x1ed6f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x974c
callq 0x98c4
leaq 0x154da(%rip), %rsi     # 0x1ed83
movl $0x2, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x115a8
incl 0x20fef(%rip)           # 0x2a8ac
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: printtoken
static void printtoken() {
	switch (t) {
	case ID: fprint(2, " `%s'", token); break;
	case ICON:
		if (*token == '\'') {
			char *s;
	case SCON:	fprint(2, " ");
			for (s = token; *s && s - token < 20; s++)
				if (*s < ' ' || *s >= 0177)
					fprint(2, "\\%o", *s);
				else
					fprint(2, "%c", *s);
			if (*s)
				fprint(2, " ...");
			else
				fprint(2, "%c", *token);
			break;
		} /* else fall thru */
	case FCON: {
		char c = *cp;
		*cp = 0;
		fprint(2, " `%s'", token);
		*cp = c;
		break;
		}
	case '`': case '\'': fprint(2, " \"%k\"", t); break;
	default: fprint(2, " `%k'", t);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2310a(%rip), %rax     # 0x2c9e0
movl (%rax), %edx
leal -0x20(%rdx), %eax
cmpl $0x7, %eax
ja 0x991b
leaq 0x1544d(%rip), %rcx     # 0x1ed34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x23051(%rip), %rax     # 0x2c948
movq (%rax), %rdx
leaq 0x154c9(%rip), %rsi     # 0x1edca
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115a8
cmpl $0x60, %edx
jne 0x9929
leaq 0x154ad(%rip), %rsi     # 0x1edd4
jmp 0x9930
leaq 0x154aa(%rip), %rsi     # 0x1edda
movl $0x2, %edi
jmp 0x9a39
leaq 0x23007(%rip), %rax     # 0x2c948
movq (%rax), %rax
cmpb $0x27, (%rax)
jne 0x99e8
leaq 0x14970(%rip), %rsi     # 0x1e2c4
movl $0x2, %edi
xorl %eax, %eax
callq 0x115a8
leaq 0x22fe1(%rip), %rbx     # 0x2c948
movq (%rbx), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x9a2a
incq %rax
leaq 0x15452(%rip), %r14     # 0x1edd0
leaq 0x17566(%rip), %r15     # 0x20eeb
movq %rax, %r12
movq %rax, %r13
movsbl %cl, %edx
leal -0x7f(%rdx), %eax
cmpb $-0x5f, %al
movq %r15, %rsi
cmovbq %r14, %rsi
movl $0x2, %edi
xorl %eax, %eax
callq 0x115a8
movb (%r13), %cl
movq (%rbx), %rax
testb %cl, %cl
je 0x99c3
movq %r12, %rdx
subq %rax, %rdx
incq %r13
incq %r12
cmpq $0x14, %rdx
jl 0x998b
testb %cl, %cl
je 0x9a2a
leaq 0x17f3f(%rip), %rsi     # 0x2190d
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115a8
leaq 0x21f09(%rip), %rbx     # 0x2b8f8
movq (%rbx), %rax
movb (%rax), %bpl
movb $0x0, (%rax)
leaq 0x22f49(%rip), %rax     # 0x2c948
movq (%rax), %rdx
leaq 0x153c1(%rip), %rsi     # 0x1edca
movl $0x2, %edi
xorl %eax, %eax
callq 0x115a8
movq (%rbx), %rax
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl (%rax), %edx
leaq 0x174b7(%rip), %rsi     # 0x20eeb
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115a8
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: fatal
int fatal(char *name, char *fmt, int n) {
	*bp++ = '\n';
	outflush();
	error("compiler error in %s--", name);
	fprint(2, fmt, n);
	exit(1);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1fbae(%rip), %rax     # 0x29610
movq (%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rax)
movb $0xa, (%rcx)
callq 0x11693
leaq 0x15319(%rip), %rdi     # 0x1ed94
movq %r15, %rsi
xorl %eax, %eax
callq 0x974c
movl $0x2, %edi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x115a8
movl $0x1, %edi
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: skipto
void skipto(int tok, char set[]) {
	int n;
	char *s;

	for (n = 0; t != EOI && t != tok; t = gettok()) {
		if (set) {
			for (s = set; *s && kind[t] != *s; s++)
				;
			if (kind[t] == *s)
				break;
		}
		if (n++ == 0) {
			errcnt--;
			error("skipping", 0, 0, 0, 0);
		}
		if (n <= 8)
			printtoken();
		else if (n == 9)
			fprint(2, " ...\n");
	}
	if (n > 8) {
		errcnt--;
		error("up to", 0, 0, 0, 0);
		printtoken();
	}
	if (n > 0)
		fprint(2, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x22f2e(%rip), %r12     # 0x2c9e0
movl (%r12), %eax
cmpl $0x7f, %eax
sete %cl
cmpl %edi, %eax
sete %dl
orb %cl, %dl
jne 0x9bb6
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1(%rsi), %r13
leaq 0x1faa7(%rip), %r15     # 0x29580
xorl %ecx, %ecx
testq %rbx, %rbx
je 0x9afe
movb (%rbx), %dl
movl %eax, %eax
movb (%r15,%rax), %al
movq %r13, %rsi
testb %dl, %dl
je 0x9afa
cmpb %dl, %al
je 0x9b63
movb (%rsi), %dl
incq %rsi
jmp 0x9aeb
testb %al, %al
je 0x9b63
leal 0x1(%rcx), %r14d
testl %ecx, %ecx
je 0x9b26
cmpl $0x7, %ecx
jbe 0x9b43
cmpl $0x9, %r14d
jne 0x9b48
movl $0x2, %edi
leaq 0x15297(%rip), %rsi     # 0x1edb4
xorl %eax, %eax
callq 0x115a8
jmp 0x9b48
decl 0x20d80(%rip)           # 0x2a8ac
leaq 0x15278(%rip), %rdi     # 0x1edab
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x974c
callq 0x98c4
callq 0xe195
movl %eax, (%r12)
cmpl $0x7f, %eax
je 0x9b66
movl %r14d, %ecx
cmpl %ebp, %eax
jne 0x9adb
jmp 0x9b66
movl %ecx, %r14d
cmpl $0x9, %r14d
jb 0x9b90
decl 0x20d3a(%rip)           # 0x2a8ac
leaq 0x15241(%rip), %rdi     # 0x1edba
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x974c
callq 0x98c4
jmp 0x9b95
testl %r14d, %r14d
je 0x9bb6
leaq 0x15ff8(%rip), %rsi     # 0x1fb94
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: test
void test(int tok, char set[])  {
	if (t == tok)
		t = gettok();
	else {
		expect(tok);
		skipto(tok, set);
		if (t == tok)
			t = gettok();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x22e0f(%rip), %r15     # 0x2c9e0
cmpl %edi, (%r15)
je 0x9bef
movq %rsi, %r14
movl %edi, %ebx
callq 0x9869
movl %ebx, %edi
movq %r14, %rsi
callq 0x9aa0
cmpl %ebx, (%r15)
jne 0x9bf7
callq 0xe195
movl %eax, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: warning
void warning(fmt, va_alist) char *fmt; va_dcl {
#endif
	va_list ap;

	va_init(ap, fmt);
	if (wflag == 0) {
		errcnt--;	/* compensate for increment in error */
		error("warning: ");
		vfprint(2, fmt, ap);
	}
	va_end(ap);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x9c5c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpl $0x0, 0x20c2d(%rip)     # 0x2a8b0
jne 0x9ca9
decl 0x20c21(%rip)           # 0x2a8ac
leaq 0x1512e(%rip), %rdi     # 0x1edc0
xorl %eax, %eax
callq 0x974c
movq %rsp, %rdx
movl $0x2, %edi
movq %rbx, %rsi
callq 0x1162c
addq $0xd0, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: addrof
Tree addrof(p) Tree p; {
	Tree q = p;

	for (;;)
		switch (generic(q->op)) {
		case RIGHT:
			assert(q->kids[0] || q->kids[1]);
			q = q->kids[1] ? q->kids[1] : q->kids[0];
			continue;
		case ASGN:
			q = q->kids[1];
			continue;
		case COND: {
			Symbol t1 = q->u.sym;
			q->u.sym = 0;
			q = idnode(t1);
			/* fall thru */
			}
		case INDIR:
			if (p == q)
				return q->kids[0];
			q = q->kids[0];
			return tree(RIGHT, q->type, root(p), q);
		default:
			error("addressable object required\n");
			return value(p);
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %rax
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x28f, %ecx            # imm = 0x28F
jg 0x9cd7
cmpl $0x30, %ecx
jne 0x9d16
movq 0x18(%rax), %rax
jmp 0x9cbf
cmpl $0x2a0, %ecx            # imm = 0x2A0
jne 0x9cfb
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, %rdx
orq %rax, %rdx
je 0x9d6c
testq %rax, %rax
cmovneq %rax, %rcx
movq %rcx, %rax
jmp 0x9cbf
cmpl $0x290, %ecx            # imm = 0x290
jne 0x9d48
movq 0x28(%rax), %rdi
movq $0x0, 0x28(%rax)
callq 0x9d8b
jmp 0x9d1b
cmpl $0x40, %ecx
jne 0x9d48
movq 0x10(%rax), %r14
cmpq %rbx, %rax
je 0x9d63
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x17b52
movl $0x2a0, %edi            # imm = 0x2A0
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x179e5
leaq 0x153d6(%rip), %rdi     # 0x1f125
xorl %eax, %eax
callq 0x974c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9e7a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1537d(%rip), %rdi     # 0x1f0f0
leaq 0x1538f(%rip), %rsi     # 0x1f109
leaq 0x15396(%rip), %rcx     # 0x1f117
movl $0x1e, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: idnode
Tree idnode(p) Symbol p; {
	Opcode op;
	Tree e;
	Type ty = p->type ? unqual(p->type) : voidtype;

	p->ref += refinc;
	p->initialized = 1;	/* in case p->ref overflows */
	if (p->scope == PARAM) {
#ifdef NOARGB
		if (isstruct(p->type)) {
			e = tree(ADDRF+P, ptr(ptr(p->type)), 0, 0);
			e->u.sym = p;
			e = rvalue(e);
		} else
#endif
		{	e = tree(ADDRF+P, ptr(p->type), 0, 0);
			e->u.sym = p;
		}
		return rvalue(e);
	}
	if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
		op = ADDRG+P;
		if (isfunc(ty))
			p->addressed = 1;
	} else
		op = ADDRL+P;
	if (isarray(ty) || isfunc(ty)) {
		e = tree(op, p->type ? p->type : voidtype, 0, 0);
		e->u.sym = p;
		return e;
	} else {
		e = tree(op, ptr(p->type), 0, 0);
		e->u.sym = p;
		return rvalue(e);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x9da8
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0x9db2
leaq 0x10(%rsi), %rax
jmp 0x9daf
leaq 0x29231(%rip), %rax     # 0x32fe0
movq (%rax), %rax
leaq 0x1f8cb(%rip), %rcx     # 0x29684
movl (%rcx), %ecx
addl %ecx, 0x1c(%rbx)
movb 0x1b(%rbx), %cl
movl %ecx, %edx
orb $0x20, %dl
movb %dl, 0x1b(%rbx)
movzwl 0x18(%rbx), %edx
cmpl $0x3, %edx
je 0x9df9
cmpl $0x4, %edx
jne 0x9de6
movq %rsi, %rdi
callq 0x188cc
movl $0x117, %edi            # imm = 0x117
jmp 0x9e5c
movzbl 0x1a(%rbx), %edx
cmpl $0x51, %edx
je 0x9df9
movl $0x127, %ebp            # imm = 0x127
cmpl $0x4a, %edx
jne 0x9e16
movl (%rax), %edx
cmpl $0xf, %edx
jb 0x9e06
movq 0x10(%rax), %rdx
movl (%rdx), %edx
movl $0x107, %ebp            # imm = 0x107
cmpl $0xb, %edx
jne 0x9e16
orb $0x30, %cl
movb %cl, 0x1b(%rbx)
movl (%rax), %ecx
cmpl $0xf, %ecx
jb 0x9e23
movq 0x10(%rax), %rax
movl (%rax), %ecx
cmpl $0xc, %ecx
je 0x9e2d
cmpl $0xb, %ecx
jne 0x9e52
testq %rsi, %rsi
jne 0x9e3c
leaq 0x291a7(%rip), %rax     # 0x32fe0
movq (%rax), %rsi
movl %ebp, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x179e5
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdi
callq 0x188cc
movl %ebp, %edi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x179e5
movq %rbx, 0x28(%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xaaaa
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: value
static Tree value(p) Tree p; {
	Opcode op = generic(rightkid(p)->op);

	if (op == AND || op == OR || op == NOT || op == EQ || op == NE
	||  op ==  LE || op == LT || op ==  GE || op == GT)
		p = condnode(p, constnode(1, inttype), constnode(0, inttype));
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xabb3
movl (%rax), %eax
movd %eax, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pand 0x14f46(%rip), %xmm0    # 0x1ede0
pshufd $0x10, %xmm0, %xmm1     # xmm1 = xmm0[0,0,1,0]
pcmpeqd 0x14f49(%rip), %xmm1    # 0x1edf0
movmskps %xmm1, %ecx
testl %ecx, %ecx
jne 0x9ed3
andl $-0x20, %eax
cmpl $0x260, %eax            # imm = 0x260
je 0x9ed3
movd %xmm0, %eax
cmpl $0x1f0, %eax            # imm = 0x1F0
je 0x9ed3
cmpl $0x200, %eax            # imm = 0x200
je 0x9ed3
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x290be(%rip), %r15     # 0x32f98
movq (%r15), %rsi
movl $0x1, %edi
callq 0x908f
movq %rax, %r14
movq (%r15), %rsi
xorl %edi, %edi
callq 0x908f
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x9298
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: asgn
Tree asgn(p, e) Symbol p; Tree e; {
	if (isarray(p->type))
		e = tree(ASGN+B, p->type, idnode(p),
			tree(INDIR+B, e->type, e, 0));
	else {
		Type ty = p->type;
		p->type = unqual(p->type);
		if (isstruct(p->type) && p->type->u.sym->u.s.cfields) {
			p->type->u.sym->u.s.cfields = 0;
			e = asgnnode(ASGN, idnode(p), e);
			p->type->u.sym->u.s.cfields = 1;
		} else
			e = asgnnode(ASGN, idnode(p), e);
		p->type = ty;
	}
	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rbx
movl (%rbx), %edx
cmpl $0xf, %edx
jb 0x9f39
movq 0x10(%rbx), %rax
movl (%rax), %ecx
cmpl $0xc, %ecx
je 0x9f45
movq %rax, 0x20(%r14)
cmpl $0xf, %ecx
jb 0x9f8d
movq 0x10(%rax), %rsi
movl (%rsi), %esi
jmp 0x9f7b
movl %edx, %ecx
movl %edx, %esi
movq %rbx, %rax
cmpl $0xc, %edx
jne 0x9f7b
movq %r14, %rdi
callq 0x9d8b
movq %rax, %r14
movq 0x8(%r15), %rsi
movl $0x49, %edi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x179e5
movl $0x39, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x179e5
cmpl $0x9, %esi
je 0x9f97
cmpl $0xf, %edx
jb 0x9f92
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
jmp 0x9f92
cmpl $0x9, %ecx
je 0x9f97
cmpl $0xa, %ecx
jne 0x9fa3
movq 0x18(%rax), %rax
movb 0x48(%rax), %cl
testb $0x1, %cl
jne 0x9fbd
movq %r14, %rdi
callq 0x9d8b
movl $0x30, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8cee
jmp 0x9fe7
andb $-0x2, %cl
movb %cl, 0x48(%rax)
movq %r14, %rdi
callq 0x9d8b
movl $0x30, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8cee
movq 0x20(%r14), %rcx
movq 0x18(%rcx), %rcx
orb $0x1, 0x48(%rcx)
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: cond
Tree cond(p) Tree p; {
	Opcode op = generic(rightkid(p)->op);

	if (op == AND || op == OR || op == NOT || op == EQ || op == NE
	||  op ==  LE || op == LT || op ==  GE || op == GT)
		return p;
	p = pointer(p);
	p = cast(p, promote(p->type));
	return (*opnode[NEQ])(NE, p, constnode(0, inttype));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xabb3
movl (%rax), %eax
movd %eax, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pand 0x142c0(%rip), %xmm0    # 0x1ede0
pshufd $0x10, %xmm0, %xmm1     # xmm1 = xmm0[0,0,1,0]
pcmpeqd 0x142c3(%rip), %xmm1    # 0x1edf0
movmskps %xmm1, %ecx
testl %ecx, %ecx
jne 0xaba8
andl $-0x20, %eax
cmpl $0x260, %eax            # imm = 0x260
je 0xaba8
movd %xmm0, %eax
cmpl $0x1f0, %eax            # imm = 0x1F0
je 0xaba8
cmpl $0x200, %eax            # imm = 0x200
je 0xaba8
movq %rbx, %rdi
callq 0xac23
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xac7b
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa2f7
movq %rax, %rbx
leaq 0x1e5e7(%rip), %rax     # 0x29160
movq 0x1b0(%rax), %r14
leaq 0x28411(%rip), %rax     # 0x32f98
movq (%rax), %rsi
xorl %edi, %edi
callq 0x908f
movl $0x230, %edi            # imm = 0x230
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: rightkid
static Tree rightkid(p) Tree p; {
	while (p && p->op == RIGHT) {
		assert(p->kids[0] || p->kids[1]);
		p = p->kids[1] ? p->kids[1] : p->kids[0];
	}
	assert(p);
	return p;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xabe0
cmpl $0x2a0, (%rdi)          # imm = 0x2A0
jne 0xabff
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rax, %rdx
orq %rcx, %rdx
je 0xac04
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rax, %rdi
testq %rax, %rax
jne 0xabb9
leaq 0x136fb(%rip), %rdi     # 0x1e2e2
leaq 0x1451b(%rip), %rsi     # 0x1f109
leaq 0x14923(%rip), %rcx     # 0x1f518
movl $0x36f, %edx            # imm = 0x36F
callq 0x30d0
movq %rdi, %rax
popq %rcx
retq
leaq 0x148f4(%rip), %rdi     # 0x1f4ff
leaq 0x144f7(%rip), %rsi     # 0x1f109
leaq 0x148ff(%rip), %rcx     # 0x1f518
movl $0x36c, %edx            # imm = 0x36C
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: pointer
Tree pointer(p) Tree p; {
	if (isarray(p->type) && (p->op != RIGHT || p->u.sym == 0))
		p = retype(p, atop(p->type));
	else if (isfunc(p->type))
		p = retype(p, ptr(p->type));
	return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
movl %eax, %ecx
cmpl $0xf, %eax
jb 0xac3a
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0xac4e
cmpl $0x2a0, (%rbx)          # imm = 0x2A0
jne 0xac65
cmpq $0x0, 0x28(%rbx)
je 0xac65
cmpl $0xf, %eax
jb 0xac59
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0xac76
callq 0x188cc
jmp 0xac6a
callq 0x18a0a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x17b29
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: promote
Type promote(ty) Type ty; {
	ty = unqual(ty);
	if (isunsigned(ty) || ty == longtype)
		return ty;
	else if (isint(ty) || isenum(ty))
		return inttype;
	return ty;
}

// Assembly:
movq %rdi, %rax
movl (%rdi), %ecx
cmpl $0xf, %ecx
jb 0xacbb
movq 0x10(%rax), %rax
movl (%rax), %ecx
cmpl $0xf, %ecx
setae %dl
jb 0xacdb
movq 0x10(%rax), %rdx
cmpl $0x6, (%rdx)
je 0xacda
leaq 0x28305(%rip), %rdx     # 0x32fa8
cmpq (%rdx), %rax
je 0xacda
movq 0x10(%rax), %rdx
cmpl $0x3, (%rdx)
jb 0xad00
movq 0x10(%rax), %rdx
movl (%rdx), %esi
movb $0x1, %dl
jmp 0xacf7
leaq 0x282e6(%rip), %rdx     # 0x32fa8
cmpq %rax, (%rdx)
je 0xacda
xorl %edx, %edx
cmpl $0x6, %ecx
ja 0xacf5
movl $0x47, %esi
btl %ecx, %esi
movl %ecx, %esi
jae 0xacf7
retq
cmpl $0x6, %ecx
je 0xacda
leaq 0x282c1(%rip), %rsi     # 0x32fa8
cmpq (%rsi), %rax
je 0xacda
movl %ecx, %esi
cmpl $0x2, %ecx
ja 0xacf7
jmp 0xacfc
movl %ecx, %esi
cmpl $0x7, %esi
jb 0xad0b
testb %dl, %dl
je 0xad06
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
cmpl $0xd, %ecx
jne 0xacda
leaq 0x28286(%rip), %rax     # 0x32f98
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: conditional
Tree conditional(int tok) {
	Tree p = expr(tok);

	if (Aflag > 1 && isfunc(p->type))
		warning("%s used in a conditional expression\n", funcname(p));
	return cond(p);
}

// Assembly:
pushq %rbx
callq 0xad94
movq %rax, %rbx
leaq 0x21d32(%rip), %rax     # 0x2ca58
cmpl $0x2, (%rax)
jl 0xad8b
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xad3c
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0xad8b
leaq 0x144b3(%rip), %rsi     # 0x1f1fb
movl $0xfffffef9, %eax       # imm = 0xFFFFFEF9
addl (%rbx), %eax
cmpl $0x20, %eax
ja 0xad7d
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0xad7d
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x14058(%rip), %rdi     # 0x1edcb
xorl %eax, %eax
callq 0x11b33
movq %rax, %rsi
leaq 0x14436(%rip), %rdi     # 0x1f1ba
xorl %eax, %eax
callq 0x9bfd
movq %rbx, %rdi
popq %rbx
jmp 0xab01
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr
Tree expr(int tok) {
	Tree p = expr1(0);

	while (t == ',') {
		Tree q;
		t = gettok();
		q = pointer(expr1(0));
		if (generic(p->op) != CNST)
			p = root(value(p));
		p = tree(RIGHT, q->type, p, q);
	}
	if (tok && t == tok)
		t = gettok();
	else if (tok) {
		static char follow[] = { IF, ID, '}', 0 };
		test(tok, follow);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
callq 0xae91
movq %rax, %r14
leaq 0x21c31(%rip), %r12     # 0x2c9e0
movl (%r12), %eax
cmpl $0x2c, %eax
jne 0xae0a
callq 0xe195
movl %eax, (%r12)
xorl %edi, %edi
callq 0xae91
movq %rax, %rdi
callq 0xac23
movq %rax, %r15
movl (%r14), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0xadf1
movq %r14, %rdi
callq 0x9e7a
movq %rax, %rdi
callq 0x17b52
movq %rax, %r14
movq 0x8(%r15), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rdx
movq %r15, %rcx
callq 0x179e5
movq %rax, %r14
jmp 0xadaf
testl %ebx, %ebx
sete %cl
cmpl %ebx, %eax
setne %al
orb %cl, %al
jne 0xae23
callq 0xe195
movl %eax, (%r12)
jmp 0xae35
testl %ebx, %ebx
je 0xae35
leaq 0x1e736(%rip), %rsi     # 0x29564
movl %ebx, %edi
callq 0x9bc5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: constexpr
Tree constexpr(int tok) {
	Tree p;

	needconst++;
	p = expr1(tok);
	needconst--;
	return p;
}

// Assembly:
pushq %rbx
leaq 0x22e72(%rip), %rbx     # 0x2dcf8
incl (%rbx)
callq 0xae91
decl (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr1
Tree expr1(int tok) {
	Tree p = expr2();

	while (t == '=' || (prec[t] >= 6 && prec[t] <= 8)
	|| (prec[t] >= 11 && prec[t] <= 13)) {
		Opcode op = t;
		t = gettok();
		if (oper[op] == ASGN)
			p = asgnnode(ASGN, p, value(expr1(0)));
		else {
			expect('=');
			p = incr(op, p, expr1(0));
		}
	}
	if (tok && t == tok)
		t = gettok();
	else if (tok) {
		static char follow[] = { IF, ID, 0 };
		test(tok, follow);
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, 0x4(%rsp)
callq 0xaf8a
movq %rax, %rbx
leaq 0x21b31(%rip), %r14     # 0x2c9e0
leaq 0x13fba(%rip), %r15     # 0x1ee70
leaq 0x1e2a3(%rip), %r12     # 0x29160
leaq 0x1402c(%rip), %r13     # 0x1eef0
movl (%r14), %eax
cmpq $0x3d, %rax
jne 0xaee6
callq 0xe195
movl %eax, (%r14)
xorl %edi, %edi
callq 0xae91
movq %rax, %rdi
callq 0x9e7a
jmp 0xaf28
movb (%rax,%r15), %cl
leal -0x6(%rcx), %edx
cmpb $0x3, %dl
setb %dl
cmpb $0xb, %cl
setge %cl
orb %dl, %cl
je 0xaf3d
movslq %eax, %rbp
callq 0xe195
movl %eax, (%r14)
movl $0x3d, %edi
callq 0x9869
xorl %edi, %edi
callq 0xae91
movl (%r13,%rbp,4), %edi
movq %rbx, %rsi
movq %rax, %rdx
callq *(%r12,%rbp,8)
movl $0x30, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8cee
movq %rax, %rbx
jmp 0xaec4
movl 0x4(%rsp), %edi
testl %edi, %edi
sete %cl
cmpl %edi, %eax
setne %al
orb %cl, %al
jne 0xaf59
callq 0xe195
movl %eax, (%r14)
jmp 0xaf69
testl %edi, %edi
je 0xaf69
leaq 0x1e604(%rip), %rsi     # 0x29568
callq 0x9bc5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr2
static Tree expr2() {
	Tree p = expr3(4);

	if (t == '?') {
		Tree l, r;
		if (Aflag > 1 && isfunc(p->type))
			warning("%s used in a conditional expression\n", funcname(p));
		p = pointer(p);
		t = gettok();
		if (events.points) {
			Tree e = 0;
			apply(events.points, (Generic)&src, (Generic)&e);
			l = right(e, pointer(expr(':')));
			e = 0;
			apply(events.points, (Generic)&src, (Generic)&e);
			r = right(e, pointer(expr2()));
		} else {
			l = pointer(expr(':'));
			r = pointer(expr2());
		}
		p = condnode(p, l, r);
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x4, %edi
callq 0xb3e0
movq %rax, %rbx
leaq 0x21a37(%rip), %r14     # 0x2c9e0
cmpl $0x3f, (%r14)
jne 0xb0e1
leaq 0x21a9e(%rip), %rax     # 0x2ca58
cmpl $0x2, (%rax)
jl 0xb01f
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xafd0
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0xb01f
leaq 0x1421f(%rip), %rsi     # 0x1f1fb
movl $0xfffffef9, %eax       # imm = 0xFFFFFEF9
addl (%rbx), %eax
cmpl $0x20, %eax
ja 0xb011
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0xb011
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x13dc4(%rip), %rdi     # 0x1edcb
xorl %eax, %eax
callq 0x11b33
movq %rax, %rsi
leaq 0x141a2(%rip), %rdi     # 0x1f1ba
xorl %eax, %eax
callq 0x9bfd
movq %rbx, %rdi
callq 0xac23
movq %rax, %rbx
callq 0xe195
movl %eax, (%r14)
leaq 0x219c7(%rip), %r13     # 0x2ca00
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0xb0ae
xorl %ebp, %ebp
movq %rsp, %r15
movq %rbp, (%r15)
leaq 0x218e7(%rip), %r12     # 0x2c938
movq %r12, %rsi
movq %r15, %rdx
callq 0x1021b
movq (%r15), %r14
movl $0x3a, %edi
callq 0xad94
movq %rax, %rdi
callq 0xac23
movq %r14, %rdi
movq %rax, %rsi
callq 0xb36d
movq %rax, %r14
movq %rbp, (%r15)
movq 0x18(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1021b
movq (%r15), %r15
callq 0xaf8a
movq %rax, %rdi
callq 0xac23
movq %r15, %rdi
movq %rax, %rsi
callq 0xb36d
jmp 0xb0d0
movl $0x3a, %edi
callq 0xad94
movq %rax, %rdi
callq 0xac23
movq %rax, %r14
callq 0xaf8a
movq %rax, %rdi
callq 0xac23
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9298
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: field
Tree field(p, name) Tree p; char *name; {
	Field q;
	Type ty1, ty = p->type;

	if (isptr(ty))
		ty = deref(ty);
	ty1 = ty;
	ty = unqual(ty);
	if (q = fieldref(name, ty)) {
		ty = q->type;
		if (isconst(ty1) && !isconst(ty))
			ty = qual(CONST, ty);
		if (isvolatile(ty1) && !isvolatile(ty))
			ty = qual(VOLATILE, ty);
		if (!isarray(q->type))
			ty = ptr(ty);
		p = simplify(ADD+P, ty, p, constnode(q->offset, inttype));
		if (q->to) {
			p = tree(FIELD, q->type, rvalue(p), 0);
			p->u.field = q;
		} else if (!isarray(q->type))
			p = rvalue(p);
	} else {
		error("unknown field `%s' of `%t'\n", name, ty);
		p = rvalue(retype(p, ptr(inttype)));
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movl (%r12), %eax
movl %eax, %ecx
cmpl $0xf, %eax
jb 0xb147
movq 0x10(%r12), %rcx
movl (%rcx), %ecx
cmpl $0x7, %ecx
jne 0xb159
movq %r12, %rdi
callq 0x19085
movq %rax, %r12
movl (%rax), %eax
movq %r12, %r13
cmpl $0xf, %eax
jb 0xb166
movq 0x10(%r12), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x1949d
testq %rax, %rax
je 0xb248
movq %rax, %r14
movq 0x8(%rax), %r15
movl (%r12), %eax
movl %eax, %ecx
orl $0x10, %ecx
cmpl $0x1f, %ecx
jne 0xb1ae
movl (%r15), %ecx
orl $0x10, %ecx
cmpl $0x1f, %ecx
je 0xb1ae
movl $0xf, %edi
movq %r15, %rsi
callq 0x18e51
movq %rax, %r15
movl (%r12), %eax
cmpl $0x1f, %eax
je 0xb1b8
cmpl $0x10, %eax
jne 0xb1d5
movl (%r15), %eax
cmpl $0x10, %eax
je 0xb1d5
cmpl $0x1f, %eax
je 0xb1d5
movl $0x10, %edi
movq %r15, %rsi
callq 0x18e51
movq %rax, %r15
movq 0x8(%r14), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xb1e6
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xc, %eax
je 0xb1f6
movq %r15, %rdi
callq 0x188cc
movq %rax, %r15
movl 0x10(%r14), %edi
leaq 0x27d97(%rip), %rax     # 0x32f98
movq (%rax), %rsi
callq 0x908f
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x12443
cmpw $0x0, 0x16(%r14)
movq 0x8(%r14), %rbx
je 0xb278
movq %rax, %rdi
callq 0xaaaa
movl $0x2b0, %edi            # imm = 0x2B0
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movq %r14, 0x28(%rax)
jmp 0xb28a
leaq 0x13f90(%rip), %rdi     # 0x1f1df
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x974c
leaq 0x27d35(%rip), %rax     # 0x32f98
movq (%rax), %rdi
callq 0x188cc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b29
jmp 0xb294
movl (%rbx), %ecx
cmpl $0xf, %ecx
jb 0xb285
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0xb294
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xaaaa
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: intexpr
int intexpr(int tok, int n) {
	Tree p = constexpr(tok);

	needconst++;
	if (generic(p->op) == CNST && isint(p->type))
		n = cast(p, inttype)->u.v.i;
	else
		error("integer expression must be constant\n");
	needconst--;
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
leaq 0x22a46(%rip), %r14     # 0x2dcf8
incl (%r14)
callq 0xae91
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x10, %ecx
jne 0xb2fd
movq 0x8(%rax), %rdx
movl (%rdx), %ecx
cmpl $0xf, %ecx
jb 0xb2dc
movq 0x10(%rdx), %rcx
movl (%rcx), %ecx
cmpl $0x2, %ecx
ja 0xb2e1
jmp 0xb2fd
cmpl $0x3, %ecx
jb 0xb2fd
cmpl $0x6, %ecx
ja 0xb2fd
leaq 0x27cab(%rip), %rcx     # 0x32f98
movq (%rcx), %rsi
movq %rax, %rdi
callq 0xa2f7
movl 0x28(%rax), %ebx
jmp 0xb30b
leaq 0x13f02(%rip), %rdi     # 0x1f206
xorl %eax, %eax
callq 0x974c
decl (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: lvalue
Tree lvalue(p) Tree p; {
	if (generic(p->op) == INDIR) {
		if (unqual(p->type) == voidtype)
			warning("`%t' used as an lvalue\n", p->type);
		return p->kids[0];
	}
	error("lvalue required\n");
	return value(p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
andl $-0x10, %eax
cmpl $0x40, %eax
jne 0xb356
movq 0x8(%rbx), %rsi
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0xb336
movq 0x10(%rsi), %rax
leaq 0x27ca3(%rip), %rcx     # 0x32fe0
cmpq (%rcx), %rax
jne 0xb350
leaq 0x13ee2(%rip), %rdi     # 0x1f22b
xorl %eax, %eax
callq 0x9bfd
movq 0x10(%rbx), %rax
popq %rbx
retq
leaq 0x13ee6(%rip), %rdi     # 0x1f243
xorl %eax, %eax
callq 0x974c
movq %rbx, %rdi
popq %rbx
jmp 0x9e7a
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: right
Tree right(p, q) Tree p, q; {
	assert(p || q);
	if (p && q)
		return tree(RIGHT, q->type, root(p), q);
	return p ? p : q;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
orq %rsi, %rax
je 0xb3c1
movq %rsi, %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xb3af
movq 0x8(%rbx), %r14
callq 0x17b52
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x179e5
testq %rdi, %rdi
cmovneq %rdi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13e8c(%rip), %rdi     # 0x1f254
leaq 0x13d3a(%rip), %rsi     # 0x1f109
leaq 0x13e85(%rip), %rcx     # 0x1f25b
movl $0x363, %edx            # imm = 0x363
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr3
static Tree expr3(int k) {
	int k1;
	Tree p = prefix();

	for (k1 = prec[t]; k1 >= k; k1--)
		while (prec[t] == k1 && *cp != '=') {
			Tree r;
			Opcode op = t;
			t = gettok();
			p = pointer(p);
			if (events.points && (op == ANDAND || op == OROR)) {
				Tree e = 0;
				apply(events.points, (Generic)&src, (Generic)&e);
				r = right(e, pointer(expr3(k1 + (k1>5))));
			} else
				r = pointer(expr3(k1 + (k1>5)));
			p = (*opnode[op])(oper[op], p, r);
		}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
callq 0xb52f
movq %rax, %r12
leaq 0x215e1(%rip), %rbx     # 0x2c9e0
movl (%rbx), %r13d
leaq 0x13a67(%rip), %rax     # 0x1ee70
movsbl (%r13,%rax), %r15d
movl %ebp, 0xc(%rsp)
cmpl %ebp, %r15d
jl 0xb51d
movl %r13d, %r14d
leaq 0x13a4a(%rip), %rax     # 0x1ee70
movsbl (%r14,%rax), %eax
cmpl %eax, %r15d
jne 0xb50b
xorl %ebp, %ebp
cmpl $0x6, %r15d
setge %bpl
addl %r15d, %ebp
leaq 0x204b0(%rip), %rax     # 0x2b8f8
movq (%rax), %rax
cmpb $0x3d, (%rax)
je 0xb50b
callq 0xe195
movl %eax, (%rbx)
movq %r12, %rdi
callq 0xac23
movq %rax, %r12
leaq 0x21593(%rip), %rax     # 0x2ca00
movq 0x18(%rax), %rdi
testq %rdi, %rdi
sete %al
andl $-0x2, %r13d
cmpl $0x32, %r13d
setne %cl
orb %al, %cl
jne 0xb4c1
movq $0x0, 0x10(%rsp)
leaq 0x214a2(%rip), %rsi     # 0x2c938
leaq 0x10(%rsp), %rdx
callq 0x1021b
movq 0x10(%rsp), %r13
movl %ebp, %edi
callq 0xb3e0
movq %rax, %rdi
callq 0xac23
movq %r13, %rdi
movq %rax, %rsi
callq 0xb36d
jmp 0xb4d0
movl %ebp, %edi
callq 0xb3e0
movq %rax, %rdi
callq 0xac23
leaq 0x13a19(%rip), %rcx     # 0x1eef0
movl (%rcx,%r14,4), %edi
movq %r12, %rsi
movq %rax, %rdx
leaq 0x1dc78(%rip), %rax     # 0x29160
callq *(%rax,%r14,8)
movq %rax, %r12
movl (%rbx), %r13d
leaq 0x13977(%rip), %rax     # 0x1ee70
movsbl (%r13,%rax), %eax
movq %r13, %r14
cmpl %eax, %r15d
je 0xb441
leal -0x1(%r15), %eax
cmpl 0xc(%rsp), %r15d
movl %eax, %r15d
jg 0xb41c
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: nullcheck
static Tree nullcheck(p) Tree p; {
	Tree q, arg;

	if (needconst)
		return p;
	arg = tree(ARG+I, inttype, constnode(lineno, inttype), 0);
	q = tree(COND, voidtype,
		tree(NOT, inttype, cond(p), 0),
		tree(RIGHT, inttype, callnode(pointer(idnode(YYnull)), voidtype, arg), 0));
	return tree(RIGHT, p->type, q, p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x21d29(%rip), %rax     # 0x2dcf8
cmpl $0x0, (%rax)
je 0xbfe6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26fab(%rip), %r13     # 0x32f98
movq (%r13), %r14
leaq 0x1f910(%rip), %rax     # 0x2b908
movl (%rax), %edi
movq %r14, %rsi
callq 0x908f
movl $0x25, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movq %rax, %r15
leaq 0x26fc2(%rip), %rbp     # 0x32fe0
movq (%rbp), %r14
movq (%r13), %r12
movq %rbx, %rdi
callq 0xab01
movl $0x270, %edi            # imm = 0x270
movq %r12, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movq %rax, %r12
movq (%r13), %r13
leaq 0x20a12(%rip), %rax     # 0x2ca60
movq (%rax), %rdi
callq 0x9d8b
movq %rax, %rdi
callq 0xac23
movq (%rbp), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x9161
movl $0x2a0, %edi            # imm = 0x2A0
movq %r13, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movl $0x290, %edi            # imm = 0x290
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x179e5
movq 0x8(%rbx), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %rax, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x179e5
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: defglobal
void defglobal(Symbol p, int seg) {
	swtoseg(p->u.seg = seg);
	if (p->sclass != STATIC)
		export(p);
	if (glevel && level == GLOBAL) {
		stabsym(p);
		swtoseg(p->u.seg);
	}
	global(p);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x48(%rdi)
cmpl %esi, 0x1df07(%rip)     # 0x2a8c0
je 0xc9c2
movl %ebp, %edi
callq 0x1a4fb
movl %ebp, 0x1def8(%rip)     # 0x2a8c0
cmpb $0x51, 0x1a(%rbx)
je 0xc9d6
movq %rbx, %rdi
callq 0x1a4f9
leaq 0x20053(%rip), %rax     # 0x2ca30
cmpl $0x0, (%rax)
je 0xca06
leaq 0x23347(%rip), %rax     # 0x2fd30
cmpl $0x3, (%rax)
jne 0xca06
movl 0x48(%rbx), %ebp
cmpl %ebp, 0x1dec9(%rip)     # 0x2a8c0
je 0xca00
movl %ebp, %edi
callq 0x1a4fb
movl %ebp, 0x1deba(%rip)     # 0x2a8c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a4fc
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: doconst
void doconst(p, cl) Symbol p; Generic cl; {
	if (p->u.c.loc) {
		defglobal(p->u.c.loc, p->u.c.loc->u.seg ? p->u.c.loc->u.seg : LIT);
		if (isarray(p->type))
			defstring(p->type->size, p->u.c.v.p);
		else
			defconst(ttob(p->type), p->u.c.v);
		p->u.c.loc->defined = 1;
		p->u.c.loc = 0;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xcaa7
movl 0x48(%rdi), %eax
testl %eax, %eax
movl $0x4, %esi
cmovnel %eax, %esi
callq 0xc9a8
movq 0x20(%rbx), %rdi
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0xca74
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0xca87
movl 0x8(%rdi), %edi
movq 0x48(%rbx), %rsi
callq 0x1a6f4
jmp 0xca97
callq 0x1a1c9
movq 0x48(%rbx), %rsi
movl %eax, %edi
callq 0x1a672
movq 0x50(%rbx), %rax
orb $0x1, 0x1b(%rax)
movq $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genconst
int genconst(Tree e, int def) {
	for (;;)
		switch (generic(e->op)) {
		case ADDRG:
			if (def)
				defaddress(e->u.sym);
			return e->type->size;
		case CNST:
			if (e->op == CNST+P && isarray(e->type)) {
				e = cvtconst(e);
				continue;
			}
			if (def)
				defconst(ttob(e->type), e->u.v);
			return e->type->size;
		case RIGHT:
			assert(e->kids[0] || e->kids[1]);
			if (e->kids[1] && e->kids[0])
				error("initializer must be constant\n");
			e = e->kids[1] ? e->kids[1] : e->kids[0];
			continue;
		case CVP:
			if (isarith(e->type))
				error("cast from `%t' to `%t' is illegal in constant expressions\n",
					e->kids[0]->type, e->type);
			/* fall thru */
		case CVC: case CVI: case CVS: case CVU:
		case CVD: case CVF:
			e = e->kids[0];
			continue;
		default:
			error("initializer must be constant\n");
			if (def)
				genconst(constnode(0, inttype), def);
			return inttype->size;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rax
movabsq $0x1000100010001, %r12  # imm = 0x1000100010001
leaq 0x12abe(%rip), %r14     # 0x1f585
leaq 0x12a99(%rip), %r15     # 0x1f567
movq %rax, %rbx
movl (%rax), %ecx
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0x8f, %eax
jg 0xcb27
leal -0x50(%rax), %edx
cmpl $0x30, %edx
ja 0xcaf1
btq %rdx, %r12
jb 0xcbad
cmpl $0x10, %eax
jne 0xcc1f
cmpl $0x17, %ecx
jne 0xcbde
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xcb14
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0xcbde
movq %rbx, %rdi
callq 0x17960
jmp 0xcace
cmpl $0xaf, %eax
jle 0xcb72
cmpl $0xb0, %eax
je 0xcbad
cmpl $0x2a0, %eax            # imm = 0x2A0
jne 0xcbf8
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
testq %rcx, %rcx
je 0xcbb6
testq %rax, %rax
movq %rcx, %rax
je 0xcace
movq %r15, %rdi
xorl %eax, %eax
callq 0x974c
movq 0x18(%rbx), %rax
testq %rax, %rax
jne 0xcace
jmp 0xcbad
cmpl $0x90, %eax
je 0xcb85
cmpl $0xa0, %eax
je 0xcbad
jmp 0xcc1f
movq 0x8(%rbx), %rdx
movl (%rdx), %eax
cmpl $0xf, %eax
jb 0xcb96
movq 0x10(%rdx), %rax
movl (%rax), %eax
cmpl $0x6, %eax
ja 0xcbad
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x974c
movq 0x10(%rbx), %rax
jmp 0xcace
testq %rax, %rax
jne 0xcace
leaq 0x12962(%rip), %rdi     # 0x1f528
leaq 0x12974(%rip), %rsi     # 0x1f541
leaq 0x1297b(%rip), %rcx     # 0x1f54f
movl $0x70, %edx
callq 0x30d0
testl %ebp, %ebp
je 0xcc0c
movq 0x8(%rbx), %rdi
callq 0x1a1c9
movq 0x28(%rbx), %rsi
movl %eax, %edi
callq 0x1a672
jmp 0xcc0c
cmpl $0x100, %eax            # imm = 0x100
jne 0xcc1f
testl %ebp, %ebp
je 0xcc0c
movq 0x28(%rbx), %rdi
callq 0x1a72f
addq $0x8, %rbx
movq (%rbx), %rax
movl 0x8(%rax), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12941(%rip), %rdi     # 0x1f567
xorl %eax, %eax
callq 0x974c
leaq 0x26364(%rip), %rbx     # 0x32f98
testl %ebp, %ebp
je 0xcc10
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x908f
movq %rax, %rdi
movl %ebp, %esi
callq 0xcaa9
jmp 0xcc10
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initglobal
void initglobal(Symbol p, int flag) {
	Type ty;

	if (t == '=' || flag) {
		if (p->sclass == STATIC) {
			for (ty = p->type; isarray(ty); ty = ty->type)
				;
			defglobal(p, isconst(ty) ? LIT : DATA);
		} else
			defglobal(p, DATA);
		if (t == '=')
			t = gettok();
		ty = initializer(p->type, 0);
		if (isarray(p->type) && p->type->size == 0)
			p->type = ty;
		p->defined = 1;
		if (p->sclass == EXTERN)
			p->sclass = AUTO;
		if (level <= GLOBAL)
			tfree();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fd84(%rip), %r14     # 0x2c9e0
testl %esi, %esi
jne 0xcc6a
cmpl $0x3d, (%r14)
jne 0xcd0f
cmpb $0x51, 0x1a(%rbx)
jne 0xcca3
leaq 0x20(%rbx), %rax
movq (%rax), %rax
movl (%rax), %ecx
movl %ecx, %edx
cmpl $0xf, %ecx
jb 0xcc86
movq 0x10(%rax), %rdx
movl (%rdx), %edx
addq $0x10, %rax
cmpl $0xc, %edx
je 0xcc74
andl $-0x11, %ecx
xorl %esi, %esi
cmpl $0xf, %ecx
sete %sil
addl $0x3, %esi
movq %rbx, %rdi
jmp 0xccab
movq %rbx, %rdi
movl $0x3, %esi
callq 0xc9a8
cmpl $0x3d, (%r14)
jne 0xccbe
callq 0xe195
movl %eax, (%r14)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0xcd17
movq 0x20(%rbx), %rcx
movl (%rcx), %edx
cmpl $0xf, %edx
jb 0xccda
movq 0x10(%rcx), %rdx
movl (%rdx), %edx
cmpl $0xc, %edx
jne 0xcce9
cmpl $0x0, 0x8(%rcx)
jne 0xcce9
movq %rax, 0x20(%rbx)
orb $0x1, 0x1b(%rbx)
cmpb $0x4a, 0x1a(%rbx)
jne 0xccf7
movb $0x43, 0x1a(%rbx)
leaq 0x23032(%rip), %rax     # 0x2fd30
cmpl $0x3, (%rax)
jg 0xcd0f
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17dcb
addq $0x8, %rsp
popq %rbx
popq %r14
retq