LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, 0x23d96(%rip)     # 0x3eeb0
je 0x1b12d
movq 0x23d8d(%rip), %rax     # 0x3eeb0
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x1b13d
movq -0x10(%rbp), %rdi
callq 0x1b260
movq %rax, 0x23d73(%rip)     # 0x3eeb0
cmpq $0x0, 0x23d6b(%rip)     # 0x3eeb0
je 0x1b24c
movq 0x23d5e(%rip), %rax     # 0x3eeb0
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq 0x23d48(%rip), %rax     # 0x3eeb0
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x1b24a
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jg 0x1b1d2
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x1b1dd
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x1b1dd
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b245
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jl 0x1b221
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x1b22c
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x1b22c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b243
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b253
jmp 0x1b245
jmp 0x1b171
jmp 0x1b24c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, 0x23bf0(%rip)     # 0x3eeb8
je 0x1b2db
movq 0x23be7(%rip), %rax     # 0x3eeb8
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x1b2eb
movq -0x18(%rbp), %rdi
callq 0x1b260
movq %rax, 0x23bcd(%rip)     # 0x3eeb8
cmpq $0x0, 0x23bc5(%rip)     # 0x3eeb8
je 0x1b336
movq 0x23bbc(%rip), %rax     # 0x3eeb8
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1b334
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1b325
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b33d
jmp 0x1b327
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1b304
jmp 0x1b336
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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/profio.c
// Function: process
int process(file) char *file; {
	int more;

#ifdef BPRINT
	if ((fp = fopen(file, "r"))) {
		while ((more = gather()) > 0)
			;
		fclose(fp);
		return more < 0 ? more : 1;
	}
#else
	int fd;
	struct file *p;

	if ((fd = open(file, 0)) >= 0) {
		inputInit(fd);
		while ((more = gather()) > 0)
			;
		close(fd);
		if (more < 0)
			return more;
		for (p = filelist; p; p = p->link)
			qsort(p->counts, p->count, sizeof *p->counts,
				(dclproto(int (*),(const void *, const void *)))
				compare);

		return 1;
	}
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3140
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x1b3e6
movl -0x18(%rbp), %edi
callq 0x146a0
callq 0x1b400
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x1b388
jmp 0x1b379
movl -0x18(%rbp), %edi
callq 0x30d0
cmpl $0x0, -0x14(%rbp)
jge 0x1b39e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b3ed
movq 0x23b1b(%rip), %rax     # 0x3eec0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1b3dd
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x14(%rax), %esi
movl $0xc, %edx
leaq 0x445(%rip), %rcx       # 0x1b810
callq 0x3060
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1b3a9
movl $0x1, -0x4(%rbp)
jmp 0x1b3ed
movl $0x0, -0x4(%rbp)
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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0xc(%rbp)
leaq 0x21222(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1b88b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x10(%rbp)
jmp 0x1b8eb
leaq 0x21206(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1b8c4
leaq 0x211f4(%rip), %rax     # 0x3ca98
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x211e6(%rip), %rax     # 0x3ca98
movq %rcx, (%rax)
callq 0x14710
movl $0xa, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b8e5
leaq 0x211cd(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x211bc(%rip), %rcx     # 0x3ca98
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, -0x8(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x1b921
movb $0x1, %al
cmpl $0x20, -0x8(%rbp)
movb %al, -0x16(%rbp)
je 0x1b91b
movb $0x1, %al
cmpl $0xa, -0x8(%rbp)
movb %al, -0x16(%rbp)
je 0x1b91b
cmpl $0x9, -0x8(%rbp)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1b92a
jmp 0x1b92f
jmp 0x1b86f
cmpl $0x30, -0x8(%rbp)
jl 0x1b9fd
cmpl $0x39, -0x8(%rbp)
jg 0x1b9fd
jmp 0x1b945
imull $0xa, -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
leaq 0x2113d(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1b970
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x1b9d0
leaq 0x21121(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1b9a9
leaq 0x2110f(%rip), %rax     # 0x3ca98
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x21101(%rip), %rax     # 0x3ca98
movq %rcx, (%rax)
callq 0x14710
movl $0xa, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b9ca
leaq 0x210e8(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x210d7(%rip), %rcx     # 0x3ca98
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x21(%rbp)
jl 0x1b9ea
cmpl $0x39, -0x8(%rbp)
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1b945
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1ba04
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x21071(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1ba3c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x3c(%rbp)
jmp 0x1ba9c
leaq 0x21055(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1ba75
leaq 0x21043(%rip), %rax     # 0x3ca98
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x21035(%rip), %rax     # 0x3ca98
movq %rcx, (%rax)
callq 0x14710
movl $0xa, %eax
movl %eax, -0x40(%rbp)
jmp 0x1ba96
leaq 0x2101c(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x2100b(%rip), %rcx     # 0x3ca98
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x41(%rbp)
je 0x1bacc
xorl %eax, %eax
cmpl $0x20, -0x4(%rbp)
movb %al, -0x41(%rbp)
je 0x1bacc
xorl %eax, %eax
cmpl $0xa, -0x4(%rbp)
movb %al, -0x41(%rbp)
je 0x1bacc
cmpl $0x9, -0x4(%rbp)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1bad5
jmp 0x1bb01
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1e, %rax
jae 0x1bafc
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
jmp 0x1ba20
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1bb1d
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x1bb2a
leaq -0x30(%rbp), %rdi
callq 0x237e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jbe 0x1c384
movl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x1c384
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1c382
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1c36d
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c38b
jmp 0x1c36f
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c354
jmp 0x1c384
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movl %edi, -0x24(%rbp)
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jne 0x1ff79
jp 0x1ff79
jmp 0x20040
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jne 0x1ff93
jp 0x1ff93
jmp 0x20040
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x1ffc1
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x1ffc1
movsd -0x8(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
subsd -0x10(%rbp), %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jae 0x20040
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x1ffde
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
ja 0x20040
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1fffb
movb $0x1, %al
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
movb %al, -0x29(%rbp)
ja 0x20040
movsd -0x8(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x2a(%rbp)
jbe 0x2003a
movsd -0x10(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x2a(%rbp)
jbe 0x2003a
movsd -0x8(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x2006c
cmpl $0x0, -0x24(%rbp)
je 0x2006c
leaq 0x11a8e(%rip), %rdi     # 0x31aec
movb $0x0, %al
callq 0xdba0
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movl %edi, -0x24(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x203ba
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x203e5
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jne 0x203fc
jp 0x203fc
jmp 0x20433
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
movsd 0x10ddd(%rip), %xmm1    # 0x311e8
ucomisd %xmm1, %xmm0
movb %al, -0x2a(%rbp)
ja 0x2042d
movsd -0x8(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x20471
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x20456
jp 0x20456
jmp 0x20471
cmpl $0x0, -0x24(%rbp)
je 0x20471
leaq 0x11689(%rip), %rdi     # 0x31aec
movb $0x0, %al
callq 0xdba0
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movl %edi, -0x24(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x10d44(%rip), %xmm1    # 0x311f0
ucomisd %xmm1, %xmm0
jbe 0x204ca
movb $0x1, %al
movsd 0x10d2c(%rip), %xmm0    # 0x311e8
ucomisd -0x8(%rbp), %xmm0
movb %al, -0x29(%rbp)
jae 0x20602
movsd -0x10(%rbp), %xmm0
movsd 0x10d19(%rip), %xmm1    # 0x311f0
ucomisd %xmm1, %xmm0
jbe 0x204f5
movb $0x1, %al
movsd 0x10d01(%rip), %xmm0    # 0x311e8
ucomisd -0x10(%rbp), %xmm0
movb %al, -0x29(%rbp)
jae 0x20602
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x20559
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x20559
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
divsd %xmm2, %xmm0
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jae 0x20602
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x2058b
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2058b
movsd -0x8(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jae 0x20602
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x205bd
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x205bd
movsd -0x8(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jae 0x20602
movsd -0x8(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x2a(%rbp)
jbe 0x205fc
movsd -0x10(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x2a(%rbp)
jbe 0x205fc
movsd -0x8(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x2062e
cmpl $0x0, -0x24(%rbp)
je 0x2062e
leaq 0x114cc(%rip), %rdi     # 0x31aec
movb $0x0, %al
callq 0xdba0
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
movl $0x5, %edi
callq 0x3300
movl -0x4(%rbp), %edi
callq 0x245d0
movq %rax, %rcx
movl $0x258, %edi            # imm = 0x258
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5bf0
movq %rax, %rcx
leaq 0x18830(%rip), %rax     # 0x39128
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0x18822(%rip), %rax     # 0x39128
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
ja 0x20924
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2090d
jmp 0x20926
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x9, (%rcx)
movb %al, -0x11(%rbp)
jne 0x2098d
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x11(%rbp)
je 0x2098d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x11(%rbp)
je 0x2098d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rcx
xorl %eax, %eax
cmpl $0x107, (%rcx)          # imm = 0x107
movb %al, -0x11(%rbp)
jne 0x2098d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movl 0x48(%rax), %eax
cmpl -0x4(%rbp), %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x20996
jmp 0x20a14
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x209bc
jmp 0x209db
leaq 0x1131d(%rip), %rdi     # 0x31ce0
leaq 0x1131f(%rip), %rsi     # 0x31ce9
movl $0x74, %edx
leaq 0x11321(%rip), %rcx     # 0x31cf7
callq 0x30c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x20926
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, %edi
callq 0x3300
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20a65
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x20a7e
movq -0x28(%rbp), %rax
leaq 0x1d068(%rip), %rcx     # 0x3dad8
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
leaq 0x1d1c3(%rip), %rax     # 0x3dc48
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
leaq 0x1907b(%rip), %rax     # 0x39b10
cmpl $0x0, (%rax)
jle 0x20ae1
leaq 0x1d037(%rip), %rax     # 0x3dad8
movq (%rax), %rdi
leaq 0x1d02d(%rip), %rax     # 0x3dad8
movzwl 0x8(%rax), %esi
leaq 0x1d022(%rip), %rax     # 0x3dad8
movzwl 0xa(%rax), %edx
callq 0x1b100
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x20ae1
imull $0x3e8, -0xc(%rbp), %eax # imm = 0x3E8
leaq 0x1903b(%rip), %rcx     # 0x39b10
cltd
idivl (%rcx)
addl $0x1, %eax
movl %eax, 0x194d3(%rip)     # 0x39fb4
leaq 0x1d0e8(%rip), %rax     # 0x3dbd0
cmpq $0x0, 0x18(%rax)
je 0x20b29
movq $0x0, -0x20(%rbp)
leaq 0x1d0d2(%rip), %rax     # 0x3dbd0
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x20(%rbp), %rdx
callq 0x18640
cmpq $0x0, -0x20(%rbp)
je 0x20b27
movq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3c30
jmp 0x20b29
leaq 0x1d0d0(%rip), %rax     # 0x3dc00
cmpl $0x2, (%rax)
jle 0x20b4c
leaq 0x1a5fc(%rip), %rax     # 0x3b138
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x24f50
movq -0x18(%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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1aad1(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x20, (%rax)
leaq 0x1aac1(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x1aab3(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x1aaa3(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x20bcc
leaq 0x1aa93(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x1aa87(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x20(%rbp)
jmp 0x20c17
leaq 0x1aa75(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x1aa69(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x1aa51(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x1aa43(%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)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x1e31f(%rip), %rcx     # 0x3ef68
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x1e30c(%rip)     # 0x3ef68
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x20cbc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x20c8e
movq 0x1e2e4(%rip), %rcx     # 0x3ef68
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x20cac
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x20caa
movq -0x18(%rbp), %rcx
movq 0x1e2c2(%rip), %rax     # 0x3ef68
movq %rcx, 0x10(%rax)
jmp 0x20cac
jmp 0x20cae
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x20c68
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20d5e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x20d5e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x20d10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x21230
movq $0x0, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0x24(%rbp)
subl $0x20, %eax
je 0x21296
jmp 0x21243
movl -0x24(%rbp), %eax
subl $0x30, %eax
je 0x212b4
jmp 0x2124d
movl -0x24(%rbp), %eax
subl $0x40, %eax
je 0x21296
jmp 0x21257
movl -0x24(%rbp), %eax
subl $0xd0, %eax
je 0x21296
jmp 0x21263
movl -0x24(%rbp), %eax
subl $0x110, %eax            # imm = 0x110
je 0x212a3
jmp 0x2126f
movl -0x24(%rbp), %eax
subl $0x120, %eax            # imm = 0x120
je 0x212a3
jmp 0x2127b
movl -0x24(%rbp), %eax
subl $0x290, %eax            # imm = 0x290
je 0x212e8
jmp 0x21287
movl -0x24(%rbp), %eax
subl $0x2a0, %eax            # imm = 0x2A0
je 0x212b4
jmp 0x21327
movq $0x0, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x212d5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21210
movq %rax, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21210
movq %rax, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x21314
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21210
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x21314
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x21210
movq %rax, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21353
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21210
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x21353
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21364
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21210
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
leaq 0x17d99(%rip), %rax     # 0x39128
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jae 0x213ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x21396
cmpl $0x0, -0x4(%rbp)
je 0x214b7
jmp 0x213b9
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x5, (%rcx)
movb %al, -0x19(%rbp)
jne 0x21418
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x19(%rbp)
je 0x21418
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpl $0x258, (%rcx)          # imm = 0x258
movb %al, -0x19(%rbp)
jne 0x21418
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x19(%rbp)
je 0x21418
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movl 0x48(%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x21424
jmp 0x214b5
movl -0x4(%rbp), %edi
callq 0x245d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20b60
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21487
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x21499
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x17c92(%rip), %rax     # 0x39128
movq %rcx, (%rax)
jmp 0x2149b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jb 0x2149b
jmp 0x213b9
jmp 0x214b7
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
je 0x214f8
movl $0x9, %edi
callq 0x3300
cmpl $0x0, -0x4(%rbp)
je 0x214de
movl -0x4(%rbp), %edi
callq 0x5a10
movq %rax, -0x28(%rbp)
jmp 0x214e6
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x214e6
movq -0x28(%rbp), %rcx
leaq 0x17c37(%rip), %rax     # 0x39128
movq (%rax), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: ifstmt
static void ifstmt(lab, loop, swp, lev) int lab,loop,lev; struct swtch *swp; {
	t = gettok();
	expect('(');
	definept(0);
	walk(conditional(')'), 0, lab);
	if ((refinc /= 2) == 0)
		refinc = 1;
	statement(loop, swp, lev);
	if (t == ELSE) {
		branch(lab + 1);
		t = gettok();
		definelab(lab);
		statement(loop, swp, lev);
		if (findlabel(lab + 1)->ref)
			definelab(lab + 1);
	} else
		definelab(lab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
callq 0x15170
movl %eax, %ecx
leaq 0x1bedd(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movl $0x28, %edi
callq 0xd670
xorl %eax, %eax
movl %eax, %edi
callq 0x20a20
movl $0x29, %edi
callq 0xfbf0
movq %rax, %rdi
movl -0x4(%rbp), %edx
xorl %esi, %esi
callq 0x3a80
movl 0x182df(%rip), %eax     # 0x39fb4
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x182d1(%rip)     # 0x39fb4
cmpl $0x0, %eax
jne 0x21cf2
movl $0x1, 0x182c2(%rip)     # 0x39fb4
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x21500
leaq 0x1be78(%rip), %rax     # 0x3db80
cmpl $0x49, (%rax)
jne 0x21d5d
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x21370
callq 0x15170
movl %eax, %ecx
leaq 0x1be5a(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0x208b0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x21500
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x245d0
cmpl $0x0, 0x1c(%rax)
je 0x21d5b
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x208b0
jmp 0x21d65
movl -0x4(%rbp), %edi
callq 0x208b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: whilestmt
static void whilestmt(lab, swp, lev) int lab, lev; struct swtch *swp; {
	Coordinate pt;
	Tree e;

	refinc *= 10;
	t = gettok();
	expect('(');
	walk(0, 0, 0);
	pt = src;
	e = texpr(conditional, ')');
	if (generic(e->op) == CNST || glevel == 2) {
			/* L, L+1: if (!e) goto L+2; S; goto L; L+2: */
		definelab(lab);
		definelab(lab + 1);
		definept(&pt);
		walk(e, 0, lab + 2);
		statement(lab, swp, lev);
		branch(lab);
	} else {	/* goto L+1; L: S; L+1: if (E) goto L; L+2: */
		branch(lab + 1);
		definelab(lab);
		statement(lab, swp, lev);
		definelab(lab + 1);
		definept(&pt);
		walk(e, lab, 0);
	}
	if (findlabel(lab + 2)->ref)
		definelab(lab + 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
imull $0xa, 0x1822b(%rip), %eax # 0x39fb4
movl %eax, 0x18225(%rip)     # 0x39fb4
callq 0x15170
movl %eax, %ecx
leaq 0x1bde3(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movl $0x28, %edi
callq 0xd670
xorl %eax, %eax
movl %eax, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
leaq 0x1bd1b(%rip), %rax     # 0x3dad8
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x121e3(%rip), %rdi    # 0xfbf0
movl $0x29, %esi
callq 0x26110
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0x21dfb
leaq 0x1be0a(%rip), %rax     # 0x3dc00
cmpl $0x2, (%rax)
jne 0x21e41
movl -0x4(%rbp), %edi
callq 0x208b0
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x208b0
leaq -0x28(%rbp), %rdi
callq 0x20a20
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %edx
addl $0x2, %edx
xorl %esi, %esi
callq 0x3a80
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x21500
movl -0x4(%rbp), %edi
callq 0x21370
jmp 0x21e85
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x21370
movl -0x4(%rbp), %edi
callq 0x208b0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x21500
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x208b0
leaq -0x28(%rbp), %rdi
callq 0x20a20
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x3a80
movl -0x4(%rbp), %edi
addl $0x2, %edi
callq 0x245d0
cmpl $0x0, 0x1c(%rax)
je 0x21ea1
movl -0x4(%rbp), %edi
addl $0x2, %edi
callq 0x208b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: dostmt
static void dostmt(lab, swp, lev) int lab, lev; struct swtch *swp; {
	refinc *= 10;
	t = gettok();
	definelab(lab);
	statement(lab, swp, lev);
	definelab(lab + 1);
	expect(WHILE);
	expect('(');
	definept(0);
	walk(conditional(')'), lab, 0);
	if (findlabel(lab + 2)->ref)
		definelab(lab + 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
imull $0xa, 0x180eb(%rip), %eax # 0x39fb4
movl %eax, 0x180e5(%rip)     # 0x39fb4
callq 0x15170
movl %eax, %ecx
leaq 0x1bca3(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0x208b0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x21500
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x208b0
movl $0x54, %edi
callq 0xd670
movl $0x28, %edi
callq 0xd670
xorl %eax, %eax
movl %eax, %edi
callq 0x20a20
movl $0x29, %edi
callq 0xfbf0
movq %rax, %rdi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x3a80
movl -0x4(%rbp), %edi
addl $0x2, %edi
callq 0x245d0
cmpl $0x0, 0x1c(%rax)
je 0x21f51
movl -0x4(%rbp), %edi
addl $0x2, %edi
callq 0x208b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: stmtlabel
static void stmtlabel(label) char *label; {
	Symbol p;

	if ((p = lookup(label, labels[0])) == 0) {
		p = install(label, &labels[0], 0);
		p->u.l.label = genlabel(1);
		p->u.l.equatedto = p;
	}
	if (p->defined)
		error("redefinition of label `%s' previously defined at %w\n",
			label, &p->src);
	p->defined = 1;
	p->src = src;
	definelab(p->u.l.label);
	t = gettok();
	expect(':');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1e5b9(%rip), %rax     # 0x40fa0
movq (%rax), %rsi
callq 0x24670
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x22a2e
movq -0x8(%rbp), %rdi
leaq 0x1e59c(%rip), %rsi     # 0x40fa0
xorl %edx, %edx
callq 0x24720
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x24d90
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movb 0x1b(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x22a59
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
leaq 0xf4a8(%rip), %rdi      # 0x31efa
movb $0x0, %al
callq 0xd530
movq -0x10(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
movq -0x10(%rbp), %rax
leaq 0x1b064(%rip), %rcx     # 0x3dad8
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %edi
callq 0x208b0
callq 0x15170
movl %eax, %ecx
leaq 0x1b0e3(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movl $0x3a, %edi
callq 0xd670
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: foldcond
static int foldcond(e1, e2) Tree e1, e2; {
	Opcode op = generic(e2->op);
	Symbol v;

	if (e1 == 0 || e2 == 0)
		return 0;
	if (generic(e1->op) == ASGN && isaddrop(e1->kids[0]->op)
	&& generic(e1->kids[1]->op) == CNST) {
		v = e1->kids[0]->u.sym;
		e1 = e1->kids[1];
	} else
		return 0;
	if ((op==LE || op==LT || op==EQ || op==NE || op==GT || op==GE)
	&& generic(e2->kids[0]->op) == INDIR
	&& e2->kids[0]->kids[0]->u.sym == v
	&& e2->kids[1]->op == e1->op) {
		e1 = simplify(op, e2->type, e1, e2->kids[1]);
		if (e1->op == CNST+I)
			return e1->u.v.i;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x22ada
cmpq $0x0, -0x18(%rbp)
jne 0x22ae6
movl $0x0, -0x4(%rbp)
jmp 0x22c0e
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x30, %eax
jne 0x22b54
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x107, (%rax)          # imm = 0x107
je 0x22b24
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x127, (%rax)          # imm = 0x127
je 0x22b24
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x117, (%rax)          # imm = 0x117
jne 0x22b54
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
jne 0x22b54
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x22b60
movl $0x0, -0x4(%rbp)
jmp 0x22c0e
cmpl $0x210, -0x1c(%rbp)     # imm = 0x210
je 0x22b96
cmpl $0x220, -0x1c(%rbp)     # imm = 0x220
je 0x22b96
cmpl $0x1e0, -0x1c(%rbp)     # imm = 0x1E0
je 0x22b96
cmpl $0x230, -0x1c(%rbp)     # imm = 0x230
je 0x22b96
cmpl $0x200, -0x1c(%rbp)     # imm = 0x200
je 0x22b96
cmpl $0x1f0, -0x1c(%rbp)     # imm = 0x1F0
jne 0x22c07
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x40, %eax
jne 0x22c07
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x22c07
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x22c07
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x1c390
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x22c05
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x22c0e
jmp 0x22c07
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1ba59(%rip), %rax     # 0x3ef70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23539
movq 0x1ba47(%rip), %rax     # 0x3ef70
movq 0x8(%rax), %rax
movq %rax, 0x1ba3c(%rip)     # 0x3ef70
jmp 0x235e8
leaq 0x18100(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl $0x10, (%rax)
leaq 0x180f0(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x180e2(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x180d2(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x23595
leaq 0x180c2(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edi
leaq 0x180b6(%rip), %rsi     # 0x3b640
callq 0x253d0
movq %rax, -0x20(%rbp)
jmp 0x235e0
leaq 0x180a4(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edx
leaq 0x18098(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x18080(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x18072(%rip), %rcx     # 0x3b640
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)
cmpq $0x0, -0x10(%rbp)
je 0x2360d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x23619
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2366b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq -0x8(%rbp), %rax
jne 0x2364e
jmp 0x2366b
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
addq $0x1e, %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x23c8f
movslq -0xc(%rbp), %rax
cmpq $0x64, %rax
jae 0x23c8f
movslq -0xc(%rbp), %rcx
leaq 0x1633e(%rip), %rax     # 0x39fc0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x23d29
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
jne 0x23ca1
movl $0x80000000, -0x3c(%rbp) # imm = 0x80000000
jmp 0x23cb9
cmpl $0x0, -0xc(%rbp)
jge 0x23cb1
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x23cb7
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x23cb9
jmp 0x23cbb
movl -0x3c(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, -0x1(%rax)
movl -0x3c(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jne 0x23cbb
cmpl $0x0, -0xc(%rbp)
jge 0x23d0b
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rax
addq $0x1e, %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
callq 0x23830
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x29d10
movl 0x1ce4d(%rip), %esi     # 0x40f90
xorl %edi, %edi
callq 0x242a0
movq 0x16fe7(%rip), %rax     # 0x3b138
movl (%rax), %eax
cmpl 0x1ce37(%rip), %eax     # 0x40f90
jne 0x24204
leaq 0x19ac2(%rip), %rax     # 0x3dc28
cmpl $0x2, (%rax)
jl 0x241da
movl $0x0, -0x4(%rbp)
movq 0x16fbf(%rip), %rax     # 0x3b138
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x241a1
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
cmpl 0x1cdf5(%rip), %eax     # 0x40f90
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x241aa
jmp 0x241d8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x7f, %eax
jle 0x241c8
leaq 0xdf8b(%rip), %rdi      # 0x3214a
movb $0x0, %al
callq 0xdba0
jmp 0x241d8
jmp 0x241ca
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x24181
jmp 0x241da
leaq 0x19a23(%rip), %rax     # 0x3dc04
cmpl $0x0, (%rax)
je 0x241f2
movq 0x16f4b(%rip), %rdi     # 0x3b138
callq 0x24320
movq 0x16f3f(%rip), %rax     # 0x3b138
movq 0x8(%rax), %rax
movq %rax, 0x16f34(%rip)     # 0x3b138
movq 0x17355(%rip), %rax     # 0x3b560
movl (%rax), %eax
cmpl 0x1cd7d(%rip), %eax     # 0x40f90
jne 0x2425c
leaq 0x199e8(%rip), %rax     # 0x3dc04
cmpl $0x0, (%rax)
je 0x2424a
movq 0x17338(%rip), %rdi     # 0x3b560
movl 0x1cd62(%rip), %esi     # 0x40f90
leaq 0x2eb(%rip), %rdx       # 0x24520
xorl %eax, %eax
movl %eax, %ecx
callq 0x243f0
movq 0x1731b(%rip), %rdi     # 0x3b560
callq 0x24320
movq 0x1730f(%rip), %rax     # 0x3b560
movq 0x8(%rax), %rax
movq %rax, 0x17304(%rip)     # 0x3b560
cmpl $0x3, 0x1cd2d(%rip)     # 0x40f90
jl 0x24267
jmp 0x24286
leaq 0xdf0b(%rip), %rdi      # 0x32179
leaq 0xde8f(%rip), %rsi      # 0x32104
movl $0x68, %edx
leaq 0xdf08(%rip), %rcx      # 0x32189
callq 0x30c0
movl 0x1cd04(%rip), %eax     # 0x40f90
addl $-0x1, %eax
movl %eax, 0x1ccfb(%rip)     # 0x40f90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)