LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genspace
static void genspace(n, sp) int n; struct structexp *sp; {
	if (sp == 0)
		space(n);
	else if (n <= inttype->size)
		for ( ; n > 0; n--)
			genasgn(constnode(0, chartype), sp);
	else {
		Tree e;
		static Symbol zeros;
		if (zeros == 0) {
			zeros = install(stringd(genlabel(1)), &globals, 1);
			zeros->sclass = STATIC;
			zeros->type = array(chartype, n, 0);
			zeros->generated = 1;
			defsymbol(zeros);
		}
		if (n > zeros->type->size)
			zeros->type = array(chartype, n, 0);
		e = tree(INDIR+B, zeros->type, idnode(zeros), 0);
		e->u.sym = intconst(n);
		genasgn(e, sp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13f93
movl -0x4(%rbp), %edi
callq 0x2a9c0
jmp 0x140e7
movl -0x4(%rbp), %eax
leaq 0x3025b(%rip), %rcx     # 0x441f8
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jg 0x13fda
jmp 0x13fa7
cmpl $0x0, -0x4(%rbp)
jle 0x13fd5
leaq 0x3022c(%rip), %rax     # 0x441e0
movq (%rax), %rsi
xorl %edi, %edi
callq 0xc7b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x138b0
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13fa7
jmp 0x140e5
cmpq $0x0, 0x27a7e(%rip)     # 0x3ba60
jne 0x1405c
movl $0x1, %edi
callq 0x24d90
movl %eax, %edi
callq 0x23c50
movq %rax, %rdi
leaq 0x27141(%rip), %rsi     # 0x3b140
movl $0x1, %edx
callq 0x24720
movq %rax, 0x27a50(%rip)     # 0x3ba60
movq 0x27a49(%rip), %rax     # 0x3ba60
movb $0x51, 0x1a(%rax)
leaq 0x301be(%rip), %rax     # 0x441e0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x27160
movq %rax, %rcx
movq 0x27a27(%rip), %rax     # 0x3ba60
movq %rcx, 0x20(%rax)
movq 0x27a1c(%rip), %rax     # 0x3ba60
movb 0x1b(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x1b(%rax)
movq 0x27a09(%rip), %rdi     # 0x3ba60
callq 0x2a470
movl -0x4(%rbp), %eax
movq 0x279fa(%rip), %rcx     # 0x3ba60
movq 0x20(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jle 0x14091
leaq 0x3016a(%rip), %rax     # 0x441e0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x27160
movq %rax, %rcx
movq 0x279d3(%rip), %rax     # 0x3ba60
movq %rcx, 0x20(%rax)
movq 0x279c8(%rip), %rax     # 0x3ba60
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x279b9(%rip), %rdi     # 0x3ba60
callq 0xddf0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x49, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x24f20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x138b0
jmp 0x140e7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: structexp
Tree structexp(ty, t1) Type ty; Symbol t1; {
	struct structexp e;

	e.var = t1;
	e.off = 0;
	e.tree = 0;
	e.link = current;
	current = &e;
	initializer(ty, 0);
	current = e.link;
	return e.tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x2792a(%rip), %rax     # 0x3ba48
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, 0x2791b(%rip)     # 0x3ba48
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x12fe0
movq -0x18(%rbp), %rax
movq %rax, 0x27905(%rip)     # 0x3ba48
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initvalue
static Tree initvalue(ty) Type ty; {
	Type aty;
	Tree e;

	needconst++;
	e = expr1(0);
	aty = assign(ty, e);
	if (aty)
		e = cast(e, aty);
	else {
		error("invalid initialization type; found `%t' expected `%s'\n",
			e->type,  ty);
		e = constnode(0, ty);
	}
	needconst--;
	if (generic(e->op) != CNST) {
		error("initializer must be constant\n");
		e = constnode(0, ty);
	}
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2ad75(%rip), %rax     # 0x3eed8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2ad69(%rip), %rax     # 0x3eed8
movl %ecx, (%rax)
xorl %edi, %edi
callq 0xfe00
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe2d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x141a7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe9b0
movq %rax, -0x18(%rbp)
jmp 0x141d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rdx
leaq 0x1c41b(%rip), %rdi     # 0x305d5
movb $0x0, %al
callq 0xd530
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xc7b0
movq %rax, -0x18(%rbp)
leaq 0x2ad01(%rip), %rax     # 0x3eed8
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x2acf5(%rip), %rax     # 0x3eed8
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0x14210
leaq 0x1c2ed(%rip), %rdi     # 0x304e7
movb $0x0, %al
callq 0xd530
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xc7b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: inputInit
void inputInit(int fd) {
	limit = cp = &buffer[MAXTOKEN + 1];
	lineno = 0;
	file = 0;			/* omit */
	bsize = -1;
	infd = fd;
	nextline();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x273be(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x283db(%rip)     # 0x3ca98
leaq 0x273ac(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x283d1(%rip)     # 0x3caa0
movl $0x0, 0x283cf(%rip)     # 0x3caa8
movq $0x0, 0x283cc(%rip) # 0x3cab0
movl $0xffffffff, 0x283ca(%rip) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
movl %eax, 0x283c5(%rip)     # 0x3cabc
callq 0x14710
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: nextline
void nextline() {
	if (cp >= limit) {	/* refill buffer */
		fillbuf();
		if (cp >= limit) {	/* signal end of file */
			cp = limit = &buffer[MAXTOKEN+1];
			*limit = '\0';
		}
		if (lineno > 0)
			return;
	}
	lineno++;
	for (line = (char *)cp; *cp == ' ' || *cp == '\t'; cp++)
		;
	if (*cp == '#') {			/* omit */
		resynch();			/* omit */
		nextline();			/* omit */
	}					/* omit */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x28379(%rip), %rax     # 0x3ca98
cmpq 0x2837a(%rip), %rax     # 0x3caa0
jb 0x14778
callq 0x14870
movq 0x28364(%rip), %rax     # 0x3ca98
cmpq 0x28365(%rip), %rax     # 0x3caa0
jb 0x1476b
leaq 0x2732c(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x28351(%rip)     # 0x3caa0
leaq 0x2731a(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x28337(%rip)     # 0x3ca98
movq 0x28338(%rip), %rax     # 0x3caa0
movb $0x0, (%rax)
cmpl $0x0, 0x28336(%rip)     # 0x3caa8
jle 0x14776
jmp 0x147f4
jmp 0x14778
movl 0x2832a(%rip), %eax     # 0x3caa8
addl $0x1, %eax
movl %eax, 0x28321(%rip)     # 0x3caa8
movq 0x2830a(%rip), %rax     # 0x3ca98
movq %rax, 0x2832b(%rip)     # 0x3cac0
movq 0x282fc(%rip), %rax     # 0x3ca98
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1(%rbp)
je 0x147bc
movq 0x282e8(%rip), %rax     # 0x3ca98
movzbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x147c5
jmp 0x147db
jmp 0x147c7
movq 0x282ca(%rip), %rax     # 0x3ca98
addq $0x1, %rax
movq %rax, 0x282bf(%rip)     # 0x3ca98
jmp 0x14795
movq 0x282b6(%rip), %rax     # 0x3ca98
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x147f4
callq 0x14a00
callq 0x14710
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: inputstring
void inputstring(str) char *str; {
	limit = cp = &buffer[MAXTOKEN+1];
	while ((*limit++ = *str++))
		;
	*limit = '\n';
	bsize = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x27261(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x2827e(%rip)     # 0x3ca98
leaq 0x2724f(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x28274(%rip)     # 0x3caa0
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movq 0x2825c(%rip), %rcx     # 0x3caa0
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x2824e(%rip)     # 0x3caa0
movb %al, (%rcx)
cmpb $0x0, %al
je 0x1485a
jmp 0x1482c
movq 0x2823f(%rip), %rax     # 0x3caa0
movb $0xa, (%rax)
movl $0x0, 0x2824a(%rip)     # 0x3cab8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: fillbuf
void fillbuf() {
	if (bsize == 0)
		return;
	if (limit <= cp)
		cp = &buffer[MAXTOKEN + 1];
	else {		/* move tail portion */
		int n = limit - cp;
		unsigned char *s = &buffer[MAXTOKEN + 1] - n;
		assert(s >= buffer);
		line = (char *)s - ((char *)cp - line);
		while (cp < limit)
			*s++ = *cp++;
		cp = &buffer[MAXTOKEN + 1] - n;
	}
	bsize = read(infd, (char *)&buffer[MAXTOKEN + 1], BUFSIZE);
	assert(bsize >= 0);
	limit = &buffer[MAXTOKEN + 1 + bsize];
	*limit = '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x28239(%rip)     # 0x3cab8
jne 0x14886
jmp 0x149f8
movq 0x28213(%rip), %rax     # 0x3caa0
cmpq 0x28204(%rip), %rax     # 0x3ca98
ja 0x148ad
leaq 0x271d3(%rip), %rax     # 0x3ba70
addq $0x21, %rax
movq %rax, 0x281f0(%rip)     # 0x3ca98
jmp 0x14986
movq 0x281ec(%rip), %rax     # 0x3caa0
movq 0x281dd(%rip), %rcx     # 0x3ca98
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rax
xorl %ecx, %ecx
subq %rax, %rcx
leaq 0x2719f(%rip), %rax     # 0x3ba70
addq $0x21, %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
leaq 0x2718d(%rip), %rax     # 0x3ba70
cmpq %rax, -0x10(%rbp)
jb 0x148eb
jmp 0x1490a
leaq 0x1bd3f(%rip), %rdi     # 0x30631
leaq 0x1bd44(%rip), %rsi     # 0x3063d
movl $0x31, %edx
leaq 0x1bd47(%rip), %rcx     # 0x3064c
callq 0x30c0
movq -0x10(%rbp), %rax
movq 0x28183(%rip), %rdx     # 0x3ca98
movq 0x281a4(%rip), %rcx     # 0x3cac0
subq %rcx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28192(%rip)     # 0x3cac0
movq 0x28163(%rip), %rax     # 0x3ca98
cmpq 0x28164(%rip), %rax     # 0x3caa0
jae 0x14968
movq 0x28153(%rip), %rax     # 0x3ca98
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x28145(%rip)     # 0x3ca98
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x1492e
movslq -0x4(%rbp), %rax
xorl %ecx, %ecx
subq %rax, %rcx
leaq 0x270f8(%rip), %rax     # 0x3ba70
addq $0x21, %rax
addq %rcx, %rax
movq %rax, 0x28112(%rip)     # 0x3ca98
movl 0x28130(%rip), %edi     # 0x3cabc
leaq 0x270dd(%rip), %rsi     # 0x3ba70
addq $0x21, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x30e0
movl %eax, 0x28111(%rip)     # 0x3cab8
cmpl $0x0, 0x2810a(%rip)     # 0x3cab8
jl 0x149b2
jmp 0x149d1
leaq 0x1bca2(%rip), %rdi     # 0x3065b
leaq 0x1bc7d(%rip), %rsi     # 0x3063d
movl $0x38, %edx
leaq 0x1bc80(%rip), %rcx     # 0x3064c
callq 0x30c0
movl 0x280e1(%rip), %eax     # 0x3cab8
addl $0x21, %eax
movslq %eax, %rcx
leaq 0x2708c(%rip), %rax     # 0x3ba70
addq %rcx, %rax
movq %rax, 0x280b2(%rip)     # 0x3caa0
movq 0x280ab(%rip), %rax     # 0x3caa0
movb $0xa, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: pragma
static void pragma() {
	if ((t = gettok()) == ID && strcmp(token, "ref") == 0)
		for (;;) {
			while (*cp == ' ' || *cp == '\t')
				cp++;
			if (*cp == '\n' || *cp == 0)
				break;
			if ((t = gettok()) == ID && tsym) {
				tsym->ref++;
				use(tsym, src);
			}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x15170
leaq 0x28bcc(%rip), %rcx     # 0x3db80
movl %eax, (%rcx)
cmpl $0x20, %eax
jne 0x150a4
leaq 0x28b22(%rip), %rax     # 0x3dae8
movq (%rax), %rdi
leaq 0x1b6f4(%rip), %rsi     # 0x306c4
callq 0x30f0
cmpl $0x0, %eax
jne 0x150a4
jmp 0x14fe0
jmp 0x14fe2
movq 0x27aaf(%rip), %rax     # 0x3ca98
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1(%rbp)
je 0x15009
movq 0x27a9b(%rip), %rax     # 0x3ca98
movzbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x15012
jmp 0x15026
movq 0x27a7f(%rip), %rax     # 0x3ca98
addq $0x1, %rax
movq %rax, 0x27a74(%rip)     # 0x3ca98
jmp 0x14fe2
movq 0x27a6b(%rip), %rax     # 0x3ca98
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x15044
movq 0x27a5c(%rip), %rax     # 0x3ca98
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x15046
jmp 0x150a2
callq 0x15170
leaq 0x28b2e(%rip), %rcx     # 0x3db80
movl %eax, (%rcx)
cmpl $0x20, %eax
jne 0x1509d
leaq 0x28a90(%rip), %rax     # 0x3daf0
cmpq $0x0, (%rax)
je 0x1509d
leaq 0x28a83(%rip), %rax     # 0x3daf0
movq (%rax), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
leaq 0x28a70(%rip), %rax     # 0x3daf0
movq (%rax), %rdi
leaq 0x28a4e(%rip), %rax     # 0x3dad8
movq (%rax), %rsi
leaq 0x28a44(%rip), %rax     # 0x3dad8
movq 0x8(%rax), %rdx
callq 0x252c0
jmp 0x14fe0
jmp 0x150a4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/lex.c
// Function: getchr
int getchr() {
	while (*cp) {
		while (map[*cp]&BLANK)
			cp++;
		if (!(map[*cp]&NEWLINE))
			return *cp;
		cp++;
		nextline();
	}
	return EOI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x279d9(%rip), %rax     # 0x3ca98
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x1515f
jmp 0x150cd
leaq 0x279c4(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x2492d(%rip), %rax     # 0x39a10
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15109
leaq 0x279a2(%rip), %rax     # 0x3ca98
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x27994(%rip), %rax     # 0x3ca98
movq %rcx, (%rax)
jmp 0x150cd
leaq 0x27988(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x248f1(%rip), %rax     # 0x39a10
movzbl (%rax,%rcx), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x1513d
leaq 0x27966(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x15166
leaq 0x27954(%rip), %rax     # 0x3ca98
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x27946(%rip), %rax     # 0x3ca98
movq %rcx, (%rax)
callq 0x14710
jmp 0x150b8
movl $0x7f, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/lex.c
// Function: icon
static Symbol icon(unsigned n, int overflow) {
	int u = 0;

	if (*cp == 'u' || *cp == 'U')
		u = *cp++;
	if (*cp == 'l' || *cp == 'L')
		cp++;
	if ((u == 0 && *cp == 'u') || *cp == 'U')
		u = *cp++;
	if (overflow) {
		char c = *cp;
		*cp = 0;
		warning("overflow in constant `%s'\n", token);
		*cp = c;
		n = INT_MAX;
	}
	if (u || n > (unsigned)INT_MAX) {
		tval.type = unsignedtype;
		tval.u.c.v.u = n;
	} else {
		tval.type = inttype;
		tval.u.c.v.i = n;
	}
	return &tval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x2564c(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x75, %eax
je 0x17469
leaq 0x2563a(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x55, %eax
jne 0x1748a
leaq 0x25628(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x25617(%rip), %rcx     # 0x3ca98
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x25607(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x6c, %eax
je 0x174ae
leaq 0x255f5(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x174c6
leaq 0x255e3(%rip), %rax     # 0x3ca98
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x255d5(%rip), %rax     # 0x3ca98
movq %rcx, (%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x174de
leaq 0x255c5(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x75, %eax
je 0x174f0
leaq 0x255b3(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x55, %eax
jne 0x17511
leaq 0x255a1(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x25590(%rip), %rcx     # 0x3ca98
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1755e
leaq 0x2557a(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movb (%rax), %al
movb %al, -0xd(%rbp)
leaq 0x2556b(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movb $0x0, (%rax)
movq 0x265ae(%rip), %rsi     # 0x3dae8
leaq 0x197ee(%rip), %rdi     # 0x30d2f
movb $0x0, %al
callq 0xdba0
movb -0xd(%rbp), %cl
leaq 0x25546(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movb %cl, (%rax)
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
cmpl $0x0, -0xc(%rbp)
jne 0x1756d
cmpl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jbe 0x17589
leaq 0x2ccc4(%rip), %rax     # 0x44238
movq (%rax), %rax
movq %rax, 0x2659a(%rip)     # 0x3db18
movl -0x4(%rbp), %eax
movl %eax, 0x265b9(%rip)     # 0x3db40
jmp 0x175a3
leaq 0x2cc68(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, 0x2657e(%rip)     # 0x3db18
movl -0x4(%rbp), %eax
movl %eax, 0x2659d(%rip)     # 0x3db40
leaq 0x2654e(%rip), %rax     # 0x3daf8
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/lex.c
// Function: assem
static void assem() {
	if (Aflag >= 2)
		warning("non-ANSI asm\n");
	t = gettok();
	expect('(');
	if (t == SCON) {
		char *s;
		Symbol *argv = (Symbol *)talloc(11*sizeof(Symbol *));
		s = asmargs(tsym, argv, 11);
		if (fname) {
			walk(0, 0, 0);
			code(Start);	/* prevent unreachable code message */
			code(Asm);
			codelist->u.acode.code = s;
			codelist->u.acode.argv = argv;
		} else
			asmcode(s, argv);
		t = gettok();
	} else
		error("missing string constant in asm\n");
	if (t != ')')
		expect(')');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x262c9(%rip), %rax     # 0x3dc28
cmpl $0x2, (%rax)
jl 0x17972
leaq 0x19355(%rip), %rdi     # 0x30cc0
movb $0x0, %al
callq 0xdba0
callq 0x15170
movl %eax, 0x26203(%rip)     # 0x3db80
movl $0x28, %edi
callq 0xd670
cmpl $0x24, 0x261f2(%rip)    # 0x3db80
jne 0x17aca
leaq 0x23cad(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x58, (%rax)
leaq 0x23c9d(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x23c8f(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x23c7f(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x179f0
leaq 0x23c6f(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x23c63(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x18(%rbp)
jmp 0x17a3b
leaq 0x23c51(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x23c45(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x23c2d(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x23c1f(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x260a6(%rip), %rdi     # 0x3daf0
movq -0x10(%rbp), %rsi
movl $0xb, %edx
callq 0x17b00
movq %rax, -0x8(%rbp)
leaq 0x23fad(%rip), %rax     # 0x3ba10
cmpq $0x0, (%rax)
je 0x17ab0
xorl %eax, %eax
movl %eax, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
movl $0x6, %edi
callq 0x3300
movl $0x7, %edi
callq 0x3300
movq -0x8(%rbp), %rcx
leaq 0x21693(%rip), %rax     # 0x39128
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
leaq 0x21681(%rip), %rax     # 0x39128
movq (%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x17abd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b7d0
callq 0x15170
movl %eax, 0x260b8(%rip)     # 0x3db80
jmp 0x17ad8
leaq 0x191fd(%rip), %rdi     # 0x30cce
movb $0x0, %al
callq 0xd530
cmpl $0x29, 0x260a1(%rip)    # 0x3db80
je 0x17aeb
movl $0x29, %edi
callq 0xd670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: apply
void apply(list, arg1, arg2) List list; Generic arg1, arg2; {
	if (list) {
		List lp = list;
		do {
			struct entry *p = (struct entry *)lp->x;
			(*p->func)(p->cl, arg1, arg2);
			lp = lp->link;
		} while (lp != list);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1869f
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x18663
jmp 0x1869f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: emitYYnull
static void emitYYnull() {
	if (YYnull && YYnull->ref > 0) {
		Aflag = 0;
		YYnull->defined = 0;
		YYnull = 0;
		compile(stringf("static char *_YYfile = \"%s\";\n", file));
		compile("static void _YYnull(int line,...) {\n\
	char buf[200];\n\
	sprintf(buf, \"null pointer dereferenced @%s:%d\\n\", _YYfile, line);\n\
	write(2, buf, strlen(buf));\n\
	abort();\n\
}\n");
	} else if (YYnull)
		YYnull->ref = 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x25574(%rip)     # 0x3dc30
je 0x18721
movq 0x2556b(%rip), %rax     # 0x3dc30
cmpl $0x0, 0x1c(%rax)
jle 0x18721
movl $0x0, 0x25553(%rip)     # 0x3dc28
movq 0x25554(%rip), %rax     # 0x3dc30
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x1b(%rax)
movq $0x0, 0x2553d(%rip) # 0x3dc30
leaq 0x243b6(%rip), %rax     # 0x3cab0
movq (%rax), %rsi
leaq 0x18740(%rip), %rdi     # 0x30e44
movb $0x0, %al
callq 0x1afc0
movq %rax, %rdi
callq 0x19b30
leaq 0x18748(%rip), %rdi     # 0x30e62
callq 0x19b30
jmp 0x1873b
cmpq $0x0, 0x25507(%rip)     # 0x3dc30
je 0x18739
movq 0x254fe(%rip), %rax     # 0x3dc30
movl $0x3e8, 0x1c(%rax)      # imm = 0x3E8
jmp 0x1873b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: typestab
static void typestab(p, cl) Symbol p; Generic cl; {
	if (*(Symbol *)cl == 0 && p->sclass && p->sclass != TYPEDEF)
		*(Symbol *)cl = p;
	if (p->sclass == TYPEDEF || p->sclass == 0)
		stabtype(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1877b
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
je 0x1877b
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x53, %eax
je 0x1877b
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x53, %eax
je 0x18795
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x18797
jmp 0x18797
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: mkstr
Symbol mkstr(str) char *str; {
	Value v;
	Symbol p;

	v.p = str;
	p = constant(array(chartype, strlen(v.p) + 1, 0), v);
	if (p->u.c.loc == 0)
		p->u.c.loc = genident(STATIC, p->type, GLOBAL);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x2ba25(%rip), %rax     # 0x441e0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3090
movq -0x20(%rbp), %rdi
addq $0x1, %rax
movl %eax, %esi
xorl %edx, %edx
callq 0x27160
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x23d40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x18819
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x24b00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: mksymbol
Symbol mksymbol(sclass, name, ty) int sclass; char *name; Type ty; {
	Symbol p;

	if (sclass == EXTERN)
		p = install(string(name), &globals, 1);
	else {
		p = (Symbol)alloc(sizeof *p);
		BZERO(p, struct symbol);
		p->name = string(name);
		p->scope = GLOBAL;
	}
	p->sclass = sclass;
	p->type = ty;
	defsymbol(p);
	p->defined = 1;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x4a, -0x4(%rbp)
jne 0x1886f
movq -0x10(%rbp), %rdi
callq 0x237e0
movq %rax, %rdi
leaq 0x228e4(%rip), %rsi     # 0x3b140
movl $0x1, %edx
callq 0x24720
movq %rax, -0x20(%rbp)
jmp 0x189d6
leaq 0x22dca(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl $0x88, (%rax)
leaq 0x22dba(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x22dac(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x22d9c(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x188cb
leaq 0x22d8c(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edi
leaq 0x22d80(%rip), %rsi     # 0x3b640
callq 0x253d0
movq %rax, -0x38(%rbp)
jmp 0x18916
leaq 0x22d6e(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edx
leaq 0x22d62(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x22d4a(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x22d3c(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x189a3
movq -0x28(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x18934
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x237e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movw $0x3, 0x18(%rax)
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1a(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x2a470
movq -0x20(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: attach
void attach(func, cl, list) Apply func; Generic cl; List *list; {
	struct entry *p = (struct entry *)alloc(sizeof *p);

	p->func = func;
	p->cl = cl;
	*list = append((Generic)p, *list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x22955(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl $0x10, (%rax)
leaq 0x22945(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x22937(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x22927(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x18d40
leaq 0x22917(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edi
leaq 0x2290b(%rip), %rsi     # 0x3b640
callq 0x253d0
movq %rax, -0x28(%rbp)
jmp 0x18d8b
leaq 0x228f9(%rip), %rax     # 0x3b640
movq (%rax), %rax
movl (%rax), %edx
leaq 0x228ed(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x228d5(%rip), %rax     # 0x3b640
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x228c7(%rip), %rcx     # 0x3b640
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x23500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbentry
static void bbentry(yylink, f) Symbol yylink, f; {
	static Symbol p;

	afunc = genident(STATIC, array(voidptype, 4, 0), GLOBAL);
	if (p == 0)
		p = mksymbol(EXTERN, "_prologue", ftype(inttype, voidptype));
	walk(callnode(pointer(idnode(p)), freturn(p->type),
		tree(ARG+P, ptr(unsignedtype), idnode(yylink),
		tree(ARG+P, ptr(unsignedtype), idnode(afunc), 0))), 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2b469(%rip), %rax     # 0x44250
movq (%rax), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x27160
movq %rax, %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x24b00
movq %rax, 0x24e49(%rip)     # 0x3dc58
cmpq $0x0, 0x24e39(%rip)     # 0x3dc50
jne 0x18e4d
leaq 0x2b3d8(%rip), %rax     # 0x441f8
movq (%rax), %rdi
leaq 0x2b426(%rip), %rax     # 0x44250
movq (%rax), %rsi
callq 0x197a0
movq %rax, %rdx
movl $0x4a, %edi
leaq 0x180c3(%rip), %rsi     # 0x30f04
callq 0x18830
movq %rax, 0x24e03(%rip)     # 0x3dc50
movq 0x24dfc(%rip), %rdi     # 0x3dc50
callq 0xddf0
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x20(%rbp)
movq 0x24de4(%rip), %rax     # 0x3dc50
movq 0x20(%rax), %rdi
callq 0x28a30
movq %rax, -0x18(%rbp)
leaq 0x2b3b8(%rip), %rax     # 0x44238
movq (%rax), %rdi
callq 0x27120
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xddf0
movq %rax, -0x28(%rbp)
leaq 0x2b398(%rip), %rax     # 0x44238
movq (%rax), %rdi
callq 0x27120
movq %rax, -0x38(%rbp)
movq 0x24da5(%rip), %rdi     # 0x3dc58
callq 0xddf0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movl $0x27, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl $0x27, %edi
callq 0x256f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0xc960
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbexit
static void bbexit(yylink, f, e) Symbol yylink, f; Tree e; {
	static Symbol p;

	if (p == 0)
		p = mksymbol(EXTERN, "_epilogue", ftype(inttype, voidptype));
	walk(callnode(pointer(idnode(p)), freturn(p->type),
		tree(ARG+P, ptr(unsignedtype), idnode(afunc), 0)), 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x24d34(%rip)     # 0x3dc60
jne 0x18f62
leaq 0x2b2c3(%rip), %rax     # 0x441f8
movq (%rax), %rdi
leaq 0x2b311(%rip), %rax     # 0x44250
movq (%rax), %rsi
callq 0x197a0
movq %rax, %rdx
movl $0x4a, %edi
leaq 0x17fb8(%rip), %rsi     # 0x30f0e
callq 0x18830
movq %rax, 0x24cfe(%rip)     # 0x3dc60
movq 0x24cf7(%rip), %rdi     # 0x3dc60
callq 0xddf0
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x28(%rbp)
movq 0x24cdf(%rip), %rax     # 0x3dc60
movq 0x20(%rax), %rdi
callq 0x28a30
movq %rax, -0x20(%rbp)
leaq 0x2b2a3(%rip), %rax     # 0x44238
movq (%rax), %rdi
callq 0x27120
movq %rax, -0x30(%rbp)
movq 0x24cb0(%rip), %rdi     # 0x3dc58
callq 0xddf0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movl $0x27, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0xc960
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbfunc
static void bbfunc(yylink, f) Symbol yylink, f; {
	Value v;
	union coordinate u;

	defglobal(afunc, DATA);
	defpointer(funclist);
	defpointer(0);
	defpointer(mkstr(f->name)->u.c.loc);
	u.c.x = f->u.f.pt[2].x;
	u.c.y = f->u.f.pt[2].y;
	u.c.index = bbfile(f->u.f.pt[2].file);
	defconst(U, (v.u = u.coord, v));
	funclist = afunc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x24c51(%rip), %rdi     # 0x3dc58
movl $0x3, %esi
callq 0x129d0
movq 0x24c50(%rip), %rdi     # 0x3dc68
callq 0x12a70
xorl %eax, %eax
movl %eax, %edi
callq 0x12a70
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x187a0
movq 0x50(%rax), %rdi
callq 0x12a70
movq -0x10(%rbp), %rax
movzwl 0x70(%rax), %ecx
movl -0x1c(%rbp), %eax
andl $0x3ff, %ecx            # imm = 0x3FF
shll $0x10, %ecx
andl $0xfc00ffff, %eax       # imm = 0xFC00FFFF
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x72(%rax), %ecx
movl -0x1c(%rbp), %eax
andl $0xffff, %ecx           # imm = 0xFFFF
andl $0xffff0000, %eax       # imm = 0xFFFF0000
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x19b60
movl %eax, %ecx
movl -0x1c(%rbp), %eax
andl $0x3f, %ecx
shll $0x1a, %ecx
andl $0x3ffffff, %eax        # imm = 0x3FFFFFF
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x6, %edi
callq 0x2a830
movq 0x24b9e(%rip), %rax     # 0x3dc58
movq %rax, 0x24ba7(%rip)     # 0x3dc68
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbcall
static void bbcall(yycounts, cp, e) Symbol yycounts; Coordinate *cp; Tree *e; {
	static Symbol caller;
	Value v;
	union coordinate u;
	Symbol p = genident(STATIC, array(voidptype, 0, 0), GLOBAL);

	defglobal(p, LIT);
	defpointer(cp->file ? mkstr(cp->file)->u.c.loc : 0);
	defpointer(mkstr(cfunc->name)->u.c.loc);
	u.c.x = cp->x;
	u.c.y = cp->y;
	defconst(U, (v.u = u.coord, v));
	if (caller == 0)
		caller = mksymbol(EXTERN, "_caller", ptr(voidptype));
	*e = right(asgn(caller, idnode(p)), *e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x2af15(%rip), %rax     # 0x44250
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x27160
movq %rax, %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x24b00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x4, %esi
callq 0x129d0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1938b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x187a0
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x19393
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x19393
movq -0x40(%rbp), %rdi
callq 0x12a70
leaq 0x22665(%rip), %rax     # 0x3ba08
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x187a0
movq 0x50(%rax), %rdi
callq 0x12a70
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %ecx
movl -0x24(%rbp), %eax
andl $0x3ff, %ecx            # imm = 0x3FF
shll $0x10, %ecx
andl $0xfc00ffff, %eax       # imm = 0xFC00FFFF
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzwl 0xa(%rax), %ecx
movl -0x24(%rbp), %eax
andl $0xffff, %ecx           # imm = 0xFFFF
andl $0xffff0000, %eax       # imm = 0xFFFF0000
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x6, %edi
callq 0x2a830
cmpq $0x0, 0x24863(%rip)     # 0x3dc78
jne 0x19441
leaq 0x2ae32(%rip), %rax     # 0x44250
movq (%rax), %rdi
callq 0x27120
movq %rax, %rdx
movl $0x4a, %edi
leaq 0x17ae3(%rip), %rsi     # 0x30f18
callq 0x18830
movq %rax, 0x24837(%rip)     # 0x3dc78
movq 0x24830(%rip), %rax     # 0x3dc78
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0xddf0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xe0f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x105b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: traceinit
void traceinit(print) char *print; {
	static Symbol printer;

	if (!printer) {
		printer = mksymbol(STATIC, print && *print ? print : "printf",
			ftype(voidtype, ptr(chartype)));
		printer->sclass = EXTERN;
		attach((Apply)tracecall,   (Generic)printer, &events.entry);
		attach((Apply)tracereturn, (Generic)printer, &events.returns);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x2454c(%rip)     # 0x3dc20
jne 0x19790
cmpq $0x0, -0x8(%rbp)
je 0x196f7
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x196f7
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x19704
leaq 0x176fd(%rip), %rax     # 0x30dfb
movq %rax, -0x10(%rbp)
jmp 0x19704
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2ab2d(%rip), %rax     # 0x44240
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x2aabf(%rip), %rax     # 0x441e0
movq (%rax), %rdi
callq 0x27120
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x197a0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movl $0x51, %edi
callq 0x18830
movq %rax, 0x244d3(%rip)     # 0x3dc20
movq 0x244cc(%rip), %rax     # 0x3dc20
movb $0x4a, 0x1a(%rax)
movq 0x244c1(%rip), %rsi     # 0x3dc20
leaq 0x16a(%rip), %rdi       # 0x198d0
leaq 0x24463(%rip), %rdx     # 0x3dbd0
callq 0x18cd0
movq 0x244a7(%rip), %rsi     # 0x3dc20
leaq 0x300(%rip), %rdi       # 0x19a80
leaq 0x24449(%rip), %rdx     # 0x3dbd0
addq $0x10, %rdx
callq 0x18cd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: tracecall
static void tracecall(printer, f) Symbol printer, f; {
	int i;
	Symbol counter = genident(STATIC, inttype, GLOBAL);

	defglobal(counter, BSS);
	space(counter->type->size);
	frameno = genident(AUTO, inttype, level);
	addlocal(frameno);
	appendstr(f->name); appendstr("#");
	tracevalue(asgn(frameno, incr(INCR, idnode(counter), constnode(1, inttype))), 0);
	appendstr("(");
	for (i = 0; f->u.f.callee[i]; i++) {
		if (i)
			appendstr(",");
		appendstr(f->u.f.callee[i]->name); appendstr("=");
		tracevalue(idnode(f->u.f.callee[i]), 0);
	}
	if (variadic(f->type))
		appendstr(",...");
	appendstr(") called\n");
	tracefinis(printer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2a911(%rip), %rax     # 0x441f8
movq (%rax), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x24b00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x129d0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %edi
callq 0x2a9c0
leaq 0x2a8d6(%rip), %rax     # 0x441f8
movq (%rax), %rsi
leaq 0x27664(%rip), %rax     # 0x40f90
movl (%rax), %edx
movl $0x43, %edi
callq 0x24b00
movq %rax, 0x24341(%rip)     # 0x3dc80
movq 0x2433a(%rip), %rdi     # 0x3dc80
callq 0x3290
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x19c10
leaq 0x175c1(%rip), %rdi     # 0x30f20
callq 0x19c10
movq 0x24315(%rip), %rax     # 0x3dc80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xddf0
movq %rax, -0x30(%rbp)
leaq 0x2a875(%rip), %rax     # 0x441f8
movq (%rax), %rsi
movl $0x1, %edi
callq 0xc7b0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movl $0x27, %edi
callq 0x10150
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xe0f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x19ea0
leaq 0x17564(%rip), %rdi     # 0x30f22
callq 0x19c10
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x19a47
cmpl $0x0, -0x14(%rbp)
je 0x199f2
leaq 0x17537(%rip), %rdi     # 0x30f24
callq 0x19c10
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x19c10
leaq 0x16275(%rip), %rdi     # 0x2fc8a
callq 0x19c10
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xddf0
movq %rax, %rdi
xorl %esi, %esi
callq 0x19ea0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x199ca
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x29ed0
cmpl $0x0, %eax
je 0x19a65
leaq 0x174c6(%rip), %rdi     # 0x30f26
callq 0x19c10
leaq 0x174bf(%rip), %rdi     # 0x30f2b
callq 0x19c10
movq -0x8(%rbp), %rdi
callq 0x1a520
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: tracereturn
static void tracereturn(printer, f, e) Symbol printer, f; Tree e; {
	appendstr(f->name); appendstr("#");
	tracevalue(idnode(frameno), 0);
	appendstr(" returned");
	if (freturn(f->type) != voidtype && e) {
		appendstr(" ");
		tracevalue(e, 0);
	}
	appendstr("\n");
	tracefinis(printer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x19c10
leaq 0x17478(%rip), %rdi     # 0x30f20
callq 0x19c10
movq 0x241cc(%rip), %rdi     # 0x3dc80
callq 0xddf0
movq %rax, %rdi
xorl %esi, %esi
callq 0x19ea0
leaq 0x174ae(%rip), %rdi     # 0x30f78
callq 0x19c10
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x28a30
leaq 0x2a75d(%rip), %rcx     # 0x44240
cmpq (%rcx), %rax
je 0x19b06
cmpq $0x0, -0x18(%rbp)
je 0x19b06
leaq 0x1570a(%rip), %rdi     # 0x2f200
callq 0x19c10
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x19ea0
leaq 0x1702f(%rip), %rdi     # 0x30b3c
callq 0x19c10
movq -0x8(%rbp), %rdi
callq 0x1a520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbfile
static int bbfile(file) char *file; {
	if (file) {
		List lp;
		int i = 1;
		lp = filelist;
		if (lp)
			do {
				lp = lp->link;
				if (((Symbol)lp->x)->u.c.v.p == file)
					return i;
				i++;
			} while (lp != filelist);
		filelist = append(mkstr(file), filelist);
		return i;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x19bf2
movl $0x1, -0x1c(%rbp)
movq 0x240ef(%rip), %rax     # 0x3dc70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x19bcb
jmp 0x19b8e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x19bb3
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19bf9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x240a9(%rip), %rax     # 0x3dc70
jne 0x19b8e
jmp 0x19bcb
movq -0x10(%rbp), %rdi
callq 0x187a0
movq %rax, %rdi
movq 0x24092(%rip), %rsi     # 0x3dc70
callq 0x23500
movq %rax, 0x24086(%rip)     # 0x3dc70
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19bf9
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/main.c
// Function: tracefinis
static void tracefinis(printer) Symbol printer; {
	Tree *ap;
	Symbol p;

	*fp = 0;
	p = mkstr(string(fmt));
	for (ap = &args; *ap; ap = &(*ap)->kids[1])
		;
	*ap = tree(ARG+P, ptr(chartype), pointer(idnode(p->u.c.loc)), 0);
	walk(callnode(pointer(idnode(printer)), freturn(printer->type), args), 0, 0);
	args = 0;
	fp = fmtend = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x23755(%rip), %rax     # 0x3dc88
movb $0x0, (%rax)
movq 0x2375b(%rip), %rdi     # 0x3dc98
callq 0x237e0
movq %rax, %rdi
callq 0x187a0
movq %rax, -0x18(%rbp)
leaq 0x23753(%rip), %rax     # 0x3dca8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a57a
jmp 0x1a565
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a559
leaq 0x29c5f(%rip), %rax     # 0x441e0
movq (%rax), %rdi
callq 0x27120
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xddf0
movq %rax, %rdi
callq 0xf9f0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movl $0x27, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xddf0
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x28a30
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq 0x236b7(%rip), %rdx     # 0x3dca8
callq 0xc960
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3a80
movq $0x0, 0x2369b(%rip) # 0x3dca8
movq $0x0, 0x23678(%rip) # 0x3dc90
movq $0x0, 0x23665(%rip) # 0x3dc88
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/output.c
// Function: vfprint
void vfprint(f, fmt, ap) int f; char *fmt; va_list ap; {
	if (f == 1)
		vprint(fmt, ap);
	else {
		fd = 2;
		io[1]->bp = bp;
		io[2]->fd = f;
		bp = io[2]->bp;
		vprint(fmt, ap);
		outflush();
		bp = io[1]->bp;
		fd = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x1a6f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a930
jmp 0x1a760
movl $0x2, 0x1f446(%rip)     # 0x39b48
movq 0x1f417(%rip), %rcx     # 0x39b20
movq 0x1f428(%rip), %rax     # 0x39b38
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq 0x1f422(%rip), %rax     # 0x39b40
movl %ecx, (%rax)
movq 0x1f419(%rip), %rax     # 0x39b40
movq 0x8(%rax), %rax
movq %rax, 0x1f3ee(%rip)     # 0x39b20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a930
callq 0x1a770
movq 0x1f3ed(%rip), %rax     # 0x39b38
movq 0x8(%rax), %rax
movq %rax, 0x1f3ca(%rip)     # 0x39b20
movl $0x1, 0x1f3e8(%rip)     # 0x39b48
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/output.c
// Function: outflush
void outflush() {
	struct io *iop = io[fd];

	assert(fd);
	if (bp > iop->buffer)
		write(iop->fd, iop->buffer, bp - iop->buffer);
	bp = iop->bp = iop->buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0x1f3c9(%rip), %rcx     # 0x39b48
leaq 0x1f3aa(%rip), %rax     # 0x39b30
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, 0x1f3b3(%rip)     # 0x39b48
je 0x1a799
jmp 0x1a7b8
leaq 0x1683c(%rip), %rdi     # 0x30fdc
leaq 0x16838(%rip), %rsi     # 0x30fdf
movl $0x2b, %edx
leaq 0x1683c(%rip), %rcx     # 0x30fef
callq 0x30c0
movq 0x1f361(%rip), %rax     # 0x39b20
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x1a7ee
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x1f342(%rip), %rdx     # 0x39b20
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
subq %rax, %rdx
callq 0x3080
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, 0x1f31b(%rip)     # 0x39b20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1f2fd(%rip), %rax     # 0x39b20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1a854
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x1a827
movq -0x10(%rbp), %rax
movq %rax, 0x1f2c1(%rip)     # 0x39b20
movq 0x1f2ba(%rip), %rax     # 0x39b20
movslq 0x1f2db(%rip), %rdx     # 0x39b48
leaq 0x1f2bc(%rip), %rcx     # 0x39b30
movq (%rcx,%rdx,8), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x1a883
callq 0x1a770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)