LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: rmtemps
void rmtemps(int sclass, int level) {
	struct temporary *p, **q = &temps;

	for (p = *q; p; p = *q)
		if (p->sym->scope == level || p->sym->sclass == sclass)
			*q = p->link;
		else
			q = &p->link;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x1ccff(%rip), %rax     # 0x40fb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24313
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzwl 0x18(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x242e7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x1a(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x242f8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x24304
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x24306
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x242c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: setuses
void setuses(tp) Table tp; {
	if (xref) {
		int i;
		struct entry *p;
		for (i = 0; i < HASHSIZE; i++)
			for (p = tp->buckets[i]; p; p = p->link) {
				if (p->refs)
					p->sym.uses = (Coordinate **)list_to_a(p->refs, 0);
				p->refs = 0;
				symbols = append((Generic)&p->sym, symbols);
			}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x198d1(%rip), %rax     # 0x3dc04
cmpl $0x0, (%rax)
je 0x243de
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x243dc
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x243cc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x24395
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23670
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x18(%rbp), %rdi
movq 0x1cc09(%rip), %rsi     # 0x40fb8
callq 0x23500
movq %rax, 0x1cbfd(%rip)     # 0x40fb8
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24361
jmp 0x243ce
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x24343
jmp 0x243de
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: foreach
void foreach(tp, lev, apply, cl)
Table tp;
int lev;
dclproto(void (*apply),(Symbol, Generic));
Generic cl;
{
	assert(tp);
	while (tp && tp->level > lev)
		tp = tp->previous;
	if (tp && tp->level == lev) {
		Symbol p;
		Coordinate sav;
		sav = src;
		for (p = tp->list; p && p->scope == lev; p = p->up) {
			src = p->src;
			(*apply)(p, cl);
		}
		src = sav;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x24410
jmp 0x2442f
leaq 0xdd83(%rip), %rdi      # 0x3219a
leaq 0xdce6(%rip), %rsi      # 0x32104
movl $0x96, %edx
leaq 0xdd85(%rip), %rcx      # 0x321af
callq 0x30c0
jmp 0x24431
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x39(%rbp)
je 0x2444c
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x24455
jmp 0x24463
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x24431
cmpq $0x0, -0x8(%rbp)
je 0x24511
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x24511
leaq 0x19654(%rip), %rax     # 0x3dad8
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x3a(%rbp)
je 0x244bc
movq -0x28(%rbp), %rax
movzwl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x244c5
jmp 0x244fb
movq -0x28(%rbp), %rcx
leaq 0x19608(%rip), %rax     # 0x3dad8
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2449f
leaq 0x195d6(%rip), %rax     # 0x3dad8
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: findlabel
Symbol findlabel(int lab) {
	char *label = stringd(lab);
	Symbol p = lookup(label, labels[1]);
	if (p) return p;
	p = install(label, &labels[1], 0);
	p->generated = 1;
	p->u.l.label = lab;
	p->u.l.equatedto = p;
	defsymbol(p);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x23c50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x1c9b6(%rip), %rsi     # 0x40fa8
callq 0x24670
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2460c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2465d
movq -0x18(%rbp), %rdi
leaq 0x1c989(%rip), %rsi     # 0x40fa0
addq $0x8, %rsi
xorl %edx, %edx
callq 0x24720
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x1b(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rdi
callq 0x2a470
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: lookup
Symbol lookup(name, tp) char *name; Table tp; {
	struct entry *p;
	unsigned h = (unsigned)name&(HASHSIZE-1);

	assert(tp);
	do
		for (p = tp->buckets[h]; p; p = p->link)
			if (name == p->sym.name)
				return &p->sym;
	while ((tp = tp->previous));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
andl $0x7f, %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24693
jmp 0x246b2
leaq 0xdb00(%rip), %rdi      # 0x3219a
leaq 0xda63(%rip), %rsi      # 0x32104
movl $0xeb, %edx
leaq 0xdb11(%rip), %rcx      # 0x321be
callq 0x30c0
jmp 0x246b4
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x246f6
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x246e3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24712
jmp 0x246e5
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x246c4
jmp 0x246f8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x246b4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: findtype
Symbol findtype(ty) Type ty; {
	Table tp = identifiers;
	int i;
	struct entry *p;

	assert(tp);
	do
		for (i = 0; i < HASHSIZE; i++)
			for (p = tp->buckets[i]; p; p = p->link)
				if (p->sym.type == ty && p->sym.sclass == TYPEDEF)
					return &p->sym;
	while ((tp = tp->previous));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0x16705(%rip), %rax     # 0x3b138
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24a40
jmp 0x24a5f
leaq 0xd753(%rip), %rdi      # 0x3219a
leaq 0xd6b6(%rip), %rsi      # 0x32104
movl $0x85, %edx
leaq 0xd743(%rip), %rcx      # 0x3219d
callq 0x30c0
jmp 0x24a61
movl $0x0, -0x1c(%rbp)
cmpl $0x80, -0x1c(%rbp)
jge 0x24ace
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x24ac1
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x24aae
movq -0x28(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x53, %eax
jne 0x24aae
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24aee
jmp 0x24ab0
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x24a82
jmp 0x24ac3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x24a68
jmp 0x24ad0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x24a61
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: table
Table table(Table tp, int lev) {
	int i;
	Table new = (Table)talloc(sizeof *new);

	assert(lev > GLOBAL || lev == LABELS);
	new->previous = tp;
	new->level = lev;
	new->list = tp ? tp->list : 0;	/* (omit) */
	for (i = 0; i < HASHSIZE; i++)
		new->buckets[i] = 0;
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x16872(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x418, (%rax)          # imm = 0x418
leaq 0x16862(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x16854(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x16844(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x24e2b
leaq 0x16834(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x16828(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x20(%rbp)
jmp 0x24e76
leaq 0x16816(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x1680a(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x167f2(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x167e4(%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)
cmpl $0x3, -0xc(%rbp)
jg 0x24e8a
cmpl $0x2, -0xc(%rbp)
jne 0x24e8c
jmp 0x24eab
leaq 0xd39a(%rip), %rdi      # 0x3222d
leaq 0xd26a(%rip), %rsi      # 0x32104
movl $0x137, %edx            # imm = 0x137
leaq 0xd3a5(%rip), %rcx      # 0x3224b
callq 0x30c0
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x24ed5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x24edd
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x24edd
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x80, -0x10(%rbp)
jge 0x24f15
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x24ef0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: newtemp
Symbol newtemp(int sclass, int tc) {
	Symbol t1;
	static Type *btot[] = { 0, &floattype, &doubletype, &chartype,
		&shorttype, &inttype, &unsignedtype, &voidptype };

	assert(tc > 0 && tc < sizeof btot/sizeof btot[0]);
	t1 = temporary(sclass, *btot[tc]);
	t1->scope = LOCAL;
	if (t1->defined == 0) {
		local(t1);
		t1->defined = 1;
	}
	return t1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x25040
movslq -0x8(%rbp), %rax
cmpq $0x8, %rax
jae 0x25040
jmp 0x2505f
leaq 0xd187(%rip), %rdi      # 0x321ce
leaq 0xd0b6(%rip), %rsi      # 0x32104
movl $0x103, %edx            # imm = 0x103
leaq 0xd1ba(%rip), %rcx      # 0x32214
callq 0x30c0
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rcx
leaq 0x16543(%rip), %rax     # 0x3b5b0
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x250c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw $0x5, 0x18(%rax)
movq -0x10(%rbp), %rax
movb 0x1b(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x250b1
movq -0x10(%rbp), %rdi
callq 0x2ade0
movq -0x10(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: temporary
Symbol temporary(int sclass, Type ty) {
	Symbol t1;
	struct temporary *p, **q = &temps;

	for (p = *q; p; q = &p->link, p = *q)
		if (p->sym->sclass == sclass
		&& p->sym->type->size  == ty->size
		&& p->sym->type->align >= ty->align) {
			*q = p->link;
			p->sym->type = ty;
			return p->sym;
		}
	t1 = genident(sclass, ty, level);
	t1->temporary = 1;
	return t1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x1beda(%rip), %rax     # 0x40fb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2517b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movzbl 0x1a(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2515d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2515d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movswl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jl 0x2515d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x251a9
jmp 0x2515f
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x250e5
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl 0x1be08(%rip), %edx     # 0x40f90
callq 0x24b00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x1b(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: release
void release(t1) Symbol t1; {
	if (t1->ref) {
		struct temporary *p = (struct temporary *) talloc(sizeof *p);
		p->sym = t1;
		p->link = temps;
		temps = p;
		t1->ref = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x252b9
leaq 0x16467(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x10, (%rax)
leaq 0x16457(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x16449(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x16439(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x25236
leaq 0x16429(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x1641d(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x18(%rbp)
jmp 0x25281
leaq 0x1640b(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x163ff(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x163e7(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x163d9(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x1bd15(%rip), %rcx     # 0x40fb0
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x1bd02(%rip)     # 0x40fb0
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: use
void use(p, src) Symbol p; Coordinate src; {
	if (xref) {
		Coordinate *cp = (Coordinate *)alloc(sizeof *cp);
		*cp = src;
		((struct entry *)p)->refs = append((Generic)cp, ((struct entry *)p)->refs);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x18929(%rip), %rax     # 0x3dc04
cmpl $0x0, (%rax)
je 0x253c8
leaq 0x16355(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl $0x10, (%rax)
leaq 0x16345(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x16337(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x16327(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x25340
leaq 0x16317(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edi
leaq 0x1630b(%rip), %rsi     # 0x3b640
callq 0x253d0
movq %rax, -0x28(%rbp)
jmp 0x2538b
leaq 0x162f9(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edx
leaq 0x162ed(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x162d5(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x162c7(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0x23500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: deallocate
void deallocate(p) Arena *p; {
	Arena first = (*p)->first;

	(*p)->next = freearenas;
	freearenas = first->next;
	first->next = 0;
	*p = first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x1ba02(%rip), %rcx     # 0x40fd0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x1b9e8(%rip)     # 0x40fd0
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: cvtconst
Tree cvtconst(p) Tree p; {
	Symbol q = constant(p->type, p->u.v);
	Tree e;

	if (q->u.c.loc == 0)
		q->u.c.loc = genident(STATIC, p->type, GLOBAL);
	if (isarray(p->type)) {
		e = tree(ADDRG+P, atop(p->type), 0, 0);
		e->u.sym = q->u.c.loc;
	} else
		e = idnode(q->u.c.loc);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x23d40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x25662
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x24b00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x25681
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2568d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x256cd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x27310
movq %rax, %rsi
movl $0x107, %edi            # imm = 0x107
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x256f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x256de
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xddf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: tree
Tree tree(op, type, left, right) int op; Type type; Tree left, right; {
	register Tree p;

	if (ntree < sizeof trees/sizeof trees[0])
		p = &trees[ntree++];
	else
		p = (Tree)talloc(sizeof *p);
	p->op = op;
	p->type = type;
	p->kids[0] = left;
	p->kids[1] = right;
	p->node = 0;
	p->u.sym = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq 0x1b8ca(%rip), %rax     # 0x40fd8
cmpq $0x64, %rax
jae 0x2573f
movl 0x1b8be(%rip), %eax     # 0x40fd8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1b8b3(%rip)     # 0x40fd8
movslq %eax, %rcx
leaq 0x1b8b1(%rip), %rax     # 0x40fe0
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x257d3
movq 0x15f02(%rip), %rax     # 0x3b648
movl $0x30, (%rax)
movq 0x15ef5(%rip), %rax     # 0x3b648
movq 0x8(%rax), %rax
movq 0x15eea(%rip), %rcx     # 0x3b648
movslq (%rcx), %rcx
addq %rcx, %rax
movq 0x15edd(%rip), %rcx     # 0x3b648
cmpq 0x10(%rcx), %rax
jb 0x2578c
movq 0x15ed0(%rip), %rax     # 0x3b648
movl (%rax), %edi
leaq 0x15ec7(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x30(%rbp)
jmp 0x257cb
movq 0x15eb5(%rip), %rax     # 0x3b648
movl (%rax), %edx
movq 0x15eac(%rip), %rax     # 0x3b648
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x15e97(%rip), %rax     # 0x3b648
movq 0x8(%rax), %rax
movq 0x15e8c(%rip), %rcx     # 0x3b648
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: hascall
int hascall(p) Tree p; {
	if (p == 0)
		return 0;
	if (generic(p->op) == CALL
#ifdef SPARC
	|| p->op == DIV+I || p->op == MOD+I || p->op == MUL+I
	|| p->op == DIV+U || p->op == MOD+U || p->op == MUL+U
#endif
	)
		return 1;
	return hascall(p->kids[0]) || hascall(p->kids[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2584c
movl $0x0, -0x4(%rbp)
jmp 0x2589f
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0xd0, %eax
jne 0x25865
movl $0x1, -0x4(%rbp)
jmp 0x2589f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x25830
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x25894
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x25830
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: opname
char *opname(int op) {
	static char *opnames[] = {
	"",
#define NEEDNAMES
#include "ops.h"
	};
	char *name;

	switch (op) {
	case AND:  return "AND";
	case NOT:  return "NOT";
	case OR:   return "OR";
	case COND: return "COND";
	case RIGHT:return "RIGHT";
	case FIELD:return "FIELD";
	}
	if (opindex(op) > 0 && opindex(op) < sizeof opnames/sizeof opnames[0])
		name = opnames[opindex(op)];
	else
		name = stringd(opindex(op));
	if (optype(op) > 0 && optype(op) < sizeof (TYPENAMES) - 1)
		return stringf("%s%c", name, TYPENAMES[optype(op)]);
	else
		return stringf("%s+%d", name, optype(op));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x260, %eax            # imm = 0x260
je 0x25906
jmp 0x258ca
movl -0x1c(%rbp), %eax
subl $0x270, %eax            # imm = 0x270
je 0x25916
jmp 0x258d6
movl -0x1c(%rbp), %eax
subl $0x280, %eax            # imm = 0x280
je 0x25926
jmp 0x258e2
movl -0x1c(%rbp), %eax
subl $0x290, %eax            # imm = 0x290
je 0x25936
jmp 0x258ee
movl -0x1c(%rbp), %eax
subl $0x2a0, %eax            # imm = 0x2A0
je 0x25946
jmp 0x258fa
movl -0x1c(%rbp), %eax
subl $0x2b0, %eax            # imm = 0x2B0
je 0x25956
jmp 0x25966
leaq 0xc9ed(%rip), %rax      # 0x322fa
movq %rax, -0x8(%rbp)
jmp 0x25a09
leaq 0xca14(%rip), %rax      # 0x32331
movq %rax, -0x8(%rbp)
jmp 0x25a09
leaq 0xc9d7(%rip), %rax      # 0x32304
movq %rax, -0x8(%rbp)
jmp 0x25a09
leaq 0xc9f8(%rip), %rax      # 0x32335
movq %rax, -0x8(%rbp)
jmp 0x25a09
leaq 0xca17(%rip), %rax      # 0x32364
movq %rax, -0x8(%rbp)
jmp 0x25a09
leaq 0xc9dd(%rip), %rax      # 0x3233a
movq %rax, -0x8(%rbp)
jmp 0x25a09
movl -0xc(%rbp), %eax
sarl $0x4, %eax
cmpl $0x0, %eax
jle 0x25999
movl -0xc(%rbp), %eax
sarl $0x4, %eax
cltq
cmpq $0x26, %rax
jae 0x25999
movl -0xc(%rbp), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x15cc1(%rip), %rax     # 0x3b650
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x259a8
movl -0xc(%rbp), %edi
sarl $0x4, %edi
callq 0x23c50
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jle 0x259ed
movl -0xc(%rbp), %eax
andl $0xf, %eax
cltq
cmpq $0xa, %rax
jae 0x259ed
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0xc970(%rip), %rax      # 0x32345
movsbl (%rax,%rcx), %edx
leaq 0xc960(%rip), %rdi      # 0x32340
movb $0x0, %al
callq 0x1afc0
movq %rax, -0x8(%rbp)
jmp 0x25a09
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
andl $0xf, %edx
leaq 0xc952(%rip), %rdi      # 0x32350
movb $0x0, %al
callq 0x1afc0
movq %rax, -0x8(%rbp)
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/tree.c
// Function: retype
Tree retype(p, ty) Tree p; Type ty;{
	Tree q;

	if (p->type == ty)
		return p;
	q = tree(p->op, ty, p->kids[0], p->kids[1]);
	q->u = p->u;
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x25a48
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25a83
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x256f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: texpr
Tree texpr(f, tok) int tok; dclproto(Tree (*f),(int)); {
	int n = ntree;
	Tree p;

	ntree = sizeof trees/sizeof trees[0];
	p = (*f)(tok);
	ntree = n;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x1aeb3(%rip), %eax     # 0x40fd8
movl %eax, -0x10(%rbp)
movl $0x64, 0x1aea6(%rip)    # 0x40fd8
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %edi
callq *%rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, 0x1ae90(%rip)     # 0x40fd8
movq -0x18(%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/tree.c
// Function: nodeid
int nodeid(p) Tree p; {
	int i = 1;

	ids[nid].node = p;
	while (ids[i].node != p)
		i++;
	if (i == nid)
		ids[nid++].printed = 0;
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq 0x155c6(%rip), %rdx     # 0x3b780
leaq 0x1c0df(%rip), %rax     # 0x422a0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1c0c9(%rip), %rax     # 0x422a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x261f3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x261cc
movl -0xc(%rbp), %eax
cmpl 0x15584(%rip), %eax     # 0x3b780
jne 0x26226
movl 0x1557c(%rip), %eax     # 0x3b780
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x15571(%rip)     # 0x3b780
movslq %eax, %rcx
leaq 0x1c087(%rip), %rax     # 0x422a0
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: printed
int *printed(int id) {
	if (id)
		return &ids[id].printed;
	nid = 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x26255
movslq -0xc(%rbp), %rcx
leaq 0x1c058(%rip), %rax     # 0x422a0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x26267
movl $0x1, 0x15521(%rip)     # 0x3b780
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: array
Type array(Type ty, int n, int a) {
	if (ty && isfunc(ty)) {
		error("illegal type `array of %t'\n", ty);
		return array(inttype, n, 0);
	}
	if (a == 0)
		a = ty->align;
	if (level > GLOBAL && isarray(ty) && ty->size == 0)
		error("missing array size\n");
	if (ty->size == 0) {
		if (unqual(ty) == voidtype)
			error("illegal type `array of %t'\n", ty);
		else if (Aflag >= 2)
			warning("declaring type `array of %t' is undefined\n", ty);
	} else if (n > INT_MAX/ty->size) {
		error("size of `array of %t' exceeds %d bytes\n", ty, INT_MAX);
		n = 1;
	}
	return tynode(ARRAY, ty, n*ty->size, a, (Generic)0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x271cd
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x27190
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x27198
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x271cd
movq -0x10(%rbp), %rsi
leaq 0xb8be(%rip), %rdi      # 0x32a6a
movb $0x0, %al
callq 0xd530
movq 0x1d03e(%rip), %rdi     # 0x441f8
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x27160
movq %rax, -0x8(%rbp)
jmp 0x272f7
cmpl $0x0, -0x18(%rbp)
jne 0x271de
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x19dab(%rip), %rax     # 0x40f90
cmpl $0x3, (%rax)
jle 0x2722a
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x27201
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x27209
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x2722a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x2722a
leaq 0xb863(%rip), %rdi      # 0x32a86
movb $0x0, %al
callq 0xd530
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x27296
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x2724b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x27253
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq 0x1cfe2(%rip), %rax     # 0x44240
jne 0x27274
movq -0x10(%rbp), %rsi
leaq 0xb7ff(%rip), %rdi      # 0x32a6a
movb $0x0, %al
callq 0xd530
jmp 0x27294
leaq 0x169ad(%rip), %rax     # 0x3dc28
cmpl $0x2, (%rax)
jl 0x27292
movq -0x10(%rbp), %rsi
leaq 0xb80f(%rip), %rdi      # 0x32a9a
movb $0x0, %al
callq 0xdba0
jmp 0x27294
jmp 0x272d2
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rcx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cltd
idivl 0x8(%rcx)
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jle 0x272d0
movq -0x10(%rbp), %rsi
leaq 0xb808(%rip), %rdi      # 0x32ac5
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movb $0x0, %al
callq 0xd530
movl $0x1, -0x14(%rbp)
jmp 0x272d2
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
imull 0x8(%rax), %edx
movl -0x18(%rbp), %ecx
movl $0xc, %edi
xorl %eax, %eax
movl %eax, %r8d
callq 0x26eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: atop
Type atop(ty) Type ty; {
	if (isarray(ty))
		return ptr(ty->type);
	error("type error: %s\n", "array expected");
	return ptr(ty);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x27333
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2733b
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x27357
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x27120
movq %rax, -0x8(%rbp)
jmp 0x27379
leaq 0xb78f(%rip), %rdi      # 0x32aed
leaq 0xb798(%rip), %rsi      # 0x32afd
movb $0x0, %al
callq 0xd530
movq -0x10(%rbp), %rdi
callq 0x27120
movq %rax, -0x8(%rbp)
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/types.c
// Function: checkfields
void checkfields(ty) Type ty; {
	Field p, inherited = 0;

	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0)
			inherited = check(p->type, ty, inherited, p->offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x273f5
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x273e5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
callq 0x27400
movq %rax, -0x18(%rbp)
jmp 0x273e7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x273b4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: deftype
Symbol deftype(name, ty, pos) char *name; Type ty; Coordinate *pos; {
	Symbol p = lookup(name, identifiers);

	if (p && p->scope == level)
		error("redeclaration of `%s'\n", name);
	p = install(name, &identifiers, level < LOCAL);
	p->type = ty;
	p->sclass = TYPEDEF;
	p->src = *pos;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x13319(%rip), %rax     # 0x3b138
movq (%rax), %rsi
callq 0x24670
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27e57
movq -0x20(%rbp), %rax
movzwl 0x18(%rax), %eax
leaq 0x1914f(%rip), %rcx     # 0x40f90
cmpl (%rcx), %eax
jne 0x27e57
movq -0x8(%rbp), %rsi
leaq 0xaccd(%rip), %rdi      # 0x32b1d
movb $0x0, %al
callq 0xd530
movq -0x8(%rbp), %rdi
leaq 0x1912e(%rip), %rax     # 0x40f90
cmpl $0x5, (%rax)
setl %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x132c4(%rip), %rsi     # 0x3b138
callq 0x24720
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movb $0x53, 0x1a(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%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/types.c
// Function: deref
Type deref(ty) Type ty; {
	if (isptr(ty))
		ty = ty->type;
	else
		error("type error: %s\n", "pointer expected");
	return isenum(ty) ? unqual(ty)->type : ty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x27ee3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x27eeb
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x27f02
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27f17
leaq 0xabe4(%rip), %rdi      # 0x32aed
leaq 0xac24(%rip), %rsi      # 0x32b34
movb $0x0, %al
callq 0xd530
movq -0x8(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x27f2e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x27f36
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x27f6c
movq -0x8(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x27f56
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x27f5e
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x27f74
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: extends
Field extends(ty, fty) Type ty, fty; {
	Field p, q;

	for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0 && unqual(p->type) == unqual(fty))
			return p;
		else if (p->name == 0 && (q = extends(p->type, fty))) {
			static struct field f;
			f = *q;
			f.offset = p->offset + q->offset;
			return &f;
		}
	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 0x282d7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x282df
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x283fa
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x28370
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x28323
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2832f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x2834e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x28356
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jne 0x28370
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28402
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x283e5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x282b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x283e5
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x1beb5(%rip)     # 0x44258
movq 0x8(%rax), %rcx
movq %rcx, 0x1beb2(%rip)     # 0x44260
movq 0x10(%rax), %rcx
movq %rcx, 0x1beaf(%rip)     # 0x44268
movq 0x18(%rax), %rax
movq %rax, 0x1beac(%rip)     # 0x44270
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
addl 0x10(%rcx), %eax
movl %eax, 0x1be90(%rip)     # 0x44268
leaq 0x1be79(%rip), %rax     # 0x44258
movq %rax, -0x8(%rbp)
jmp 0x28402
jmp 0x283e7
jmp 0x283e9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x282ef
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: isfield
static Field isfield(name, flist) char *name; Field flist; {
	for ( ; flist; flist = flist->link)
		if (flist->name == name)
			break;
	return flist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x28a22
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x28a12
jmp 0x28a22
jmp 0x28a14
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x289fc
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: freturn
Type freturn(ty) Type ty; {
	if (isfunc(ty))
		return ty->type;
	error("type error: %s\n", "function expected");
	return inttype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x28a53
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28a5b
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x28a72
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x28a92
leaq 0xa074(%rip), %rdi      # 0x32aed
leaq 0xa0ff(%rip), %rsi      # 0x32b7f
movb $0x0, %al
callq 0xd530
movq 0x1b76a(%rip), %rax     # 0x441f8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: hasproto
int hasproto(ty) Type ty; {
	if (Aflag < 1 || ty == 0)
		return 1;
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE: case POINTER:
	case ARRAY:
		return hasproto(ty->type);
	case FUNCTION:
		return hasproto(ty->type) && ty->u.proto;
	case STRUCT: case UNION:
	case CHAR:   case SHORT: case INT:  case DOUBLE:
	case VOID:   case FLOAT: case ENUM: case UNSIGNED:
		return 1;
	default:
		assert(0);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x15175(%rip), %rax     # 0x3dc28
cmpl $0x1, (%rax)
jl 0x28abf
cmpq $0x0, -0x10(%rbp)
jne 0x28acb
movl $0x1, -0x4(%rbp)
jmp 0x28b9c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
decl %eax
subl $0x6, %eax
jb 0x28b74
jmp 0x28ae1
movl -0x14(%rbp), %eax
subl $0x7, %eax
je 0x28b2d
jmp 0x28aeb
movl -0x14(%rbp), %eax
addl $-0x8, %eax
subl $0x3, %eax
jb 0x28b74
jmp 0x28af8
movl -0x14(%rbp), %eax
subl $0xb, %eax
je 0x28b3f
jmp 0x28b02
movl -0x14(%rbp), %eax
subl $0xc, %eax
je 0x28b2d
jmp 0x28b0c
movl -0x14(%rbp), %eax
subl $0xd, %eax
je 0x28b74
jmp 0x28b16
movl -0x14(%rbp), %eax
addl $-0xf, %eax
subl $0x2, %eax
jb 0x28b2d
jmp 0x28b23
movl -0x14(%rbp), %eax
subl $0x1f, %eax
jne 0x28b7d
jmp 0x28b2d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28aa0
movl %eax, -0x4(%rbp)
jmp 0x28b9c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28aa0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x28b67
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x28b9c
movl $0x1, -0x4(%rbp)
jmp 0x28b9c
leaq 0x6553(%rip), %rdi      # 0x2f0d7
leaq 0x9af5(%rip), %rsi      # 0x32680
movl $0x173, %edx            # imm = 0x173
leaq 0xa014(%rip), %rcx      # 0x32bab
callq 0x30c0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: newstruct
Type newstruct(op, tag) int op; char *tag; {
	Symbol p;

	if (!tag || *tag == '\0')  /* anonymous structure/union/enum */
		tag = stringd(genlabel(1));
	if ((p = lookup(tag, types)) && (p->scope == level
	|| (p->scope == PARAM && level == PARAM+1))) {
		if (p->type->op == op && !p->defined)
			return p->type;
		error("redeclaration of `%s'\n", tag);
	}
	p = install(tag, &types, 1);
	p->type = tynode(op, 0, 0, 0, p);
	if (p->scope > maxlevel)
		maxlevel = p->scope;
	p->src = src;
	return p->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28e32
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x28e47
movl $0x1, %edi
callq 0x24d90
movl %eax, %edi
callq 0x23c50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1270e(%rip), %rax     # 0x3b560
movq (%rax), %rsi
callq 0x24670
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x28ed3
movq -0x20(%rbp), %rax
movzwl 0x18(%rax), %eax
leaq 0x1811d(%rip), %rcx     # 0x40f90
cmpl (%rcx), %eax
je 0x28e90
movq -0x20(%rbp), %rax
movzwl 0x18(%rax), %eax
cmpl $0x4, %eax
jne 0x28ed3
leaq 0x18105(%rip), %rax     # 0x40f90
cmpl $0x5, (%rax)
jne 0x28ed3
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x28ec1
movq -0x20(%rbp), %rax
movb 0x1b(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x28ec1
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x28f4f
movq -0x18(%rbp), %rsi
leaq 0x9c51(%rip), %rdi      # 0x32b1d
movb $0x0, %al
callq 0xd530
movq -0x18(%rbp), %rdi
leaq 0x12682(%rip), %rsi     # 0x3b560
movl $0x1, %edx
callq 0x24720
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x26eb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movzwl 0x18(%rax), %eax
cmpl 0x1b37f(%rip), %eax     # 0x44298
jle 0x28f29
movq -0x20(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, 0x1b36f(%rip)     # 0x44298
movq -0x20(%rbp), %rax
leaq 0x14ba4(%rip), %rcx     # 0x3dad8
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printdecl
void printdecl(p, ty) Symbol p; Type ty; {
	switch (p->sclass) {
	case AUTO:
		fprint(2, "%s;\n", typestring(ty, p->name));
		break;
	case STATIC: case EXTERN:
		fprint(2, "%k %s;\n", p->sclass, typestring(ty, p->name));
	case TYPEDEF: case ENUM:
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xd, %eax
je 0x293dc
jmp 0x29356
movl -0x14(%rbp), %eax
subl $0x43, %eax
je 0x2937e
jmp 0x29360
movl -0x14(%rbp), %eax
subl $0x4a, %eax
je 0x293a7
jmp 0x2936a
movl -0x14(%rbp), %eax
subl $0x51, %eax
je 0x293a7
jmp 0x29374
movl -0x14(%rbp), %eax
subl $0x53, %eax
je 0x293dc
jmp 0x293de
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x29410
movq %rax, %rdx
movl $0x2, %edi
leaq 0x98ca(%rip), %rsi      # 0x32c68
movb $0x0, %al
callq 0x1a630
jmp 0x293fd
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x29410
movl -0x18(%rbp), %edx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x9890(%rip), %rsi      # 0x32c65
movb $0x0, %al
callq 0x1a630
jmp 0x293fd
leaq 0x5cf2(%rip), %rdi      # 0x2f0d7
leaq 0x9294(%rip), %rsi      # 0x32680
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x9875(%rip), %rcx      # 0x32c6d
callq 0x30c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printproto
void printproto(p, callee) Symbol p, callee[]; {
	if (p->type->u.proto)
		printdecl(p, p->type);
	else {
		int i;
		List list = 0;
		if (callee[0] == 0)
			list = append(voidtype, list);
		else
			for (i = 0; callee[i]; i++)
				list = append(callee[i]->type, list);
		printdecl(p, funcl(freturn(p->type), list));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x29ac5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x29330
jmp 0x29b5a
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29aed
movq 0x1a762(%rip), %rdi     # 0x44240
movq -0x20(%rbp), %rsi
callq 0x23500
movq %rax, -0x20(%rbp)
jmp 0x29b2d
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x29b2b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x23500
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29af4
jmp 0x29b2d
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x28a30
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x27d00
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x29330
addq $0x30, %rsp
popq %rbp
retq