LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: node
Node node(int op, Node l, Node r, Symbol sym) {
	int i = (opindex(op)^((unsigned)sym>>2))&(NBUCKETS-1);
	register struct dag *p;

	for (p = buckets[i]; p; p = p->hlink)
		if (p->node.op == op && p->node.syms[0] == sym
		&& p->node.kids[0] == l && p->node.kids[1] == r)
			return &p->node;
	p = dagnode(op, l, r, sym);
	p->hlink = buckets[i];
	buckets[i] = p;
	++nodecount;
	return &p->node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %eax
sarl $0x4, %eax
movq -0x28(%rbp), %rcx
shrl $0x2, %ecx
xorl %ecx, %eax
andl $0xf, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x35ed9(%rip), %rax     # 0x3b980
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5b05
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x5af5
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x5af5
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x5af5
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x5af5
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b5e
jmp 0x5af7
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x5aaf
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5c30
movq %rax, -0x38(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x35e58(%rip), %rax     # 0x3b980
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x38(%rbp), %rdx
movslq -0x2c(%rbp), %rcx
leaq 0x35e3d(%rip), %rax     # 0x3b980
movq %rdx, (%rax,%rcx,8)
movl 0x35eb3(%rip), %eax     # 0x3ba00
addl $0x1, %eax
movl %eax, 0x35eaa(%rip)     # 0x3ba00
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: haskid
static int haskid(Node p, Node t) {
	if (t == 0)
		return 0;
	else if (p == t)
		return 1;
	else
		return haskid(p, t->kids[0]) || haskid(p, t->kids[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5b90
movl $0x0, -0x4(%rbp)
jmp 0x5be5
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5ba3
movl $0x1, -0x4(%rbp)
jmp 0x5be5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5b70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x5bda
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x5b70
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: dagnode
static struct dag *dagnode(int op, Node l, Node r, Symbol sym)
{
	register struct dag *p = (struct dag *) talloc(sizeof *p);

	BZERO(p, struct dag);
	p->node.op = op;
	p->node.kids[0] = l; if (l) l->count++;
	p->node.kids[1] = r; if (r) r->count++;
	p->node.syms[0] = sym;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x359fa(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x70, (%rax)
leaq 0x359ea(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x359dc(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x359cc(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x5ca3
leaq 0x359bc(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x359b0(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x40(%rbp)
jmp 0x5cee
leaq 0x3599e(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x35992(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x3597a(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x3596c(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x5d79
movq -0x30(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x5d0a
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0xc(%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x5dd0
movq -0x10(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x5df3
movq -0x18(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: printdag
void printdag(Node p, int fd) {
	printed(0);
	if (p == 0) {
		p = nodelist;
		if (p)
			do {
				p = p->link;
				printdag1(p, fd, 0);
			} while (p != nodelist);
	} else if (*printed(nodeid((Tree)p)))
		fprint(fd, "node'%d printed above\n", nodeid((Tree)p));
	else
		printdag1(p, fd, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
callq 0x26230
cmpq $0x0, -0x8(%rbp)
jne 0x5e6c
movq 0x35b3c(%rip), %rax     # 0x3b970
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e6a
jmp 0x5e41
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x5ec0
movq -0x8(%rbp), %rax
cmpq 0x35b0a(%rip), %rax     # 0x3b970
jne 0x5e41
jmp 0x5e6a
jmp 0x5eb5
movq -0x8(%rbp), %rdi
callq 0x261a0
movl %eax, %edi
callq 0x26230
cmpl $0x0, (%rax)
je 0x5ea5
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x261a0
movl -0x10(%rbp), %edi
movl %eax, %edx
leaq 0x29314(%rip), %rsi     # 0x2f1b0
movb $0x0, %al
callq 0x1a630
jmp 0x5eb3
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x5ec0
jmp 0x5eb5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: printdag1
static void printdag1(Node p, int fd, int lev) {
	int id, i;

	if (p == 0 || *printed(id = nodeid((Tree)p)))
		return;
	*printed(id) = 1;
	for (i = 0; i < MAXKIDS; i++)
		printdag1(p->kids[i], fd, lev + 1);
	printnode(p, fd, lev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ef1
movq -0x8(%rbp), %rdi
callq 0x261a0
movl %eax, %edi
movl %edi, -0x14(%rbp)
callq 0x26230
cmpl $0x0, (%rax)
je 0x5ef3
jmp 0x5f43
movl -0x14(%rbp), %edi
callq 0x26230
movl $0x1, (%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0x5f34
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
callq 0x5ec0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5f08
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5ff0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: printnode
static void printnode(Node p, int fd, int lev) {
	if (p) {
		int i, id = nodeid((Tree)p);
		fprint(fd, "%c%d%s", lev == 0 ? '\'' : '#', id,
			&"   "[id < 10 ? 0 : id < 100 ? 1 : 2]);
		fprint(fd, "%s count=%d", opname(p->op), p->count);
		for (i = 0; i < MAXKIDS && p->kids[i]; i++)
			fprint(fd, " #%d", nodeid((Tree)p->kids[i]));
		for (i = 0; i < MAXSYMS && p->syms[i]; i++)
			fprint(fd, " %s", p->syms[i]->name);
		fprint(fd, "\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6183
movq -0x8(%rbp), %rdi
callq 0x261a0
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %edx
movl $0x23, %eax
movl $0x27, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x6048
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x605e
movl -0x18(%rbp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x64, %edx
cmovll %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %eax
cltq
leaq 0x2918b(%rip), %r8      # 0x2f1fe
addq %rax, %r8
leaq 0x2917a(%rip), %rsi     # 0x2f1f7
movb $0x0, %al
callq 0x1a630
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x258b0
movl -0x2c(%rbp), %edi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %ecx
leaq 0x29158(%rip), %rsi     # 0x2f202
movb $0x0, %al
callq 0x1a630
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x14(%rbp)
movb %al, -0x2d(%rbp)
jge 0x60d7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x20(%rax,%rcx,8)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x60e0
jmp 0x6116
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rdi
callq 0x261a0
movl -0x34(%rbp), %edi
movl %eax, %edx
leaq 0x2910a(%rip), %rsi     # 0x2f20e
movb $0x0, %al
callq 0x1a630
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x60b8
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x3, -0x14(%rbp)
movb %al, -0x35(%rbp)
jge 0x613c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x6145
jmp 0x6172
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
leaq 0x2cc0d(%rip), %rsi     # 0x32d6d
movb $0x0, %al
callq 0x1a630
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x611d
movl -0xc(%rbp), %edi
leaq 0x2a9c0(%rip), %rsi     # 0x30b3c
movb $0x0, %al
callq 0x1a630
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: finalize
void finalize() {
	if (xref) {
		setuses(identifiers);
		foreach(types, level, fielduses, (Generic)0);
		setuses(types);
	}
	foreach(identifiers, GLOBAL, doglobal, (Generic)0);
	foreach(externals, GLOBAL, doextern, (Generic)0);
	foreach(identifiers, GLOBAL, checkref, (Generic)0);
	foreach(constants, CONSTANTS, doconst, (Generic)0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x36549(%rip), %rax     # 0x3dc04
cmpl $0x0, (%rax)
je 0x7701
leaq 0x33a71(%rip), %rax     # 0x3b138
movq (%rax), %rdi
callq 0x24320
leaq 0x33e8a(%rip), %rax     # 0x3b560
movq (%rax), %rdi
leaq 0x398b0(%rip), %rax     # 0x40f90
movl (%rax), %esi
leaq 0x1ce37(%rip), %rdx     # 0x24520
xorl %eax, %eax
movl %eax, %ecx
callq 0x243f0
leaq 0x33e67(%rip), %rax     # 0x3b560
movq (%rax), %rdi
callq 0x24320
leaq 0x33a30(%rip), %rax     # 0x3b138
movq (%rax), %rdi
movl $0x3, %esi
leaq 0x69(%rip), %rdx        # 0x7780
xorl %eax, %eax
movl %eax, %ecx
callq 0x243f0
leaq 0x335f1(%rip), %rax     # 0x3ad18
movq (%rax), %rdi
movl $0x3, %esi
leaq 0x21a(%rip), %rdx       # 0x7950
xorl %eax, %eax
movl %eax, %ecx
callq 0x243f0
leaq 0x339f2(%rip), %rax     # 0x3b138
movq (%rax), %rdi
movl $0x3, %esi
leaq -0x375(%rip), %rdx      # 0x73e0
xorl %eax, %eax
movl %eax, %ecx
callq 0x243f0
leaq 0x33193(%rip), %rax     # 0x3a8f8
movq (%rax), %rdi
movl $0x1, %esi
leaq 0xb34c(%rip), %rdx      # 0x12ac0
xorl %eax, %eax
movl %eax, %ecx
callq 0x243f0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: doglobal
static void doglobal(Symbol p, Generic cl) {
	if (p->sclass == TYPEDEF || p->sclass == ENUM || p->defined) {
		if (Pflag && !isfunc(p->type) && !p->generated)
			printdecl(p, p->type);
		return;
	}
	if (p->sclass == EXTERN || isfunc(p->type))
		import(p);
	else if (!isfunc(p->type)) {
		if (p->type->size > 0) {
			defglobal(p, BSS);
			space(p->type->size);
		} else
			error("undefined size for `%t %s'\n", p->type, p->name);
		p->defined = 1;
		if (Pflag && !p->generated)
			printdecl(p, p->type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x53, %eax
je 0x77bb
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0xd, %eax
je 0x77bb
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x7825
leaq 0x3646a(%rip), %rax     # 0x3dc2c
cmpl $0x0, (%rax)
je 0x7820
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0x77e6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x77f2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
je 0x7820
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7820
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x29330
jmp 0x793d
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x4a, %eax
je 0x7866
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0x7851
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x785d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x7874
movq -0x8(%rbp), %rdi
callq 0x2a5b0
jmp 0x793d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0x7893
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x789f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xb, (%rax)
je 0x793b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jle 0x78da
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x129d0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %edi
callq 0x2a9c0
jmp 0x78f8
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x27cd7(%rip), %rdi     # 0x2f5c8
movb $0x0, %al
callq 0xd530
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
leaq 0x3631d(%rip), %rax     # 0x3dc2c
cmpl $0x0, (%rax)
je 0x7939
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7939
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x29330
jmp 0x793b
jmp 0x793d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: doextern
static void doextern(Symbol p, Generic cl){
	Symbol q;

	if (q = lookup(p->name, identifiers))
		q->ref += p->ref;
	else {
		defsymbol(p);
		import(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x337c9(%rip), %rax     # 0x3b138
movq (%rax), %rsi
callq 0x24670
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7994
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x79a6
movq -0x8(%rbp), %rdi
callq 0x2a470
movq -0x8(%rbp), %rdi
callq 0x2a5b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: program
void program() {
	int n;

	level = GLOBAL;
	for (n= 0; t != EOI; n++)
		if (kind[t] == CHAR || kind[t] == STATIC || t == ID)
			decl(dclglobal, 0);
		else {
			if (t == ';')
				warning("empty declaration\n");
			else
				error("unrecognized declaration\n");
			t = gettok();
		}
	if (n == 0)
		warning("empty input file\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x395d1(%rip), %rax     # 0x40f90
movl $0x3, (%rax)
movl $0x0, -0x4(%rbp)
leaq 0x361ad(%rip), %rax     # 0x3db80
cmpl $0x7f, (%rax)
je 0x7a78
leaq 0x3619d(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x31fa2(%rip), %rax     # 0x39990
movsbl (%rax,%rcx), %eax
cmpl $0x3, %eax
je 0x7a1e
leaq 0x36182(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x31f87(%rip), %rax     # 0x39990
movsbl (%rax,%rcx), %eax
cmpl $0x51, %eax
je 0x7a1e
leaq 0x36167(%rip), %rax     # 0x3db80
cmpl $0x20, (%rax)
jne 0x7a2e
leaq 0x7b(%rip), %rdi        # 0x7aa0
xorl %esi, %esi
callq 0x66e0
jmp 0x7a68
leaq 0x3614b(%rip), %rax     # 0x3db80
cmpl $0x3b, (%rax)
jne 0x7a4a
leaq 0x279a3(%rip), %rdi     # 0x2f3e4
movb $0x0, %al
callq 0xdba0
jmp 0x7a58
leaq 0x279a6(%rip), %rdi     # 0x2f3f7
movb $0x0, %al
callq 0xd530
callq 0x15170
movl %eax, %ecx
leaq 0x3611a(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
jmp 0x7a6a
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x79cc
cmpl $0x0, -0x4(%rbp)
jne 0x7a8c
leaq 0x2798c(%rip), %rdi     # 0x2f411
movb $0x0, %al
callq 0xdba0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: typename
Type typename() {
	Type ty = type(0, (int *)0);

	if (t == '*' || t == '(' || t == '[') {
		ty = dclr(ty, (char **)0, 1);
		if (Aflag >= 1 && !hasproto(ty))
			warning("missing prototype\n");
	}
	return ty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x7f00
movq %rax, -0x8(%rbp)
leaq 0x35cf2(%rip), %rax     # 0x3db80
cmpl $0x2a, (%rax)
je 0x7eab
leaq 0x35ce6(%rip), %rax     # 0x3db80
cmpl $0x28, (%rax)
je 0x7eab
leaq 0x35cda(%rip), %rax     # 0x3db80
cmpl $0x5b, (%rax)
jne 0x7eeb
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x82c0
movq %rax, -0x8(%rbp)
leaq 0x35d60(%rip), %rax     # 0x3dc28
cmpl $0x1, (%rax)
jl 0x7ee9
movq -0x8(%rbp), %rdi
callq 0x28aa0
cmpl $0x0, %eax
jne 0x7ee9
leaq 0x27541(%rip), %rdi     # 0x2f423
movb $0x0, %al
callq 0xdba0
jmp 0x7eeb
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: dclr
static Type dclr(Type basety, char **id, int lev) {
	Type ty;

	for (ty = dclr1(id, lev); ty; ty = ty->type)
		switch (ty->op) {
		case POINTER:
			basety = ptr(basety);
			break;
		case FUNCTION:
			basety = func(basety, ty->u.proto);
			break;
		case ARRAY:
			basety = array(basety, ty->size, 0);
			break;
		case CONST: case VOLATILE:
			basety = qual(ty->op, basety);
			break;
		default:
			assert(0);
		}
	if (Aflag >= 2 && basety->size > 32767)
		warning("more than 32767 bytes in `%t'\n", basety);
	return basety;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa5c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x839b
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x9, %eax
ja 0x8369
movq -0x28(%rbp), %rax
leaq 0x270af(%rip), %rcx     # 0x2f3bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x27120
movq %rax, -0x8(%rbp)
jmp 0x8388
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x27c60
movq %rax, -0x8(%rbp)
jmp 0x8388
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
xorl %edx, %edx
callq 0x27160
movq %rax, -0x8(%rbp)
jmp 0x8388
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rsi
callq 0x27a70
movq %rax, -0x8(%rbp)
jmp 0x8388
leaq 0x26d67(%rip), %rdi     # 0x2f0d7
leaq 0x271d3(%rip), %rsi     # 0x2f54a
movl $0x147, %edx            # imm = 0x147
leaq 0x277cf(%rip), %rcx     # 0x2fb52
callq 0x30c0
jmp 0x838a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x82e3
leaq 0x35886(%rip), %rax     # 0x3dc28
cmpl $0x2, (%rax)
jl 0x83c6
movq -0x8(%rbp), %rax
cmpl $0x7fff, 0x8(%rax)      # imm = 0x7FFF
jle 0x83c6
movq -0x8(%rbp), %rsi
leaq 0x277b1(%rip), %rdi     # 0x2fb70
movb $0x0, %al
callq 0xdba0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/decl.c
// Function: newstyle
static Type newstyle(Type ty, Symbol caller[], Symbol callee[]) {
	int i;

	for (i = 0; callee[i]; i++) {
		*caller[i] = *callee[i];
		caller[i]->type = promote(callee[i]->type);
		if (callee[i]->sclass == REGISTER) {
			caller[i]->sclass = AUTO;
			++regcount;
		}
	}
	return ty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8d8c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x88, %edx
callq 0x3120
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
callq 0xfae0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x4e, %eax
jne 0x8d7c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb $0x43, 0x1a(%rax)
movl 0x32cbd(%rip), %eax     # 0x3ba30
addl $0x1, %eax
movl %eax, 0x32cb4(%rip)     # 0x3ba30
jmp 0x8d7e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8ceb
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x94e7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x10(%rcx), %rax
jne 0x94da
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x94fd
jmp 0x94dc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x949f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x262f8(%rip), %rdi     # 0x2f7ee
movb $0x0, %al
callq 0xd530
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30ca2(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x28, (%rax)
leaq 0x30c92(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x30c84(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x30c74(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0xa9fb
leaq 0x30c64(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x30c58(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x20(%rbp)
jmp 0xaa46
leaq 0x30c46(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x30c3a(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x30c22(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x30c14(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x3933e(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xaee0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xaeec
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x3, (%rax)
jb 0xb011
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xaf18
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xaf24
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xb011
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xaf50
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xaf5c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x3, (%rax)
jb 0xb011
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xaf88
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xaf94
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xb011
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc840
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x20(%rbp)
cmpl $0x160, -0xc(%rbp)      # imm = 0x160
je 0xb00f
movq -0x18(%rbp), %rdi
leaq 0x3924c(%rip), %rax     # 0x44238
movq (%rax), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x39235(%rip), %rax     # 0x44238
movq (%rax), %rsi
callq 0xe9b0
movq %rax, -0x20(%rbp)
jmp 0xb021
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc6a0
cmpl $0x160, -0xc(%rbp)      # imm = 0x160
jne 0xb044
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c390
movq %rax, -0x8(%rbp)
jmp 0xb06e
movl -0xc(%rbp), %edi
leaq 0x391ea(%rip), %rax     # 0x44238
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c390
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x38e1e(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xb400
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb40c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xb486
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xb434
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xb440
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xb486
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc840
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
jmp 0xb496
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc6a0
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1c390
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x388ae(%rip), %rax     # 0x44238
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xb9b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb9bc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xba36
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xb9e4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xb9f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xba36
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc840
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
jmp 0xba86
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xd3d0
cmpl $0x0, %eax
je 0xba74
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
jmp 0xba84
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc6a0
jmp 0xba86
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x29e30
movl -0x34(%rbp), %edi
addl %eax, %edi
leaq 0x38757(%rip), %rax     # 0x441f8
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1c390
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x382ee(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xbf30
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xbf3c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
jb 0xc024
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xbf68
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xbf74
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xc024
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xbfa0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xbfac
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x3, (%rax)
jb 0xc024
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xbfd4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xbfe0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x6, (%rax)
ja 0xc024
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfae0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x381e2(%rip), %rax     # 0x441f8
movq (%rax), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
jmp 0xc034
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc6a0
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1c390
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/enode.c
// Function: typeerror
void typeerror(int op, Tree l, Tree r) {
	int i;
	static struct { Opcode op; char *name; } ops[] = {
		{ ASGN,  "="},
		{ INDIR, "*"},
		{ NEG,   "-"},
		{ ADD,   "+"},
		{ SUB,   "-"},
		{ LSH,  "<<"},
		{ MOD,   "%"},
		{ RSH,  ">>"},
		{ BAND,  "&"},
		{ BCOM,  "~"},
		{ BOR,   "|"},
		{ BXOR,  "^"},
		{ DIV,   "/"},
		{ MUL,   "*"},
		{ EQ,   "=="},
		{ GE,   ">="},
		{ GT,    ">"},
		{ LE,   "<="},
		{ LT,    "<"},
		{ NE,   "!="},
		{ AND,  "&&"},
		{ NOT,   "!"},
		{ OR,   "||"},
		{ COND, "?:"},
		{ 0, 0}
	};

	op = generic(op);
	for (i = 0; ops[i].op; i++)
		if (op == ops[i].op)
			break;
	assert(ops[i].name);
	if (r)
		error("operands of %s have illegal types `%t' and `%t'\n",
			ops[i].name, l->type, r->type);
	else
		error("operand of unary %s has illegal type `%t'\n", ops[i].name,
			l->type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
andl $-0x10, %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x2ce82(%rip), %rax     # 0x39550
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0xc702
movl -0x4(%rbp), %eax
movslq -0x1c(%rbp), %rdx
leaq 0x2ce68(%rip), %rcx     # 0x39550
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0xc6f5
jmp 0xc702
jmp 0xc6f7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc6c3
movslq -0x1c(%rbp), %rcx
leaq 0x2ce43(%rip), %rax     # 0x39550
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0xc71d
jmp 0xc73c
leaq 0x23587(%rip), %rdi     # 0x2fcab
leaq 0x2358c(%rip), %rsi     # 0x2fcb7
movl $0x17c, %edx            # imm = 0x17C
leaq 0x2358f(%rip), %rcx     # 0x2fcc6
callq 0x30c0
cmpq $0x0, -0x18(%rbp)
je 0xc779
movslq -0x1c(%rbp), %rcx
leaq 0x2ce02(%rip), %rax     # 0x39550
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x23576(%rip), %rdi     # 0x2fce6
movb $0x0, %al
callq 0xd530
jmp 0xc7a5
movslq -0x1c(%rbp), %rcx
leaq 0x2cdcc(%rip), %rax     # 0x39550
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x23579(%rip), %rdi     # 0x2fd17
movb $0x0, %al
callq 0xd530
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xc7d6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc7de
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0xc80a
movq -0x10(%rbp), %rdi
callq 0x27310
movq %rax, %rsi
movl $0x17, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x256f0
movq %rax, -0x18(%rbp)
jmp 0xc82c
movq -0x10(%rbp), %rdi
callq 0x29e30
movl %eax, %edi
addl $0x10, %edi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x256f0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xc863
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc86b
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0xc89c
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xc88b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc893
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc8af
leaq 0x37945(%rip), %rax     # 0x441e8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc94d
movq -0x10(%rbp), %rax
leaq 0x37936(%rip), %rcx     # 0x441f0
cmpq (%rcx), %rax
je 0xc8cf
movq -0x18(%rbp), %rax
leaq 0x37926(%rip), %rcx     # 0x441f0
cmpq (%rcx), %rax
jne 0xc8df
leaq 0x3791a(%rip), %rax     # 0x441f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc94d
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xc8f6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc8fe
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
je 0xc92f
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xc91e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xc926
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xc93f
leaq 0x37902(%rip), %rax     # 0x44238
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc94d
leaq 0x378b2(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xd3f7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xd3ff
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xd518
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xd423
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xd42b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xd518
jmp 0xd43a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0xf, (%rax)
jb 0xd459
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xd465
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0xf, (%rax)
jb 0xd48c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xd498
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xd4b7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xd4bf
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpl $0x7, (%rcx)
movb %al, -0x41(%rbp)
jne 0xd4f9
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xd4e4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xd4ec
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x7, (%rax)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xd43a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x27f80
movl %eax, -0x4(%rbp)
jmp 0xd51f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xd565
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq 0x2f511(%rip), %rax     # 0x3cac8
movq (%rax), %rax
leaq 0x2f4ef(%rip), %rcx     # 0x3cab0
cmpq (%rcx), %rax
je 0xd602
leaq 0x2f4fb(%rip), %rax     # 0x3cac8
cmpq $0x0, (%rax)
je 0xd602
leaq 0x2f4ee(%rip), %rax     # 0x3cac8
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xd602
leaq 0x2f4dc(%rip), %rax     # 0x3cac8
movq (%rax), %rdx
movl $0x2, %edi
leaq 0x22762(%rip), %rsi     # 0x2fd5d
movb $0x0, %al
callq 0x1a630
movl $0x2, %edi
leaq 0x22754(%rip), %rsi     # 0x2fd62
leaq 0x304c3(%rip), %rdx     # 0x3dad8
movb $0x0, %al
callq 0x1a630
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x1a6d0
movl 0x2e408(%rip), %eax     # 0x3ba3c
addl $0x1, %eax
movl %eax, 0x2e3ff(%rip)     # 0x3ba3c
cmpl 0x2c09d(%rip), %eax     # 0x396e0
jl 0xd667
movl $0xffffffff, 0x2e3ed(%rip) # imm = 0xFFFFFFFF
leaq 0x22711(%rip), %rdi     # 0x2fd67
movb $0x0, %al
callq 0xd530
movl $0x1, %edi
callq 0x3180
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x304fe(%rip), %rax     # 0x3db80
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xd6a7
callq 0x15170
movl %eax, %ecx
leaq 0x304e9(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
leaq 0x304e0(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xd6f5
movl 0x2e38f(%rip), %eax     # 0x3ba3c
addl $-0x1, %eax
movl %eax, 0x2e386(%rip)     # 0x3ba3c
leaq 0x226bb(%rip), %rdi     # 0x2fd78
movb $0x0, %al
callq 0xd530
callq 0xd700
movl -0x8(%rbp), %edx
movl $0x2, %edi
leaq 0x226b4(%rip), %rsi     # 0x2fd8c
movb $0x0, %al
callq 0x1a630
movl 0x2e357(%rip), %eax     # 0x3ba3c
addl $0x1, %eax
movl %eax, 0x2e34e(%rip)     # 0x3ba3c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x2c1e6(%rip), %rax     # 0x39b20
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x2c1d5(%rip), %rcx     # 0x39b20
movq %rdx, (%rcx)
movb $0xa, (%rax)
callq 0x1a770
movq -0x8(%rbp), %rsi
leaq 0x2243c(%rip), %rdi     # 0x2fd9d
movb $0x0, %al
callq 0xd530
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl $0x2, %edi
movb $0x0, %al
callq 0x1a630
movl $0x1, %edi
callq 0x3180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
leaq 0x301d1(%rip), %rcx     # 0x3db80
cmpl $0x7f, (%rcx)
movb %al, -0x21(%rbp)
je 0xd9c9
leaq 0x301c2(%rip), %rax     # 0x3db80
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xd9d5
jmp 0xdad0
cmpq $0x0, -0x10(%rbp)
je 0xda58
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0xda1a
leaq 0x30184(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2bf89(%rip), %rax     # 0x39990
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0xda23
jmp 0xda33
jmp 0xda25
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd9e4
leaq 0x30146(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2bf4b(%rip), %rax     # 0x39990
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xda56
jmp 0xdad0
jmp 0xda58
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jne 0xda91
movl 0x2dfce(%rip), %eax     # 0x3ba3c
addl $-0x1, %eax
movl %eax, 0x2dfc5(%rip)     # 0x3ba3c
leaq 0x22336(%rip), %rdi     # 0x2fdb4
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
movb $0x0, %al
callq 0xd530
cmpl $0x8, -0x14(%rbp)
jg 0xda9e
callq 0xd700
jmp 0xdab9
cmpl $0x9, -0x14(%rbp)
jne 0xdab7
movl $0x2, %edi
leaq 0x2230d(%rip), %rsi     # 0x2fdbd
movb $0x0, %al
callq 0x1a630
jmp 0xdab9
jmp 0xdabb
callq 0x15170
movl %eax, %ecx
leaq 0x300b7(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
jmp 0xd9a6
cmpl $0x8, -0x14(%rbp)
jle 0xdb04
movl 0x2df60(%rip), %eax     # 0x3ba3c
addl $-0x1, %eax
movl %eax, 0x2df57(%rip)     # 0x3ba3c
leaq 0x222d7(%rip), %rdi     # 0x2fdc3
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
movb $0x0, %al
callq 0xd530
callq 0xd700
cmpl $0x0, -0x14(%rbp)
jle 0xdb1d
movl $0x2, %edi
leaq 0x23026(%rip), %rsi     # 0x30b3c
movb $0x0, %al
callq 0x1a630
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)