LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: dclparam
static Symbol dclparam(int sclass, char *id, Type ty, Coordinate *pos) {
	Symbol p;

	if ((p = lookup(id, identifiers)) && p->scope == level
	&& (p->defined || p->type == 0 && ty == 0))
		error("duplicate definition for `%s' previously declared at %w\n",
			id, &p->src);
	else if (p == 0 || p->scope < level)
		p = install(id, &identifiers, 0);
	if (ty && isfunc(ty))
		ty = ptr(ty);
	else if (ty && isarray(ty))
		ty = atop(ty);
	if (sclass == 0)
		sclass = AUTO;
	if (sclass == REGISTER && ty && (isvolatile(ty) || isstruct(ty))) {
		warning("register declaration ignored for `%t%s\n", ty,
			stringf(id ? " %s'" : "' parameter", id));
		sclass = AUTO;
	}
	p->sclass = sclass;
	p->src = *pos;
	if (p->type = ty)
		p->defined = 1;
	if (t == '=') {
		error("illegal initialization for parameter `%s'\n", id);
		t = gettok();
		expr1(0);
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x21fd2(%rip), %rax     # 0x292e8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x15ec0
testq %rax, %rax
je 0x7368
movq %rax, %r14
movzwl 0x18(%rax), %eax
leaq 0x279fc(%rip), %rcx     # 0x2ed30
movl (%rcx), %ecx
cmpl %eax, %ecx
jne 0x7364
testb $0x1, 0x1b(%r14)
jne 0x734a
movq 0x20(%r14), %rdx
orq %r12, %rdx
jne 0x7364
movq %r14, %rdx
addq $0x28, %rdx
leaq 0x153b5(%rip), %rdi     # 0x1c70d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8dd4
jmp 0x737c
cmpl %eax, %ecx
jle 0x737c
leaq 0x21f79(%rip), %rsi     # 0x292e8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15f13
movq %rax, %r14
testq %r12, %r12
je 0x73a0
movl (%r12), %eax
cmpl $0xf, %eax
jb 0x7391
movq 0x10(%r12), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0x73a5
movq %r12, %rdi
callq 0x1736a
jmp 0x73b2
xorl %r12d, %r12d
jmp 0x73b5
cmpl $0xc, %eax
jne 0x73b5
movq %r12, %rdi
callq 0x1749b
movq %rax, %r12
testl %ebp, %ebp
pushq $0x43
popq %r13
cmovel %r13d, %ebp
cmpl $0x4e, %ebp
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7430
movl (%r12), %eax
cmpl $0x10, %eax
je 0x73fa
cmpl $0x1f, %eax
je 0x73fa
cmpl $0xf, %eax
jb 0x73ec
movq 0x10(%r12), %rax
movl (%rax), %eax
cmpl $0x9, %eax
je 0x73fa
cmpl $0xa, %eax
jne 0x748a
testq %rbx, %rbx
leaq 0x1536f(%rip), %rax     # 0x1c773
leaq 0x15363(%rip), %rdi     # 0x1c76e
cmoveq %rax, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a97
leaq 0x15326(%rip), %rdi     # 0x1c746
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x9239
movl %r13d, %ebp
movb %bpl, 0x1a(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x28(%r14)
movq %r12, 0x20(%r14)
testq %r12, %r12
je 0x744b
orb $0x1, 0x1b(%r14)
leaq 0x2458e(%rip), %r15     # 0x2b9e0
cmpl $0x3d, (%r15)
jne 0x7478
leaq 0x15320(%rip), %rdi     # 0x1c77f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8dd4
callq 0xd3c9
movl %eax, (%r15)
xorl %edi, %edi
callq 0xa439
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4e
popq %rbp
jmp 0x7430
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: oldparam
static void oldparam(Symbol p, Generic cl) {
	Symbol *callee = (Symbol *)cl;
	int i;

	for (i = 0; callee[i]; i++)
		if (p->name == callee[i]->name) {
			callee[i] = p;
			return;
		}
	error("declared parameter `%s' is missing\n", p->name);
}

// Assembly:
movq %rsi, %rax
movq 0x10(%rdi), %rsi
movq (%rax), %rcx
testq %rcx, %rcx
je 0x74ad
addq $0x8, %rax
cmpq 0x10(%rcx), %rsi
jne 0x7496
movq %rdi, -0x8(%rax)
retq
leaq 0x152f6(%rip), %rdi     # 0x1c7aa
xorl %eax, %eax
jmp 0x8dd4
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: tnode
static Type tnode(int op, Type type) {
	Type ty = (Type) talloc(sizeof *ty);

	ty->op = op;
	ty->type = type;
	return ty;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x22027(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x28, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x28(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x776e
movq %rdx, 0x8(%rcx)
jmp 0x777d
leaq 0x22003(%rip), %rsi     # 0x29778
pushq $0x28
popq %rdi
callq 0x16438
movl %ebp, (%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: bitnode
Tree bitnode(int op, Tree l, Tree r) {
	Type ty = inttype;

	if (isint(l->type) && isint(r->type)) {
 		ty = binary(l->type, r->type);
		l = cast(l, ty);
		r = cast(r, ty);
		if (op != MOD) {
			l = cast(l, unsignedtype);
			r = cast(r, unsignedtype);
		}
	} else
		typeerror(op, l, r);
	if (op == MOD)
		return simplify(op, ty, l, r);
	return cast(simplify(op, unsignedtype, l, r), ty);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
leaq 0x2a521(%rip), %rax     # 0x31f98
movq (%rax), %rbx
movq 0x8(%rsi), %rdi
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x7a92
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x2, %eax
ja 0x7a97
jmp 0x7b11
cmpl $0x3, %eax
jb 0x7b11
cmpl $0x6, %eax
ja 0x7b11
movq 0x8(%r14), %rsi
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x7ab4
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x2, %eax
ja 0x7ab9
jmp 0x7b11
cmpl $0x3, %eax
jb 0x7b11
cmpl $0x6, %eax
ja 0x7b11
callq 0x8773
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x9912
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9912
movq %rax, %r14
cmpl $0x160, %ebp            # imm = 0x160
je 0x7b26
leaq 0x2a4e7(%rip), %r12     # 0x31fd8
movq (%r12), %rsi
movq %r15, %rdi
callq 0x9912
movq %rax, %r15
movq (%r12), %rsi
movq %r14, %rdi
callq 0x9912
movq %rax, %r14
jmp 0x7b41
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x86ad
cmpl $0x160, %ebp            # imm = 0x160
jne 0x7b41
movl $0x160, %edi            # imm = 0x160
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1131b
leaq 0x2a490(%rip), %rax     # 0x31fd8
movq (%rax), %rsi
movl %ebp, %edi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1131b
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9912
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: addnode
static Tree addnode(int op, Tree l, Tree r) {
	int n;
	Type ty = inttype;

	if (isarith(l->type) && isarith(r->type)) {
		ty = binary(l->type, r->type);
		l = cast(l, ty);
		r = cast(r, ty);
	} else if (isptr(l->type) && isint(r->type))
		return addnode(ADD, r, l);
	else if (isptr(r->type) && isint(l->type)) {
		ty = unqual(r->type);
		if ((n = ty->type->size) == 0)
			error("unknown size of type `%t'\n", ty->type);
		l = cast(l, promote(l->type));
		if (n > 1)
			l = mulnode(MUL, constnode(n, inttype), l);
		return simplify(ADD+P, ty, l, r);
	} else
		typeerror(op, l, r);
	return simplify(op, ty, l, r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %edi, %eax
movq 0x8(%rsi), %r15
movl (%r15), %edx
movq %r14, %rbx
movq %rsi, %r14
movl %eax, %ebp
movq %r15, %rdi
movl %edx, %ecx
movl %edx, %eax
cmpl $0xf, %edx
jb 0x7b99
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x6, %eax
ja 0x7bb4
movq 0x8(%rbx), %rsi
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x7baf
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x6, %eax
jbe 0x7c0a
movl %ecx, %eax
cmpl $0xf, %ecx
jb 0x7bc1
movq 0x10(%rdi), %rax
movl (%rax), %eax
movq 0x8(%rbx), %r15
movl (%r15), %edx
cmpl $0x7, %eax
jne 0x7bf7
cmpl $0xf, %edx
jb 0x7be1
movq 0x10(%r15), %rax
movl (%rax), %r8d
cmpl $0x2, %r8d
ja 0x7be9
jmp 0x7c42
movl %edx, %r8d
cmpl $0x2, %edx
jbe 0x7c33
movl $0x130, %eax            # imm = 0x130
movq %rbx, %rsi
cmpl $0x7, %r8d
jb 0x7b7f
leaq 0x2a39a(%rip), %rax     # 0x31f98
movq (%rax), %r12
cmpl $0xf, %edx
jae 0x7c4c
xorl %eax, %eax
jmp 0x7c54
callq 0x8773
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x9912
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9912
movq %rax, %rbx
jmp 0x7cf3
leaq 0x2a35e(%rip), %rax     # 0x31f98
movq (%rax), %r12
jmp 0x7ce6
leaq 0x2a34f(%rip), %rax     # 0x31f98
movq (%rax), %r12
movq 0x10(%r15), %rax
movl (%rax), %edx
movb $0x1, %al
cmpl $0x7, %edx
jne 0x7ce6
cmpl $0xf, %ecx
jb 0x7c6f
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
cmpl $0x2, %ecx
ja 0x7c76
jmp 0x7ce6
movl (%rdi), %ecx
cmpl $0x3, %ecx
jb 0x7ce6
cmpl $0x6, %ecx
ja 0x7ce6
testb %al, %al
je 0x7c83
movq 0x10(%r15), %r15
movq 0x10(%r15), %rsi
movl 0x8(%rsi), %ebp
testl %ebp, %ebp
jne 0x7c9c
leaq 0x15082(%rip), %rdi     # 0x1cd17
xorl %eax, %eax
callq 0x8dd4
movq 0x8(%r14), %rdi
callq 0xa287
movq %r14, %rdi
movq %rax, %rsi
callq 0x9912
movq %rax, %r14
cmpl $0x2, %ebp
jl 0x7cdc
leaq 0x2a2d9(%rip), %rax     # 0x31f98
movq (%rax), %rsi
movl %ebp, %edi
callq 0x8726
movl $0x1d0, %edi            # imm = 0x1D0
movq %rax, %rsi
movq %r14, %rdx
callq 0x7d0b
movq %rax, %r14
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
jmp 0x7cf8
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x86ad
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1131b
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: mulnode
static Tree mulnode(int op, Tree l, Tree r){
	Type ty = inttype;

	if (isarith(l->type) && isarith(r->type)) {
		ty = binary(l->type, r->type);
		l = cast(l, ty);
		r = cast(r, ty);
	} else
		typeerror(op, l, r);
	return simplify(op, ty, l, r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x2a277(%rip), %rax     # 0x31f98
movq 0x8(%rsi), %rdi
movl (%rdi), %ecx
cmpl $0xf, %ecx
jb 0x7d32
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
movq (%rax), %r15
cmpl $0x6, %ecx
ja 0x7d76
movq 0x8(%rbx), %rsi
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x7d4b
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x6, %eax
ja 0x7d76
callq 0x8773
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x9912
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9912
movq %rax, %rbx
jmp 0x7d83
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x86ad
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1131b
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: cmpnode
static Tree cmpnode(int op, Tree l, Tree r) {
	Type ty = unsignedtype;

	if (isarith(l->type) && isarith(r->type)) {
		ty = binary(l->type, r->type);
		l = cast(l, ty);
		r = cast(r, ty);
	} else if (compatible(l->type, r->type)) {
		l = cast(l, ty);
		r = cast(r, ty);
	} else
		typeerror(op, l, r);
	return simplify(op + ttob(ty), inttype, l, r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
leaq 0x29faf(%rip), %rax     # 0x31fd8
movq 0x8(%rsi), %rdi
movl (%rdi), %ecx
cmpl $0xf, %ecx
jb 0x803a
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
movq (%rax), %r12
movq 0x8(%r14), %rsi
cmpl $0x6, %ecx
ja 0x8068
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x8053
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x6, %eax
ja 0x8068
callq 0x8773
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
jmp 0x8077
callq 0x8d68
testl %eax, %eax
je 0x808f
movq %r15, %rdi
movq %r12, %rsi
callq 0x9912
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x9912
movq %rax, %r14
jmp 0x809c
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x86ad
movq %r12, %rdi
callq 0x18b82
addl %eax, %ebx
leaq 0x29eeb(%rip), %rax     # 0x31f98
movq (%rax), %rsi
movl %ebx, %edi
movq %r15, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1131b
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: shnode
Tree shnode(int op, Tree l, Tree r) {
	Type ty = inttype;

	if (isint(l->type) && isint(r->type)) {
		ty = promote(l->type);
		l = cast(l, ty);
		r = cast(r, inttype);
	} else
		typeerror(op, l, r);
	return simplify(op, ty, l, r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x29caa(%rip), %r12     # 0x31f98
movq (%r12), %r15
movq 0x8(%rsi), %rdi
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x830a
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x2, %eax
ja 0x830f
jmp 0x835d
cmpl $0x3, %eax
jb 0x835d
cmpl $0x6, %eax
ja 0x835d
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0x832c
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0x2, %eax
ja 0x8331
jmp 0x835d
cmpl $0x3, %eax
jb 0x835d
cmpl $0x6, %eax
ja 0x835d
callq 0xa287
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x9912
movq %rax, %r14
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x9912
movq %rax, %rbx
jmp 0x836a
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x86ad
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1131b
// File: /workspace/github_c_makefile_star2_O2/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 0x873c
movq 0x10(%r14), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0x8751
movq %r14, %rdi
callq 0x1749b
pushq $0x17
popq %rdi
movq %rax, %rsi
jmp 0x875f
movq %r14, %rdi
callq 0x18b82
leal 0x10(%rax), %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x165eb
movl %ebx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8782
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
leaq 0x297ff(%rip), %rdx     # 0x31f88
cmpl $0x2, %ecx
je 0x87f2
movl (%rsi), %ecx
movl %ecx, %r8d
cmpl $0xf, %ecx
jb 0x879f
movq 0x10(%rsi), %r8
movl (%r8), %r8d
cmpl $0x2, %r8d
je 0x87f2
leaq 0x297e4(%rip), %rdx     # 0x31f90
movq (%rdx), %r8
cmpq %rdi, %r8
sete %r9b
cmpq %rsi, %r8
sete %r8b
orb %r9b, %r8b
jne 0x87f2
cmpl $0xf, %eax
jb 0x87cd
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x6, %eax
je 0x87e2
cmpl $0xf, %ecx
jb 0x87dd
movq 0x10(%rsi), %rax
movl (%rax), %ecx
cmpl $0x6, %ecx
jne 0x87eb
leaq 0x297ef(%rip), %rdx     # 0x31fd8
jmp 0x87f2
leaq 0x297a6(%rip), %rdx     # 0x31f98
movq (%rdx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x881a
movq 0x8(%r14), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rcx
callq 0x165eb
movq %rax, %r14
movl (%rbx), %eax
cmpl $0xf, %eax
jb 0x8831
movq 0x10(%rbx), %rsi
movl (%rsi), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x883c
jmp 0x88a7
leal -0x9(%rax), %ecx
movq %rbx, %rsi
cmpl $0x1, %ecx
ja 0x88a4
pushq $0x43
popq %rdi
callq 0x16311
movq %rax, %r15
cmpl $0x0, 0x8(%rbx)
jne 0x885e
leaq 0x13da1(%rip), %rdi     # 0x1c5f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8dd4
movq %r15, %rdi
callq 0x93b4
movq %rax, %rdi
callq 0xa87d
movl $0xd9, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x165eb
movq %rax, %r14
movq %r15, %rdi
callq 0x93b4
movl $0x2a0, %edi            # imm = 0x2A0
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x165eb
movq %rbx, %rsi
cmpl $0xd, %eax
jne 0x88b2
movq 0x10(%rsi), %r15
jmp 0x88c4
movq %rbx, %r15
cmpl $0x7, %eax
jne 0x88c4
leaq 0x29717(%rip), %rax     # 0x31fd8
movq (%rax), %r15
movl (%r15), %eax
cmpl $0xf, %eax
jb 0x88d2
movq 0x10(%r15), %rax
movl (%rax), %eax
cmpl $0x2, %eax
jbe 0x88e6
movl $0xd5, %edi
cmpl $0x7, %eax
jb 0x88f6
cmpl $0xd, %eax
je 0x88f6
movq %r15, %rdi
callq 0x18b82
movl %eax, %edi
addl $0xd0, %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x165eb
movl (%rbx), %ecx
cmpl $0xf, %ecx
jb 0x8910
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
cmpl $0x7, %ecx
jne 0x8925
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9912
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8d75
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x8dd1
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x8d87
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x8dd1
movq 0x10(%rdi), %rdi
cmpl $0xf, (%rdi)
jb 0x8d99
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
cmpl $0xf, (%rsi)
jb 0x8da6
movq 0x10(%rsi), %rsi
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x8db3
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x8dca
movl (%rsi), %eax
cmpl $0xf, %eax
jb 0x8dc5
movq 0x10(%rsi), %rax
movl (%rax), %eax
cmpl $0x7, %eax
je 0x8d8c
xorl %edx, %edx
jmp 0x17b46
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0xd8, %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 0x8e34
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 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
leaq 0x21acd(%rip), %rax     # 0x2a928
movq (%rax), %rdx
testq %rdx, %rdx
je 0x8e85
leaq 0x21aa6(%rip), %rax     # 0x2a910
cmpq (%rax), %rdx
je 0x8e85
cmpb $0x0, (%rdx)
je 0x8e85
leaq 0x13ed9(%rip), %rsi     # 0x1cd54
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x10528
leaq 0x13ecd(%rip), %rsi     # 0x1cd59
leaq 0x22aa5(%rip), %rdx     # 0x2b938
pushq $0x2
popq %rbp
movl %ebp, %edi
xorl %eax, %eax
callq 0x10528
movq %rsp, %rdx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x105ac
movl 0x209fa(%rip), %eax     # 0x298ac
incl %eax
movl %eax, 0x209f2(%rip)     # 0x298ac
cmpl 0x1f6a0(%rip), %eax     # 0x28560
jge 0x8ecc
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
orl $-0x1, 0x209d9(%rip)    # 0x298ac
leaq 0x13e84(%rip), %rdi     # 0x1cd5e
xorl %eax, %eax
callq 0x8dd4
pushq $0x1
popq %rdi
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O2/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 0x22aec(%rip), %r14     # 0x2b9e0
cmpl %edi, (%r14)
jne 0x8f05
callq 0xd3c9
movl %eax, %ebx
movl %eax, (%r14)
jmp 0x8f3b
movl %edi, %ebp
decl 0x2099f(%rip)           # 0x298ac
leaq 0x13e5b(%rip), %rdi     # 0x1cd6f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8dd4
callq 0x8f42
leaq 0x13e5a(%rip), %rsi     # 0x1cd83
pushq $0x2
popq %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10528
incl 0x20971(%rip)           # 0x298ac
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22a8c(%rip), %rax     # 0x2b9e0
movl (%rax), %edx
leal -0x20(%rdx), %eax
cmpl $0x7, %eax
ja 0x8f97
leaq 0x13dcf(%rip), %rcx     # 0x1cd34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x229d3(%rip), %rax     # 0x2b948
movq (%rax), %rdx
leaq 0x13e4b(%rip), %rsi     # 0x1cdca
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10528
cmpl $0x60, %edx
jne 0x8fa5
leaq 0x13e31(%rip), %rsi     # 0x1cdd4
jmp 0x8fac
leaq 0x13e2e(%rip), %rsi     # 0x1cdda
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10528
leaq 0x2297d(%rip), %rax     # 0x2b948
movq (%rax), %rax
cmpb $0x27, (%rax)
jne 0x9039
leaq 0x132ea(%rip), %rsi     # 0x1c2c4
pushq $0x2
popq %rbx
movl %ebx, %edi
xorl %eax, %eax
callq 0x10528
leaq 0x2295b(%rip), %r14     # 0x2b948
movq (%r14), %r15
leaq 0x13dd9(%rip), %r12     # 0x1cdd0
leaq 0x15eed(%rip), %r13     # 0x1eeeb
movq %r15, %rax
movq %r15, %rbp
movsbl (%rbp), %edx
testl %edx, %edx
je 0x9079
movq %r15, %rcx
subq %rax, %rcx
cmpq $0x13, %rcx
jg 0x9079
leal -0x7f(%rdx), %eax
movq %r12, %rsi
cmpb $-0x5f, %al
jb 0x9025
movq %r13, %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x10528
incq %rbp
movq (%r14), %rax
incq %r15
jmp 0x9004
leaq 0x218b8(%rip), %rbx     # 0x2a8f8
movq (%rbx), %rax
movb (%rax), %bpl
movb $0x0, (%rax)
leaq 0x228f8(%rip), %rax     # 0x2b948
movq (%rax), %rdx
leaq 0x13d70(%rip), %rsi     # 0x1cdca
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x10528
movq (%rbx), %rax
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %dl, %dl
je 0x909c
leaq 0x16889(%rip), %rsi     # 0x1f90d
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10528
movsbl (%rax), %edx
leaq 0x15e45(%rip), %rsi     # 0x1eeeb
pushq $0x2
popq %rdi
jmp 0x8faf
// File: /workspace/github_c_makefile_star2_O2/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 0x1f54e(%rip), %rax     # 0x28610
movq (%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rax)
movb $0xa, (%rcx)
callq 0x10613
leaq 0x13cb9(%rip), %rdi     # 0x1cd94
movq %r15, %rsi
xorl %eax, %eax
callq 0x8dd4
pushq $0x2
popq %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10528
pushq $0x1
popq %rdi
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x228cd(%rip), %r13     # 0x2b9e0
movl (%r13), %eax
leaq 0x13c8d(%rip), %r14     # 0x1cdab
leaq 0x1f45b(%rip), %r15     # 0x28580
xorl %ecx, %ecx
cmpl $0x7f, %eax
je 0x91a6
cmpl %ebp, %eax
je 0x91a6
testq %rbx, %rbx
je 0x9154
movl %eax, %eax
movb (%r15,%rax), %al
movq %rbx, %rdx
movb (%rdx), %sil
testb %sil, %sil
je 0x9150
incq %rdx
cmpb %sil, %al
jne 0x913e
jmp 0x91a6
testb %al, %al
je 0x91a6
leal 0x1(%rcx), %r12d
testl %ecx, %ecx
je 0x917a
cmpl $0x7, %ecx
jbe 0x9193
cmpl $0x9, %r12d
jne 0x9198
pushq $0x2
popq %rdi
leaq 0x13c43(%rip), %rsi     # 0x1cdb4
xorl %eax, %eax
callq 0x10528
jmp 0x9198
decl 0x2072c(%rip)           # 0x298ac
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dd4
callq 0x8f42
callq 0xd3c9
movl %eax, (%r13)
movl %r12d, %ecx
jmp 0x9127
cmpl $0x9, %ecx
jb 0x91cf
decl 0x206fb(%rip)           # 0x298ac
leaq 0x13c02(%rip), %rdi     # 0x1cdba
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dd4
callq 0x8f42
jmp 0x91d3
testl %ecx, %ecx
je 0x91f2
leaq 0x149ba(%rip), %rsi     # 0x1db94
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10528
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x227d3(%rip), %r15     # 0x2b9e0
cmpl %edi, (%r15)
je 0x922b
movq %rsi, %r14
movl %edi, %ebx
callq 0x8ee9
movl %ebx, %edi
movq %r14, %rsi
callq 0x90fc
cmpl %ebx, (%r15)
jne 0x9233
callq 0xd3c9
movl %eax, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9298
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, 0x205f1(%rip)     # 0x298b0
jne 0x92e3
decl 0x205e5(%rip)           # 0x298ac
leaq 0x13af2(%rip), %rdi     # 0x1cdc0
xorl %eax, %eax
callq 0x8dd4
pushq $0x2
popq %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x105ac
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x30, %ecx
je 0x9325
cmpl $0x2a0, %ecx            # imm = 0x2A0
jne 0x932b
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, %rdx
orq %rax, %rdx
je 0x9397
testq %rax, %rax
cmovneq %rax, %rcx
movq %rcx, %rax
jmp 0x92f7
movq 0x18(%rax), %rax
jmp 0x92f7
cmpl $0x40, %ecx
je 0x9346
cmpl $0x290, %ecx            # imm = 0x290
jne 0x9373
movq 0x28(%rax), %rdi
andq $0x0, 0x28(%rax)
callq 0x93b4
movq 0x10(%rax), %r14
cmpq %rbx, %rax
je 0x938e
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x16750
movl $0x2a0, %edi            # imm = 0x2A0
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x165eb
leaq 0x13dab(%rip), %rdi     # 0x1d125
xorl %eax, %eax
callq 0x8dd4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x94a3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x13d52(%rip), %rdi     # 0x1d0f0
leaq 0x13d64(%rip), %rsi     # 0x1d109
leaq 0x13d6b(%rip), %rcx     # 0x1d117
pushq $0x1e
popq %rdx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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 0x93d1
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0x93db
leaq 0x10(%rsi), %rax
jmp 0x93d8
leaq 0x28c08(%rip), %rax     # 0x31fe0
movq (%rax), %rax
leaq 0x1f2a2(%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 0x9422
cmpl $0x4, %edx
jne 0x940f
movq %rsi, %rdi
callq 0x1736a
movl $0x117, %edi            # imm = 0x117
jmp 0x9485
movzbl 0x1a(%rbx), %edx
cmpl $0x51, %edx
je 0x9422
movl $0x127, %ebp            # imm = 0x127
cmpl $0x4a, %edx
jne 0x943f
movl (%rax), %edx
cmpl $0xf, %edx
jb 0x942f
movq 0x10(%rax), %rdx
movl (%rdx), %edx
movl $0x107, %ebp            # imm = 0x107
cmpl $0xb, %edx
jne 0x943f
orb $0x30, %cl
movb %cl, 0x1b(%rbx)
movl (%rax), %ecx
cmpl $0xf, %ecx
jb 0x944c
movq 0x10(%rax), %rax
movl (%rax), %ecx
cmpl $0xc, %ecx
je 0x9456
cmpl $0xb, %ecx
jne 0x947b
testq %rsi, %rsi
jne 0x9465
leaq 0x28b7e(%rip), %rax     # 0x31fe0
movq (%rax), %rsi
movl %ebp, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x165eb
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdi
callq 0x1736a
movl %ebp, %edi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x165eb
movq %rbx, 0x28(%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa0b9
// File: /workspace/github_c_makefile_star2_O2/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 0xa1c2
movl (%rax), %eax
movd %eax, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pand 0x1391d(%rip), %xmm0    # 0x1cde0
pshufd $0x10, %xmm0, %xmm1     # xmm1 = xmm0[0,0,1,0]
pcmpeqd 0x13920(%rip), %xmm1    # 0x1cdf0
movmskps %xmm1, %ecx
testl %ecx, %ecx
jne 0x94fc
andl $-0x20, %eax
cmpl $0x260, %eax            # imm = 0x260
je 0x94fc
movd %xmm0, %eax
cmpl $0x1f0, %eax            # imm = 0x1F0
je 0x94fc
cmpl $0x200, %eax            # imm = 0x200
je 0x94fc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x28a95(%rip), %r15     # 0x31f98
movq (%r15), %rsi
pushq $0x1
popq %rdi
callq 0x8726
movq %rax, %r14
movq (%r15), %rsi
xorl %edi, %edi
callq 0x8726
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x892b
// File: /workspace/github_c_makefile_star2_O2/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 0x9560
movq 0x10(%rbx), %rax
movl (%rax), %ecx
cmpl $0xc, %ecx
je 0x956c
movq %rax, 0x20(%r14)
cmpl $0xf, %ecx
jb 0x95b0
movq 0x10(%rax), %rsi
movl (%rsi), %esi
jmp 0x959e
movl %edx, %ecx
movl %edx, %esi
movq %rbx, %rax
cmpl $0xc, %edx
jne 0x959e
movq %r14, %rdi
callq 0x93b4
movq %rax, %r14
movq 0x8(%r15), %rsi
pushq $0x49
popq %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x165eb
pushq $0x39
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x165eb
cmpl $0x9, %esi
je 0x95ba
cmpl $0xf, %edx
jb 0x95b5
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
jmp 0x95b5
cmpl $0x9, %ecx
je 0x95ba
cmpl $0xa, %ecx
jne 0x95c6
movq 0x18(%rax), %rax
movb 0x48(%rax), %cl
testb $0x1, %cl
jne 0x95de
movq %r14, %rdi
callq 0x93b4
pushq $0x30
popq %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8382
jmp 0x9606
andb $-0x2, %cl
movb %cl, 0x48(%rax)
movq %r14, %rdi
callq 0x93b4
pushq $0x30
popq %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8382
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_O2/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 0xa1c2
movl (%rax), %eax
movd %eax, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pand 0x12cb1(%rip), %xmm0    # 0x1cde0
pshufd $0x10, %xmm0, %xmm1     # xmm1 = xmm0[0,0,1,0]
pcmpeqd 0x12cb4(%rip), %xmm1    # 0x1cdf0
movmskps %xmm1, %ecx
testl %ecx, %ecx
jne 0xa1b7
andl $-0x20, %eax
cmpl $0x260, %eax            # imm = 0x260
je 0xa1b7
movd %xmm0, %eax
cmpl $0x1f0, %eax            # imm = 0x1F0
je 0xa1b7
cmpl $0x200, %eax            # imm = 0x200
je 0xa1b7
movq %rbx, %rdi
callq 0xa22f
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xa287
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9912
movq %rax, %rbx
leaq 0x1dfd8(%rip), %rax     # 0x28160
movq 0x1b0(%rax), %r14
leaq 0x27e02(%rip), %rax     # 0x31f98
movq (%rax), %rsi
xorl %edi, %edi
callq 0x8726
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_O2/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 0xa1f1
cmpl $0x2a0, (%rdi)          # imm = 0x2A0
jne 0xa1ec
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rax, %rdx
orq %rcx, %rdx
je 0xa210
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rax, %rdi
jmp 0xa1c3
movq %rdi, %rax
popq %rcx
retq
leaq 0x120ea(%rip), %rdi     # 0x1c2e2
leaq 0x12f0a(%rip), %rsi     # 0x1d109
leaq 0x13312(%rip), %rcx     # 0x1d518
movl $0x36f, %edx            # imm = 0x36F
callq 0x30d0
leaq 0x132e8(%rip), %rdi     # 0x1d4ff
leaq 0x12eeb(%rip), %rsi     # 0x1d109
leaq 0x132f3(%rip), %rcx     # 0x1d518
movl $0x36c, %edx            # imm = 0x36C
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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 0xa246
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0xa25a
cmpl $0x2a0, (%rbx)          # imm = 0x2A0
jne 0xa271
cmpq $0x0, 0x28(%rbx)
je 0xa271
cmpl $0xf, %eax
jb 0xa265
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0xa282
callq 0x1736a
jmp 0xa276
callq 0x1749b
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x16727
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa2a6
movq 0x10(%rax), %rax
movl (%rax), %ecx
cmpl $0xf, %ecx
jb 0xa2a6
movq 0x10(%rax), %rdx
movl (%rdx), %esi
movb $0x1, %dl
jmp 0xa2aa
xorl %edx, %edx
movl %ecx, %esi
cmpl $0x6, %esi
je 0xa2ee
leaq 0x27cf2(%rip), %rsi     # 0x31fa8
cmpq (%rsi), %rax
je 0xa2ee
testb %dl, %dl
je 0xa2d5
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
addl $-0x3, %ecx
cmpl $0x4, %ecx
jb 0xa2e4
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
jmp 0xa2df
cmpl $0x3, %ecx
jb 0xa2ee
cmpl $0x7, %ecx
jb 0xa2e4
cmpl $0xd, %ecx
jne 0xa2ee
leaq 0x27cad(%rip), %rax     # 0x31f98
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa33c
movq %rax, %rbx
leaq 0x21759(%rip), %rax     # 0x2ba58
cmpl $0x2, (%rax)
jl 0xa333
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xa315
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0xa333
movq %rbx, %rdi
callq 0xa3ec
leaq 0x12e91(%rip), %rdi     # 0x1d1ba
movq %rax, %rsi
xorl %eax, %eax
callq 0x9239
movq %rbx, %rdi
popq %rbx
jmp 0xa110
// File: /workspace/github_c_makefile_star2_O2/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 0xa439
movq %rax, %r14
leaq 0x21689(%rip), %r12     # 0x2b9e0
movl (%r12), %eax
cmpl $0x2c, %eax
jne 0xa3b2
callq 0xd3c9
movl %eax, (%r12)
xorl %edi, %edi
callq 0xa439
movq %rax, %rdi
callq 0xa22f
movq %rax, %r15
movl (%r14), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0xa399
movq %r14, %rdi
callq 0x94a3
movq %rax, %rdi
callq 0x16750
movq %rax, %r14
movq 0x8(%r15), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rdx
movq %r15, %rcx
callq 0x165eb
movq %rax, %r14
jmp 0xa357
testl %ebx, %ebx
sete %cl
cmpl %ebx, %eax
setne %al
orb %cl, %al
jne 0xa3cb
callq 0xd3c9
movl %eax, (%r12)
jmp 0xa3dd
testl %ebx, %ebx
je 0xa3dd
leaq 0x1e18e(%rip), %rsi     # 0x28564
movl %ebx, %edi
callq 0x9201
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x228ca(%rip), %rbx     # 0x2ccf8
incl (%rbx)
callq 0xa439
decl (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa529
movq %rax, %r14
leaq 0x21589(%rip), %r13     # 0x2b9e0
pushq $0x30
popq %rbp
leaq 0x12a0f(%rip), %rbx     # 0x1ce70
pushq $0x3d
popq %r15
movl (%r13), %r12d
cmpq $0x3d, %r12
jne 0xa499
callq 0xd3c9
movl %eax, (%r13)
xorl %edi, %edi
callq 0xa439
movq %rax, %rdi
callq 0x94a3
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8382
movq %rax, %r14
jmp 0xa465
movb (%r12,%rbx), %al
leal -0x6(%rax), %ecx
cmpb $0x3, %cl
setb %cl
cmpb $0xb, %al
setge %al
orb %cl, %al
je 0xa4da
callq 0xd3c9
movl %eax, (%r13)
movl %r15d, %edi
callq 0x8ee9
xorl %edi, %edi
callq 0xa439
movl %r12d, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa65e
movq %rax, %r14
jmp 0xa465
movl 0x4(%rsp), %edi
testl %edi, %edi
sete %al
cmpl %edi, %r12d
setne %cl
orb %al, %cl
jne 0xa4f8
callq 0xd3c9
movl %eax, (%r13)
jmp 0xa508
testl %edi, %edi
je 0xa508
leaq 0x1e065(%rip), %rsi     # 0x28568
callq 0x9201
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
pushq $0x4
popq %rdi
callq 0xa945
movq %rax, %rbx
leaq 0x21498(%rip), %r14     # 0x2b9e0
cmpl $0x3f, (%r14)
jne 0xa64d
leaq 0x214ff(%rip), %rax     # 0x2ba58
cmpl $0x2, (%rax)
jl 0xa58d
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xa56f
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0xa58d
movq %rbx, %rdi
callq 0xa3ec
leaq 0x12c37(%rip), %rdi     # 0x1d1ba
movq %rax, %rsi
xorl %eax, %eax
callq 0x9239
movq %rbx, %rdi
callq 0xa22f
movq %rax, %rbx
callq 0xd3c9
movl %eax, (%r14)
leaq 0x21459(%rip), %r13     # 0x2ba00
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0xa61c
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
leaq 0x21378(%rip), %r12     # 0x2b938
movq %r12, %rsi
movq %r15, %rdx
callq 0xf206
movq (%r15), %r14
pushq $0x3a
popq %rdi
callq 0xa33c
movq %rax, %rdi
callq 0xa22f
movq %r14, %rdi
movq %rax, %rsi
callq 0xa8d2
movq %rax, %r14
andq $0x0, (%r15)
movq 0x18(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf206
movq (%r15), %r15
callq 0xa529
movq %rax, %rdi
callq 0xa22f
movq %r15, %rdi
movq %rax, %rsi
callq 0xa8d2
jmp 0xa63c
pushq $0x3a
popq %rdi
callq 0xa33c
movq %rax, %rdi
callq 0xa22f
movq %rax, %r14
callq 0xa529
movq %rax, %rdi
callq 0xa22f
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x892b
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa6b0
movq 0x10(%r12), %rcx
movl (%rcx), %ecx
cmpl $0x7, %ecx
jne 0xa6c2
movq %r12, %rdi
callq 0x17af2
movq %rax, %r12
movl (%rax), %eax
movq %r12, %r13
cmpl $0xf, %eax
jb 0xa6cf
movq 0x10(%r12), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x17edc
testq %rax, %rax
je 0xa7ad
movq %rax, %r14
movq 0x8(%rax), %r15
movl (%r12), %eax
movl %eax, %ecx
orl $0x10, %ecx
cmpl $0x1f, %ecx
jne 0xa715
movl (%r15), %ecx
orl $0x10, %ecx
cmpl $0x1f, %ecx
je 0xa715
pushq $0xf
popq %rdi
movq %r15, %rsi
callq 0x178ba
movq %rax, %r15
movl (%r12), %eax
cmpl $0x1f, %eax
je 0xa71f
cmpl $0x10, %eax
jne 0xa73a
movl (%r15), %eax
cmpl $0x10, %eax
je 0xa73a
cmpl $0x1f, %eax
je 0xa73a
pushq $0x10
popq %rdi
movq %r15, %rsi
callq 0x178ba
movq %rax, %r15
movq 0x8(%r14), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xa74b
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xc, %eax
je 0xa75b
movq %r15, %rdi
callq 0x1736a
movq %rax, %r15
movl 0x10(%r14), %edi
leaq 0x27832(%rip), %rax     # 0x31f98
movq (%rax), %rsi
callq 0x8726
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1131b
cmpw $0x0, 0x16(%r14)
movq 0x8(%r14), %rbx
je 0xa7dd
movq %rax, %rdi
callq 0xa0b9
movl $0x2b0, %edi            # imm = 0x2B0
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movq %r14, 0x28(%rax)
jmp 0xa7ef
leaq 0x12a2b(%rip), %rdi     # 0x1d1df
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x8dd4
leaq 0x277d0(%rip), %rax     # 0x31f98
movq (%rax), %rdi
callq 0x1736a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16727
jmp 0xa7f9
movl (%rbx), %ecx
cmpl $0xf, %ecx
jb 0xa7ea
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0xa7f9
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 0xa0b9
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xa426
leaq 0x224dc(%rip), %r14     # 0x2ccf8
incl (%r14)
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x10, %ecx
jne 0xa862
movq 0x8(%rax), %rdx
movl (%rdx), %ecx
cmpl $0xf, %ecx
jb 0xa841
movq 0x10(%rdx), %rcx
movl (%rcx), %ecx
cmpl $0x2, %ecx
ja 0xa846
jmp 0xa862
cmpl $0x3, %ecx
jb 0xa862
cmpl $0x6, %ecx
ja 0xa862
leaq 0x27746(%rip), %rcx     # 0x31f98
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x9912
movl 0x28(%rax), %ebx
jmp 0xa870
leaq 0x1299d(%rip), %rdi     # 0x1d206
xorl %eax, %eax
callq 0x8dd4
decl (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq