LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: test
void test(int tok, char set[])  {
	if (t == tok)
		t = gettok();
	else {
		expect(tok);
		skipto(tok, set);
		if (t == tok)
			t = gettok();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3003a(%rip), %rax     # 0x3db80
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xdb5f
callq 0x15170
movl %eax, %ecx
leaq 0x30025(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
jmp 0xdb93
movl -0x4(%rbp), %edi
callq 0xd670
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xd990
leaq 0x30006(%rip), %rax     # 0x3db80
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xdb91
callq 0x15170
movl %eax, %ecx
leaq 0x2fff1(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
jmp 0xdb93
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/error.c
// Function: warning
void warning(fmt, va_alist) char *fmt; va_dcl {
#endif
	va_list ap;

	va_init(ap, fmt);
	if (wflag == 0) {
		errcnt--;	/* compensate for increment in error */
		error("warning: ");
		vfprint(2, fmt, ap);
	}
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xdbd5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpl $0x0, 0x2de19(%rip)     # 0x3ba40
jne 0xdc58
movl 0x2de0d(%rip), %eax     # 0x3ba3c
addl $-0x1, %eax
movl %eax, 0x2de04(%rip)     # 0x3ba3c
leaq 0x2218a(%rip), %rdi     # 0x2fdc9
movb $0x0, %al
callq 0xd530
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x1a6d0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: addrof
Tree addrof(p) Tree p; {
	Tree q = p;

	for (;;)
		switch (generic(q->op)) {
		case RIGHT:
			assert(q->kids[0] || q->kids[1]);
			q = q->kids[1] ? q->kids[1] : q->kids[0];
			continue;
		case ASGN:
			q = q->kids[1];
			continue;
		case COND: {
			Symbol t1 = q->u.sym;
			q->u.sym = 0;
			q = idnode(t1);
			/* fall thru */
			}
		case INDIR:
			if (p == q)
				return q->kids[0];
			q = q->kids[0];
			return tree(RIGHT, q->type, root(p), q);
		default:
			error("addressable object required\n");
			return value(p);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0x24(%rbp)
subl $0x30, %eax
je 0xdd32
jmp 0xdc9b
movl -0x24(%rbp), %eax
subl $0x40, %eax
je 0xdd68
jmp 0xdca9
movl -0x24(%rbp), %eax
subl $0x290, %eax            # imm = 0x290
je 0xdd43
jmp 0xdcb9
movl -0x24(%rbp), %eax
subl $0x2a0, %eax            # imm = 0x2A0
jne 0xddbc
jmp 0xdcc9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdcdf
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdce1
jmp 0xdd00
leaq 0x22388(%rip), %rdi     # 0x30070
leaq 0x2239a(%rip), %rsi     # 0x30089
movl $0x1e, %edx
leaq 0x2239c(%rip), %rcx     # 0x30097
callq 0x30c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdd19
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xdd25
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xdc84
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xdc84
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rdi
callq 0xddf0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xdd80
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xddd7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25a90
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x256f0
movq %rax, -0x8(%rbp)
jmp 0xddd7
leaq 0x222e2(%rip), %rdi     # 0x300a5
movb $0x0, %al
callq 0xd530
movq -0x10(%rbp), %rdi
callq 0xe030
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: value
static Tree value(p) Tree p; {
	Opcode op = generic(rightkid(p)->op);

	if (op == AND || op == OR || op == NOT || op == EQ || op == NE
	||  op ==  LE || op == LT || op ==  GE || op == GT)
		p = condnode(p, constnode(1, inttype), constnode(0, inttype));
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf920
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0xc(%rbp)
cmpl $0x260, -0xc(%rbp)      # imm = 0x260
je 0xe09e
cmpl $0x280, -0xc(%rbp)      # imm = 0x280
je 0xe09e
cmpl $0x270, -0xc(%rbp)      # imm = 0x270
je 0xe09e
cmpl $0x1e0, -0xc(%rbp)      # imm = 0x1E0
je 0xe09e
cmpl $0x230, -0xc(%rbp)      # imm = 0x230
je 0xe09e
cmpl $0x210, -0xc(%rbp)      # imm = 0x210
je 0xe09e
cmpl $0x220, -0xc(%rbp)      # imm = 0x220
je 0xe09e
cmpl $0x1f0, -0xc(%rbp)      # imm = 0x1F0
je 0xe09e
cmpl $0x200, -0xc(%rbp)      # imm = 0x200
jne 0xe0e3
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x3614b(%rip), %rax     # 0x441f8
movq (%rax), %rsi
movl $0x1, %edi
callq 0xc7b0
movq %rax, -0x18(%rbp)
leaq 0x36133(%rip), %rax     # 0x441f8
movq (%rax), %rsi
xorl %edi, %edi
callq 0xc7b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0xcc60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: asgn
Tree asgn(p, e) Symbol p; Tree e; {
	if (isarray(p->type))
		e = tree(ASGN+B, p->type, idnode(p),
			tree(INDIR+B, e->type, e, 0));
	else {
		Type ty = p->type;
		p->type = unqual(p->type);
		if (isstruct(p->type) && p->type->u.sym->u.s.cfields) {
			p->type->u.sym->u.s.cfields = 0;
			e = asgnnode(ASGN, idnode(p), e);
			p->type->u.sym->u.s.cfields = 1;
		} else
			e = asgnnode(ASGN, idnode(p), e);
		p->type = ty;
	}
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0xe11f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe12b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0xe185
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xddf0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movl $0x49, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl $0x39, %edi
callq 0x256f0
movq %rax, -0x10(%rbp)
jmp 0xe2c3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0xe1b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xe1bc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0xe1e7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xe1f3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x9, (%rax)
je 0xe230
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0xe21b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe227
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpl $0xa, (%rax)
jne 0xe299
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movb 0x48(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xe299
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movb 0x48(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x48(%rax)
movq -0x8(%rbp), %rdi
callq 0xddf0
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movl $0x30, %edi
callq 0xc050
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movb 0x48(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x48(%rax)
jmp 0xe2b7
movq -0x8(%rbp), %rdi
callq 0xddf0
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movl $0x30, %edi
callq 0xc050
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: cond
Tree cond(p) Tree p; {
	Opcode op = generic(rightkid(p)->op);

	if (op == AND || op == OR || op == NOT || op == EQ || op == NE
	||  op ==  LE || op == LT || op ==  GE || op == GT)
		return p;
	p = pointer(p);
	p = cast(p, promote(p->type));
	return (*opnode[NEQ])(NE, p, constnode(0, inttype));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf920
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0x14(%rbp)
cmpl $0x260, -0x14(%rbp)     # imm = 0x260
je 0xf88e
cmpl $0x280, -0x14(%rbp)     # imm = 0x280
je 0xf88e
cmpl $0x270, -0x14(%rbp)     # imm = 0x270
je 0xf88e
cmpl $0x1e0, -0x14(%rbp)     # imm = 0x1E0
je 0xf88e
cmpl $0x230, -0x14(%rbp)     # imm = 0x230
je 0xf88e
cmpl $0x210, -0x14(%rbp)     # imm = 0x210
je 0xf88e
cmpl $0x220, -0x14(%rbp)     # imm = 0x220
je 0xf88e
cmpl $0x1f0, -0x14(%rbp)     # imm = 0x1F0
je 0xf88e
cmpl $0x200, -0x14(%rbp)     # imm = 0x200
jne 0xf898
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf90b
movq -0x10(%rbp), %rdi
callq 0xf9f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfae0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xe9b0
movq %rax, -0x10(%rbp)
leaq 0x2987f(%rip), %rax     # 0x39150
movq 0x1b0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x3490d(%rip), %rax     # 0x441f8
movq (%rax), %rsi
xorl %edi, %edi
callq 0xc7b0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl $0x230, %edi            # imm = 0x230
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: rightkid
static Tree rightkid(p) Tree p; {
	while (p && p->op == RIGHT) {
		assert(p->kids[0] || p->kids[1]);
		p = p->kids[1] ? p->kids[1] : p->kids[0];
	}
	assert(p);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0xf948
movq -0x8(%rbp), %rax
cmpl $0x2a0, (%rax)          # imm = 0x2A0
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xf951
jmp 0xf9ba
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xf967
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf969
jmp 0xf988
leaq 0x20b0f(%rip), %rdi     # 0x3047f
leaq 0x20712(%rip), %rsi     # 0x30089
movl $0x36c, %edx            # imm = 0x36C
leaq 0x20b15(%rip), %rcx     # 0x30498
callq 0x30c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf9a1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf9ad
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf92c
cmpq $0x0, -0x8(%rbp)
je 0xf9c3
jmp 0xf9e2
leaq 0x1f854(%rip), %rdi     # 0x2f21e
leaq 0x206b8(%rip), %rsi     # 0x30089
movl $0x36f, %edx            # imm = 0x36F
leaq 0x20abb(%rip), %rcx     # 0x30498
callq 0x30c0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: pointer
Tree pointer(p) Tree p; {
	if (isarray(p->type) && (p->op != RIGHT || p->u.sym == 0))
		p = retype(p, atop(p->type));
	else if (isfunc(p->type))
		p = retype(p, ptr(p->type));
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xfa1b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xfa27
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xc, (%rax)
jne 0xfa6e
movq -0x8(%rbp), %rax
cmpl $0x2a0, (%rax)          # imm = 0x2A0
jne 0xfa47
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xfa6e
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x27310
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x25a20
movq %rax, -0x8(%rbp)
jmp 0xfac9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xfa8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xfa99
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jne 0xfac7
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x27120
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x25a20
movq %rax, -0x8(%rbp)
jmp 0xfac9
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: promote
Type promote(ty) Type ty; {
	ty = unqual(ty);
	if (isunsigned(ty) || ty == longtype)
		return ty;
	else if (isint(ty) || isenum(ty))
		return inttype;
	return ty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xfaff
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfb07
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xfb26
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xfb2e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
je 0xfb47
movq -0x10(%rbp), %rax
leaq 0x346c6(%rip), %rcx     # 0x44208
cmpq (%rcx), %rax
jne 0xfb54
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfbe6
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xfb6b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfb73
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
jb 0xfba4
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xfb93
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xfb9b
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
jbe 0xfbcc
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0xfbbb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xfbc3
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0xd, (%rax)
jne 0xfbdc
leaq 0x34625(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xfbe6
jmp 0xfbde
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: conditional
Tree conditional(int tok) {
	Tree p = expr(tok);

	if (Aflag > 1 && isfunc(p->type))
		warning("%s used in a conditional expression\n", funcname(p));
	return cond(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xfc70
movq %rax, -0x10(%rbp)
leaq 0x2e01a(%rip), %rax     # 0x3dc28
cmpl $0x1, (%rax)
jle 0xfc61
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0xfc32
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfc3e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
jne 0xfc61
movq -0x10(%rbp), %rdi
callq 0xfd40
movq %rax, %rsi
leaq 0x204e0(%rip), %rdi     # 0x3013a
movb $0x0, %al
callq 0xdba0
movq -0x10(%rbp), %rdi
callq 0xf820
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr
Tree expr(int tok) {
	Tree p = expr1(0);

	while (t == ',') {
		Tree q;
		t = gettok();
		q = pointer(expr1(0));
		if (generic(p->op) != CNST)
			p = root(value(p));
		p = tree(RIGHT, q->type, p, q);
	}
	if (tok && t == tok)
		t = gettok();
	else if (tok) {
		static char follow[] = { IF, ID, '}', 0 };
		test(tok, follow);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
xorl %edi, %edi
callq 0xfe00
movq %rax, -0x10(%rbp)
leaq 0x2def3(%rip), %rax     # 0x3db80
cmpl $0x2c, (%rax)
jne 0xfcf8
callq 0x15170
movl %eax, %ecx
leaq 0x2dee0(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
xorl %edi, %edi
callq 0xfe00
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0xfcd8
movq -0x10(%rbp), %rdi
callq 0xe030
movq %rax, %rdi
callq 0x25a90
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x256f0
movq %rax, -0x10(%rbp)
jmp 0xfc86
cmpl $0x0, -0x4(%rbp)
je 0xfd1e
leaq 0x2de7b(%rip), %rax     # 0x3db80
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xfd1e
callq 0x15170
movl %eax, %ecx
leaq 0x2de66(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
jmp 0xfd35
cmpl $0x0, -0x4(%rbp)
je 0xfd33
movl -0x4(%rbp), %edi
leaq 0x299c2(%rip), %rsi     # 0x396f0
callq 0xdb30
jmp 0xfd35
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: constexpr
Tree constexpr(int tok) {
	Tree p;

	needconst++;
	p = expr1(tok);
	needconst--;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2f116(%rip), %rax     # 0x3eed8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2f10a(%rip), %rax     # 0x3eed8
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0xfe00
movq %rax, -0x10(%rbp)
leaq 0x2f0f5(%rip), %rax     # 0x3eed8
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x2f0e9(%rip), %rax     # 0x3eed8
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr1
Tree expr1(int tok) {
	Tree p = expr2();

	while (t == '=' || (prec[t] >= 6 && prec[t] <= 8)
	|| (prec[t] >= 11 && prec[t] <= 13)) {
		Opcode op = t;
		t = gettok();
		if (oper[op] == ASGN)
			p = asgnnode(ASGN, p, value(expr1(0)));
		else {
			expect('=');
			p = incr(op, p, expr1(0));
		}
	}
	if (tok && t == tok)
		t = gettok();
	else if (tok) {
		static char follow[] = { IF, ID, 0 };
		test(tok, follow);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
callq 0xffc0
movq %rax, -0x10(%rbp)
movb $0x1, %al
leaq 0x2dd63(%rip), %rcx     # 0x3db80
cmpl $0x3d, (%rcx)
movb %al, -0x15(%rbp)
je 0xfea9
leaq 0x2dd50(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x298c5(%rip), %rax     # 0x39700
movsbl (%rax,%rcx), %eax
cmpl $0x6, %eax
jl 0xfe64
leaq 0x2dd35(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x298aa(%rip), %rax     # 0x39700
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x8, %ecx
movb %al, -0x15(%rbp)
jle 0xfea9
leaq 0x2dd15(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2988a(%rip), %rax     # 0x39700
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xb, %ecx
movb %al, -0x16(%rbp)
jl 0xfea3
leaq 0x2dcf5(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2986a(%rip), %rax     # 0x39700
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
setle %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xfeb5
jmp 0xff48
leaq 0x2dcc4(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x15170
movl %eax, %ecx
leaq 0x2dcb1(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x298a3(%rip), %rax     # 0x39780
cmpl $0x30, (%rax,%rcx,4)
jne 0xff11
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %edi, %edi
callq 0xfe00
movq %rax, %rdi
callq 0xe030
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x30, %edi
callq 0xc050
movq %rax, -0x10(%rbp)
jmp 0xff43
movl $0x3d, %edi
callq 0xd670
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %edi, %edi
callq 0xfe00
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x10150
movq %rax, -0x10(%rbp)
jmp 0xfe14
cmpl $0x0, -0x4(%rbp)
je 0xff6e
leaq 0x2dc2b(%rip), %rax     # 0x3db80
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xff6e
callq 0x15170
movl %eax, %ecx
leaq 0x2dc16(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
jmp 0xff85
cmpl $0x0, -0x4(%rbp)
je 0xff83
movl -0x4(%rbp), %edi
leaq 0x29a02(%rip), %rsi     # 0x39980
callq 0xdb30
jmp 0xff85
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: expr2
static Tree expr2() {
	Tree p = expr3(4);

	if (t == '?') {
		Tree l, r;
		if (Aflag > 1 && isfunc(p->type))
			warning("%s used in a conditional expression\n", funcname(p));
		p = pointer(p);
		t = gettok();
		if (events.points) {
			Tree e = 0;
			apply(events.points, (Generic)&src, (Generic)&e);
			l = right(e, pointer(expr(':')));
			e = 0;
			apply(events.points, (Generic)&src, (Generic)&e);
			r = right(e, pointer(expr2()));
		} else {
			l = pointer(expr(':'));
			r = pointer(expr2());
		}
		p = condnode(p, l, r);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x4, %edi
callq 0x10660
movq %rax, -0x8(%rbp)
leaq 0x2dba3(%rip), %rax     # 0x3db80
cmpl $0x3f, (%rax)
jne 0x10142
leaq 0x2dc3b(%rip), %rax     # 0x3dc28
cmpl $0x1, (%rax)
jle 0x10040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x10011
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1001d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x10040
movq -0x8(%rbp), %rdi
callq 0xfd40
movq %rax, %rsi
leaq 0x20101(%rip), %rdi     # 0x3013a
movb $0x0, %al
callq 0xdba0
movq -0x8(%rbp), %rdi
callq 0xf9f0
movq %rax, -0x8(%rbp)
callq 0x15170
movl %eax, %ecx
leaq 0x2db25(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
leaq 0x2db6c(%rip), %rax     # 0x3dbd0
cmpq $0x0, 0x18(%rax)
je 0x10106
movq $0x0, -0x20(%rbp)
leaq 0x2db52(%rip), %rax     # 0x3dbd0
movq 0x18(%rax), %rdi
leaq 0x2da4f(%rip), %rsi     # 0x3dad8
leaq -0x20(%rbp), %rdx
callq 0x18640
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x3a, %edi
callq 0xfc70
movq %rax, %rdi
callq 0xf9f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x105b0
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x2db05(%rip), %rax     # 0x3dbd0
movq 0x18(%rax), %rdi
leaq 0x2da02(%rip), %rsi     # 0x3dad8
leaq -0x20(%rbp), %rdx
callq 0x18640
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xffc0
movq %rax, %rdi
callq 0xf9f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x105b0
movq %rax, -0x18(%rbp)
jmp 0x1012d
movl $0x3a, %edi
callq 0xfc70
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x10(%rbp)
callq 0xffc0
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcc60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/expr.c
// Function: intexpr
int intexpr(int tok, int n) {
	Tree p = constexpr(tok);

	needconst++;
	if (generic(p->op) == CNST && isint(p->type))
		n = cast(p, inttype)->u.v.i;
	else
		error("integer expression must be constant\n");
	needconst--;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0xfdb0
movq %rax, -0x10(%rbp)
leaq 0x2ea97(%rip), %rax     # 0x3eed8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2ea8b(%rip), %rax     # 0x3eed8
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
jne 0x104e4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x10480
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1048c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jb 0x104e4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x104b4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x104c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
ja 0x104e4
movq -0x10(%rbp), %rdi
leaq 0x33d24(%rip), %rax     # 0x441f8
movq (%rax), %rsi
callq 0xe9b0
movl 0x28(%rax), %eax
movl %eax, -0x8(%rbp)
jmp 0x104f2
leaq 0x1fc9b(%rip), %rdi     # 0x30186
movb $0x0, %al
callq 0xd530
leaq 0x2e9df(%rip), %rax     # 0x3eed8
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x2e9d3(%rip), %rax     # 0x3eed8
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x40, %eax
jne 0x10589
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x10549
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10555
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x33ce0(%rip), %rcx     # 0x44240
cmpq (%rcx), %rax
jne 0x1057b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1fc37(%rip), %rdi     # 0x301ab
movb $0x0, %al
callq 0xdba0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x105a4
leaq 0x1fc33(%rip), %rdi     # 0x301c3
movb $0x0, %al
callq 0xd530
movq -0x10(%rbp), %rdi
callq 0xe030
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x105ce
cmpq $0x0, -0x18(%rbp)
je 0x105d0
jmp 0x105ef
leaq 0x1fbfd(%rip), %rdi     # 0x301d4
leaq 0x1faab(%rip), %rsi     # 0x30089
movl $0x363, %edx            # imm = 0x363
leaq 0x1fbf1(%rip), %rcx     # 0x301db
callq 0x30c0
cmpq $0x0, -0x10(%rbp)
je 0x1062d
cmpq $0x0, -0x18(%rbp)
je 0x1062d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25a90
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x256f0
movq %rax, -0x8(%rbp)
jmp 0x1064e
cmpq $0x0, -0x10(%rbp)
je 0x1063e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x10646
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
callq 0x107f0
movq %rax, -0x10(%rbp)
leaq 0x2d505(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2907a(%rip), %rax     # 0x39700
movsbl (%rax,%rcx), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x107df
jmp 0x1069b
leaq 0x2d4de(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, %ecx
leaq 0x29053(%rip), %rax     # 0x39700
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x29(%rbp)
jne 0x106d1
leaq 0x2c3d6(%rip), %rax     # 0x3ca98
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x3d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x106dd
jmp 0x107cf
leaq 0x2d49c(%rip), %rax     # 0x3db80
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0x15170
movl %eax, %ecx
leaq 0x2d489(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xf9f0
movq %rax, -0x10(%rbp)
leaq 0x2d4c3(%rip), %rax     # 0x3dbd0
cmpq $0x0, 0x18(%rax)
je 0x1077b
cmpl $0x32, -0x1c(%rbp)
je 0x10720
cmpl $0x33, -0x1c(%rbp)
jne 0x1077b
movq $0x0, -0x28(%rbp)
leaq 0x2d4a1(%rip), %rax     # 0x3dbd0
movq 0x18(%rax), %rdi
leaq 0x2d39e(%rip), %rsi     # 0x3dad8
leaq -0x28(%rbp), %rdx
callq 0x18640
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x8(%rbp), %edi
cmpl $0x5, -0x8(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl %eax, %edi
callq 0x10660
movq %rax, %rdi
callq 0xf9f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x105b0
movq %rax, -0x18(%rbp)
jmp 0x1079d
movl -0x8(%rbp), %edi
cmpl $0x5, -0x8(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl %eax, %edi
callq 0x10660
movq %rax, %rdi
callq 0xf9f0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x289a7(%rip), %rax     # 0x39150
movq (%rax,%rcx,8), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
leaq 0x28fc7(%rip), %rcx     # 0x39780
movl (%rcx,%rdx,4), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq %rax, -0x10(%rbp)
jmp 0x1069b
jmp 0x107d1
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1068d
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x2d855(%rip), %rax     # 0x3eed8
cmpl $0x0, (%rax)
je 0x11695
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11799
leaq 0x32b5c(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
leaq 0x2b3fe(%rip), %rax     # 0x3caa8
movl (%rax), %edi
leaq 0x32b45(%rip), %rax     # 0x441f8
movq (%rax), %rsi
callq 0xc7b0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
movl $0x25, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq %rax, -0x20(%rbp)
leaq 0x32b65(%rip), %rax     # 0x44240
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x32b0f(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf820
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movl $0x270, %edi            # imm = 0x270
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq %rax, -0x28(%rbp)
leaq 0x32adf(%rip), %rax     # 0x441f8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0x2c509(%rip), %rax     # 0x3dc30
movq (%rax), %rdi
callq 0xddf0
movq %rax, %rdi
callq 0xf9f0
movq %rax, %rdi
leaq 0x32aff(%rip), %rax     # 0x44240
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xc960
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movl $0x2a0, %edi            # imm = 0x2A0
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl $0x290, %edi            # imm = 0x290
callq 0x256f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x256f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl %edi, 0x48(%rax)
callq 0x12a40
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x51, %eax
je 0x12a04
movq -0x8(%rbp), %rdi
callq 0x2a5a0
leaq 0x2b1f5(%rip), %rax     # 0x3dc00
cmpl $0x0, (%rax)
je 0x12a28
leaq 0x2e579(%rip), %rax     # 0x40f90
cmpl $0x3, (%rax)
jne 0x12a28
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edi
callq 0x12a40
movq -0x8(%rbp), %rdi
callq 0x2a5d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: defpointer
void defpointer(p) Symbol p; {
	if (p)
		defaddress(p);
	else {
		Value v;
		defconst(P, (v.p = 0, v));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12a8e
movq -0x8(%rbp), %rdi
callq 0x2a980
jmp 0x12aac
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x7, %edi
callq 0x2a830
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x12ba9
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x0, 0x48(%rax)
je 0x12b09
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movl 0x48(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x12b13
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12b13
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x129d0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0x12b3e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12b4a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x12b6d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %edi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2a920
jmp 0x12b89
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x29e30
movl %eax, %edi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2a830
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2ad1a(%rip), %rax     # 0x3db80
cmpl $0x3d, (%rax)
je 0x12e75
cmpl $0x0, -0xc(%rbp)
je 0x12fce
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x51, %eax
jne 0x12f0b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x12ea9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12eb1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x12eca
jmp 0x12ebc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12e92
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpl $0xf, (%rcx)
movb %al, -0x21(%rbp)
je 0x12eed
movq -0x18(%rbp), %rax
cmpl $0x1f, (%rax)
sete %al
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rdi
movb -0x21(%rbp), %cl
movl $0x3, %esi
movl $0x4, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x129d0
jmp 0x12f19
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x129d0
leaq 0x2ac60(%rip), %rax     # 0x3db80
cmpl $0x3d, (%rax)
jne 0x12f35
callq 0x15170
movl %eax, %ecx
leaq 0x2ac4d(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0x12fe0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0x12f67
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x12f73
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x12f96
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x12f96
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x4a, %eax
jne 0x12fbb
movq -0x8(%rbp), %rax
movb $0x43, 0x1a(%rax)
leaq 0x2dfce(%rip), %rax     # 0x40f90
cmpl $0x3, (%rax)
jg 0x12fcc
callq 0x26160
jmp 0x12fce
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x27120
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xddf0
movq %rax, %rdi
callq 0x10510
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x308d0(%rip), %rax     # 0x441f8
movq (%rax), %rsi
callq 0xc7b0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
movl $0x137, %edi            # imm = 0x137
callq 0x1c390
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jb 0x13968
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x13974
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x139b8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x39, %edi
callq 0x256f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edi
callq 0x24f20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x139e6
movq -0x18(%rbp), %rdi
callq 0xf780
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x25a20
movq %rax, %rsi
movq -0x8(%rbp), %rdx
movl $0x30, %edi
callq 0xc050
movq %rax, -0x18(%rbp)
leaq 0x30853(%rip), %rax     # 0x44240
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x256f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genchar
static void genchar(p, sp) Symbol p; struct structexp *sp; {
	char *s = p->u.c.v.p;
	int n;

	for (n = p->type->size; n > 0 && sp->off%inttype->align; n--)
		genasgn(constnode((*s++)&0377, chartype), sp);
	if (n > 0) {
		static Value v;
		Type ty = array(chartype, p->type->size - (s - p->u.c.v.p), 0);
		Tree e = tree(ADDRG+P, atop(ty), 0, 0);
		v.p = stringn(s, ty->size);
		p = constant(ty, v);
		if (p->u.c.loc == 0)
			p->u.c.loc = genident(STATIC, ty, GLOBAL);
		e->u.sym = p->u.c.loc;
		e = tree(INDIR+B, ty, e, 0);
		e->u.sym = intconst(ty->size);
		genasgn(e, sp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
jle 0x13c46
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
leaq 0x305c5(%rip), %rcx     # 0x441f8
movq (%rcx), %rcx
movswl 0x4(%rcx), %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x13c4f
jmp 0x13c8d
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
andl $0xff, %edi
leaq 0x30572(%rip), %rax     # 0x441e0
movq (%rax), %rsi
callq 0xc7b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x138b0
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13c1a
cmpl $0x0, -0x1c(%rbp)
jle 0x13d8f
leaq 0x30542(%rip), %rax     # 0x441e0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x48(%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movl %eax, %esi
xorl %edx, %edx
callq 0x27160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x27310
movq %rax, %rsi
movl $0x107, %edi            # imm = 0x107
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x256f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x23830
movq %rax, 0x27d54(%rip)     # 0x3ba58
movq -0x28(%rbp), %rdi
movq 0x27d49(%rip), %rsi     # 0x3ba58
callq 0x23d40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x13d41
movq -0x28(%rbp), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x24b00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x49, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x256f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x24f20
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x138b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x27c82(%rip)     # 0x3ba48
je 0x13e2e
xorl %edi, %edi
callq 0xfe00
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe2d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x13e09
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xe9b0
movq %rax, %rdi
movq 0x27c46(%rip), %rsi     # 0x3ba48
callq 0x138b0
jmp 0x13e23
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1c7b9(%rip), %rdi     # 0x305d5
movb $0x0, %al
callq 0xd530
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13e87
movq -0x10(%rbp), %rdi
callq 0x14150
movb 0x28(%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq 0x3039d(%rip), %rcx     # 0x441f8
movq (%rcx), %rcx
cltd
idivl 0x8(%rcx)
cmpl $0x0, %edx
jne 0x13e85
leaq 0x3038a(%rip), %rax     # 0x441f8
movq (%rax), %rax
movl 0x8(%rax), %edi
leaq -0x30(%rbp), %rsi
callq 0x2a920
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x13e87
cmpl $0x0, -0x4(%rbp)
jle 0x13e95
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x13ea1
leaq 0x29ce4(%rip), %rax     # 0x3db80
cmpl $0x2c, (%rax)
je 0x13ea3
jmp 0x13ec3
callq 0x15170
movl %eax, %ecx
leaq 0x29ccf(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
leaq 0x29cc6(%rip), %rax     # 0x3db80
cmpl $0x7d, (%rax)
jne 0x13dbe
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x13ee6
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edi
leaq -0x30(%rbp), %rsi
callq 0x2a920
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12fe0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x13f30
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x13f3c
leaq 0x29c49(%rip), %rax     # 0x3db80
cmpl $0x2c, (%rax)
je 0x13f3e
jmp 0x13f5a
callq 0x15170
movl %eax, %ecx
leaq 0x29c34(%rip), %rax     # 0x3db80
movl %ecx, (%rax)
leaq 0x29c2b(%rip), %rax     # 0x3db80
cmpl $0x7d, (%rax)
jne 0x13f09
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)