LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: lvalue
Tree lvalue(p) Tree p; {
	if (generic(p->op) == INDIR) {
		if (unqual(p->type) == voidtype)
			warning("`%t' used as an lvalue\n", p->type);
		return p->kids[0];
	}
	error("lvalue required\n");
	return value(p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
andl $-0x10, %eax
cmpl $0x40, %eax
jne 0xa8bb
movq 0x8(%rbx), %rsi
cmpl $0xf, (%rsi)
movq %rsi, %rax
jb 0xa89b
movq 0x10(%rsi), %rax
leaq 0x2773e(%rip), %rcx     # 0x31fe0
cmpq (%rcx), %rax
jne 0xa8b5
leaq 0x1297d(%rip), %rdi     # 0x1d22b
xorl %eax, %eax
callq 0x9239
movq 0x10(%rbx), %rax
popq %rbx
retq
leaq 0x12981(%rip), %rdi     # 0x1d243
xorl %eax, %eax
callq 0x8dd4
movq %rbx, %rdi
popq %rbx
jmp 0x94a3
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: right
Tree right(p, q) Tree p, q; {
	assert(p || q);
	if (p && q)
		return tree(RIGHT, q->type, root(p), q);
	return p ? p : q;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
orq %rsi, %rax
je 0xa926
movq %rsi, %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xa914
movq 0x8(%rbx), %r14
callq 0x16750
movl $0x2a0, %edi            # imm = 0x2A0
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x165eb
testq %rdi, %rdi
cmovneq %rdi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x12927(%rip), %rdi     # 0x1d254
leaq 0x127d5(%rip), %rsi     # 0x1d109
leaq 0x12920(%rip), %rcx     # 0x1d25b
movl $0x363, %edx            # imm = 0x363
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr3
static Tree expr3(int k) {
	int k1;
	Tree p = prefix();

	for (k1 = prec[t]; k1 >= k; k1--)
		while (prec[t] == k1 && *cp != '=') {
			Tree r;
			Opcode op = t;
			t = gettok();
			p = pointer(p);
			if (events.points && (op == ANDAND || op == OROR)) {
				Tree e = 0;
				apply(events.points, (Generic)&src, (Generic)&e);
				r = right(e, pointer(expr3(k1 + (k1>5))));
			} else
				r = pointer(expr3(k1 + (k1>5)));
			p = (*opnode[op])(oper[op], p, r);
		}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
callq 0xaa73
movq %rax, %r12
leaq 0x2107a(%rip), %rbx     # 0x2b9e0
movl (%rbx), %r13d
leaq 0x12500(%rip), %rax     # 0x1ce70
movsbl (%r13,%rax), %r15d
cmpl 0xc(%rsp), %r15d
jl 0xaa61
xorl %ebp, %ebp
cmpl $0x6, %r15d
setge %bpl
addl %r15d, %ebp
movl %r13d, %r14d
leaq 0x124d8(%rip), %rax     # 0x1ce70
movsbl (%r14,%rax), %eax
cmpl %eax, %r15d
jne 0xaa59
leaq 0x1ff4b(%rip), %rax     # 0x2a8f8
movq (%rax), %rax
cmpb $0x3d, (%rax)
je 0xaa59
callq 0xd3c9
movl %eax, (%rbx)
movq %r12, %rdi
callq 0xa22f
movq %rax, %r12
leaq 0x2102e(%rip), %rax     # 0x2ba00
movq 0x18(%rax), %rdi
testq %rdi, %rdi
sete %al
andl $-0x2, %r13d
cmpl $0x32, %r13d
setne %cl
orb %al, %cl
jne 0xaa23
andq $0x0, 0x10(%rsp)
leaq 0x20f40(%rip), %rsi     # 0x2b938
leaq 0x10(%rsp), %rdx
callq 0xf206
movq 0x10(%rsp), %r13
movl %ebp, %edi
callq 0xa945
movq %rax, %rdi
callq 0xa22f
movq %r13, %rdi
movq %rax, %rsi
callq 0xa8d2
jmp 0xaa32
movl %ebp, %edi
callq 0xa945
movq %rax, %rdi
callq 0xa22f
leaq 0x124b7(%rip), %rcx     # 0x1cef0
movl (%rcx,%r14,4), %edi
movq %r12, %rsi
movq %rax, %rdx
leaq 0x1d716(%rip), %rax     # 0x28160
callq *(%rax,%r14,8)
movq %rax, %r12
movl (%rbx), %r13d
jmp 0xa98e
decl %r15d
jmp 0xa976
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: nullcheck
static Tree nullcheck(p) Tree p; {
	Tree q, arg;

	if (needconst)
		return p;
	arg = tree(ARG+I, inttype, constnode(lineno, inttype), 0);
	q = tree(COND, voidtype,
		tree(NOT, inttype, cond(p), 0),
		tree(RIGHT, inttype, callnode(pointer(idnode(YYnull)), voidtype, arg), 0));
	return tree(RIGHT, p->type, q, p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x21824(%rip), %rax     # 0x2ccf8
cmpl $0x0, (%rax)
je 0xb4eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26aa6(%rip), %r13     # 0x31f98
movq (%r13), %r14
leaq 0x1f40b(%rip), %rax     # 0x2a908
movl (%rax), %edi
movq %r14, %rsi
callq 0x8726
pushq $0x25
popq %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movq %rax, %r15
leaq 0x26abf(%rip), %rbp     # 0x31fe0
movq (%rbp), %r14
movq (%r13), %r12
movq %rbx, %rdi
callq 0xa110
movl $0x270, %edi            # imm = 0x270
movq %r12, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movq %rax, %r12
movq (%r13), %r13
leaq 0x2050f(%rip), %rax     # 0x2ba60
movq (%rax), %rdi
callq 0x93b4
movq %rax, %rdi
callq 0xa22f
movq (%rbp), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x87f6
movl $0x2a0, %edi            # imm = 0x2A0
movq %r13, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movl $0x290, %edi            # imm = 0x290
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x165eb
movq 0x8(%rbx), %rsi
movl $0x2a0, %edi            # imm = 0x2A0
movq %rax, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x165eb
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: defglobal
void defglobal(Symbol p, int seg) {
	swtoseg(p->u.seg = seg);
	if (p->sclass != STATIC)
		export(p);
	if (glevel && level == GLOBAL) {
		stabsym(p);
		swtoseg(p->u.seg);
	}
	global(p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x48(%rdi)
movl %esi, %edi
callq 0xbd3d
cmpb $0x51, 0x1a(%rbx)
je 0xbd14
movq %rbx, %rdi
callq 0x1900c
leaq 0x1fd15(%rip), %rax     # 0x2ba30
cmpl $0x0, (%rax)
je 0xbd34
leaq 0x23009(%rip), %rax     # 0x2ed30
cmpl $0x3, (%rax)
jne 0xbd34
movl 0x48(%rbx), %edi
callq 0xbd3d
movq %rbx, %rdi
popq %rbx
jmp 0x1900f
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: doconst
void doconst(p, cl) Symbol p; Generic cl; {
	if (p->u.c.loc) {
		defglobal(p->u.c.loc, p->u.c.loc->u.seg ? p->u.c.loc->u.seg : LIT);
		if (isarray(p->type))
			defstring(p->type->size, p->u.c.v.p);
		else
			defconst(ttob(p->type), p->u.c.v);
		p->u.c.loc->defined = 1;
		p->u.c.loc = 0;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xbdc9
movl 0x48(%rdi), %eax
testl %eax, %eax
pushq $0x4
popq %rsi
cmovnel %eax, %esi
callq 0xbcf8
movq 0x20(%rbx), %rdi
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0xbd99
movq 0x10(%rdi), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0xbdac
movl 0x8(%rdi), %edi
movq 0x48(%rbx), %rsi
callq 0x191ff
jmp 0xbdbc
callq 0x18b82
movq 0x48(%rbx), %rsi
movl %eax, %edi
callq 0x1917d
movq 0x50(%rbx), %rax
orb $0x1, 0x1b(%rax)
andq $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genconst
int genconst(Tree e, int def) {
	for (;;)
		switch (generic(e->op)) {
		case ADDRG:
			if (def)
				defaddress(e->u.sym);
			return e->type->size;
		case CNST:
			if (e->op == CNST+P && isarray(e->type)) {
				e = cvtconst(e);
				continue;
			}
			if (def)
				defconst(ttob(e->type), e->u.v);
			return e->type->size;
		case RIGHT:
			assert(e->kids[0] || e->kids[1]);
			if (e->kids[1] && e->kids[0])
				error("initializer must be constant\n");
			e = e->kids[1] ? e->kids[1] : e->kids[0];
			continue;
		case CVP:
			if (isarith(e->type))
				error("cast from `%t' to `%t' is illegal in constant expressions\n",
					e->kids[0]->type, e->type);
			/* fall thru */
		case CVC: case CVI: case CVS: case CVU:
		case CVD: case CVF:
			e = e->kids[0];
			continue;
		default:
			error("initializer must be constant\n");
			if (def)
				genconst(constnode(0, inttype), def);
			return inttype->size;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rax
leaq 0x117a6(%rip), %r14     # 0x1d585
leaq 0x11781(%rip), %r15     # 0x1d567
movabsq $0x1000100010001, %r12  # imm = 0x1000100010001
movq %rax, %rbx
movl (%rax), %ecx
movl %ecx, %eax
andl $-0x10, %eax
leal -0x50(%rax), %edx
cmpl $0x30, %edx
jbe 0xbe55
cmpl $0x10, %eax
je 0xbe8b
cmpl $0x90, %eax
je 0xbe61
cmpl $0xa0, %eax
je 0xbe5b
cmpl $0xb0, %eax
je 0xbe5b
cmpl $0x2a0, %eax            # imm = 0x2A0
jne 0xbed9
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
testq %rcx, %rcx
je 0xbeb3
testq %rax, %rax
movq %rcx, %rax
je 0xbdf0
movq %r15, %rdi
xorl %eax, %eax
callq 0x8dd4
movq 0x18(%rbx), %rax
testq %rax, %rax
jne 0xbdf0
jmp 0xbe5b
btq %rdx, %r12
jae 0xbe02
movq 0x10(%rbx), %rax
jmp 0xbdf0
movq 0x8(%rbx), %rdx
movl (%rdx), %eax
cmpl $0xf, %eax
jb 0xbe72
movq 0x10(%rdx), %rax
movl (%rax), %eax
cmpl $0x6, %eax
ja 0xbe5b
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x8dd4
jmp 0xbe5b
cmpl $0x17, %ecx
jne 0xbeef
movq 0x8(%rbx), %rcx
movl (%rcx), %eax
cmpl $0xf, %eax
jb 0xbea1
movq 0x10(%rcx), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0xbeef
movq %rbx, %rdi
callq 0x1656a
jmp 0xbdf0
testq %rax, %rax
jne 0xbdf0
leaq 0x11665(%rip), %rdi     # 0x1d528
leaq 0x11677(%rip), %rsi     # 0x1d541
leaq 0x1167e(%rip), %rcx     # 0x1d54f
pushq $0x70
popq %rdx
callq 0x30d0
cmpl $0x100, %eax            # imm = 0x100
jne 0xbf1a
testl %ebp, %ebp
je 0xbf07
movq 0x28(%rbx), %rdi
callq 0x1923a
jmp 0xbf07
testl %ebp, %ebp
je 0xbf07
movq 0x8(%rbx), %rdi
callq 0x18b82
movq 0x28(%rbx), %rsi
movl %eax, %edi
callq 0x1917d
addq $0x8, %rbx
movq (%rbx), %rax
movl 0x8(%rax), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11646(%rip), %rdi     # 0x1d567
xorl %eax, %eax
callq 0x8dd4
leaq 0x26069(%rip), %rbx     # 0x31f98
testl %ebp, %ebp
je 0xbf0b
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x8726
movq %rax, %rdi
movl %ebp, %esi
callq 0xbdcb
jmp 0xbf0b
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initglobal
void initglobal(Symbol p, int flag) {
	Type ty;

	if (t == '=' || flag) {
		if (p->sclass == STATIC) {
			for (ty = p->type; isarray(ty); ty = ty->type)
				;
			defglobal(p, isconst(ty) ? LIT : DATA);
		} else
			defglobal(p, DATA);
		if (t == '=')
			t = gettok();
		ty = initializer(p->type, 0);
		if (isarray(p->type) && p->type->size == 0)
			p->type = ty;
		p->defined = 1;
		if (p->sclass == EXTERN)
			p->sclass = AUTO;
		if (level <= GLOBAL)
			tfree();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fa89(%rip), %r14     # 0x2b9e0
testl %esi, %esi
jne 0xbf65
cmpl $0x3d, (%r14)
jne 0xc005
cmpb $0x51, 0x1a(%rbx)
jne 0xbf9b
leaq 0x20(%rbx), %rax
movq (%rax), %rax
movl (%rax), %ecx
movl %ecx, %edx
cmpl $0xf, %ecx
jb 0xbf81
movq 0x10(%rax), %rdx
movl (%rdx), %edx
addq $0x10, %rax
cmpl $0xc, %edx
je 0xbf6f
andl $-0x11, %ecx
xorl %esi, %esi
cmpl $0xf, %ecx
sete %sil
addl $0x3, %esi
jmp 0xbf9e
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xbcf8
cmpl $0x3d, (%r14)
jne 0xbfb4
callq 0xd3c9
movl %eax, (%r14)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0xc00d
movq 0x20(%rbx), %rcx
movl (%rcx), %edx
cmpl $0xf, %edx
jb 0xbfd0
movq 0x10(%rcx), %rdx
movl (%rdx), %edx
cmpl $0xc, %edx
jne 0xbfdf
cmpl $0x0, 0x8(%rcx)
jne 0xbfdf
movq %rax, 0x20(%rbx)
orb $0x1, 0x1b(%rbx)
cmpb $0x4a, 0x1a(%rbx)
jne 0xbfed
movb $0x43, 0x1a(%rbx)
leaq 0x22d3c(%rip), %rax     # 0x2ed30
cmpl $0x3, (%rax)
jg 0xc005
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x169be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genasgn
static int genasgn(e, sp) Tree e; struct structexp *sp; {
	Tree p;

	sp->off = roundup(sp->off, e->type->size);
	p = simplify(ADD+P, ptr(e->type), lvalue(idnode(sp->var)), constnode(sp->off, inttype));
	if (isarray(e->type)) {
		p = tree(ASGN+B, e->type, p, e);
		p->u.sym = intconst(e->type->size);
	} else
		p = asgnnode(ASGN, retype(rvalue(p), e->type), e);
	sp->tree = tree(RIGHT, voidtype, sp->tree, p);
	sp->off += e->type->size;
	return e->type->size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movq 0x8(%rdi), %rdi
movl 0x8(%rdi), %ecx
addl %ecx, %eax
decl %eax
negl %ecx
andl %eax, %ecx
movl %ecx, 0x8(%rsi)
callq 0x1736a
movq %rax, %r15
movq (%rbx), %rdi
callq 0x93b4
movq %rax, %rdi
callq 0xa87d
movq %rax, %r12
movl 0x8(%rbx), %edi
leaq 0x2594a(%rip), %rax     # 0x31f98
movq (%rax), %rsi
callq 0x8726
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x1131b
movq 0x8(%r14), %rsi
movl (%rsi), %ecx
cmpl $0xf, %ecx
jb 0xc67a
movq 0x10(%rsi), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0xc6a2
pushq $0x39
popq %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x165eb
movq %rax, %r15
movq 0x8(%r14), %rax
movl 0x8(%rax), %edi
callq 0x16220
movq %rax, 0x28(%r15)
jmp 0xc6c7
movq %rax, %rdi
callq 0xa0b9
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x16727
pushq $0x30
popq %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x8382
movq %rax, %r15
leaq 0x25912(%rip), %rax     # 0x31fe0
movq (%rax), %rsi
movq 0x10(%rbx), %rdx
movl $0x2a0, %edi            # imm = 0x2A0
movq %r15, %rcx
callq 0x165eb
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movl 0x8(%rax), %eax
addl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initchar
static int initchar(int len, Type ty) {
	int n = 0;
	char buf[16], *s = buf;

	do {
		if (current) {
			Type aty;
			Tree e = expr1(0);
			aty = assign(ty, e);
			if (aty)
				genasgn(cast(e, aty), current);
			else
				error("invalid initialization type; found `%t' expected `%s'\n",
					e->type, ty);
			++n;
		} else {
			*s++ = initvalue(ty)->u.v.sc;
			if (++n%inttype->size == 0) {
				defstring(inttype->size, buf);
				s = buf;
			}
		}
		if ((len > 0 && n >= len) || t != ',')
			break;
		t = gettok();
	} while (t != '}');
	if (s > buf)
		defstring(s - buf, buf);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
movq %rsp, %r15
leaq 0x1eecc(%rip), %r12     # 0x2b9e0
xorl %ebx, %ebx
cmpq $0x0, 0x1cd9a(%rip)     # 0x298b8
je 0xcb56
xorl %edi, %edi
callq 0xa439
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x9610
testq %rax, %rax
je 0xcb81
movq %r13, %rdi
movq %rax, %rsi
callq 0x9912
movq 0x1cd6c(%rip), %rsi     # 0x298b8
movq %rax, %rdi
callq 0xc606
jmp 0xcb96
movq %r14, %rdi
callq 0xcda2
movb 0x28(%rax), %al
movb %al, (%r15)
incl %ebx
leaq 0x2542b(%rip), %rax     # 0x31f98
movq (%rax), %rax
movl 0x8(%rax), %edi
movl %ebx, %eax
cltd
idivl %edi
testl %edx, %edx
je 0xcbbb
incq %r15
jmp 0xcb98
movq 0x8(%r13), %rsi
leaq 0x10ac9(%rip), %rdi     # 0x1d655
movq %r14, %rdx
xorl %eax, %eax
callq 0x8dd4
incl %ebx
testl %ebp, %ebp
jle 0xcba0
cmpl %ebp, %ebx
jge 0xcbc8
cmpl $0x2c, (%r12)
jne 0xcbc8
callq 0xd3c9
movl %eax, (%r12)
cmpl $0x7d, %eax
jne 0xcb16
jmp 0xcbc8
movq %rsp, %r15
movq %r15, %rsi
callq 0x191ff
jmp 0xcb98
movq %rsp, %rax
cmpq %rax, %r15
jbe 0xcbde
movq %rsp, %rsi
subl %esi, %r15d
movl %r15d, %edi
callq 0x191ff
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initarray
static int initarray(len, ty, lev) int len,lev; Type ty; {
	int n = 0;

	do {
		initializer(ty, lev);
		n += ty->size;
		if ((len > 0 && n >= len) || t != ',')
			break;
		t = gettok();
	} while (t != '}');
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
xorl %ebp, %ebp
leaq 0x1edd8(%rip), %r12     # 0x2b9e0
movq %r14, %rdi
movl %ebx, %esi
callq 0xc00d
addl 0x8(%r14), %ebp
testl %r15d, %r15d
jle 0xcc20
cmpl %r15d, %ebp
jge 0xcc35
cmpl $0x2c, (%r12)
jne 0xcc35
callq 0xd3c9
movl %eax, (%r12)
cmpl $0x7d, %eax
jne 0xcc08
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebp
testq %rsi, %rsi
je 0xcd2c
movq %rsi, %rbx
leaq 0x2533f(%rip), %rax     # 0x31f98
movq (%rax), %rax
cmpl %ebp, 0x8(%rax)
jge 0xcd37
movq 0x1cc5c(%rip), %rdi     # 0x298c8
testq %rdi, %rdi
jne 0xcccf
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x1616e
movl %eax, %edi
callq 0x159ba
leaq 0x1c665(%rip), %rsi     # 0x292f0
movq %rax, %rdi
movl %r14d, %edx
callq 0x15f13
movq %rax, 0x1cc2b(%rip)     # 0x298c8
movb $0x51, 0x1a(%rax)
leaq 0x252d8(%rip), %rax     # 0x31f80
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x17382
movq 0x1cc0d(%rip), %rdi     # 0x298c8
movq %rax, 0x20(%rdi)
orb $0x4, 0x1b(%rdi)
callq 0x18f6d
movq 0x1cbf9(%rip), %rdi     # 0x298c8
movq 0x20(%rdi), %r14
cmpl %ebp, 0x8(%r14)
jge 0xccfa
leaq 0x252a0(%rip), %rax     # 0x31f80
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x17382
movq %rax, %r14
movq 0x1cbd2(%rip), %rdi     # 0x298c8
movq %rax, 0x20(%rdi)
callq 0x93b4
pushq $0x49
popq %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movq %rax, %r14
movl %ebp, %edi
callq 0x16220
movq %rax, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xc606
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x19255
leaq 0x25242(%rip), %r14     # 0x31f80
testl %ebp, %ebp
jle 0xcd5b
movq (%r14), %rsi
xorl %edi, %edi
callq 0x8726
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc606
decl %ebp
jmp 0xcd3e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movq %rsi, (%rbx)
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq 0x1cb3d(%rip), %rax     # 0x298b8
movq %rax, 0x18(%rbx)
movq %rbx, 0x1cb32(%rip)     # 0x298b8
xorl %esi, %esi
callq 0xc00d
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x1cb1c(%rip)     # 0x298b8
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1ff47(%rip), %r15     # 0x2ccf8
incl (%r15)
xorl %edi, %edi
callq 0xa439
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9610
testq %rax, %rax
je 0xcddb
movq %r14, %rdi
movq %rax, %rsi
callq 0x9912
jmp 0xcdfa
movq 0x8(%r14), %rsi
leaq 0x1086f(%rip), %rdi     # 0x1d655
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8dd4
xorl %edi, %edi
movq %rbx, %rsi
callq 0x8726
decl (%r15)
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x10, %ecx
jne 0xce0d
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10753(%rip), %rdi     # 0x1d567
xorl %eax, %eax
callq 0x8dd4
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8726
nop
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x1cabe(%rip), %rax     # 0x298f1
movq %rax, 0x1dabe(%rip)     # 0x2a8f8
andl $0x0, 0x1dac7(%rip)     # 0x2a908
movq %rax, 0x1dab8(%rip)     # 0x2a900
andq $0x0, 0x1dac0(%rip)     # 0x2a910
orl $-0x1, 0x1dac1(%rip)    # 0x2a918
movl %edi, 0x1dabf(%rip)     # 0x2a91c
jmp 0xce62
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x1c6aa(%rip), %rax     # 0x298f1
movq %rax, 0x1d6aa(%rip)     # 0x2a8f8
movq %rax, 0x1d6ab(%rip)     # 0x2a900
movb (%rdi), %al
incq %rdi
movq 0x1d69f(%rip), %rcx     # 0x2a900
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1d694(%rip)     # 0x2a900
movb %al, (%rcx)
testb %al, %al
jne 0xd255
movq 0x1d687(%rip), %rax     # 0x2a900
movb $0xa, (%rax)
andl $0x0, 0x1d695(%rip)     # 0x2a918
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpl $0x0, 0x1d68c(%rip)     # 0x2a918
je 0xd341
movq 0x1d667(%rip), %rax     # 0x2a900
movq 0x1d658(%rip), %rdx     # 0x2a8f8
cmpq %rdx, %rax
jbe 0xd2f9
movl %eax, %ecx
subl %edx, %ecx
movslq %ecx, %rsi
leaq 0x1c61d(%rip), %rdi     # 0x298d0
movq %rdi, %rcx
subq %rsi, %rcx
addq $0x21, %rcx
cmpq %rdi, %rcx
jb 0xd35c
movq 0x1d653(%rip), %rsi     # 0x2a920
subq %rdx, %rsi
addq %rcx, %rsi
movq %rsi, 0x1d646(%rip)     # 0x2a920
movq %rcx, %rsi
cmpq %rax, %rdx
jae 0xd300
leaq 0x1(%rdx), %rdi
movq %rdi, 0x1d60b(%rip)     # 0x2a8f8
movb (%rdx), %dl
movb %dl, (%rsi)
incq %rsi
movq %rdi, %rdx
jmp 0xd2dd
leaq 0x1c5f1(%rip), %rcx     # 0x298f1
movq %rcx, 0x1d5f1(%rip)     # 0x2a8f8
movl 0x1d60f(%rip), %edi     # 0x2a91c
leaq 0x1c5dd(%rip), %rsi     # 0x298f1
movl $0x1000, %edx           # imm = 0x1000
callq 0x3100
movl %eax, 0x1d5f4(%rip)     # 0x2a918
testl %eax, %eax
js 0xd343
addl $0x21, %eax
leaq 0x1c59e(%rip), %rcx     # 0x298d0
leaq (%rcx,%rax), %rdx
movq %rdx, 0x1d5c3(%rip)     # 0x2a900
movb $0xa, (%rax,%rcx)
popq %rax
retq
leaq 0x10391(%rip), %rdi     # 0x1d6db
leaq 0x1036c(%rip), %rsi     # 0x1d6bd
leaq 0x10374(%rip), %rcx     # 0x1d6cc
pushq $0x38
jmp 0xd373
leaq 0x1034e(%rip), %rdi     # 0x1d6b1
leaq 0x10353(%rip), %rsi     # 0x1d6bd
leaq 0x1035b(%rip), %rcx     # 0x1d6cc
pushq $0x31
popq %rdx
callq 0x30d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0x1d570(%rip), %r14     # 0x2a8f8
pushq $0x7f
popq %rbx
leaq 0x105be(%rip), %r15     # 0x1d950
movq (%r14), %rcx
movb (%rcx), %al
testb %al, %al
je 0xd3c1
incq %rcx
movzbl %al, %eax
movzbl (%rax,%r15), %edx
testb $0x1, %dl
je 0xd3b2
movq %rcx, (%r14)
movb (%rcx), %al
jmp 0xd39b
testb $0x2, %dl
je 0xd3c3
movq %rcx, (%r14)
callq 0xce62
jmp 0xd392
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x1bd43(%rip), %r14     # 0x2a8f8
movq (%r14), %rax
movzbl (%rax), %ecx
movl %ecx, %edx
orl $0x20, %edx
cmpl $0x75, %edx
jne 0xebd7
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movzbl (%rax), %ebx
movb 0x1(%rax), %cl
movq %rdx, %rax
jmp 0xebd9
xorl %ebx, %ebx
movzbl %cl, %edx
orl $0x20, %edx
cmpl $0x6c, %edx
jne 0xebf1
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movb 0x1(%rax), %cl
movq %rdx, %rax
testl %ebx, %ebx
sete %dl
cmpb $0x75, %cl
sete %r8b
andb %dl, %r8b
cmpb $0x55, %cl
sete %cl
orb %r8b, %cl
cmpb $0x1, %cl
jne 0xec1b
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %ebx
movq %rcx, %rax
testl %esi, %esi
je 0xec45
movb (%rax), %bpl
movb $0x0, (%rax)
movq 0x1cd1c(%rip), %rsi     # 0x2b948
leaq 0xf154(%rip), %rdi      # 0x1dd87
xorl %eax, %eax
callq 0x9239
movq (%r14), %rax
movb %bpl, (%rax)
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
leaq 0x2338c(%rip), %rax     # 0x31fd8
movq %rax, %rcx
testl %edi, %edi
js 0xec5a
leaq 0x2333e(%rip), %rcx     # 0x31f98
testl %ebx, %ebx
cmovneq %rax, %rcx
movq (%rcx), %rax
movq %rax, 0x1cd0e(%rip)     # 0x2b978
movl %edi, 0x1cd30(%rip)     # 0x2b9a0
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0xf244
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, %r12
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *(%rax)
movq 0x8(%r12), %r12
cmpq %r15, %r12
jne 0xf21f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22d15(%rip), %rax     # 0x31f80
movq (%rax), %r14
callq 0x30a0
leal 0x1(%rax), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x17382
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15a24
movq %rax, %rbx
cmpq $0x0, 0x50(%rax)
jne 0xf2a8
movq 0x20(%rbx), %rsi
pushq $0x51
popq %rdi
pushq $0x3
popq %rdx
callq 0x16090
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
cmpl $0x4a, %edi
jne 0xf2e6
movq %r15, %rdi
callq 0x157b6
leaq 0x1a01a(%rip), %rsi     # 0x292f0
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x15f13
movq %rax, %r14
jmp 0xf355
leaq 0x1a483(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r14
leaq 0x88(%r14), %rcx
cmpq 0x10(%rax), %rcx
jae 0xf30d
movq %rcx, 0x8(%rax)
jmp 0xf321
leaq 0x1a45c(%rip), %rsi     # 0x29770
movl $0x88, %edi
callq 0x16438
movq %rax, %r14
xorl %eax, %eax
xorps %xmm0, %xmm0
cmpq $0x7f, %rax
ja 0xf33d
leaq (%r14,%rax), %rcx
addq $0x20, %rax
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
jmp 0xf326
andq $0x0, (%r14,%rax)
movq %r15, %rdi
callq 0x157b6
movq %rax, 0x10(%r14)
movw $0x3, 0x18(%r14)
movb %bpl, 0x1a(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rdi
callq 0x18f6d
orb $0x1, 0x1b(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1a211(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x10, (%rax)
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0xf57c
movq %rcx, 0x8(%rax)
jmp 0xf58e
leaq 0x1a1ed(%rip), %rsi     # 0x29770
pushq $0x10
popq %rdi
callq 0x16438
movq %rax, %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movq (%rbx), %rsi
callq 0x156a0
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22a35(%rip), %r14     # 0x31ff0
movq (%r14), %rdi
pushq $0x4
popq %rsi
xorl %edx, %edx
callq 0x17382
pushq $0x51
popq %rdi
pushq $0x3
popq %rdx
movq %rax, %rsi
callq 0x16090
movq %rax, 0x1c4ab(%rip)     # 0x2ba88
movq 0x1c49c(%rip), %rdi     # 0x2ba80
testq %rdi, %rdi
jne 0xf617
leaq 0x229a8(%rip), %rax     # 0x31f98
movq (%rax), %rdi
movq (%r14), %rsi
callq 0xfc95
leaq 0xe990(%rip), %rsi      # 0x1df92
pushq $0x4a
popq %rdi
movq %rax, %rdx
callq 0xf2b3
movq %rax, %rdi
movq %rax, 0x1c469(%rip)     # 0x2ba80
callq 0x93b4
movq %rax, %rdi
callq 0xa22f
movq %rax, %r14
movq 0x1c452(%rip), %rax     # 0x2ba80
movq 0x20(%rax), %rdi
callq 0x18021
movq %rax, %r15
leaq 0x22997(%rip), %r13     # 0x31fd8
movq (%r13), %rdi
callq 0x1736a
movq %rax, %r12
movq %rbx, %rdi
callq 0x93b4
movq %rax, %rbx
movq (%r13), %rdi
callq 0x1736a
movq %rax, %r13
movq 0x1c41d(%rip), %rdi     # 0x2ba88
callq 0x93b4
pushq $0x27
popq %rbp
movl %ebp, %edi
movq %r13, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movl %ebp, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x165eb
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x87f6
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x376d
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x1c3ca(%rip), %rdi     # 0x2ba90
testq %rdi, %rdi
jne 0xf700
leaq 0x228c6(%rip), %rax     # 0x31f98
movq (%rax), %rdi
leaq 0x22914(%rip), %rax     # 0x31ff0
movq (%rax), %rsi
callq 0xfc95
leaq 0xe8b1(%rip), %rsi      # 0x1df9c
pushq $0x4a
popq %rdi
movq %rax, %rdx
callq 0xf2b3
movq %rax, %rdi
movq %rax, 0x1c390(%rip)     # 0x2ba90
callq 0x93b4
movq %rax, %rdi
callq 0xa22f
movq %rax, %rbx
movq 0x1c379(%rip), %rax     # 0x2ba90
movq 0x20(%rax), %rdi
callq 0x18021
movq %rax, %r14
leaq 0x228ae(%rip), %rax     # 0x31fd8
movq (%rax), %rdi
callq 0x1736a
movq %rax, %r15
movq 0x1c34c(%rip), %rdi     # 0x2ba88
callq 0x93b4
pushq $0x27
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x87f6
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x376d
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x1c30a(%rip), %rdi     # 0x2ba88
pushq $0x3
popq %rsi
callq 0xbcf8
movq 0x1c30b(%rip), %rdi     # 0x2ba98
callq 0xbd57
xorl %edi, %edi
callq 0xbd57
movq 0x10(%rbx), %rdi
callq 0xf25d
movq 0x50(%rax), %rdi
callq 0xbd57
movzwl 0x70(%rbx), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movzwl 0x72(%rbx), %r14d
orl %eax, %r14d
movq 0x68(%rbx), %rdi
callq 0xff22
shll $0x1a, %eax
orl %eax, %r14d
pushq $0x6
popq %rdi
movq %r14, %rsi
callq 0x1917d
movq 0x1c2a8(%rip), %rax     # 0x2ba88
movq %rax, 0x1c2b1(%rip)     # 0x2ba98
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x22635(%rip), %r13     # 0x31ff0
movq (%r13), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x17382
pushq $0x51
popq %rdi
pushq $0x3
popq %rdx
movq %rax, %rsi
callq 0x16090
movq %rax, %r14
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0xbcf8
movq (%r15), %rdi
testq %rdi, %rdi
je 0xf9f8
callq 0xf25d
movq 0x50(%rax), %r12
movq %r12, %rdi
callq 0xbd57
leaq 0x19e71(%rip), %rax     # 0x29878
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0xf25d
movq 0x50(%rax), %rdi
callq 0xbd57
movzwl 0x8(%r15), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movzwl 0xa(%r15), %esi
orq %rax, %rsi
pushq $0x6
popq %rdi
callq 0x1917d
movq 0x1c068(%rip), %r15     # 0x2baa8
testq %r15, %r15
jne 0xfa6a
movq (%r13), %rdi
callq 0x1736a
leaq 0xe551(%rip), %rsi      # 0x1dfa6
pushq $0x4a
popq %rdi
movq %rax, %rdx
callq 0xf2b3
movq %rax, %r15
movq %rax, 0x1c03e(%rip)     # 0x2baa8
movq %r14, %rdi
callq 0x93b4
movq %r15, %rdi
movq %rax, %rsi
callq 0x952e
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xa8d2
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbincr
static void bbincr(yycounts, cp, e) Symbol yycounts; Coordinate *cp; Tree *e; {
	struct map *mp = (struct map *)maplist->x;

	/* append *cp to source map */
	if (mp->size >= sizeof mp->u/sizeof mp->u[0]) {
		mp = (struct map *)alloc(sizeof *mp);
		mp->size = 0;
		maplist = append((Generic *)mp, maplist);
	}
	mp->u[mp->size].c.x = cp->x;
	mp->u[mp->size].c.y = cp->y;
	mp->u[mp->size++].c.index = bbfile(cp->file);
	*e = right(incr('+', rvalue((*opnode['+'])(ADD, pointer(idnode(yycounts)),
		constnode(npoints++, inttype))), constnode(1, inttype)), *e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x1bf9b(%rip), %rsi     # 0x2ba48
movq (%rsi), %r15
movl (%r15), %eax
cmpl $0xc8, %eax
jb 0xfb12
leaq 0x19caf(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x328, (%rax)          # imm = 0x328
movq 0x8(%rax), %r15
leaq 0x328(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0xfae1
movq %rcx, 0x8(%rax)
jmp 0xfafc
leaq 0x19c88(%rip), %rsi     # 0x29770
movl $0x328, %edi            # imm = 0x328
callq 0x16438
movq %rax, %r15
movq 0x1bf4c(%rip), %rsi     # 0x2ba48
andl $0x0, (%r15)
movq %r15, %rdi
callq 0x156a0
movq %rax, 0x1bf39(%rip)     # 0x2ba48
movl (%r15), %eax
movzwl 0x8(%r12), %ecx
cltq
andl $0x3ff, %ecx            # imm = 0x3FF
shll $0x10, %ecx
movl $0xfc00ffff, %edx       # imm = 0xFC00FFFF
andl 0x4(%r15,%rax,4), %edx
orl %ecx, %edx
movl %edx, 0x4(%r15,%rax,4)
movzwl 0xa(%r12), %eax
movslq (%r15), %rcx
movw %ax, 0x4(%r15,%rcx,4)
movq (%r12), %rdi
callq 0xff22
movslq (%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r15)
shll $0x1a, %eax
movl $0x3ffffff, %edx        # imm = 0x3FFFFFF
andl 0x4(%r15,%rcx,4), %edx
orl %eax, %edx
movl %edx, 0x4(%r15,%rcx,4)
leaq 0x185f0(%rip), %rax     # 0x28160
movq 0x158(%rax), %r15
movq %r14, %rdi
callq 0x93b4
movq %rax, %rdi
callq 0xa22f
movq %rax, %r14
movl 0x1bee8(%rip), %edi     # 0x2ba78
leal 0x1(%rdi), %eax
movl %eax, 0x1bedf(%rip)     # 0x2ba78
leaq 0x223f8(%rip), %r12     # 0x31f98
movq (%r12), %rsi
callq 0x8726
movl $0x130, %edi            # imm = 0x130
movq %r14, %rsi
movq %rax, %rdx
callq *%r15
movq %rax, %rdi
callq 0xa0b9
movq %rax, %r14
movq (%r12), %rsi
pushq $0x1
popq %rdi
callq 0x8726
pushq $0x2b
popq %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa65e
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xa8d2
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/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:
cmpq $0x0, 0x1be52(%rip)     # 0x2ba50
je 0xfc01
retq
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xfc1a
cmpb $0x0, (%rdi)
leaq 0xe296(%rip), %rbx      # 0x1deaa
cmovneq %rdi, %rbx
jmp 0xfc21
leaq 0xe289(%rip), %rbx      # 0x1deaa
leaq 0x223b8(%rip), %rax     # 0x31fe0
movq (%rax), %r14
leaq 0x2234e(%rip), %rax     # 0x31f80
movq (%rax), %rdi
callq 0x1736a
movq %r14, %rdi
movq %rax, %rsi
callq 0xfc95
pushq $0x51
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf2b3
movq %rax, 0x1bdf6(%rip)     # 0x2ba50
movb $0x4a, 0x1a(%rax)
leaq 0xb0(%rip), %rdi        # 0xfd15
leaq 0x1bd94(%rip), %rdx     # 0x2ba00
movq %rax, %rsi
callq 0xf54a
movq 0x1bdd5(%rip), %rsi     # 0x2ba50
leaq 0x1f8(%rip), %rdi       # 0xfe7a
leaq 0x1bd87(%rip), %rdx     # 0x2ba10
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf54a
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2226d(%rip), %r13     # 0x31f98
movq (%r13), %rsi
pushq $0x51
popq %rdi
pushq $0x3
popq %rdx
callq 0x16090
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0xbcf8
movq 0x20(%r15), %rax
movl 0x8(%rax), %edi
callq 0x19255
movq (%r13), %rsi
leaq 0x1efd1(%rip), %rax     # 0x2ed30
movl (%rax), %edx
pushq $0x43
popq %rdi
callq 0x16090
movq %rax, 0x1bd40(%rip)     # 0x2bab0
movq %rax, %rdi
callq 0x32ac
movq 0x10(%r14), %rdi
callq 0xff71
leaq 0xe226(%rip), %rdi      # 0x1dfae
callq 0xff71
movq 0x1bd1c(%rip), %r12     # 0x2bab0
movq %r15, %rdi
callq 0x93b4
movq %rax, %r15
movq (%r13), %rsi
pushq $0x1
popq %rdi
callq 0x8726
pushq $0x27
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa65e
movq %r12, %rdi
movq %rax, %rsi
callq 0x952e
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
callq 0x10078
leaq 0xe1d8(%rip), %rdi      # 0x1dfb0
callq 0xff71
leaq 0xce7b(%rip), %r15      # 0x1cc5f
leaq 0xe1c7(%rip), %r12      # 0x1dfb2
movq 0x80(%r14), %rax
movq (%rax,%r13), %rax
testq %rax, %rax
je 0xfe44
testq %r13, %r13
je 0xfe13
movq %r12, %rdi
callq 0xff71
movq 0x80(%r14), %rax
movq (%rax,%r13), %rax
movq 0x10(%rax), %rdi
callq 0xff71
movq %r15, %rdi
callq 0xff71
movq 0x80(%r14), %rax
movq (%rax,%r13), %rdi
callq 0x93b4
movq %rax, %rdi
xorl %esi, %esi
callq 0x10078
addq $0x8, %r13
jmp 0xfdeb
movq 0x20(%r14), %rdi
callq 0x18bcf
testl %eax, %eax
je 0xfe5d
leaq 0xe15c(%rip), %rdi      # 0x1dfb4
callq 0xff71
leaq 0xe155(%rip), %rdi      # 0x1dfb9
callq 0xff71
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10450
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
callq 0xff71
leaq 0xe116(%rip), %rdi      # 0x1dfae
callq 0xff71
movq 0x1bc0c(%rip), %rdi     # 0x2bab0
callq 0x93b4
movq %rax, %rdi
xorl %esi, %esi
callq 0x10078
leaq 0xe14c(%rip), %rdi      # 0x1e006
callq 0xff71
movq 0x20(%r15), %rdi
callq 0x18021
testq %r14, %r14
je 0xfeef
leaq 0x2210c(%rip), %rcx     # 0x31fe0
cmpq (%rcx), %rax
je 0xfeef
leaq 0xc3e4(%rip), %rdi      # 0x1c2c4
callq 0xff71
movq %r14, %rdi
xorl %esi, %esi
callq 0x10078
leaq 0xdc9e(%rip), %rdi      # 0x1db94
callq 0xff71
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10450
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0xff6b
movq 0x1bb71(%rip), %rax     # 0x2baa0
pushq $0x1
popq %rbx
testq %rax, %rax
je 0xff4e
movq %rax, %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rdx
cmpq %rdi, 0x48(%rdx)
je 0xff6d
incl %ebx
cmpq %rax, %rcx
jne 0xff3a
callq 0xf25d
movq 0x1bb46(%rip), %rsi     # 0x2baa0
movq %rax, %rdi
callq 0x156a0
movq %rax, 0x1bb37(%rip)     # 0x2baa0
jmp 0xff6d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: appendstr
static void appendstr(str) char *str; {
	do {
		if (fp == fmtend) {
			if (fp) {
				char *s = (char *)talloc(2*(fmtend - fmt));
				strncpy(s, fmt, fmtend - fmt);
				fp = s + (fmtend - fmt);
				fmtend = s + 2*(fmtend - fmt);
				fmt = s;
			} else {
				fp = fmt = (char *)talloc(80);
				fmtend = fmt + 80;
			}
		}
		*fp++ = *str;
	} while (*str++);
	fp--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1bb35(%rip), %rcx     # 0x2bab8
movq 0x1bb36(%rip), %r15     # 0x2bac0
leaq 0x197e7(%rip), %r14     # 0x29778
pushq $0x50
popq %rbp
cmpq %r15, %rcx
je 0xffa1
movq %rcx, %rax
jmp 0x1004e
testq %r15, %r15
je 0xffd6
movq 0x1bb1b(%rip), %rsi     # 0x2bac8
subq %rsi, %r15
leal 0x7(,%r15,2), %edi
andl $-0x8, %edi
movq (%r14), %rax
movl %edi, (%rax)
movq 0x8(%rax), %r12
movslq %edi, %rcx
addq %r12, %rcx
cmpq 0x10(%rax), %rcx
jae 0xfff3
movq %rcx, 0x8(%rax)
jmp 0x1000f
movq (%r14), %rcx
movl $0x50, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x50(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x10032
movq %rdx, 0x8(%rcx)
jmp 0x1003c
movq %r14, %rsi
callq 0x16438
movq %rax, %r12
movq 0x1bac3(%rip), %rsi     # 0x2bac8
movq 0x1bab4(%rip), %r15     # 0x2bac0
subq %rsi, %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0x3040
leaq (%r12,%r15), %rax
leaq (%r12,%r15,2), %r15
movq %r15, 0x1ba97(%rip)     # 0x2bac0
movq %r12, 0x1ba98(%rip)     # 0x2bac8
jmp 0x1004e
movl %ebp, %edi
movq %r14, %rsi
callq 0x16438
movq %rax, 0x1ba85(%rip)     # 0x2bac8
leaq 0x50(%rax), %r15
movq %r15, 0x1ba72(%rip)     # 0x2bac0
movb (%rbx), %dl
leaq 0x1(%rax), %rcx
movq %rcx, 0x1ba5d(%rip)     # 0x2bab8
movb %dl, (%rax)
incq %rbx
testb %dl, %dl
jne 0xff94
movq %rax, 0x1ba49(%rip)     # 0x2bab8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b656(%rip), %rax     # 0x2bab8
movb $0x0, (%rax)
movq 0x1b65c(%rip), %rdi     # 0x2bac8
callq 0x157b6
movq %rax, %rdi
callq 0xf25d
movq %rax, %r14
leaq 0x1b655(%rip), %rax     # 0x2bad8
movq %rax, %r12
movq (%rax), %rcx
leaq 0x18(%rcx), %rax
testq %rcx, %rcx
jne 0x10483
leaq 0x21ae7(%rip), %rax     # 0x31f80
movq (%rax), %rdi
callq 0x1736a
movq %rax, %r15
movq 0x50(%r14), %rdi
callq 0x93b4
movq %rax, %rdi
callq 0xa22f
pushq $0x27
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x165eb
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x93b4
movq %rax, %rdi
callq 0xa22f
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x18021
movq 0x1b5ec(%rip), %rdx     # 0x2bad8
movq %r14, %rdi
movq %rax, %rsi
callq 0x87f6
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x376d
andq $0x0, 0x1b5cd(%rip)     # 0x2bad8
andq $0x0, 0x1b5ad(%rip)     # 0x2bac0
andq $0x0, 0x1b59d(%rip)     # 0x2bab8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x1, %edi
jne 0x105bc
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x10731
pushq %rax
movl $0x2, 0x18051(%rip)     # 0x28618
movq 0x18042(%rip), %rax     # 0x28610
movq %rax, 0x18073(%rip)     # 0x28648
movl %edi, 0x18085(%rip)     # 0x28660
movq 0x18086(%rip), %rax     # 0x28668
movq %rax, 0x18027(%rip)     # 0x28610
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10731
callq 0x10613
movq 0x18048(%rip), %rax     # 0x28648
movq %rax, 0x18009(%rip)     # 0x28610
movl $0x1, 0x18007(%rip)     # 0x28618
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl 0x17ffe(%rip), %eax     # 0x28618
testq %rax, %rax
je 0x10652
leaq 0x16f0a(%rip), %rcx     # 0x27530
movq (%rcx,%rax,8), %rbx
movq 0x17fdf(%rip), %rdx     # 0x28610
movq 0x10(%rbx), %rsi
subq %rsi, %rdx
jbe 0x10645
movl (%rbx), %edi
callq 0x3090
movq 0x10(%rbx), %rsi
movq %rsi, 0x8(%rbx)
movq %rsi, 0x17fc0(%rip)     # 0x28610
popq %rbx
retq
leaq 0xd9ef(%rip), %rdi      # 0x1e048
leaq 0xd9eb(%rip), %rsi      # 0x1e04b
leaq 0xd9f4(%rip), %rcx      # 0x1e05b
pushq $0x2b
popq %rdx
callq 0x30d0