LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/output.c
// Function: outs
void outs(s) char *s; {
	char *p = bp;

	while (*s) *p++ = *s++;
	bp = p;
	if (bp > io[fd]->limit)
		outflush();
}

// Assembly:
movq 0x17f9a(%rip), %rax     # 0x28610
movb (%rdi), %cl
testb %cl, %cl
je 0x10686
incq %rdi
movb %cl, (%rax)
incq %rax
jmp 0x10676
movq %rax, 0x17f83(%rip)     # 0x28610
movl 0x17f85(%rip), %ecx     # 0x28618
leaq 0x16e96(%rip), %rdx     # 0x27530
movq (%rdx,%rcx,8), %rcx
cmpq 0x18(%rcx), %rax
ja 0x10613
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: findcount
int findcount(file, x, y) char *file; int x,y; {
	static struct file *cursor;

	if (cursor == 0 || cursor->name != file)
		cursor = findfile(file);
	if (cursor) {
		int l, u;
		struct count *c = cursor->counts;
		for (l = 0, u = cursor->count - 1; l <= u; ) {
			int k = (l + u)/2;
			if (c[k].y > y || c[k].y == y && c[k].x > x)
				u = k - 1;
			else if (c[k].y < y || c[k].y == y && c[k].x < x)
				l = k + 1;
			else
				return c[k].count;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq 0x1c144(%rip), %rax     # 0x2cce0
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x10baa
cmpq %rdi, 0x8(%rax)
je 0x10bbb
callq 0x10c00
movq %rax, 0x1c12a(%rip)     # 0x2cce0
testq %rax, %rax
je 0x10bf9
movq 0x18(%rax), %rcx
movl 0x14(%rax), %eax
xorl %edx, %edx
leal -0x1(%rax), %esi
cmpl %eax, %edx
jge 0x10bf9
leal (%rdx,%rsi), %edi
shrl %edi
imulq $0xc, %rdi, %r9
leaq (%rcx,%r9), %r8
movl 0x4(%rcx,%r9), %r9d
cmpl %ebp, %r9d
jg 0x10bf1
jne 0x10be9
cmpl %r14d, (%r8)
jg 0x10bf1
jge 0x10bf5
incl %edi
movl %edi, %edx
jmp 0x10bc7
movl %edi, %eax
jmp 0x10bc4
movl 0x8(%r8), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: findfunc
int findfunc(name, file) char *name, *file; {
	static struct file *cursor;

	if (cursor == 0 || cursor->name != file)
		cursor = findfile(file);
	if (cursor) {
		struct func *p;
		for (p = cursor->funcs; p; p = p->link)
			if (p->name == name)
				return p->count.count;
	}
	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x1c0c4(%rip), %rax     # 0x2cce8
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x10c32
cmpq %rsi, 0x8(%rax)
je 0x10c46
movq %rsi, %rdi
callq 0x10c00
movq %rax, 0x1c0a7(%rip)     # 0x2cce8
testq %rax, %rax
je 0x10c5b
addq $0x20, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x10c5b
cmpq %r14, 0x8(%rax)
jne 0x10c4a
movl 0x18(%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: getd
static int getd() {
	int c, n = 0;

	while ((c = ngetc()) != EOF && (c == ' ' || c == '\n' || c == '\t'))
		;
	if (c >= '0' && c <= '9') {
		do
			n = 10*n + (c - '0');
		while ((c = ngetc()) >= '0' && c <= '9');
		return n;
	}
	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1974b(%rip), %r14     # 0x2a8f8
movq (%r14), %rdx
movabsq $0x100000600, %rbx      # imm = 0x100000600
movq %rdx, %rax
movzbl (%rdx), %ecx
cmpl $0xa, %ecx
je 0x111e1
testl %ecx, %ecx
je 0x11230
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x111f1
btq %rcx, %rbx
jb 0x111ba
jmp 0x111f1
incq %rax
movq %rax, (%r14)
callq 0xce62
movq (%r14), %rdx
jmp 0x111ba
leal -0x30(%rcx), %edx
cmpl $0x9, %edx
ja 0x11230
addq $0x2, %rax
xorl %ebx, %ebx
imull $0xa, %ebx, %edx
leal (%rcx,%rdx), %ebx
addl $-0x30, %ebx
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x11233
cmpl $0xa, %ecx
je 0x1123d
leaq -0x1(%rax), %rcx
incq %rcx
movq %rcx, (%r14)
movzbl -0x1(%rax), %ecx
leal -0x30(%rcx), %edx
incq %rax
cmpl $0xa, %edx
jb 0x111ff
jmp 0x11233
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, (%r14)
callq 0xce62
jmp 0x11233
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: getstr
static char *getstr() {
	int c;
	char buf[MAXTOKEN], *s = buf;

	while ((c = ngetc()) != EOF && c != ' ' && c != '\n' && c != '\t')
		if (s - buf < sizeof buf - 2)
			*s++ = c;
	*s = 0;
	return s == buf ? 0 : string(buf);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x196a5(%rip), %rax     # 0x2a8f8
movq (%rax), %rsi
movq %rsp, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movq %rcx, %rbx
movq %rbx, %rdi
subq %rcx, %rdi
movq %rsi, %r8
movzbl (%r8), %esi
testl %esi, %esi
je 0x112af
cmpl $0xa, %esi
je 0x112a4
leaq 0x1(%r8), %rsi
movq %rsi, (%rax)
movzbl (%r8), %r9d
cmpq $0x20, %r9
ja 0x11293
btq %r9, %rdx
jb 0x112af
movq %rsi, %r8
cmpq $0x1d, %rdi
ja 0x1126f
movb %r9b, (%rbx)
incq %rbx
jmp 0x11266
incq %r8
movq %r8, (%rax)
callq 0xce62
movb $0x0, (%rbx)
movq %rsp, %rax
cmpq %rax, %rbx
je 0x112c4
movq %rsp, %rdi
callq 0x157b6
jmp 0x112c6
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: ispow2
int ispow2(u) unsigned u; {
	int n;

	if (u > 1 && (u&(u-1)) == 0)
		for (n = 0; u; u >>= 1, n++)
			if (u&1)
				return n;
	return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %edi
jb 0x1131a
movl %edi, %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
movl %edi, %edx
subl %ecx, %edx
movl $0x33333333, %ecx       # imm = 0x33333333
movl %edx, %esi
andl %ecx, %esi
shrl $0x2, %edx
andl %ecx, %edx
addl %esi, %edx
movl %edx, %ecx
shrl $0x4, %ecx
addl %edx, %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
imull $0x1010101, %ecx, %ecx  # imm = 0x1010101
shrl $0x18, %ecx
cmpl $0x1, %ecx
ja 0x1131a
xorl %eax, %eax
testb $0x1, %dil
jne 0x1131a
shrl %edi
incl %eax
jmp 0x1130e
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: add
static int add(x, y, min, max, needconst) double x, y, min, max;  int needconst; {
	int cond =
        x == 0
    ||  y == 0
	|| (x < 0 && y < 0 && x >= min - y)
	|| (x < 0 && y > 0)
	|| (x > 0 && y < 0)
	|| (x > 0 && y > 0 && x <= max - y);
	if (!cond && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
pushq %rbx
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
pushq $0x1
popq %rbx
jne 0x1372c
jnp 0x137a9
ucomisd %xmm4, %xmm1
jne 0x13734
jnp 0x137a9
ucomisd %xmm0, %xmm4
jbe 0x1374a
ucomisd %xmm1, %xmm4
jbe 0x1374a
subsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jae 0x137a9
ucomisd %xmm0, %xmm4
jbe 0x1375a
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
ja 0x137a9
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x1376a
ucomisd %xmm1, %xmm2
ja 0x137a9
subsd %xmm1, %xmm3
ucomisd %xmm0, %xmm3
setae %cl
xorpd %xmm3, %xmm3
cmpltpd %xmm0, %xmm3
cmpltpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb %cl, %al
testl %edi, %edi
sete %cl
orb %al, %cl
je 0x1379b
movzbl %al, %ebx
jmp 0x137a9
leaq 0xac9e(%rip), %rdi      # 0x1e440
xorl %eax, %eax
callq 0x9239
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: addrnode
static Tree addrnode(p, n, ty) Symbol p; int n; Type ty; {
	Symbol q = (Symbol)talloc(sizeof *q);
	Tree e;
	static struct symbol z;

	*q = z;
	q->name = stringd(genlabel(1));
	q->sclass = p->sclass;
	q->scope = p->scope;
	q->type = ty;
	q->defined = 1;
	q->temporary = p->temporary;
	q->generated = p->generated;
	q->computed = 1;
	q->addressed = p->addressed;
	q->initialized = p->initialized;
	q->ref = 1;
	if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
		q->sclass = p->sclass == AUTO ? STATIC : p->sclass;
		address(q, p, n);
		e = tree(ADDRG+P, ty, 0, 0);
	} else {
		Code cp;
		if (!p->defined)
			addlocal(p);
		cp = code(Address);
		cp->u.addr.sym = q;
		cp->u.addr.base = p;
		cp->u.addr.offset = n;
		e = tree(p->scope == PARAM ? ADDRF+P : ADDRL+P, ty, 0, 0);
	}
	e->u.sym = q;
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x15fb5(%rip), %rax     # 0x29778
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r14
leaq 0x88(%r14), %rcx
cmpq 0x10(%rax), %rcx
jae 0x137e3
movq %rcx, 0x8(%rax)
jmp 0x137f7
leaq 0x15f8e(%rip), %rsi     # 0x29778
movl $0x88, %edi
callq 0x16438
movq %rax, %r14
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x30e0
pushq $0x1
popq %rdi
callq 0x1616e
movl %eax, %edi
callq 0x159ba
movq %rax, 0x10(%r14)
movb 0x1a(%r15), %al
movb %al, 0x1a(%r14)
movzwl 0x18(%r15), %eax
movw %ax, 0x18(%r14)
movq %rbx, 0x20(%r14)
movb 0x1b(%r14), %al
orb $0x1, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x2, %cl
andb $-0x3, %al
orb %cl, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x4, %cl
andb $-0xd, %al
orb %cl, %al
orb $0x8, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x10, %cl
andb $-0x11, %al
orb %cl, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x20, %cl
andb $-0x21, %al
orb %cl, %al
movb %al, 0x1b(%r14)
movl $0x1, 0x1c(%r14)
cmpw $0x3, 0x18(%r15)
movzbl 0x1a(%r15), %eax
je 0x13896
cmpl $0x51, %eax
je 0x13896
cmpl $0x4a, %eax
jne 0x138d0
cmpl $0x43, %eax
pushq $0x51
popq %rcx
cmovnel %eax, %ecx
movb %cl, 0x1a(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x19584
movl $0x107, %edi            # imm = 0x107
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x165eb
movq %r14, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, 0x1b(%r15)
jne 0x138df
movq %r15, %rdi
callq 0x32ac
pushq $0x3
popq %rdi
callq 0x32d6
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movl %ebp, 0x28(%rax)
xorl %edi, %edi
cmpw $0x4, 0x18(%r15)
setne %dil
shll $0x4, %edi
addl $0x117, %edi            # imm = 0x117
jmp 0x138b5
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: div
static int div(x, y, min, max, needconst) double x, y, min, max; int needconst; {
	int cond;

	if (x < 0) x = -x;
	if (y < 0) y = -y;
	cond = y != 0 && (y > 1 || x <= max*y);
	if (!cond && y != 0 && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
pushq %rbx
movapd 0xa95e(%rip), %xmm3     # 0x1e270
movapd %xmm1, %xmm4
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
jne 0x13922
jnp 0x13935
maxsd %xmm1, %xmm4
ucomisd 0xa92a(%rip), %xmm4     # 0x1e258
jbe 0x13939
pushq $0x1
popq %rbx
jmp 0x1394e
xorl %ebx, %ebx
jmp 0x1394e
xorpd %xmm0, %xmm3
maxsd %xmm0, %xmm3
mulsd %xmm2, %xmm4
xorl %ebx, %ebx
ucomisd %xmm3, %xmm4
setae %bl
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x1395a
jnp 0x13973
testl %edi, %edi
je 0x13973
testl %ebx, %ebx
jne 0x13973
pushq $0x1
popq %rbx
leaq 0xaad4(%rip), %rdi      # 0x1e440
xorl %eax, %eax
callq 0x9239
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: mul
static int mul(x, y, min, max, needconst) double x, y, min, max; int needconst; {
	int cond =
	   (x > -1 && x <= 1)
    || (y > -1 && y <= 1)
	|| (x < 0 && y < 0 && -x <= max/-y)
	|| (x < 0 && y > 0 &&  x >= min/y)
	|| (x > 0 && y < 0 &&  x >= min/y)
	|| (x > 0 && y > 0 &&  x <= max/y);
	if (!cond && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
pushq %rbx
ucomisd 0xa8e0(%rip), %xmm0     # 0x1e260
pushq $0x1
popq %rbx
jbe 0x13997
movsd 0xa8cb(%rip), %xmm4     # 0x1e258
ucomisd %xmm0, %xmm4
jae 0x13a58
ucomisd 0xa8c1(%rip), %xmm1     # 0x1e260
jbe 0x139b3
movsd 0xa8af(%rip), %xmm4     # 0x1e258
ucomisd %xmm1, %xmm4
jae 0x13a58
xorpd %xmm4, %xmm4
ucomisd %xmm0, %xmm4
jbe 0x139e5
ucomisd %xmm1, %xmm4
jbe 0x139e5
movapd 0xa8a5(%rip), %xmm4     # 0x1e270
movapd %xmm0, %xmm5
xorpd %xmm4, %xmm5
xorpd %xmm1, %xmm4
movapd %xmm3, %xmm6
divsd %xmm4, %xmm6
ucomisd %xmm5, %xmm6
jae 0x13a58
divsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x139ff
xorpd %xmm4, %xmm4
ucomisd %xmm0, %xmm4
jbe 0x139ff
ucomisd %xmm4, %xmm1
ja 0x13a58
ucomisd %xmm2, %xmm0
jb 0x13a15
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x13a15
ucomisd %xmm1, %xmm2
ja 0x13a58
divsd %xmm1, %xmm3
ucomisd %xmm0, %xmm3
setae %cl
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
cmpltpd %xmm0, %xmm3
cmpltpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb %cl, %al
testl %edi, %edi
sete %cl
orb %al, %cl
je 0x13a4a
movzbl %al, %ebx
jmp 0x13a58
leaq 0xa9ef(%rip), %rdi      # 0x1e440
xorl %eax, %eax
callq 0x9239
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: definelab
void definelab(int lab) {
	Code cp;

	walk(0, 0, 0);
	code(Label);
	codelist->u.node = newnode(LABEL+V, 0, 0, findlabel(lab));
	for (cp = codelist; cp->kind <= Label; )
		cp = cp->prev;
	while (cp->kind == Jump && cp->u.node && cp->u.node->kids[0]
	&& cp->u.node->kids[0]->op == ADDRG+P
	&& cp->u.node->kids[0]->syms[0]->u.l.label == lab) {
		cp->u.node->kids[0]->syms[0]->ref--;
		assert(cp->next);
		cp->prev->next = cp->next;
		cp->next->prev = cp->prev;
		cp = cp->prev;
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x376d
pushq $0x5
popq %rdi
callq 0x32d6
movl %ebx, %edi
callq 0x15e6a
movl $0x258, %edi            # imm = 0x258
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4820
leaq 0x14583(%rip), %rcx     # 0x28138
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
movl (%rcx), %eax
cmpl $0x6, %eax
jae 0x13c0d
movq 0x8(%rcx), %rcx
jmp 0x13bbc
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0x13c12
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x13c12
cmpl $0x107, (%rax)          # imm = 0x107
jne 0x13c12
movq 0x8(%rax), %rax
cmpl %ebx, 0x48(%rax)
jne 0x13c12
decl 0x1c(%rax)
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x13c14
movq 0x8(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movl (%rdx), %eax
movq %rdx, %rcx
cmpl $0x9, %eax
je 0x13bc9
popq %rbx
retq
leaq 0xa911(%rip), %rdi      # 0x1e52c
leaq 0xa913(%rip), %rsi      # 0x1e535
leaq 0xa91a(%rip), %rcx      # 0x1e543
pushq $0x74
popq %rdx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: definept
Code definept(p) Coordinate *p; {
	int n;
	Code cp = code(Defpoint);

	cp->u.point.src = p ? *p : src;
	cp->u.point.point = npoints;
	if (ncalled > 0 && (n = findcount(src.file, src.x, src.y)) >= 0)
		refinc = 1000*n/ncalled + 1;
	if (events.points) {
		Tree e = 0;
		apply(events.points, (Generic)&cp->u.point.src, (Generic)&e);
		if (e)
			listnodes(e, 0, 0);
	}
	if (glevel > 2)
		locus(identifiers, &cp->u.point.src);
	return cp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
pushq $0x4
popq %rdi
callq 0x32d6
movq %rax, %rbx
movq %rax, %r14
addq $0x18, %r14
testq %r15, %r15
je 0x13c5a
movups (%r15), %xmm0
jmp 0x13c64
leaq 0x17cd7(%rip), %rax     # 0x2b938
movups (%rax), %xmm0
movups %xmm0, (%r14)
leaq 0x17e09(%rip), %rax     # 0x2ba78
movl (%rax), %eax
movl %eax, 0x28(%rbx)
leaq 0x14985(%rip), %r15     # 0x28600
cmpl $0x0, (%r15)
jle 0x13cae
leaq 0x17cb0(%rip), %rax     # 0x2b938
movq (%rax), %rdi
movzwl 0x8(%rax), %esi
movzwl 0xa(%rax), %edx
callq 0x10b8c
testl %eax, %eax
js 0x13cae
imull $0x3e8, %eax, %eax      # imm = 0x3E8
cltd
idivl (%r15)
incl %eax
movl %eax, 0x149d6(%rip)     # 0x28684
leaq 0x17d4b(%rip), %rax     # 0x2ba00
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x13ce3
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r14, %rsi
movq %r15, %rdx
callq 0xf206
movq (%r15), %rdi
testq %rdi, %rdi
je 0x13ce3
xorl %esi, %esi
xorl %edx, %edx
callq 0x37ca
leaq 0x17d46(%rip), %rax     # 0x2ba30
cmpl $0x3, (%rax)
jl 0x13d01
leaq 0x155f2(%rip), %rax     # 0x292e8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x16234
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: equatelab
void equatelab(new, old) Symbol new, old; {
	struct equate *e = (struct equate *) talloc(sizeof *e);

	e->new = new;
	e->old = old;
	e->oldlink = 0;
	e->link = equlist;
	equlist = e;
	for (e = e->link; e; e = e->link)
		if (e->old == new)
			e->oldlink = equlist;
		else if (e->new == old)
			equlist->oldlink = e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x15a59(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x13d3c
movq %rdx, 0x8(%rcx)
jmp 0x13d4b
leaq 0x15a35(%rip), %rsi     # 0x29778
pushq $0x20
popq %rdi
callq 0x16438
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq 0x18fa2(%rip), %rcx     # 0x2cd00
movq %rcx, 0x18(%rax)
movq %rax, 0x18f97(%rip)     # 0x2cd00
testq %rcx, %rcx
je 0x13d89
cmpq %r14, 0x8(%rcx)
je 0x13d7f
cmpq %rbx, (%rcx)
jne 0x13d83
movq %rcx, 0x10(%rax)
jmp 0x13d83
movq %rax, 0x10(%rcx)
movq 0x18(%rcx), %rcx
jmp 0x13d69
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: visit
static void visit(p) struct equate *p; {
	if (p && p->old) {
		visit(p->oldlink);
		p->new->u.l.equatedto = p->old->u.l.equatedto;
		p->old = 0;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x13de3
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x13de2
movq 0x10(%rbx), %rdi
callq 0x13db5
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: localaddr
static Symbol localaddr(p) Tree p; {
	if (p == 0)
		return 0;
	switch (generic(p->op)) {
	case INDIR: case CALL: case ARG:
		return 0;
	case ADDRL: case ADDRF:
		return p->u.sym;
	case RIGHT: case ASGN:
		if (p->kids[1])
			return localaddr(p->kids[1]);
		return localaddr(p->kids[0]);
	case COND: {
		Symbol q;
		if (p->kids[1] && (q = localaddr(p->kids[1])))
			return q;
		return localaddr(p->kids[2]);
		}
	default: {
		Symbol q;
		if (p->kids[0] && (q = localaddr(p->kids[0])))
			return q;
		return localaddr(p->kids[1]);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
pushq $0x10
popq %r14
pushq $0x20
popq %r15
pushq $0x18
popq %r12
testq %rdi, %rdi
je 0x14132
movq %rdi, %r13
movl (%rdi), %eax
andl $-0x10, %eax
cmpl $0x30, %eax
je 0x140f8
cmpl $0x290, %eax            # imm = 0x290
je 0x14106
cmpl $0x2a0, %eax            # imm = 0x2A0
je 0x140f8
cmpl $0x20, %eax
je 0x14132
cmpl $0x40, %eax
je 0x14132
cmpl $0xd0, %eax
je 0x14132
cmpl $0x120, %eax            # imm = 0x120
je 0x14129
cmpl $0x110, %eax            # imm = 0x110
je 0x14129
movq 0x10(%r13), %rdi
movq %r12, %rcx
testq %rdi, %rdi
je 0x1411f
callq 0x14088
movq %r12, %rcx
jmp 0x1411a
movq 0x18(%r13), %rdi
movq %r14, %rcx
testq %rdi, %rdi
jne 0x1409f
jmp 0x1411f
movq 0x18(%r13), %rdi
movq %r15, %rcx
testq %rdi, %rdi
je 0x1411f
callq 0x14088
movq %r15, %rcx
testq %rax, %rax
jne 0x1412f
movq (%r13,%rcx), %rdi
jmp 0x1409f
movq 0x28(%r13), %rbx
jmp 0x14132
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: branch
static void branch(int lab) {
	Code cp;

	walk(0, 0, 0);
	for (cp = codelist; cp->kind < Label; )
		cp = cp->prev;
	if (lab)
		while (cp->kind == Label && islabel(cp->u.node)
		&& cp->u.node->syms[0]->u.l.label != lab) {
			Symbol old = findlabel(lab);
			equatelab(cp->u.node->syms[0], old);
			old->ref++;
			cp->prev->next = cp->next;
			if (cp->next)
				cp->next->prev = cp->prev;
			else
				codelist = cp->prev;
			do
				cp = cp->prev;
			while (cp->kind < Label);
		}
	if (cp->kind != Jump) {
		code(Jump);
		codelist->u.node = lab ? jump(lab) : 0;
	}
	/* else do nothing and thus delete dead branch */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x376d
leaq 0x13fdd(%rip), %rcx     # 0x28138
movq (%rcx), %r15
movl (%r15), %eax
leaq 0x8(%r15), %rcx
cmpl $0x5, %eax
jb 0x1415b
testl %ebx, %ebx
je 0x141e2
leaq 0x13fc3(%rip), %r12     # 0x28138
cmpl $0x5, %eax
jne 0x141e2
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x141e7
cmpl $0x258, (%rax)          # imm = 0x258
jne 0x141e7
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x141e7
cmpl %ebx, 0x48(%rax)
je 0x141e7
movl %ebx, %edi
callq 0x15e6a
movq %rax, %r14
movq 0x18(%r15), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x13d0e
incl 0x1c(%r14)
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
jne 0x141cd
movq %r12, %rcx
jmp 0x141d1
addq $0x8, %rcx
movq %rax, (%rcx)
movq 0x8(%r15), %r15
movl (%r15), %eax
cmpl $0x5, %eax
jb 0x141d4
jmp 0x14175
cmpl $0x9, %eax
je 0x1420c
pushq $0x9
popq %rdi
callq 0x32d6
testl %ebx, %ebx
je 0x141fc
movl %ebx, %edi
callq 0x475f
jmp 0x141fe
xorl %eax, %eax
leaq 0x13f33(%rip), %rcx     # 0x28138
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/string.c
// Function: append
List append(x, list) Generic x; List list; {
	List new = freenodes;

	if (new)
		freenodes = freenodes->link;
	else
		new = (List)alloc(sizeof *new);
	if (list) {
		new->link = list->link;
		list->link = new;
	} else
		new->link = new;
	new->x = x;
	return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1765f(%rip), %rax     # 0x2cd10
testq %rax, %rax
je 0x156c3
movq 0x8(%rax), %rcx
movq %rcx, 0x1764f(%rip)     # 0x2cd10
jmp 0x156f6
leaq 0x140a6(%rip), %rax     # 0x29770
movq (%rax), %rcx
movl $0x10, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x156e7
movq %rdx, 0x8(%rcx)
jmp 0x156f6
leaq 0x14082(%rip), %rsi     # 0x29770
pushq $0x10
popq %rdi
callq 0x16438
testq %r14, %r14
je 0x15709
movq 0x8(%r14), %rcx
addq $0x8, %r14
movq %rcx, 0x8(%rax)
jmp 0x1570d
leaq 0x8(%rax), %r14
movq %rax, (%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/string.c
// Function: length
int length(list) List list; {
	int n = 0;

	if (list) {
		List lp = list;
		do n++;
		while ((lp = lp->link) != list);
	}
	return n;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x15730
movq %rdi, %rcx
incl %eax
movq 0x8(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x15725
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/string.c
// Function: stringd
char *stringd(int n) {
	char str[30], *s = &str[30];
	unsigned m;

	if (n >= 0 && n < sizeof nums/sizeof nums[0])
		return nums[n];
	if (n == INT_MIN)
		m = (unsigned)INT_MAX + 1;
	else if (n < 0)
		m = -n;
	else
		m = n;
	do
		*--s = m%10 + '0';
	while (m /= 10);
	if (n < 0)
		*--s = '-';
	return stringn(s, &str[30] - s);
}

// Assembly:
movl %edi, %ecx
cmpl $0x63, %edi
ja 0x159cf
movl %ecx, %eax
leaq 0x11f86(%rip), %rcx     # 0x27950
movq (%rcx,%rax,8), %rax
retq
subq $0x28, %rsp
leaq 0x1e(%rsp), %rsi
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movl $0x80000000, %r8d       # imm = 0x80000000
cmovnol %eax, %r8d
leaq 0x1d(%rsp), %rdi
pushq $0xa
popq %r9
movl %r8d, %eax
xorl %edx, %edx
divl %r9d
orb $0x30, %dl
movb %dl, (%rdi)
decq %rdi
cmpl $0x9, %r8d
movl %eax, %r8d
ja 0x159f2
testl %ecx, %ecx
js 0x15a14
incq %rdi
jmp 0x15a17
movb $0x2d, (%rdi)
subl %edi, %esi
callq 0x157c9
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: exitscope
void exitscope() {
	rmtypes();
	rmtemps(0, level);
	if (identifiers->level == level) {
		if (Aflag >= 2) {
			int n = 0;
			Symbol p;
			for (p = identifiers->list; p && p->scope == level; p = p->up)
				if (++n > 127) {
					warning("more than 127 identifiers declared in a block\n");
					break;
				}
		}
		if (xref)	/* (omit) */
			setuses(identifiers);	/* (omit) */
		identifiers = identifiers->previous;
	}
	if (types->level == level) {
		if (xref) {	/* (omit) */
			foreach(types, level, fielduses, (Generic)0);	/* (omit) */
			setuses(types);	/* (omit) */
		}	/* (omit) */
		types = types->previous;
	}
	assert(level >= GLOBAL);
	--level;
}

// Assembly:
pushq %rax
callq 0x18b0b
movl 0x19140(%rip), %esi     # 0x2ed30
xorl %edi, %edi
callq 0x15ceb
movq 0x136ea(%rip), %rdi     # 0x292e8
movl (%rdi), %eax
movl 0x1912a(%rip), %esi     # 0x2ed30
cmpl %esi, %eax
jne 0x15c76
leaq 0x15e47(%rip), %rcx     # 0x2ba58
cmpl $0x2, (%rcx)
jl 0x15c4d
leaq 0x10(%rdi), %rcx
pushq $0x7f
popq %rdx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x15c4d
movzwl 0x18(%rcx), %esi
cmpl %esi, %eax
jne 0x15c4d
subl $0x1, %edx
jb 0x15c38
addq $0x40, %rcx
jmp 0x15c1d
leaq 0x8f57(%rip), %rdi      # 0x1eb96
xorl %eax, %eax
callq 0x9239
movq 0x1369b(%rip), %rdi     # 0x292e8
leaq 0x15de0(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x15c65
callq 0x15d22
movq 0x13683(%rip), %rdi     # 0x292e8
movq 0x8(%rdi), %rax
movq %rax, 0x13678(%rip)     # 0x292e8
movl 0x190ba(%rip), %esi     # 0x2ed30
movq 0x13a93(%rip), %rdi     # 0x29710
cmpl %esi, (%rdi)
jne 0x15cbf
leaq 0x15dac(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x15cb4
leaq 0x1a8(%rip), %rdx       # 0x15e3c
xorl %ecx, %ecx
callq 0x15d9b
movq 0x13a6e(%rip), %rdi     # 0x29710
callq 0x15d22
movq 0x13a62(%rip), %rdi     # 0x29710
movl 0x1907c(%rip), %esi     # 0x2ed30
movq 0x8(%rdi), %rax
movq %rax, 0x13a51(%rip)     # 0x29710
cmpl $0x2, %esi
jle 0x15cce
decl %esi
movl %esi, 0x19064(%rip)     # 0x2ed30
popq %rax
retq
leaq 0x8ef0(%rip), %rdi      # 0x1ebc5
leaq 0x8e74(%rip), %rsi      # 0x1eb50
leaq 0x8ef2(%rip), %rcx      # 0x1ebd5
pushq $0x68
popq %rdx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x1905e(%rip), %rax     # 0x2ed50
movq (%rax), %rcx
testq %rcx, %rcx
je 0x15d21
movq (%rcx), %rdx
movzwl 0x18(%rdx), %r8d
cmpl %esi, %r8d
je 0x15d0f
movzbl 0x1a(%rdx), %edx
cmpl %edi, %edx
jne 0x15d18
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x15cf5
addq $0x8, %rcx
movq %rcx, %rax
jmp 0x15cf2
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0x15d06(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x15d95
movq %rdi, %rbx
addq $0x18, %rbx
xorl %r15d, %r15d
cmpq $0x80, %r15
je 0x15d95
leaq (%rbx,%r15,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x15d90
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x15d69
xorl %esi, %esi
callq 0x15731
movq %rax, 0x38(%r14)
andq $0x0, 0x88(%r14)
movq 0x18fe0(%rip), %rsi     # 0x2ed58
movq %r14, %rdi
callq 0x156a0
movq %rax, 0x18fd1(%rip)     # 0x2ed58
addq $0x90, %r14
jmp 0x15d4a
incq %r15
jmp 0x15d3d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x15e1d
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testq %r15, %r15
je 0x15e10
cmpl %ebp, (%r15)
jle 0x15dc7
movq 0x8(%r15), %r15
jmp 0x15db7
jne 0x15e10
leaq 0x15b68(%rip), %r12     # 0x2b938
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
addq $0x10, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x15e07
movzwl 0x18(%r15), %eax
cmpl %ebp, %eax
jne 0x15e07
movups 0x28(%r15), %xmm0
movups %xmm0, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
addq $0x40, %r15
jmp 0x15ddd
movaps (%rsp), %xmm0
movups %xmm0, (%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8dc2(%rip), %rdi      # 0x1ebe6
leaq 0x8d25(%rip), %rsi      # 0x1eb50
leaq 0x8dc9(%rip), %rcx      # 0x1ebfb
movl $0x96, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x159ba
movq %rax, %r15
movq 0x18ec8(%rip), %rsi     # 0x2ed48
movq %rax, %rdi
callq 0x15ec0
movq %rax, %r14
testq %rax, %rax
jne 0x15eb7
leaq 0x18eb1(%rip), %rsi     # 0x2ed48
movq %r15, %rdi
xorl %edx, %edx
callq 0x15f13
movq %rax, %r14
orb $0x4, 0x1b(%rax)
movl %ebx, 0x48(%rax)
movq %rax, 0x50(%rax)
movq %rax, %rdi
callq 0x18f6d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rsi, %rsi
je 0x15ef4
movl %edi, %ecx
andl $0x7f, %ecx
leaq (%rsi,%rcx,8), %rax
addq $0x18, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x15ee9
cmpq %rdi, 0x10(%rax)
je 0x15ef2
addq $0x90, %rax
jmp 0x15ed3
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x15ecb
popq %rcx
retq
leaq 0x8ceb(%rip), %rdi      # 0x1ebe6
leaq 0x8c4e(%rip), %rsi      # 0x1eb50
leaq 0x8d01(%rip), %rcx      # 0x1ec0a
movl $0xeb, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: install
Symbol install(char *name, Table *tpp, int perm) {
	struct entry *p;
	unsigned h = (unsigned)name&(HASHSIZE-1);

	if ((tpp == &identifiers || tpp == &types) && (*tpp)->level < level)
		*tpp = table(*tpp, level);
	if (perm)
		p = (struct entry *) alloc(sizeof *p);
	else
		p = (struct entry *) talloc(sizeof *p);
	BZERO(&p->sym, struct symbol);
	p->sym.name = name;
	p->sym.scope = (*tpp)->level;
	p->sym.up = (*tpp)->list;
	(*tpp)->list = &p->sym;
	p->link = (*tpp)->buckets[h];
	(*tpp)->buckets[h] = p;
	p->refs = 0;	/* (omit) */
	return &p->sym;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x133c2(%rip), %rax     # 0x292e8
cmpq %rax, %rsi
setne %al
leaq 0x137dd(%rip), %rcx     # 0x29710
cmpq %rcx, %rsi
setne %cl
testb %cl, %al
jne 0x15f52
movq (%rbx), %rdi
movl 0x18dea(%rip), %esi     # 0x2ed30
cmpl %esi, (%rdi)
jge 0x15f52
callq 0x1617d
movq %rax, (%rbx)
testl %ebp, %ebp
je 0x15f80
leaq 0x13813(%rip), %rax     # 0x29770
movq (%rax), %rcx
movl $0x98, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x98(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jb 0x15fa1
leaq 0x137f2(%rip), %rsi     # 0x29770
jmp 0x15fae
leaq 0x137f1(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x98, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x98(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x15fa7
movq %rdx, 0x8(%rcx)
jmp 0x15fb8
leaq 0x137ca(%rip), %rsi     # 0x29778
movl $0x98, %edi
callq 0x16438
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpq $0x7f, %rcx
ja 0x15fd4
leaq (%rax,%rcx), %rdx
addq $0x20, %rcx
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
jmp 0x15fbd
andq $0x0, (%rax,%rcx)
movl %r14d, %ecx
andl $0x7f, %ecx
movq %r14, 0x10(%rax)
movq (%rbx), %rdx
movzwl (%rdx), %esi
movw %si, 0x18(%rax)
movq 0x10(%rdx), %rdx
movq %rdx, 0x40(%rax)
movq (%rbx), %rdx
movq %rax, 0x10(%rdx)
movq (%rbx), %rdx
shll $0x3, %ecx
movq 0x18(%rdx,%rcx), %rdx
movq %rdx, 0x90(%rax)
movq (%rbx), %rdx
movq %rax, 0x18(%rdx,%rcx)
andq $0x0, 0x88(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0x132bd(%rip), %rcx     # 0x292e8
testq %rcx, %rcx
je 0x16071
leaq 0x18(%rcx), %rdx
xorl %esi, %esi
cmpq $0x80, %rsi
je 0x16064
leaq (%rdx,%rsi,8), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1605f
cmpq %rdi, 0x20(%rax)
jne 0x16057
cmpb $0x53, 0x1a(%rax)
je 0x1606f
addq $0x90, %rax
jmp 0x16043
incq %rsi
jmp 0x16036
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x16030
xorl %eax, %eax
popq %rcx
retq
leaq 0x8b6e(%rip), %rdi      # 0x1ebe6
leaq 0x8ad1(%rip), %rsi      # 0x1eb50
leaq 0x8b63(%rip), %rcx      # 0x1ebe9
movl $0x85, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: genident
Symbol genident(int sclass, Type ty, int lev) {
	Symbol p;

	if (lev <= PARAM)
		p = (Symbol) alloc(sizeof *p);
	else
		p = (Symbol) talloc(sizeof *p);
	BZERO(p, struct symbol);
	p->name = stringd(genlabel(1));
	p->scope = lev;
	p->sclass = sclass;
	p->type = ty;
	p->generated = 1;
	if (lev < PARAM)
		defsymbol(p);
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
cmpl $0x4, %edx
jg 0x160cd
leaq 0x136c6(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r15
leaq 0x88(%r15), %rcx
cmpq 0x10(%rax), %rcx
jb 0x160ee
leaq 0x136a5(%rip), %rsi     # 0x29770
jmp 0x160fb
leaq 0x136a4(%rip), %rax     # 0x29778
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r15
leaq 0x88(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0x160f4
movq %rcx, 0x8(%rax)
jmp 0x16108
leaq 0x1367d(%rip), %rsi     # 0x29778
movl $0x88, %edi
callq 0x16438
movq %rax, %r15
xorl %eax, %eax
xorps %xmm0, %xmm0
cmpq $0x7f, %rax
ja 0x16124
leaq (%r15,%rax), %rcx
addq $0x20, %rax
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
jmp 0x1610d
andq $0x0, (%r15,%rax)
movl 0x135e9(%rip), %edi     # 0x29718
leal 0x1(%rdi), %eax
movl %eax, 0x135e0(%rip)     # 0x29718
callq 0x159ba
movq %rax, 0x10(%r15)
movw %bx, 0x18(%r15)
movb %bpl, 0x1a(%r15)
movq %r14, 0x20(%r15)
orb $0x4, 0x1b(%r15)
cmpl $0x3, %ebx
jg 0x16160
movq %r15, %rdi
callq 0x18f6d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x135ec(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x418, (%rcx)          # imm = 0x418
movq 0x8(%rcx), %rax
leaq 0x418(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x161ac
movq %rdx, 0x8(%rcx)
jmp 0x161bd
leaq 0x135c5(%rip), %rsi     # 0x29778
movl $0x418, %edi            # imm = 0x418
callq 0x16438
cmpl $0x4, %ebp
setge %cl
cmpl $0x2, %ebp
sete %dl
orb %cl, %dl
je 0x16201
movq %rbx, 0x8(%rax)
movl %ebp, (%rax)
testq %rbx, %rbx
je 0x161de
movq 0x10(%rbx), %rcx
jmp 0x161e0
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
pushq $0x3
popq %rcx
cmpq $0x83, %rcx
je 0x161fa
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x161e7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8a71(%rip), %rdi      # 0x1ec79
leaq 0x8941(%rip), %rsi      # 0x1eb50
leaq 0x8a81(%rip), %rcx      # 0x1ec97
movl $0x137, %edx            # imm = 0x137
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: newconst
Symbol newconst(Value v, int tc) {
	static Type *btot[] = { 0, &floattype, &doubletype, &chartype,
		&shorttype, &inttype, &unsignedtype, &voidptype };

	assert(tc > 0 && tc < sizeof btot/sizeof btot[0]);
	return constant(*btot[tc], v);
}

// Assembly:
leal -0x1(%rsi), %ecx
cmpl $0x7, %ecx
jae 0x16294
movq %rdi, %rax
movl %esi, %ecx
leaq 0x119eb(%rip), %rdx     # 0x27c70
movq (%rdx,%rcx,8), %rcx
movq (%rcx), %rdi
movq %rax, %rsi
jmp 0x15a24
pushq %rax
leaq 0x897e(%rip), %rdi      # 0x1ec1a
leaq 0x88ad(%rip), %rsi      # 0x1eb50
leaq 0x899a(%rip), %rcx      # 0x1ec44
movl $0xf9, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leal -0x1(%rsi), %eax
cmpl $0x7, %eax
jae 0x162f2
movl %esi, %eax
leaq 0x119aa(%rip), %rcx     # 0x27c70
movq (%rcx,%rax,8), %rax
movq (%rax), %rsi
callq 0x16311
movq %rax, %rbx
movw $0x5, 0x18(%rax)
testb $0x1, 0x1b(%rax)
jne 0x162ed
movq %rbx, %rdi
callq 0x19518
orb $0x1, 0x1b(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x8921(%rip), %rdi      # 0x1ec1a
leaq 0x8850(%rip), %rsi      # 0x1eb50
leaq 0x8959(%rip), %rcx      # 0x1ec60
movl $0x103, %edx            # imm = 0x103
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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 %rax
leaq 0x18a37(%rip), %rax     # 0x2ed50
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1634f
movq (%rcx), %rdx
movzbl 0x1a(%rdx), %r8d
cmpl %edi, %r8d
jne 0x16346
movq 0x20(%rdx), %rdx
movl 0x8(%rdx), %r8d
cmpl 0x8(%rsi), %r8d
jne 0x16346
movzwl 0x4(%rdx), %edx
cmpw 0x4(%rsi), %dx
jge 0x16360
addq $0x8, %rcx
movq %rcx, %rax
jmp 0x16319
movl 0x189db(%rip), %edx     # 0x2ed30
callq 0x16090
orb $0x2, 0x1b(%rax)
popq %rcx
retq
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq (%rcx), %rax
movq %rsi, 0x20(%rax)
jmp 0x1635e
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x1c(%rdi)
je 0x163c7
pushq %rbx
movq %rdi, %rbx
leaq 0x133f7(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x10, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x1639e
movq %rdx, 0x8(%rcx)
jmp 0x163ad
leaq 0x133d3(%rip), %rsi     # 0x29778
pushq $0x10
popq %rdi
callq 0x16438
movq %rbx, (%rax)
movq 0x18999(%rip), %rcx     # 0x2ed50
movq %rcx, 0x8(%rax)
movq %rax, 0x1898e(%rip)     # 0x2ed50
andl $0x0, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x15665(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x16437
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x13387(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x10, (%rax)
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0x16406
movq %rcx, 0x8(%rax)
jmp 0x16418
leaq 0x13363(%rip), %rsi     # 0x29770
pushq $0x10
popq %rdi
callq 0x16438
movq %rax, %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movq 0x88(%rbx), %rsi
callq 0x156a0
movq %rax, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: allocate
char *allocate(int n, Arena *p) {
	Arena ap = *p;

	while (ap->avail + n > ap->limit)
		if (ap->next) {		/* move to next arena */
			ap = ap->next;
			ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
		} else if (freearenas) {
		    ap->next = freearenas;
			freearenas = freearenas->next;
			ap = ap->next;
			ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
			ap->first = (*p)->first;
			ap->next = 0;
		} else {		/* allocate a new arena */
			int m = n + MEMINCR*1024 + roundup(sizeof *ap, sizeof (double));
			ap->next = (Arena) malloc(m);
			assert(ap->next);
			if ((char *)ap->next == ap->limit) /* extend previous arena? */
				ap->limit = (char *)ap->next + m;
			else {			/* link to a new arena */
				ap = ap->next;
				ap->limit = (char *)ap + m;
				ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
			}
			ap->first = (*p)->first;
			ap->next = 0;
		}
	*p = ap;
	ap->avail += n;
	return ap->avail - n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movslq %edi, %r15
movq 0x1891f(%rip), %rcx     # 0x2ed70
leal 0x2828(%r15), %edx
movslq %edx, %r14
movq %rax, %r12
movq %rcx, %rax
movq 0x8(%r12), %rcx
addq %r15, %rcx
movq 0x10(%r12), %r13
cmpq %r13, %rcx
jbe 0x1650d
movq 0x20(%r12), %rcx
testq %rcx, %rcx
je 0x1648e
leaq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rcx)
movq %rcx, %r12
jmp 0x16461
testq %rax, %rax
je 0x164bd
movq %rax, 0x20(%r12)
movq 0x20(%rax), %rcx
movq %rcx, 0x188cd(%rip)     # 0x2ed70
leaq 0x28(%rax), %rdx
movq %rdx, 0x8(%rax)
movq (%rbx), %rdx
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
andq $0x0, 0x20(%rax)
jmp 0x1645b
movq %r14, %rdi
callq 0x3150
movq %rax, 0x20(%r12)
testq %rax, %rax
je 0x16527
leaq (%rax,%r14), %rcx
cmpq %r13, %rax
je 0x164ec
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rax)
movq %rax, %r12
jmp 0x164f1
movq %rcx, 0x10(%r12)
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%r12)
andq $0x0, 0x20(%r12)
xorl %ecx, %ecx
movq %r12, %rax
jmp 0x1645b
movq %r12, (%rbx)
movq 0x8(%r12), %rax
addq %rax, %r15
movq %r15, 0x8(%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x88de(%rip), %rdi      # 0x1ee0c
leaq 0x88e0(%rip), %rsi      # 0x1ee15
leaq 0x88e7(%rip), %rcx      # 0x1ee23
pushq $0x21
popq %rdx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rdi), %rax
movq 0x18(%rax), %rcx
movq 0x1881e(%rip), %rdx     # 0x2ed70
movq %rdx, 0x20(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0x1880f(%rip)     # 0x2ed70
andq $0x0, 0x20(%rcx)
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x28(%r14), %rsi
callq 0x15a24
movq %rax, %rbx
movq 0x50(%rax), %rdi
testq %rdi, %rdi
jne 0x165a0
movq 0x8(%r14), %rsi
pushq $0x51
popq %rdi
pushq $0x3
popq %rdx
callq 0x16090
movq %rax, %rdi
movq %rax, 0x50(%rbx)
movq 0x8(%r14), %rax
movl (%rax), %ecx
cmpl $0xf, %ecx
jb 0x165b1
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0x165df
movq %rax, %rdi
callq 0x1749b
movl $0x107, %edi            # imm = 0x107
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x165eb
movq 0x50(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x93b4
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl 0x18775(%rip), %eax     # 0x2ed78
cmpq $0x63, %rax
ja 0x16622
leal 0x1(%rax), %ecx
movl %ecx, 0x18766(%rip)     # 0x2ed78
imulq $0x30, %rax, %rcx
leaq 0x18763(%rip), %rax     # 0x2ed80
addq %rcx, %rax
jmp 0x16652
movq 0x1314f(%rip), %rcx     # 0x29778
movl $0x30, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x30(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x16643
movq %rdx, 0x8(%rcx)
jmp 0x16652
leaq 0x1312e(%rip), %rsi     # 0x29778
pushq $0x30
popq %rdi
callq 0x16438
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
testq %r14, %r14
je 0x166a1
movl (%r14), %eax
andl $-0x10, %eax
cmpl $0xd0, %eax
je 0x166a3
movq 0x10(%r14), %rdi
callq 0x16672
testl %eax, %eax
jne 0x166a3
movq 0x18(%r14), %r14
jmp 0x1667c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leal -0x260(%rbx), %eax
roll $0x1c, %eax
cmpl $0x6, %eax
jae 0x166d0
movl %eax, %eax
leaq 0x872d(%rip), %rcx      # 0x1edf4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
popq %rbx
retq
movl %ebx, %edi
sarl $0x4, %edi
leal -0x1(%rdi), %eax
cmpl $0x24, %eax
ja 0x166ef
movl %edi, %eax
leaq 0x8676(%rip), %rcx      # 0x1ed5c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x166f7
callq 0x159ba
movq %rax, %rsi
andl $0xf, %ebx
leal -0x1(%rbx), %eax
cmpl $0x8, %eax
ja 0x16716
leaq 0x87e5(%rip), %rax      # 0x1eeee
movsbl (%rbx,%rax), %edx
leaq 0x87d5(%rip), %rdi      # 0x1eee9
jmp 0x1671f
leaq 0x87dc(%rip), %rdi      # 0x1eef9
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
jmp 0x10a97
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpq %rsi, 0x8(%rdi)
je 0x1674b
movl (%rbx), %edi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
callq 0x165eb
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq