LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x9131
movq 0x8(%r14), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rcx
callq 0x17b61
movq %rax, %r14
movl (%rbx), %eax
movq %rbx, %rcx
cmpl $0xf, %eax
jb 0x913f
movq 0x10(%rbx), %rcx
cmpl $0x9, (%rcx)
je 0x9155
movq %rbx, %rcx
cmpl $0xf, %eax
jb 0x9150
movq 0x10(%rbx), %rcx
cmpl $0xa, (%rcx)
jne 0x91cb
movq %rbx, %rsi
cmpl $0xf, %eax
jb 0x9161
movq 0x10(%rbx), %rsi
movl $0x43, %edi
callq 0x1783c
movq %rax, %r15
cmpl $0x0, 0x8(%rbx)
jne 0x9185
leaq 0x1547a(%rip), %rdi     # 0x1e5f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x9720
movq %r15, %rdi
callq 0x9d77
movq %rax, %rdi
callq 0xb339
movl $0xd9, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x17b61
movq %rax, %r14
movq %r15, %rdi
callq 0x9d77
movl $0x2a0, %edi            # imm = 0x2A0
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x17b61
movq %rbx, %rcx
cmpl $0xf, %eax
jb 0x91d7
movq 0x10(%rbx), %rcx
cmpl $0xd, (%rcx)
jne 0x91ee
movq %rbx, %rcx
cmpl $0xf, %eax
jb 0x91e8
movq 0x10(%rbx), %rcx
movq 0x10(%rcx), %r15
jmp 0x920c
movq %rbx, %rcx
cmpl $0xf, %eax
jb 0x91fa
movq 0x10(%rbx), %rcx
cmpl $0x7, (%rcx)
movq %rbx, %r15
jne 0x920c
leaq 0x28dcf(%rip), %rax     # 0x31fd8
movq (%rax), %r15
movl (%r15), %eax
movq %r15, %rcx
cmpl $0xf, %eax
jb 0x921b
movq 0x10(%r15), %rcx
cmpl $0x3, (%rcx)
jb 0x9236
movq %r15, %rcx
cmpl $0xf, %eax
jb 0x922c
movq 0x10(%r15), %rcx
movl $0xd5, %edi
cmpl $0x7, (%rcx)
jb 0x925c
movq %r15, %rcx
cmpl $0xf, %eax
jb 0x9242
movq 0x10(%r15), %rcx
movl $0xd5, %edi
cmpl $0xd, (%rcx)
je 0x925c
movq %r15, %rdi
callq 0x1a3e6
movl %eax, %edi
addl $0xd0, %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x17b61
cmpl $0xf, (%rbx)
movq %rbx, %rcx
jb 0x9275
movq 0x10(%rbx), %rcx
cmpl $0x7, (%rcx)
jne 0x928a
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa341
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x96c1
movq 0x10(%rdi), %rax
cmpl $0x7, (%rax)
jne 0x971a
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0x96d2
movq 0x10(%rsi), %rax
cmpl $0x7, (%rax)
jne 0x971a
movq 0x10(%rdi), %rdi
cmpl $0xf, (%rdi)
jb 0x96e4
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
cmpl $0xf, (%rsi)
jb 0x96f1
movq 0x10(%rsi), %rsi
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x96fd
movq 0x10(%rdi), %rax
cmpl $0x7, (%rax)
jne 0x9713
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0x970e
movq 0x10(%rsi), %rax
cmpl $0x7, (%rax)
je 0x96d7
xorl %edx, %edx
jmp 0x192a9
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x977f
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 0x21182(%rip), %rax     # 0x2a928
movq (%rax), %rdx
testq %rdx, %rdx
je 0x97d2
leaq 0x2115b(%rip), %rax     # 0x2a910
cmpq (%rax), %rdx
je 0x97d2
cmpb $0x0, (%rdx)
je 0x97d2
leaq 0x15576(%rip), %rsi     # 0x1ed3c
movl $0x2, %edi
xorl %eax, %eax
callq 0x116f4
leaq 0x15568(%rip), %rsi     # 0x1ed41
leaq 0x22158(%rip), %rdx     # 0x2b938
movl $0x2, %edi
xorl %eax, %eax
callq 0x116f4
movq %rsp, %rdx
movl $0x2, %edi
movq %rbx, %rsi
callq 0x11778
movl 0x200aa(%rip), %eax     # 0x298ac
incl %eax
movl %eax, 0x200a2(%rip)     # 0x298ac
cmpl 0x1ed50(%rip), %eax     # 0x28560
jge 0x981b
addq $0xd0, %rsp
popq %rbx
retq
movl $0xffffffff, 0x20087(%rip) # imm = 0xFFFFFFFF
leaq 0x1551a(%rip), %rdi     # 0x1ed46
xorl %eax, %eax
callq 0x9720
movl $0x1, %edi
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O1/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 0x22198(%rip), %r14     # 0x2b9e0
cmpl %edi, (%r14)
jne 0x9859
callq 0xe1c6
movl %eax, %ebx
movl %eax, (%r14)
jmp 0x9891
movl %edi, %ebp
decl 0x2004b(%rip)           # 0x298ac
leaq 0x154ef(%rip), %rdi     # 0x1ed57
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x9720
callq 0x9898
leaq 0x154ee(%rip), %rsi     # 0x1ed6b
movl $0x2, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x116f4
incl 0x2001b(%rip)           # 0x298ac
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22136(%rip), %rax     # 0x2b9e0
movl (%rax), %edx
leal -0x20(%rdx), %eax
cmpl $0x7, %eax
ja 0x98ef
leaq 0x15461(%rip), %rcx     # 0x1ed1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2207d(%rip), %rax     # 0x2b948
movq (%rax), %rdx
leaq 0x154dd(%rip), %rsi     # 0x1edb2
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x116f4
cmpl $0x60, %edx
jne 0x98fd
leaq 0x154c1(%rip), %rsi     # 0x1edbc
jmp 0x9904
leaq 0x154be(%rip), %rsi     # 0x1edc2
movl $0x2, %edi
jmp 0x99f1
leaq 0x22033(%rip), %rax     # 0x2b948
movq (%rax), %rax
cmpb $0x27, (%rax)
jne 0x999a
leaq 0x149a0(%rip), %rsi     # 0x1e2c4
movl $0x2, %edi
xorl %eax, %eax
callq 0x116f4
leaq 0x22011(%rip), %rbx     # 0x2b948
movq (%rbx), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x99dc
incq %rax
leaq 0x1546a(%rip), %r14     # 0x1edb8
leaq 0x17516(%rip), %r15     # 0x20e6b
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 0x116f4
movb (%r13), %cl
movq (%rbx), %rax
testb %cl, %cl
je 0x9993
movq %r12, %rdx
subq %rax, %rdx
incq %r13
incq %r12
cmpq $0x14, %rdx
jl 0x995b
testb %cl, %cl
sete %cl
jmp 0x99de
leaq 0x20f57(%rip), %rbx     # 0x2a8f8
movq (%rbx), %rax
movb (%rax), %bpl
movb $0x0, (%rax)
leaq 0x21f97(%rip), %rax     # 0x2b948
movq (%rax), %rdx
leaq 0x153f7(%rip), %rsi     # 0x1edb2
movl $0x2, %edi
xorl %eax, %eax
callq 0x116f4
movq (%rbx), %rax
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %cl
testb %cl, %cl
je 0x9a06
movsbl (%rax), %edx
leaq 0x1747f(%rip), %rsi     # 0x20e6b
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x116f4
leaq 0x17e80(%rip), %rsi     # 0x2188d
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x116f4
// File: /workspace/github_c_makefile_star2_O1/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 0x1ebd5(%rip), %rax     # 0x28610
movq (%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rax)
movb $0xa, (%rcx)
callq 0x117df
leaq 0x15328(%rip), %rdi     # 0x1ed7c
movq %r15, %rsi
xorl %eax, %eax
callq 0x9720
movl $0x2, %edi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x116f4
movl $0x1, %edi
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O1/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 0x21f55(%rip), %r12     # 0x2b9e0
movl (%r12), %eax
cmpl $0x7f, %eax
sete %cl
cmpl %edi, %eax
sete %dl
xorl %r14d, %r14d
orb %cl, %dl
jne 0x9b4e
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1(%rsi), %rcx
movq %rcx, (%rsp)
leaq 0x1eac7(%rip), %r15     # 0x28580
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x9ae4
movb (%rbx), %cl
movl %eax, %eax
testb %cl, %cl
je 0x9ade
movb (%r15,%rax), %dl
movq (%rsp), %rsi
cmpb %cl, %dl
je 0x9ade
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x9ad1
cmpb %cl, (%r15,%rax)
je 0x9b4b
testl %r13d, %r13d
jne 0x9b06
decl 0x1fdbd(%rip)           # 0x298ac
leaq 0x1529d(%rip), %rdi     # 0x1ed93
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x9720
leal 0x1(%r13), %r14d
cmpl $0x7, %r13d
ja 0x9b17
callq 0x9898
jmp 0x9b30
cmpl $0x9, %r14d
jne 0x9b30
movl $0x2, %edi
leaq 0x15273(%rip), %rsi     # 0x1ed9c
xorl %eax, %eax
callq 0x116f4
callq 0xe1c6
movl %eax, (%r12)
cmpl $0x7f, %eax
je 0x9b4e
movl %r14d, %r13d
cmpl %ebp, %eax
jne 0x9abc
jmp 0x9b4e
movl %r13d, %r14d
cmpl $0x9, %r14d
jb 0x9b76
decl 0x1fd52(%rip)           # 0x298ac
leaq 0x15241(%rip), %rdi     # 0x1eda2
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x9720
callq 0x9898
testl %r14d, %r14d
je 0x9b9c
leaq 0x15fc2(%rip), %rsi     # 0x1fb44
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x116f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21e29(%rip), %r15     # 0x2b9e0
cmpl %edi, (%r15)
je 0x9bd5
movq %rsi, %r14
movl %edi, %ebx
callq 0x983d
movl %ebx, %edi
movq %r14, %rsi
callq 0x9a79
cmpl %ebx, (%r15)
jne 0x9bdd
callq 0xe1c6
movl %eax, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9c42
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, 0x1fc47(%rip)     # 0x298b0
jne 0x9c8f
decl 0x1fc3b(%rip)           # 0x298ac
leaq 0x15130(%rip), %rdi     # 0x1eda8
xorl %eax, %eax
callq 0x9720
movq %rsp, %rdx
movl $0x2, %edi
movq %rbx, %rsi
callq 0x11778
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9cbb
cmpl $0x30, %ecx
jne 0x9ce7
movq 0x18(%rax), %rax
jmp 0x9ca3
cmpl $0x2a0, %ecx            # imm = 0x2A0
jne 0x9cee
movq 0x10(%rax), %rcx
testq %rcx, %rcx
jne 0x9cd7
cmpq $0x0, 0x18(%rax)
je 0x9d58
movq 0x18(%rax), %rax
testq %rax, %rax
cmovneq %rax, %rcx
movq %rcx, %rax
jmp 0x9ca3
cmpl $0x40, %ecx
je 0x9d07
jmp 0x9d34
cmpl $0x290, %ecx            # imm = 0x290
jne 0x9d34
movq 0x28(%rax), %rdi
movq $0x0, 0x28(%rax)
callq 0x9d77
movq 0x10(%rax), %r14
cmpq %rbx, %rax
je 0x9d4f
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x17ccb
movl $0x2a0, %edi            # imm = 0x2A0
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x17b61
leaq 0x1539a(%rip), %rdi     # 0x1f0d5
xorl %eax, %eax
callq 0x9720
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9e6f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x15341(%rip), %rdi     # 0x1f0a0
leaq 0x15353(%rip), %rsi     # 0x1f0b9
leaq 0x1535a(%rip), %rcx     # 0x1f0c7
movl $0x1e, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/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 0x9d94
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0x9d9e
leaq 0x10(%rsi), %rax
jmp 0x9d9b
leaq 0x28245(%rip), %rax     # 0x31fe0
movq (%rax), %rax
leaq 0x1e8df(%rip), %rcx     # 0x28684
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 0x9de5
cmpl $0x4, %edx
jne 0x9dd2
movq %rsi, %rdi
callq 0x18a44
movl $0x117, %edi            # imm = 0x117
jmp 0x9e51
movzbl 0x1a(%rbx), %edx
cmpl $0x51, %edx
je 0x9de5
movl $0x127, %ebp            # imm = 0x127
cmpl $0x4a, %edx
jne 0x9e01
cmpl $0xf, (%rax)
movq %rax, %rdx
jb 0x9df1
movq 0x10(%rax), %rdx
movl $0x107, %ebp            # imm = 0x107
cmpl $0xb, (%rdx)
jne 0x9e01
orb $0x30, %cl
movb %cl, 0x1b(%rbx)
movl (%rax), %ecx
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0x9e0f
movq 0x10(%rax), %rdx
cmpl $0xc, (%rdx)
je 0x9e22
cmpl $0xf, %ecx
jb 0x9e1d
movq 0x10(%rax), %rax
cmpl $0xb, (%rax)
jne 0x9e47
testq %rsi, %rsi
jne 0x9e31
leaq 0x281b2(%rip), %rax     # 0x31fe0
movq (%rax), %rsi
movl %ebp, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x17b61
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdi
callq 0x18a44
movl %ebp, %edi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x17b61
movq %rbx, 0x28(%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xab00
// File: /workspace/github_c_makefile_star2_O1/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 0xac0d
movl (%rax), %ecx
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0x200, %eax            # imm = 0x200
je 0x9ec7
cmpl $0x1f0, %eax            # imm = 0x1F0
je 0x9ec7
cmpl $0x220, %eax            # imm = 0x220
je 0x9ec7
movl %ecx, %edx
andl $-0x30, %edx
cmpl $0x210, %edx            # imm = 0x210
je 0x9ec7
cmpl $0x1e0, %eax            # imm = 0x1E0
je 0x9ec7
andl $-0x20, %ecx
cmpl $0x260, %ecx            # imm = 0x260
je 0x9ec7
cmpl $0x280, %eax            # imm = 0x280
je 0x9ec7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x280ca(%rip), %r15     # 0x31f98
movq (%r15), %rsi
movl $0x1, %edi
callq 0x9044
movq %rax, %r14
movq (%r15), %rsi
xorl %edi, %edi
callq 0x9044
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x9290
// File: /workspace/github_c_makefile_star2_O1/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), %ecx
movq %rbx, %rax
cmpl $0xf, %ecx
jb 0x9f18
movq 0x10(%rbx), %rax
cmpl $0xc, (%rax)
jne 0x9f53
movq %r14, %rdi
callq 0x9d77
movq %rax, %r14
movq 0x8(%r15), %rsi
movl $0x49, %edi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x17b61
movl $0x39, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x17b61
movq %rbx, %rax
cmpl $0xf, %ecx
jb 0x9f5f
movq 0x10(%rbx), %rax
movq %rax, 0x20(%r14)
movl (%rax), %ecx
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0x9f71
movq 0x10(%rax), %rdx
cmpl $0x9, (%rdx)
je 0x9f87
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0x9f82
movq 0x10(%rax), %rdx
cmpl $0xa, (%rdx)
jne 0x9f93
movq 0x18(%rax), %rax
movb 0x48(%rax), %cl
testb $0x1, %cl
jne 0x9fad
movq %r14, %rdi
callq 0x9d77
movl $0x30, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8c8d
jmp 0x9fd7
andb $-0x2, %cl
movb %cl, 0x48(%rax)
movq %r14, %rdi
callq 0x9d77
movl $0x30, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8c8d
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_O1/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 0xac0d
movl (%rax), %ecx
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0x200, %eax            # imm = 0x200
je 0xac02
cmpl $0x1f0, %eax            # imm = 0x1F0
je 0xac02
cmpl $0x220, %eax            # imm = 0x220
je 0xac02
movl %ecx, %edx
andl $-0x30, %edx
cmpl $0x210, %edx            # imm = 0x210
je 0xac02
cmpl $0x1e0, %eax            # imm = 0x1E0
je 0xac02
andl $-0x20, %ecx
cmpl $0x260, %ecx            # imm = 0x260
je 0xac02
cmpl $0x280, %eax            # imm = 0x280
je 0xac02
movq %rbx, %rdi
callq 0xac81
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xacd9
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa341
movq %rax, %rbx
leaq 0x1d58d(%rip), %rax     # 0x28160
movq 0x1b0(%rax), %r14
leaq 0x273b7(%rip), %rax     # 0x31f98
movq (%rax), %rsi
xorl %edi, %edi
callq 0x9044
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_O1/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 0xac3e
cmpl $0x2a0, (%rdi)          # imm = 0x2A0
jne 0xac5d
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0xac2b
cmpq $0x0, 0x18(%rdi)
je 0xac62
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rax, %rdi
testq %rax, %rax
jne 0xac13
leaq 0x1369d(%rip), %rdi     # 0x1e2e2
leaq 0x1446d(%rip), %rsi     # 0x1f0b9
leaq 0x14875(%rip), %rcx     # 0x1f4c8
movl $0x36f, %edx            # imm = 0x36F
callq 0x30d0
movq %rdi, %rax
popq %rcx
retq
leaq 0x14846(%rip), %rdi     # 0x1f4af
leaq 0x14449(%rip), %rsi     # 0x1f0b9
leaq 0x14851(%rip), %rcx     # 0x1f4c8
movl $0x36c, %edx            # imm = 0x36C
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rcx
cmpl $0xf, %eax
jb 0xac97
movq 0x10(%rdi), %rcx
cmpl $0xc, (%rcx)
jne 0xacab
cmpl $0x2a0, (%rbx)          # imm = 0x2A0
jne 0xacc3
cmpq $0x0, 0x28(%rbx)
je 0xacc3
movq %rdi, %rcx
cmpl $0xf, %eax
jb 0xacb7
movq 0x10(%rdi), %rcx
cmpl $0xb, (%rcx)
jne 0xacd4
callq 0x18a44
jmp 0xacc8
callq 0x18b7d
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x17ca2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0xf, (%rdi)
jb 0xace5
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0xacf3
movq 0x10(%rax), %rdx
cmpl $0x6, (%rdx)
je 0xad41
leaq 0x272a9(%rip), %rdx     # 0x31fa8
cmpq (%rdx), %rax
je 0xad41
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0xad10
movq 0x10(%rax), %rdx
cmpl $0x3, (%rdx)
jb 0xad26
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0xad21
movq 0x10(%rax), %rdx
cmpl $0x7, (%rdx)
jb 0xad37
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0xad32
movq 0x10(%rax), %rdx
cmpl $0xd, (%rdx)
jne 0xad41
leaq 0x2725a(%rip), %rax     # 0x31f98
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xadbc
movq %rax, %rbx
leaq 0x20d06(%rip), %rax     # 0x2ba58
cmpl $0x2, (%rax)
jl 0xadb3
movq 0x8(%rbx), %rax
cmpl $0xf, (%rax)
jb 0xad64
movq 0x10(%rax), %rax
cmpl $0xb, (%rax)
jne 0xadb3
leaq 0x1443b(%rip), %rsi     # 0x1f1ab
movl $0xfffffef9, %eax       # imm = 0xFFFFFEF9
addl (%rbx), %eax
cmpl $0x20, %eax
ja 0xada5
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0xada5
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x14018(%rip), %rdi     # 0x1edb3
xorl %eax, %eax
callq 0x11c7f
movq %rax, %rsi
leaq 0x143be(%rip), %rdi     # 0x1f16a
xorl %eax, %eax
callq 0x9be3
movq %rbx, %rdi
popq %rbx
jmp 0xab54
// File: /workspace/github_c_makefile_star2_O1/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 0xaeb9
movq %rax, %r14
leaq 0x20c09(%rip), %r12     # 0x2b9e0
movl (%r12), %eax
cmpl $0x2c, %eax
jne 0xae32
callq 0xe1c6
movl %eax, (%r12)
xorl %edi, %edi
callq 0xaeb9
movq %rax, %rdi
callq 0xac81
movq %rax, %r15
movl (%r14), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0xae19
movq %r14, %rdi
callq 0x9e6f
movq %rax, %rdi
callq 0x17ccb
movq %rax, %r14
movq 0x8(%r15), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rdx
movq %r15, %rcx
callq 0x17b61
movq %rax, %r14
jmp 0xadd7
testl %ebx, %ebx
sete %cl
cmpl %ebx, %eax
setne %al
orb %cl, %al
jne 0xae4b
callq 0xe1c6
movl %eax, (%r12)
jmp 0xae5d
testl %ebx, %ebx
je 0xae5d
leaq 0x1d70e(%rip), %rsi     # 0x28564
movl %ebx, %edi
callq 0x9bab
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21e4a(%rip), %rbx     # 0x2ccf8
incl (%rbx)
callq 0xaeb9
decl (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xafb9
movq %rax, %rbx
leaq 0x20b09(%rip), %r14     # 0x2b9e0
leaq 0x13f42(%rip), %r15     # 0x1ee20
leaq 0x1d27b(%rip), %r12     # 0x28160
leaq 0x13fb4(%rip), %r13     # 0x1eea0
movl (%r14), %ebp
cmpq $0x3d, %rbp
jne 0xaeff
callq 0xe1c6
movl %eax, (%r14)
jmp 0xaf23
movb (%rbp,%r15), %al
leal -0x6(%rax), %ecx
cmpb $0x3, %cl
setae %cl
cmpb $0xb, %al
setl %al
testb %cl, %al
jne 0xaf6c
callq 0xe1c6
movl %eax, (%r14)
cmpl $0x3d, %ebp
jne 0xaf34
xorl %edi, %edi
callq 0xaeb9
movq %rax, %rdi
callq 0x9e6f
jmp 0xaf57
movslq %ebp, %rbp
movl $0x3d, %edi
callq 0x983d
xorl %edi, %edi
callq 0xaeb9
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 0x8c8d
movq %rax, %rbx
jmp 0xaeec
movl 0x4(%rsp), %edi
testl %edi, %edi
sete %al
cmpl %edi, %ebp
setne %cl
orb %al, %cl
jne 0xaf88
callq 0xe1c6
movl %eax, (%r14)
jmp 0xaf98
testl %edi, %edi
je 0xaf98
leaq 0x1d5d5(%rip), %rsi     # 0x28568
callq 0x9bab
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_O1/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 0xb401
movq %rax, %rbx
leaq 0x20a08(%rip), %r14     # 0x2b9e0
cmpl $0x3f, (%r14)
jne 0xb10c
leaq 0x20a6f(%rip), %rax     # 0x2ba58
cmpl $0x2, (%rax)
jl 0xb04a
movq 0x8(%rbx), %rax
cmpl $0xf, (%rax)
jb 0xaffb
movq 0x10(%rax), %rax
cmpl $0xb, (%rax)
jne 0xb04a
leaq 0x141a4(%rip), %rsi     # 0x1f1ab
movl $0xfffffef9, %eax       # imm = 0xFFFFFEF9
addl (%rbx), %eax
cmpl $0x20, %eax
ja 0xb03c
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0xb03c
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x13d81(%rip), %rdi     # 0x1edb3
xorl %eax, %eax
callq 0x11c7f
movq %rax, %rsi
leaq 0x14127(%rip), %rdi     # 0x1f16a
xorl %eax, %eax
callq 0x9be3
movq %rbx, %rdi
callq 0xac81
movq %rax, %rbx
callq 0xe1c6
movl %eax, (%r14)
leaq 0x2099c(%rip), %r13     # 0x2ba00
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0xb0d9
xorl %ebp, %ebp
movq %rsp, %r15
movq %rbp, (%r15)
leaq 0x208bc(%rip), %r12     # 0x2b938
movq %r12, %rsi
movq %r15, %rdx
callq 0x102f8
movq (%r15), %r14
movl $0x3a, %edi
callq 0xadbc
movq %rax, %rdi
callq 0xac81
movq %r14, %rdi
movq %rax, %rsi
callq 0xb38e
movq %rax, %r14
movq %rbp, (%r15)
movq 0x18(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x102f8
movq (%r15), %r15
callq 0xafb9
movq %rax, %rdi
callq 0xac81
movq %r15, %rdi
movq %rax, %rsi
callq 0xb38e
jmp 0xb0fb
movl $0x3a, %edi
callq 0xadbc
movq %rax, %rdi
callq 0xac81
movq %rax, %r14
callq 0xafb9
movq %rax, %rdi
callq 0xac81
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9290
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_O1/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
cmpl $0xf, (%r12)
movq %r12, %rax
jb 0xb16f
movq 0x10(%r12), %rax
cmpl $0x7, (%rax)
jne 0xb17f
movq %r12, %rdi
callq 0x19254
movq %rax, %r12
cmpl $0xf, (%r12)
movq %r12, %r13
jb 0xb18e
movq 0x10(%r12), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x1969b
testq %rax, %rax
je 0xb26a
movq %rax, %r14
movq 0x8(%rax), %r15
movl (%r12), %eax
orl $0x10, %eax
cmpl $0x1f, %eax
jne 0xb1d0
movl (%r15), %eax
orl $0x10, %eax
cmpl $0x1f, %eax
je 0xb1d0
movl $0xf, %edi
movq %r15, %rsi
callq 0x19015
movq %rax, %r15
movl (%r12), %eax
cmpl $0x1f, %eax
je 0xb1de
cmpl $0x10, %eax
jne 0xb1fb
movl (%r15), %eax
cmpl $0x10, %eax
je 0xb1fb
cmpl $0x1f, %eax
je 0xb1fb
movl $0x10, %edi
movq %r15, %rsi
callq 0x19015
movq %rax, %r15
movq 0x8(%r14), %rax
cmpl $0xf, (%rax)
jb 0xb208
movq 0x10(%rax), %rax
cmpl $0xc, (%rax)
je 0xb218
movq %r15, %rdi
callq 0x18a44
movq %rax, %r15
movl 0x10(%r14), %edi
leaq 0x26d75(%rip), %rax     # 0x31f98
movq (%rax), %rsi
callq 0x9044
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x12653
cmpw $0x0, 0x16(%r14)
movq 0x8(%r14), %rbx
je 0xb29a
movq %rax, %rdi
callq 0xab00
movl $0x2b0, %edi            # imm = 0x2B0
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movq %r14, 0x28(%rax)
jmp 0xb2a8
leaq 0x13f1e(%rip), %rdi     # 0x1f18f
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x9720
leaq 0x26d13(%rip), %rax     # 0x31f98
movq (%rax), %rdi
callq 0x18a44
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17ca2
jmp 0xb2b2
cmpl $0xf, (%rbx)
jb 0xb2a3
movq 0x10(%rbx), %rbx
cmpl $0xc, (%rbx)
jne 0xb2b2
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 0xab00
// File: /workspace/github_c_makefile_star2_O1/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 0x21a28(%rip), %r14     # 0x2ccf8
incl (%r14)
callq 0xaeb9
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x10, %ecx
jne 0xb31e
movq 0x8(%rax), %rcx
movl (%rcx), %edx
movq %rcx, %rsi
cmpl $0xf, %edx
jb 0xb2f4
movq 0x10(%rcx), %rsi
cmpl $0x3, (%rsi)
jb 0xb31e
cmpl $0xf, %edx
jb 0xb302
movq 0x10(%rcx), %rcx
cmpl $0x6, (%rcx)
ja 0xb31e
leaq 0x26c8a(%rip), %rcx     # 0x31f98
movq (%rcx), %rsi
movq %rax, %rdi
callq 0xa341
movl 0x28(%rax), %ebx
jmp 0xb32c
leaq 0x13e91(%rip), %rdi     # 0x1f1b6
xorl %eax, %eax
callq 0x9720
decl (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb377
movq 0x8(%rbx), %rsi
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0xb357
movq 0x10(%rsi), %rax
leaq 0x26c82(%rip), %rcx     # 0x31fe0
cmpq (%rcx), %rax
jne 0xb371
leaq 0x13e71(%rip), %rdi     # 0x1f1db
xorl %eax, %eax
callq 0x9be3
movq 0x10(%rbx), %rax
popq %rbx
retq
leaq 0x13e75(%rip), %rdi     # 0x1f1f3
xorl %eax, %eax
callq 0x9720
movq %rbx, %rdi
popq %rbx
jmp 0x9e6f
// File: /workspace/github_c_makefile_star2_O1/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 0xb3e2
movq %rsi, %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xb3d0
movq 0x8(%rbx), %r14
callq 0x17ccb
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17b61
testq %rdi, %rdi
cmovneq %rdi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13e1b(%rip), %rdi     # 0x1f204
leaq 0x13cc9(%rip), %rsi     # 0x1f0b9
leaq 0x13e14(%rip), %rcx     # 0x1f20b
movl $0x363, %edx            # imm = 0x363
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/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 0xb550
movq %rax, %r12
leaq 0x205c0(%rip), %rbx     # 0x2b9e0
movl (%rbx), %eax
leaq 0x139f7(%rip), %rcx     # 0x1ee20
movsbl (%rax,%rcx), %r15d
movl %ebp, 0xc(%rsp)
cmpl %ebp, %r15d
jl 0xb53e
movl (%rbx), %r14d
leaq 0x139db(%rip), %rax     # 0x1ee20
movsbl (%r14,%rax), %eax
cmpl %eax, %r15d
jne 0xb52c
xorl %ebp, %ebp
cmpl $0x6, %r15d
setge %bpl
addl %r15d, %ebp
movl %r14d, %r13d
leaq 0x1f48e(%rip), %rax     # 0x2a8f8
movq (%rax), %rax
cmpb $0x3d, (%rax)
je 0xb52c
callq 0xe1c6
movl %eax, (%rbx)
movq %r12, %rdi
callq 0xac81
movq %rax, %r12
leaq 0x20571(%rip), %rax     # 0x2ba00
movq 0x18(%rax), %rdi
testq %rdi, %rdi
sete %al
andl $-0x2, %r13d
cmpl $0x32, %r13d
setne %cl
orb %al, %cl
jne 0xb4e3
movq $0x0, 0x10(%rsp)
leaq 0x20480(%rip), %rsi     # 0x2b938
leaq 0x10(%rsp), %rdx
callq 0x102f8
movq 0x10(%rsp), %r13
movl %ebp, %edi
callq 0xb401
movq %rax, %rdi
callq 0xac81
movq %r13, %rdi
movq %rax, %rsi
callq 0xb38e
jmp 0xb4f2
movl %ebp, %edi
callq 0xb401
movq %rax, %rdi
callq 0xac81
leaq 0x139a7(%rip), %rcx     # 0x1eea0
movl (%rcx,%r14,4), %edi
movq %r12, %rsi
movq %rax, %rdx
leaq 0x1cc56(%rip), %rax     # 0x28160
callq *(%rax,%r14,8)
movq %rax, %r12
movl (%rbx), %r14d
leaq 0x13905(%rip), %rax     # 0x1ee20
movsbl (%r14,%rax), %eax
movl %r14d, %r13d
cmpl %eax, %r15d
je 0xb463
leal -0x1(%r15), %eax
cmpl 0xc(%rsp), %r15d
movl %eax, %r15d
jg 0xb43b
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_O1/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 0x20d04(%rip), %rax     # 0x2ccf8
cmpl $0x0, (%rax)
je 0xc00b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25f86(%rip), %r13     # 0x31f98
movq (%r13), %r14
leaq 0x1e8eb(%rip), %rax     # 0x2a908
movl (%rax), %edi
movq %r14, %rsi
callq 0x9044
movl $0x25, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movq %rax, %r15
leaq 0x25f9d(%rip), %rbp     # 0x31fe0
movq (%rbp), %r14
movq (%r13), %r12
movq %rbx, %rdi
callq 0xab54
movl $0x270, %edi            # imm = 0x270
movq %r12, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movq %rax, %r12
movq (%r13), %r13
leaq 0x1f9ed(%rip), %rax     # 0x2ba60
movq (%rax), %rdi
callq 0x9d77
movq %rax, %rdi
callq 0xac81
movq (%rbp), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x910d
movl $0x2a0, %edi            # imm = 0x2A0
movq %r13, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movl $0x290, %edi            # imm = 0x290
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x17b61
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 0x17b61
// File: /workspace/github_c_makefile_star2_O1/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, 0x1ced3(%rip)     # 0x298c0
je 0xc9f6
movl %ebp, %edi
callq 0x1a72a
movl %ebp, 0x1cec4(%rip)     # 0x298c0
cmpb $0x51, 0x1a(%rbx)
je 0xca0a
movq %rbx, %rdi
callq 0x1a728
leaq 0x1f01f(%rip), %rax     # 0x2ba30
cmpl $0x0, (%rax)
je 0xca3a
leaq 0x22313(%rip), %rax     # 0x2ed30
cmpl $0x3, (%rax)
jne 0xca3a
movl 0x48(%rbx), %ebp
cmpl %ebp, 0x1ce95(%rip)     # 0x298c0
je 0xca34
movl %ebp, %edi
callq 0x1a72a
movl %ebp, 0x1ce86(%rip)     # 0x298c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a72b
// File: /workspace/github_c_makefile_star2_O1/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 0xcada
movl 0x48(%rdi), %eax
testl %eax, %eax
movl $0x4, %esi
cmovnel %eax, %esi
callq 0xc9dc
movq 0x20(%rbx), %rdi
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0xcaa7
movq 0x10(%rdi), %rax
cmpl $0xc, (%rax)
jne 0xcaba
movl 0x8(%rdi), %edi
movq 0x48(%rbx), %rsi
callq 0x1a936
jmp 0xcaca
callq 0x1a3e6
movq 0x48(%rbx), %rsi
movl %eax, %edi
callq 0x1a8a1
movq 0x50(%rbx), %rax
orb $0x1, 0x1b(%rax)
movq $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12a3b(%rip), %r14     # 0x1f535
leaq 0x12a16(%rip), %r15     # 0x1f517
movq %rax, %rbx
movl (%rax), %ecx
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0x8f, %eax
jg 0xcb56
leal -0x50(%rax), %edx
cmpl $0x30, %edx
ja 0xcb24
btq %rdx, %r12
jb 0xcbdf
cmpl $0x10, %eax
jne 0xcc29
cmpl $0x17, %ecx
jne 0xcbe8
movq 0x8(%rbx), %rax
cmpl $0xf, (%rax)
jb 0xcb43
movq 0x10(%rax), %rax
cmpl $0xc, (%rax)
jne 0xcbe8
movq %rbx, %rdi
callq 0x17ae1
jmp 0xcb01
cmpl $0xaf, %eax
jle 0xcba8
cmpl $0xb0, %eax
je 0xcbdf
cmpl $0x2a0, %eax            # imm = 0x2A0
jne 0xcc02
movq 0x10(%rbx), %rax
testq %rax, %rax
jne 0xcb83
cmpq $0x0, 0x18(%rbx)
je 0xcc58
testq %rax, %rax
je 0xcb99
cmpq $0x0, 0x18(%rbx)
je 0xcb99
movq %r15, %rdi
xorl %eax, %eax
callq 0x9720
movq 0x18(%rbx), %rax
testq %rax, %rax
jne 0xcb01
jmp 0xcbdf
cmpl $0x90, %eax
je 0xcbb8
cmpl $0xa0, %eax
je 0xcbdf
jmp 0xcc29
movq 0x8(%rbx), %rdx
cmpl $0xf, (%rdx)
movq %rdx, %rax
jb 0xcbc8
movq 0x10(%rdx), %rax
cmpl $0x6, (%rax)
ja 0xcbdf
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x9720
movq 0x10(%rbx), %rax
jmp 0xcb01
testl %ebp, %ebp
je 0xcc16
movq 0x8(%rbx), %rdi
callq 0x1a3e6
movq 0x28(%rbx), %rsi
movl %eax, %edi
callq 0x1a8a1
jmp 0xcc16
cmpl $0x100, %eax            # imm = 0x100
jne 0xcc29
testl %ebp, %ebp
je 0xcc16
movq 0x28(%rbx), %rdi
callq 0x1a971
addq $0x8, %rbx
movq (%rbx), %rax
movl 0x8(%rax), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x128e7(%rip), %rdi     # 0x1f517
xorl %eax, %eax
callq 0x9720
leaq 0x2535a(%rip), %rbx     # 0x31f98
testl %ebp, %ebp
je 0xcc1a
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x9044
movq %rax, %rdi
movl %ebp, %esi
callq 0xcadc
jmp 0xcc1a
leaq 0x12879(%rip), %rdi     # 0x1f4d8
leaq 0x1288b(%rip), %rsi     # 0x1f4f1
leaq 0x12892(%rip), %rcx     # 0x1f4ff
movl $0x70, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/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 0x1ed5b(%rip), %r14     # 0x2b9e0
testl %esi, %esi
jne 0xcc93
cmpl $0x3d, (%r14)
jne 0xcd31
movl $0x3, %esi
cmpb $0x51, 0x1a(%rbx)
jne 0xcccb
leaq 0x20(%rbx), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq %rax, %rdx
cmpl $0xf, %ecx
jb 0xccb3
movq 0x10(%rax), %rdx
addq $0x10, %rax
cmpl $0xc, (%rdx)
je 0xcca2
andl $-0x11, %ecx
xorl %esi, %esi
cmpl $0xf, %ecx
sete %sil
addl $0x3, %esi
movq %rbx, %rdi
callq 0xc9dc
cmpl $0x3d, (%r14)
jne 0xcce1
callq 0xe1c6
movl %eax, (%r14)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0xcd39
movq 0x20(%rbx), %rcx
cmpl $0xf, (%rcx)
movq %rcx, %rdx
jb 0xccfc
movq 0x10(%rcx), %rdx
cmpl $0xc, (%rdx)
jne 0xcd0b
cmpl $0x0, 0x8(%rcx)
jne 0xcd0b
movq %rax, 0x20(%rbx)
orb $0x1, 0x1b(%rbx)
cmpb $0x4a, 0x1a(%rbx)
jne 0xcd19
movb $0x43, 0x1a(%rbx)
leaq 0x22010(%rip), %rax     # 0x2ed30
cmpl $0x3, (%rax)
jg 0xcd31
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17f3f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genasgn
static int genasgn(e, sp) Tree e; struct structexp *sp; {
	Tree p;

	sp->off = roundup(sp->off, e->type->size);
	p = simplify(ADD+P, ptr(e->type), lvalue(idnode(sp->var)), constnode(sp->off, inttype));
	if (isarray(e->type)) {
		p = tree(ASGN+B, e->type, p, e);
		p->u.sym = intconst(e->type->size);
	} else
		p = asgnnode(ASGN, retype(rvalue(p), e->type), e);
	sp->tree = tree(RIGHT, voidtype, sp->tree, p);
	sp->off += e->type->size;
	return e->type->size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movq 0x8(%rdi), %rdi
movl 0x8(%rdi), %ecx
addl %ecx, %eax
decl %eax
negl %ecx
andl %eax, %ecx
movl %ecx, 0x8(%rsi)
callq 0x18a44
movq %rax, %r15
movq (%rbx), %rdi
callq 0x9d77
movq %rax, %rdi
callq 0xb339
movq %rax, %r12
movl 0x8(%rbx), %edi
leaq 0x24bc4(%rip), %rax     # 0x31f98
movq (%rax), %rsi
callq 0x9044
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x12653
movq 0x8(%r14), %rsi
cmpl $0xf, (%rsi)
movq %rsi, %rcx
jb 0xd3ff
movq 0x10(%rsi), %rcx
cmpl $0xc, (%rcx)
jne 0xd429
movl $0x39, %edi
movq %rax, %rdx
movq %r14, %rcx
callq 0x17b61
movq %rax, %r15
movq 0x8(%r14), %rax
movl 0x8(%rax), %edi
callq 0x1774b
movq %rax, 0x28(%r15)
jmp 0xd450
movq %rax, %rdi
callq 0xab00
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x17ca2
movl $0x30, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x8c8d
movq %rax, %r15
leaq 0x24b89(%rip), %rax     # 0x31fe0
movq (%rax), %rsi
movq 0x10(%rbx), %rdx
movl $0x2a0, %edi            # imm = 0x2A0
movq %r15, %rcx
callq 0x17b61
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movl 0x8(%rax), %eax
addl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq